--- a/dom/browser-element/BrowserElementParent.cpp
+++ b/dom/browser-element/BrowserElementParent.cpp
@@ -181,17 +181,17 @@ BrowserElementParent::DispatchOpenWindow
BrowserElementParent::OpenWindowResult
BrowserElementParent::OpenWindowOOP(TabParent* aOpenerTabParent,
TabParent* aPopupTabParent,
PRenderFrameParent* aRenderFrame,
const nsAString& aURL,
const nsAString& aName,
const nsAString& aFeatures,
TextureFactoryIdentifier* aTextureFactoryIdentifier,
- uint64_t* aLayersId)
+ layers::LayersId* aLayersId)
{
// Create an iframe owned by the same document which owns openerFrameElement.
nsCOMPtr<Element> openerFrameElement = aOpenerTabParent->GetOwnerElement();
NS_ENSURE_TRUE(openerFrameElement,
BrowserElementParent::OPEN_WINDOW_IGNORED);
RefPtr<HTMLIFrameElement> popupFrameElement =
CreateIframe(openerFrameElement, aName, /* aRemote = */ true);
--- a/dom/browser-element/BrowserElementParent.h
+++ b/dom/browser-element/BrowserElementParent.h
@@ -95,17 +95,17 @@ public:
static OpenWindowResult
OpenWindowOOP(dom::TabParent* aOpenerTabParent,
dom::TabParent* aPopupTabParent,
layout::PRenderFrameParent* aRenderFrame,
const nsAString& aURL,
const nsAString& aName,
const nsAString& aFeatures,
layers::TextureFactoryIdentifier* aTextureFactoryIdentifier,
- uint64_t* aLayersId);
+ layers::LayersId* aLayersId);
/**
* Handle a window.open call from an in-process <iframe mozbrowser>.
*
* (These parameter types are silly, but they match what our caller has in
* hand. Feel free to add an override, if they are inconvenient to you.)
*
* @param aURI the URI the new window should load. May be null.
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -966,17 +966,17 @@ ContentChild::ProvideWindowCommon(TabChi
// until one of these callbacks is called.
auto resolve = [&] (const CreatedWindowInfo& info) {
MOZ_RELEASE_ASSERT(NS_IsMainThread());
rv = info.rv();
*aWindowIsNew = info.windowOpened();
nsTArray<FrameScriptInfo> frameScripts(info.frameScripts());
nsCString urlToLoad = info.urlToLoad();
TextureFactoryIdentifier textureFactoryIdentifier = info.textureFactoryIdentifier();
- uint64_t layersId = info.layersId();
+ layers::LayersId layersId = info.layersId();
CompositorOptions compositorOptions = info.compositorOptions();
uint32_t maxTouchPoints = info.maxTouchPoints();
DimensionInfo dimensionInfo = info.dimensions();
// Once this function exits, we should try to exit the nested event loop.
ready = true;
// NOTE: We have to handle this immediately in the resolve callback in order
@@ -995,17 +995,17 @@ ContentChild::ProvideWindowCommon(TabChi
}
// If the TabChild has been torn down, we don't need to do this anymore.
if (NS_WARN_IF(!newChild->IPCOpen() || newChild->IsDestroyed())) {
rv = NS_ERROR_ABORT;
return;
}
- if (layersId == 0) { // if renderFrame is invalid.
+ if (!layersId.IsValid()) { // if renderFrame is invalid.
renderFrame = nullptr;
}
ShowInfo showInfo(EmptyString(), false, false, true, false, 0, 0, 0);
auto* opener = nsPIDOMWindowOuter::From(aParent);
nsIDocShell* openerShell;
if (opener && (openerShell = opener->GetDocShell())) {
nsCOMPtr<nsILoadContext> context = do_QueryInterface(openerShell);
@@ -1455,17 +1455,17 @@ ContentChild::RecvReinitRendering(Endpoi
Endpoint<PVideoDecoderManagerChild>&& aVideoManager,
nsTArray<uint32_t>&& namespaces)
{
MOZ_ASSERT(namespaces.Length() == 3);
nsTArray<RefPtr<TabChild>> tabs = TabChild::GetAll();
// Zap all the old layer managers we have lying around.
for (const auto& tabChild : tabs) {
- if (tabChild->LayersId()) {
+ if (tabChild->GetLayersId().IsValid()) {
tabChild->InvalidateLayers();
}
}
// Re-establish singleton bridges to the compositor.
if (!CompositorManagerChild::Init(Move(aCompositor), namespaces[0])) {
return GetResultForRenderingInitFailure(aCompositor.OtherPid());
}
@@ -1477,17 +1477,17 @@ ContentChild::RecvReinitRendering(Endpoi
}
if (!gfx::VRManagerChild::ReinitForContent(Move(aVRBridge))) {
return GetResultForRenderingInitFailure(aVRBridge.OtherPid());
}
gfxPlatform::GetPlatform()->CompositorUpdated();
// Establish new PLayerTransactions.
for (const auto& tabChild : tabs) {
- if (tabChild->LayersId()) {
+ if (tabChild->GetLayersId().IsValid()) {
tabChild->ReinitRendering();
}
}
VideoDecoderManagerChild::InitForContent(Move(aVideoManager));
return IPC_OK();
}
@@ -1502,17 +1502,17 @@ ContentChild::RecvAudioDefaultDeviceChan
mozilla::ipc::IPCResult
ContentChild::RecvReinitRenderingForDeviceReset()
{
gfxPlatform::GetPlatform()->CompositorUpdated();
nsTArray<RefPtr<TabChild>> tabs = TabChild::GetAll();
for (const auto& tabChild : tabs) {
- if (tabChild->LayersId()) {
+ if (tabChild->GetLayersId().IsValid()) {
tabChild->ReinitRenderingForDeviceReset();
}
}
return IPC_OK();
}
#if defined(XP_MACOSX) && defined(MOZ_CONTENT_SANDBOX)
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -1557,44 +1557,44 @@ ContentParent::ProcessingError(Result aC
return;
}
// Other errors are big deals.
KillHard(aReason);
}
/* static */
bool
-ContentParent::AllocateLayerTreeId(TabParent* aTabParent, uint64_t* aId)
+ContentParent::AllocateLayerTreeId(TabParent* aTabParent, layers::LayersId* aId)
{
return AllocateLayerTreeId(aTabParent->Manager()->AsContentParent(),
aTabParent, aTabParent->GetTabId(), aId);
}
/* static */
bool
ContentParent::AllocateLayerTreeId(ContentParent* aContent,
TabParent* aTopLevel, const TabId& aTabId,
- uint64_t* aId)
+ layers::LayersId* aId)
{
GPUProcessManager* gpu = GPUProcessManager::Get();
*aId = gpu->AllocateLayerTreeId();
if (!aContent || !aTopLevel) {
return false;
}
gpu->MapLayerTreeId(*aId, aContent->OtherPid());
return true;
}
mozilla::ipc::IPCResult
ContentParent::RecvAllocateLayerTreeId(const ContentParentId& aCpId,
- const TabId& aTabId, uint64_t* aId)
+ const TabId& aTabId, layers::LayersId* aId)
{
// Protect against spoofing by a compromised child. aCpId must either
// correspond to the process that this ContentParent represents or be a
// child of it.
ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
RefPtr<ContentParent> contentParent = cpm->GetContentProcessById(aCpId);
if (ChildID() != aCpId && !contentParent->CanCommunicateWith(ChildID())) {
return IPC_FAIL_NO_REASON(this);
@@ -1609,17 +1609,17 @@ ContentParent::RecvAllocateLayerTreeId(c
if (!AllocateLayerTreeId(contentParent, browserParent, aTabId, aId)) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
mozilla::ipc::IPCResult
ContentParent::RecvDeallocateLayerTreeId(const ContentParentId& aCpId,
- const uint64_t& aId)
+ const layers::LayersId& aId)
{
GPUProcessManager* gpu = GPUProcessManager::Get();
ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
RefPtr<ContentParent> contentParent = cpm->GetContentProcessById(aCpId);
if (!contentParent->CanCommunicateWith(ChildID())) {
return IPC_FAIL(this, "Spoofed DeallocateLayerTreeId call");
}
@@ -4889,17 +4889,17 @@ ContentParent::RecvCreateWindow(PBrowser
const uint32_t& aReferrerPolicy,
CreateWindowResolver&& aResolve)
{
nsresult rv = NS_OK;
CreatedWindowInfo cwi;
// We always expect to open a new window here. If we don't, it's an error.
cwi.windowOpened() = true;
- cwi.layersId() = 0;
+ cwi.layersId() = LayersId{0};
cwi.maxTouchPoints() = 0;
// Make sure to resolve the resolver when this function exits, even if we
// failed to generate a valid response.
auto resolveOnExit = MakeScopeExit([&] {
// Copy over the nsresult, and then resolve.
cwi.rv() = rv;
aResolve(cwi);
--- a/dom/ipc/ContentParent.h
+++ b/dom/ipc/ContentParent.h
@@ -552,17 +552,17 @@ public:
const OptionalURIParams& aURIToLoad,
const nsCString& aFeatures,
const nsCString& aBaseURI,
const float& aFullZoom,
const nsString& aName,
const IPC::Principal& aTriggeringPrincipal,
const uint32_t& aReferrerPolicy) override;
- static bool AllocateLayerTreeId(TabParent* aTabParent, uint64_t* aId);
+ static bool AllocateLayerTreeId(TabParent* aTabParent, layers::LayersId* aId);
static void
BroadcastBlobURLRegistration(const nsACString& aURI,
BlobImpl* aBlobImpl,
nsIPrincipal* aPrincipal,
ContentParent* aIgnoreThisCP = nullptr);
static void
@@ -832,17 +832,17 @@ private:
// See nsIPermissionManager::GetPermissionsForKey for more information on
// these keys.
void EnsurePermissionsByKey(const nsCString& aKey);
static void ForceKillTimerCallback(nsITimer* aTimer, void* aClosure);
static bool AllocateLayerTreeId(ContentParent* aContent,
TabParent* aTopLevel, const TabId& aTabId,
- uint64_t* aId);
+ layers::LayersId* aId);
/**
* Get or create the corresponding content parent array to |aContentProcessType|.
*/
static nsTArray<ContentParent*>& GetOrCreatePool(const nsAString& aContentProcessType);
virtual mozilla::ipc::IPCResult RecvInitBackground(Endpoint<mozilla::ipc::PBackgroundParent>&& aEndpoint) override;
@@ -1101,20 +1101,20 @@ public:
const URIParams& aNewURI,
const IPC::Principal& aLoadingPrincipal,
const bool& aInPrivateBrowsing) override;
virtual void ProcessingError(Result aCode, const char* aMsgName) override;
virtual mozilla::ipc::IPCResult RecvAllocateLayerTreeId(const ContentParentId& aCpId,
const TabId& aTabId,
- uint64_t* aId) override;
+ layers::LayersId* aId) override;
virtual mozilla::ipc::IPCResult RecvDeallocateLayerTreeId(const ContentParentId& aCpId,
- const uint64_t& aId) override;
+ const layers::LayersId& aId) override;
virtual mozilla::ipc::IPCResult RecvGraphicsError(const nsCString& aError) override;
virtual mozilla::ipc::IPCResult
RecvBeginDriverCrashGuard(const uint32_t& aGuardType,
bool* aOutCrashed) override;
virtual mozilla::ipc::IPCResult RecvEndDriverCrashGuard(const uint32_t& aGuardType) override;
--- a/dom/ipc/DOMTypes.ipdlh
+++ b/dom/ipc/DOMTypes.ipdlh
@@ -22,16 +22,17 @@ using DesktopIntRect from "Units.h";
using DesktopToLayoutDeviceScale from "Units.h";
using CSSToLayoutDeviceScale from "Units.h";
using CSSRect from "Units.h";
using CSSSize from "Units.h";
using mozilla::LayoutDeviceIntPoint from "Units.h";
using mozilla::dom::ScreenOrientationInternal from "mozilla/dom/ScreenOrientation.h";
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
using mozilla::layers::CompositorOptions from "mozilla/layers/CompositorOptions.h";
+using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
namespace mozilla {
namespace dom {
struct MessagePortIdentifier
{
nsID uuid;
nsID destinationUuid;
@@ -113,17 +114,17 @@ struct FrameScriptInfo
*/
struct CreatedWindowInfo
{
nsresult rv;
bool windowOpened;
FrameScriptInfo[] frameScripts;
nsCString urlToLoad;
TextureFactoryIdentifier textureFactoryIdentifier;
- uint64_t layersId;
+ LayersId layersId;
CompositorOptions compositorOptions;
uint32_t maxTouchPoints;
DimensionInfo dimensions;
};
/**
* PerformanceInfo is used to pass performance info stored
--- a/dom/ipc/PBrowser.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -35,16 +35,17 @@ using class IPC::Principal from "mozilla
using mozilla::gfx::Matrix from "mozilla/gfx/Matrix.h";
using mozilla::LayoutDeviceIntPoint from "Units.h";
using mozilla::LayoutDevicePoint from "Units.h";
using mozilla::ScreenIntPoint from "Units.h";
using ScreenIntSize from "Units.h";
using struct mozilla::layers::FrameMetrics from "FrameMetrics.h";
using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h";
using struct mozilla::layers::ZoomConstraints from "FrameMetrics.h";
+using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
using mozilla::layers::MaybeZoomConstraints from "FrameMetrics.h";
using mozilla::layers::GeckoContentController::TapType from "mozilla/layers/GeckoContentController.h";
using FrameMetrics::ViewID from "FrameMetrics.h";
using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
using mozilla::WindowsHandle from "ipc/IPCMessageUtils.h";
using nscolor from "nsColor.h";
using class mozilla::WidgetCompositionEvent from "ipc/nsGUIEventIPC.h";
using struct mozilla::widget::IMENotification from "mozilla/widget/IMEData.h";
@@ -592,17 +593,17 @@ child:
* point.
*/
async Show(ScreenIntSize size,
ShowInfo info,
bool parentIsActive,
nsSizeMode sizeMode);
async InitRendering(TextureFactoryIdentifier textureFactoryIdentifier,
- uint64_t layersId,
+ LayersId layersId,
CompositorOptions compositorOptions,
bool layersConnected,
nullable PRenderFrame renderFrame);
async LoadURL(nsCString uri, ShowInfo info);
async UpdateDimensions(DimensionInfo dimensions) compressall;
--- a/dom/ipc/PContent.ipdl
+++ b/dom/ipc/PContent.ipdl
@@ -85,16 +85,17 @@ using mozilla::dom::ContentParentId from
using mozilla::LayoutDeviceIntPoint from "Units.h";
using struct LookAndFeelInt from "mozilla/widget/WidgetMessageUtils.h";
using class mozilla::dom::MessagePort from "mozilla/dom/MessagePort.h";
using class mozilla::dom::ipc::StructuredCloneData from "mozilla/dom/ipc/StructuredCloneData.h";
using mozilla::DataStorageType from "ipc/DataStorageIPCUtils.h";
using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
using mozilla::layers::CompositorOptions from "mozilla/layers/CompositorOptions.h";
+using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
using mozilla::Telemetry::HistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedHistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ScalarAction from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedScalarAction from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::DynamicScalarDefinition from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ChildEventData from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::DiscardedData from "mozilla/TelemetryComms.h";
using mozilla::CrossProcessMutexHandle from "mozilla/ipc/CrossProcessMutex.h";
@@ -886,18 +887,18 @@ parent:
returns (nsString providerName, nsCOMPtr<nsIInputStream> postData, OptionalURIParams uri);
sync NotifyKeywordSearchLoading(nsString providerName, nsString keyword);
async CopyFavicon(URIParams oldURI, URIParams newURI, Principal aLoadingPrincipal, bool isPrivate);
// Tell the compositor to allocate a layer tree id for nested remote mozbrowsers.
sync AllocateLayerTreeId(ContentParentId cpId, TabId tabId)
- returns (uint64_t id);
- async DeallocateLayerTreeId(ContentParentId cpId, uint64_t id);
+ returns (LayersId id);
+ async DeallocateLayerTreeId(ContentParentId cpId, LayersId id);
/**
* Notifies the parent about a recording device is starting or shutdown.
* @param recordingStatus starting or shutdown
* @param pageURL URL that request that changing the recording status
* @param isAudio recording start with microphone
* @param isVideo recording start with camera
*/
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -399,17 +399,17 @@ TabChild::TabChild(nsIContentChild* aMan
uint32_t aChromeFlags)
: TabContext(aContext)
, mTabGroup(aTabGroup)
, mRemoteFrame(nullptr)
, mManager(aManager)
, mChromeFlags(aChromeFlags)
, mMaxTouchPoints(0)
, mActiveSuppressDisplayport(0)
- , mLayersId(0)
+ , mLayersId{0}
, mBeforeUnloadListeners(0)
, mDidFakeShow(false)
, mNotified(false)
, mTriedBrowserInit(false)
, mOrientation(eScreenOrientation_PortraitPrimary)
, mIgnoreKeyPressEvent(false)
, mHasValidInnerSize(false)
, mDestroyed(false)
@@ -1080,26 +1080,26 @@ TabChild::DestroyWindow()
}
if (mRemoteFrame) {
mRemoteFrame->Destroy();
mRemoteFrame = nullptr;
}
- if (mLayersId != 0) {
+ if (mLayersId.IsValid()) {
StaticMutexAutoLock lock(sTabChildrenMutex);
MOZ_ASSERT(sTabChildren);
- sTabChildren->Remove(mLayersId);
+ sTabChildren->Remove(uint64_t(mLayersId));
if (!sTabChildren->Count()) {
delete sTabChildren;
sTabChildren = nullptr;
}
- mLayersId = 0;
+ mLayersId = layers::LayersId{0};
}
}
void
TabChild::ActorDestroy(ActorDestroyReason why)
{
mIPCOpen = false;
@@ -1171,17 +1171,17 @@ TabChild::RecvLoadURL(const nsCString& a
CrashReporter::AnnotateCrashReport(NS_LITERAL_CSTRING("URL"), aURI);
return IPC_OK();
}
void
TabChild::DoFakeShow(const TextureFactoryIdentifier& aTextureFactoryIdentifier,
- const uint64_t& aLayersId,
+ const layers::LayersId& aLayersId,
const CompositorOptions& aCompositorOptions,
PRenderFrameChild* aRenderFrame, const ShowInfo& aShowInfo)
{
mLayersConnected = aRenderFrame ? Some(true) : Some(false);
InitRenderingState(aTextureFactoryIdentifier, aLayersId, aCompositorOptions, aRenderFrame);
RecvShow(ScreenIntSize(0, 0), aShowInfo, mParentIsActive, nsSizeMode_Normal);
mDidFakeShow = true;
}
@@ -1267,17 +1267,17 @@ TabChild::RecvShow(const ScreenIntSize&
if (!res) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
mozilla::ipc::IPCResult
TabChild::RecvInitRendering(const TextureFactoryIdentifier& aTextureFactoryIdentifier,
- const uint64_t& aLayersId,
+ const layers::LayersId& aLayersId,
const CompositorOptions& aCompositorOptions,
const bool& aLayersConnected,
PRenderFrameChild* aRenderFrame)
{
MOZ_ASSERT((!mDidFakeShow && aRenderFrame) || (mDidFakeShow && !aRenderFrame));
mLayersConnected = Some(aLayersConnected);
InitRenderingState(aTextureFactoryIdentifier, aLayersId, aCompositorOptions, aRenderFrame);
@@ -2762,51 +2762,51 @@ TabChild::InitTabChildGlobal()
}
}
return true;
}
void
TabChild::InitRenderingState(const TextureFactoryIdentifier& aTextureFactoryIdentifier,
- const uint64_t& aLayersId,
+ const layers::LayersId& aLayersId,
const CompositorOptions& aCompositorOptions,
PRenderFrameChild* aRenderFrame)
{
mPuppetWidget->InitIMEState();
if (!aRenderFrame) {
mLayersConnected = Some(false);
NS_WARNING("failed to construct RenderFrame");
return;
}
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
mTextureFactoryIdentifier = aTextureFactoryIdentifier;
// Pushing layers transactions directly to a separate
// compositor context.
PCompositorBridgeChild* compositorChild = CompositorBridgeChild::Get();
if (!compositorChild) {
mLayersConnected = Some(false);
NS_WARNING("failed to get CompositorBridgeChild instance");
return;
}
mCompositorOptions = Some(aCompositorOptions);
mRemoteFrame = static_cast<RenderFrameChild*>(aRenderFrame);
- if (aLayersId != 0) {
+ if (aLayersId.IsValid()) {
StaticMutexAutoLock lock(sTabChildrenMutex);
if (!sTabChildren) {
sTabChildren = new TabChildMap;
}
- MOZ_ASSERT(!sTabChildren->Get(aLayersId));
- sTabChildren->Put(aLayersId, this);
+ MOZ_ASSERT(!sTabChildren->Get(uint64_t(aLayersId)));
+ sTabChildren->Put(uint64_t(aLayersId), this);
mLayersId = aLayersId;
}
MOZ_ASSERT(!mPuppetWidget->HasLayerManager());
bool success = false;
if (mLayersConnected == Some(true)) {
success = CreateRemoteLayerManager(compositorChild);
}
@@ -2845,17 +2845,17 @@ TabChild::CreateRemoteLayerManager(mozil
success = mPuppetWidget->CreateRemoteLayerManager([&] (LayerManager* aLayerManager) -> bool {
MOZ_ASSERT(aLayerManager->AsWebRenderLayerManager());
return aLayerManager->AsWebRenderLayerManager()->Initialize(aCompositorChild,
wr::AsPipelineId(mLayersId),
&mTextureFactoryIdentifier);
});
} else {
nsTArray<LayersBackend> ignored;
- PLayerTransactionChild* shadowManager = aCompositorChild->SendPLayerTransactionConstructor(ignored, LayersId());
+ PLayerTransactionChild* shadowManager = aCompositorChild->SendPLayerTransactionConstructor(ignored, GetLayersId());
if (shadowManager &&
shadowManager->SendGetTextureFactoryIdentifier(&mTextureFactoryIdentifier) &&
mTextureFactoryIdentifier.mParentBackend != LayersBackend::LAYERS_NONE)
{
success = true;
}
if (!success) {
// Since no LayerManager is associated with the tab's widget, we will never
@@ -3101,23 +3101,23 @@ TabChild::GetFrom(nsIPresShell* aPresShe
if (!doc) {
return nullptr;
}
nsCOMPtr<nsIDocShell> docShell(doc->GetDocShell());
return GetFrom(docShell);
}
TabChild*
-TabChild::GetFrom(uint64_t aLayersId)
+TabChild::GetFrom(layers::LayersId aLayersId)
{
StaticMutexAutoLock lock(sTabChildrenMutex);
if (!sTabChildren) {
return nullptr;
}
- return sTabChildren->Get(aLayersId);
+ return sTabChildren->Get(uint64_t(aLayersId));
}
void
TabChild::DidComposite(uint64_t aTransactionId,
const TimeStamp& aCompositeStart,
const TimeStamp& aCompositeEnd)
{
MOZ_ASSERT(mPuppetWidget);
@@ -3171,17 +3171,17 @@ TabChild::InvalidateLayers()
MOZ_ASSERT(lm);
FrameLayerBuilder::InvalidateAllLayers(lm);
}
void
TabChild::ReinitRendering()
{
- MOZ_ASSERT(mLayersId);
+ MOZ_ASSERT(mLayersId.IsValid());
// Before we establish a new PLayerTransaction, we must connect our layer tree
// id, CompositorBridge, and the widget compositor all together again.
// Normally this happens in TabParent before TabChild is given rendering
// information.
//
// In this case, we will send a sync message to our TabParent, which in turn
// will send a sync message to the Compositor of the widget owning this tab.
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -312,17 +312,17 @@ public:
virtual mozilla::ipc::IPCResult
RecvShow(const ScreenIntSize& aSize,
const ShowInfo& aInfo,
const bool& aParentIsActive,
const nsSizeMode& aSizeMode) override;
virtual mozilla::ipc::IPCResult
RecvInitRendering(const TextureFactoryIdentifier& aTextureFactoryIdentifier,
- const uint64_t& aLayersId,
+ const layers::LayersId& aLayersId,
const mozilla::layers::CompositorOptions& aCompositorOptions,
const bool& aLayersConnected,
PRenderFrameChild* aRenderFrame) override;
virtual mozilla::ipc::IPCResult
RecvUpdateDimensions(const mozilla::dom::DimensionInfo& aDimensionInfo) override;
virtual mozilla::ipc::IPCResult
RecvSizeModeChanged(const nsSizeMode& aSizeMode) override;
@@ -533,19 +533,19 @@ public:
GetFrom(mozIDOMWindowProxy* aWindow)
{
nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(aWindow);
nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(webNav);
return GetFrom(docShell);
}
static TabChild* GetFrom(nsIPresShell* aPresShell);
- static TabChild* GetFrom(uint64_t aLayersId);
+ static TabChild* GetFrom(layers::LayersId aLayersId);
- uint64_t LayersId() { return mLayersId; }
+ layers::LayersId GetLayersId() { return mLayersId; }
Maybe<bool> IsLayersConnected() { return mLayersConnected; }
void DidComposite(uint64_t aTransactionId,
const TimeStamp& aCompositeStart,
const TimeStamp& aCompositeEnd);
void DidRequestComposite(const TimeStamp& aCompositeReqStart,
const TimeStamp& aCompositeReqEnd);
@@ -613,17 +613,17 @@ public:
const mozilla::layers::CompositorOptions& GetCompositorOptions() const;
bool AsyncPanZoomEnabled() const;
virtual ScreenIntSize GetInnerSize() override;
// Call RecvShow(nsIntSize(0, 0)) and block future calls to RecvShow().
void DoFakeShow(const TextureFactoryIdentifier& aTextureFactoryIdentifier,
- const uint64_t& aLayersId,
+ const layers::LayersId& aLayersId,
const mozilla::layers::CompositorOptions& aCompositorOptions,
PRenderFrameChild* aRenderFrame,
const ShowInfo& aShowInfo);
void ContentReceivedInputBlock(const ScrollableLayerGuid& aGuid,
uint64_t aInputBlockId,
bool aPreventDefault) const;
void SetTargetAPZC(uint64_t aInputBlockId,
@@ -769,17 +769,17 @@ private:
// Update the frameType on our docshell.
void UpdateFrameType();
void ActorDestroy(ActorDestroyReason why) override;
bool InitTabChildGlobal();
void InitRenderingState(const TextureFactoryIdentifier& aTextureFactoryIdentifier,
- const uint64_t& aLayersId,
+ const layers::LayersId& aLayersId,
const mozilla::layers::CompositorOptions& aCompositorOptions,
PRenderFrameChild* aRenderFrame);
void InitAPZState();
void DestroyWindow();
void ApplyShowInfo(const ShowInfo& aInfo);
@@ -825,17 +825,17 @@ private:
RefPtr<mozilla::dom::TabGroup> mTabGroup;
RefPtr<PuppetWidget> mPuppetWidget;
nsCOMPtr<nsIURI> mLastURI;
RenderFrameChild* mRemoteFrame;
RefPtr<nsIContentChild> mManager;
uint32_t mChromeFlags;
uint32_t mMaxTouchPoints;
int32_t mActiveSuppressDisplayport;
- uint64_t mLayersId;
+ layers::LayersId mLayersId;
int64_t mBeforeUnloadListeners;
CSSRect mUnscaledOuterRect;
nscolor mLastBackgroundColor;
Maybe<bool> mLayersConnected;
bool mDidFakeShow;
bool mNotified;
bool mTriedBrowserInit;
ScreenOrientationInternal mOrientation;
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -183,40 +183,40 @@ TabParent::TabParent(nsIContentParent* a
mIsReadyToHandleInputEvents = !ContentParent::IsInputEventQueueSupported();
}
TabParent::~TabParent()
{
}
TabParent*
-TabParent::GetTabParentFromLayersId(uint64_t aLayersId)
+TabParent::GetTabParentFromLayersId(layers::LayersId aLayersId)
{
if (!sLayerToTabParentTable) {
return nullptr;
}
- return sLayerToTabParentTable->Get(aLayersId);
+ return sLayerToTabParentTable->Get(uint64_t(aLayersId));
}
void
-TabParent::AddTabParentToTable(uint64_t aLayersId, TabParent* aTabParent)
+TabParent::AddTabParentToTable(layers::LayersId aLayersId, TabParent* aTabParent)
{
if (!sLayerToTabParentTable) {
sLayerToTabParentTable = new LayerToTabParentTable();
}
- sLayerToTabParentTable->Put(aLayersId, aTabParent);
+ sLayerToTabParentTable->Put(uint64_t(aLayersId), aTabParent);
}
void
-TabParent::RemoveTabParentFromTable(uint64_t aLayersId)
+TabParent::RemoveTabParentFromTable(layers::LayersId aLayersId)
{
if (!sLayerToTabParentTable) {
return;
}
- sLayerToTabParentTable->Remove(aLayersId);
+ sLayerToTabParentTable->Remove(uint64_t(aLayersId));
if (sLayerToTabParentTable->Count() == 0) {
delete sLayerToTabParentTable;
sLayerToTabParentTable = nullptr;
}
}
void
TabParent::CacheFrameLoader(nsFrameLoader* aFrameLoader)
@@ -629,17 +629,17 @@ TabParent::InitRenderFrame()
// be created here. If TabParent is initialized by child side,
// child side will create RenderFrame.
MOZ_ASSERT(!GetRenderFrame());
RefPtr<nsFrameLoader> frameLoader = GetFrameLoader();
MOZ_ASSERT(frameLoader);
if (frameLoader) {
RenderFrameParent* renderFrame = new RenderFrameParent(frameLoader);
MOZ_ASSERT(renderFrame->IsInitted());
- uint64_t layersId = renderFrame->GetLayersId();
+ layers::LayersId layersId = renderFrame->GetLayersId();
AddTabParentToTable(layersId, this);
if (!SendPRenderFrameConstructor(renderFrame)) {
return;
}
TextureFactoryIdentifier textureFactoryIdentifier;
renderFrame->GetTextureFactoryIdentifier(&textureFactoryIdentifier);
Unused << SendInitRendering(textureFactoryIdentifier, layersId,
@@ -2622,17 +2622,17 @@ TabParent::DeallocPColorPickerParent(PCo
PRenderFrameParent*
TabParent::AllocPRenderFrameParent()
{
MOZ_ASSERT(ManagedPRenderFrameParent().IsEmpty());
RefPtr<nsFrameLoader> frameLoader = GetFrameLoader();
RenderFrameParent* rfp = new RenderFrameParent(frameLoader);
if (rfp->IsInitted()) {
- uint64_t layersId = rfp->GetLayersId();
+ layers::LayersId layersId = rfp->GetLayersId();
AddTabParentToTable(layersId, this);
}
return rfp;
}
bool
TabParent::DeallocPRenderFrameParent(PRenderFrameParent* aFrame)
{
@@ -2656,25 +2656,25 @@ TabParent::SetRenderFrame(PRenderFramePa
RenderFrameParent* renderFrame = static_cast<RenderFrameParent*>(aRFParent);
bool success = renderFrame->Init(frameLoader);
if (!success) {
return false;
}
frameLoader->MaybeShowFrame();
- uint64_t layersId = renderFrame->GetLayersId();
+ layers::LayersId layersId = renderFrame->GetLayersId();
AddTabParentToTable(layersId, this);
return true;
}
bool
TabParent::GetRenderFrameInfo(TextureFactoryIdentifier* aTextureFactoryIdentifier,
- uint64_t* aLayersId)
+ layers::LayersId* aLayersId)
{
RenderFrameParent* rfp = GetRenderFrame();
if (!rfp) {
return false;
}
*aLayersId = rfp->GetLayersId();
rfp->GetTextureFactoryIdentifier(aTextureFactoryIdentifier);
@@ -2781,17 +2781,17 @@ TabParent::RecvBrowserFrameOpenWindow(PB
PRenderFrameParent* aRenderFrame,
const nsString& aURL,
const nsString& aName,
const nsString& aFeatures,
BrowserFrameOpenWindowResolver&& aResolve)
{
CreatedWindowInfo cwi;
cwi.rv() = NS_OK;
- cwi.layersId() = 0;
+ cwi.layersId() = LayersId{0};
cwi.maxTouchPoints() = 0;
BrowserElementParent::OpenWindowResult opened =
BrowserElementParent::OpenWindowOOP(TabParent::GetFrom(aOpener),
this, aRenderFrame, aURL, aName, aFeatures,
&cwi.textureFactoryIdentifier(),
&cwi.layersId());
cwi.compositorOptions() =
@@ -3462,17 +3462,17 @@ TabParent::StartApzAutoscroll(float aAnc
{
if (!AsyncPanZoomEnabled()) {
*aOutRetval = false;
return NS_OK;
}
bool success = false;
if (RenderFrameParent* renderFrame = GetRenderFrame()) {
- uint64_t layersId = renderFrame->GetLayersId();
+ layers::LayersId layersId = renderFrame->GetLayersId();
if (nsCOMPtr<nsIWidget> widget = GetWidget()) {
ScrollableLayerGuid guid{layersId, aPresShellId, aScrollId};
// The anchor coordinates that are passed in are relative to the origin
// of the screen, but we are sending them to APZ which only knows about
// coordinates relative to the widget, so convert them accordingly.
CSSPoint anchorCss{aAnchorX, aAnchorY};
LayoutDeviceIntPoint anchor = RoundedToInt(anchorCss * widget->GetDefaultScale());
@@ -3490,17 +3490,17 @@ TabParent::StartApzAutoscroll(float aAnc
NS_IMETHODIMP
TabParent::StopApzAutoscroll(nsViewID aScrollId, uint32_t aPresShellId)
{
if (!AsyncPanZoomEnabled()) {
return NS_OK;
}
if (RenderFrameParent* renderFrame = GetRenderFrame()) {
- uint64_t layersId = renderFrame->GetLayersId();
+ layers::LayersId layersId = renderFrame->GetLayersId();
if (nsCOMPtr<nsIWidget> widget = GetWidget()) {
ScrollableLayerGuid guid{layersId, aPresShellId, aScrollId};
widget->StopAsyncAutoscroll(guid);
}
}
return NS_OK;
}
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -577,17 +577,17 @@ public:
bool TakeDragVisualization(RefPtr<mozilla::gfx::SourceSurface>& aSurface,
LayoutDeviceIntRect* aDragRect);
layout::RenderFrameParent* GetRenderFrame();
bool SetRenderFrame(PRenderFrameParent* aRFParent);
bool GetRenderFrameInfo(TextureFactoryIdentifier* aTextureFactoryIdentifier,
- uint64_t* aLayersId);
+ layers::LayersId* aLayersId);
mozilla::ipc::IPCResult RecvEnsureLayersConnected(CompositorOptions* aCompositorOptions) override;
// LiveResizeListener implementation
void LiveResizeStarted() override;
void LiveResizeStopped() override;
void SetReadyToHandleInputEvents() { mIsReadyToHandleInputEvents = true; }
@@ -748,19 +748,19 @@ private:
ShowInfo GetShowInfo();
private:
// This is used when APZ needs to find the TabParent associated with a layer
// to dispatch events.
typedef nsDataHashtable<nsUint64HashKey, TabParent*> LayerToTabParentTable;
static LayerToTabParentTable* sLayerToTabParentTable;
- static void AddTabParentToTable(uint64_t aLayersId, TabParent* aTabParent);
+ static void AddTabParentToTable(layers::LayersId aLayersId, TabParent* aTabParent);
- static void RemoveTabParentFromTable(uint64_t aLayersId);
+ static void RemoveTabParentFromTable(layers::LayersId aLayersId);
uint64_t mLayerTreeEpoch;
// If this flag is set, then the tab's layers will be preserved even when
// the tab's docshell is inactive.
bool mPreserveLayers;
// Holds the most recent value passed to the RenderLayers function. This
@@ -784,17 +784,17 @@ private:
bool mIsReadyToHandleInputEvents;
// True if we suppress the eMouseEnterIntoWidget event due to the TabChild was
// not ready to handle it. We will resend it when the next time we fire a
// mouse event and the TabChild is ready.
bool mIsMouseEnterIntoWidgetEventSuppressed;
public:
- static TabParent* GetTabParentFromLayersId(uint64_t aLayersId);
+ static TabParent* GetTabParentFromLayersId(layers::LayersId aLayersId);
};
struct MOZ_STACK_CLASS TabParent::AutoUseNewTab final
{
public:
AutoUseNewTab(TabParent* aNewTab, nsCString* aURLToLoad)
: mNewTab(aNewTab), mURLToLoad(aURLToLoad)
{
--- a/gfx/ipc/CompositorSession.cpp
+++ b/gfx/ipc/CompositorSession.cpp
@@ -15,17 +15,17 @@ namespace mozilla {
namespace layers {
using namespace gfx;
using namespace widget;
CompositorSession::CompositorSession(CompositorWidgetDelegate* aDelegate,
CompositorBridgeChild* aChild,
- const uint64_t& aRootLayerTreeId)
+ const LayersId& aRootLayerTreeId)
: mCompositorWidgetDelegate(aDelegate),
mCompositorBridgeChild(aChild),
mRootLayerTreeId(aRootLayerTreeId)
{
}
CompositorSession::~CompositorSession()
{
--- a/gfx/ipc/CompositorSession.h
+++ b/gfx/ipc/CompositorSession.h
@@ -62,17 +62,17 @@ public:
CompositorBridgeChild* GetCompositorBridgeChild();
// Return the proxy for accessing the compositor's widget.
CompositorWidgetDelegate* GetCompositorWidgetDelegate() {
return mCompositorWidgetDelegate;
}
// Return the id of the root layer tree.
- uint64_t RootLayerTreeId() const {
+ LayersId RootLayerTreeId() const {
return mRootLayerTreeId;
}
#if defined(MOZ_WIDGET_ANDROID)
// Set the UiCompositorControllerChild after Session creation so the Session constructor
// doesn't get mucked up for other platforms.
void SetUiCompositorControllerChild(RefPtr<UiCompositorControllerChild> aUiController) {
mUiCompositorControllerChild = aUiController;
@@ -80,23 +80,23 @@ public:
RefPtr<UiCompositorControllerChild> GetUiCompositorControllerChild() {
return mUiCompositorControllerChild;
}
#endif // defined(MOZ_WIDGET_ANDROID)
protected:
CompositorSession(CompositorWidgetDelegate* aDelegate,
CompositorBridgeChild* aChild,
- const uint64_t& aRootLayerTreeId);
+ const LayersId& aRootLayerTreeId);
virtual ~CompositorSession();
protected:
CompositorWidgetDelegate* mCompositorWidgetDelegate;
RefPtr<CompositorBridgeChild> mCompositorBridgeChild;
- uint64_t mRootLayerTreeId;
+ LayersId mRootLayerTreeId;
#if defined(MOZ_WIDGET_ANDROID)
RefPtr<UiCompositorControllerChild> mUiCompositorControllerChild;
#endif // defined(MOZ_WIDGET_ANDROID)
private:
DISALLOW_COPY_AND_ASSIGN(CompositorSession);
};
} // namespace layers
--- a/gfx/ipc/CompositorWidgetVsyncObserver.cpp
+++ b/gfx/ipc/CompositorWidgetVsyncObserver.cpp
@@ -7,17 +7,17 @@
#include "CompositorWidgetVsyncObserver.h"
#include "mozilla/gfx/VsyncBridgeChild.h"
namespace mozilla {
namespace widget {
CompositorWidgetVsyncObserver::CompositorWidgetVsyncObserver(
RefPtr<VsyncBridgeChild> aVsyncBridge,
- const uint64_t& aRootLayerTreeId)
+ const layers::LayersId& aRootLayerTreeId)
: mVsyncBridge(aVsyncBridge),
mRootLayerTreeId(aRootLayerTreeId)
{
MOZ_ASSERT(XRE_IsParentProcess());
MOZ_ASSERT(NS_IsMainThread());
}
bool
--- a/gfx/ipc/CompositorWidgetVsyncObserver.h
+++ b/gfx/ipc/CompositorWidgetVsyncObserver.h
@@ -2,36 +2,37 @@
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_gfx_ipc_CompositorWidgetVsyncObserver_h
#define mozilla_gfx_ipc_CompositorWidgetVsyncObserver_h
+#include "mozilla/layers/LayersTypes.h"
#include "mozilla/VsyncDispatcher.h"
namespace mozilla {
namespace gfx {
class VsyncBridgeChild;
} // namespace gfx
namespace widget {
class CompositorWidgetVsyncObserver : public VsyncObserver
{
typedef gfx::VsyncBridgeChild VsyncBridgeChild;
public:
CompositorWidgetVsyncObserver(RefPtr<VsyncBridgeChild> aVsyncBridge,
- const uint64_t& aRootLayerTreeId);
+ const layers::LayersId& aRootLayerTreeId);
bool NotifyVsync(TimeStamp aVsyncTimestamp) override;
private:
RefPtr<VsyncBridgeChild> mVsyncBridge;
- uint64_t mRootLayerTreeId;
+ layers::LayersId mRootLayerTreeId;
};
} // namespace widget
} // namespace mozilla
#endif // mozilla_gfx_ipc_CompositorWidgetVsyncObserver_h
--- a/gfx/ipc/GPUChild.cpp
+++ b/gfx/ipc/GPUChild.cpp
@@ -68,17 +68,17 @@ GPUChild::Init()
DevicePrefs devicePrefs;
devicePrefs.hwCompositing() = gfxConfig::GetValue(Feature::HW_COMPOSITING);
devicePrefs.d3d11Compositing() = gfxConfig::GetValue(Feature::D3D11_COMPOSITING);
devicePrefs.oglCompositing() = gfxConfig::GetValue(Feature::OPENGL_COMPOSITING);
devicePrefs.advancedLayers() = gfxConfig::GetValue(Feature::ADVANCED_LAYERS);
devicePrefs.useD2D1() = gfxConfig::GetValue(Feature::DIRECT2D);
nsTArray<LayerTreeIdMapping> mappings;
- LayerTreeOwnerTracker::Get()->Iterate([&](uint64_t aLayersId, base::ProcessId aProcessId) {
+ LayerTreeOwnerTracker::Get()->Iterate([&](LayersId aLayersId, base::ProcessId aProcessId) {
mappings.AppendElement(LayerTreeIdMapping(aLayersId, aProcessId));
});
SendInit(prefs, updates, devicePrefs, mappings);
gfxVars::AddReceiver(this);
#ifdef MOZ_GECKO_PROFILER
@@ -106,17 +106,17 @@ GPUChild::EnsureGPUReady()
gfxPlatform::GetPlatform()->ImportGPUDeviceData(data);
Telemetry::AccumulateTimeDelta(Telemetry::GPU_PROCESS_LAUNCH_TIME_MS_2, mHost->GetLaunchTime());
mGPUReady = true;
return true;
}
PAPZInputBridgeChild*
-GPUChild::AllocPAPZInputBridgeChild(const uint64_t& aLayersId)
+GPUChild::AllocPAPZInputBridgeChild(const LayersId& aLayersId)
{
APZInputBridgeChild* child = new APZInputBridgeChild();
child->AddRef();
return child;
}
bool
GPUChild::DeallocPAPZInputBridgeChild(PAPZInputBridgeChild* aActor)
--- a/gfx/ipc/GPUChild.h
+++ b/gfx/ipc/GPUChild.h
@@ -32,17 +32,17 @@ class GPUChild final
public:
explicit GPUChild(GPUProcessHost* aHost);
~GPUChild();
void Init();
bool EnsureGPUReady();
- PAPZInputBridgeChild* AllocPAPZInputBridgeChild(const uint64_t& aLayersId) override;
+ PAPZInputBridgeChild* AllocPAPZInputBridgeChild(const LayersId& aLayersId) override;
bool DeallocPAPZInputBridgeChild(PAPZInputBridgeChild* aActor) override;
// gfxVarReceiver overrides.
void OnVarChanged(const GfxVarUpdate& aVar) override;
// PGPUChild overrides.
mozilla::ipc::IPCResult RecvInitComplete(const GPUDeviceData& aData) override;
mozilla::ipc::IPCResult RecvReportCheckerboard(const uint32_t& aSeverity, const nsCString& aLog) override;
--- a/gfx/ipc/GPUParent.cpp
+++ b/gfx/ipc/GPUParent.cpp
@@ -159,17 +159,17 @@ GPUParent::NotifyDeviceReset()
// Notify the main process that there's been a device reset
// and that they should reset their compositors and repaint
GPUDeviceData data;
RecvGetDeviceStatus(&data);
Unused << SendNotifyDeviceReset(data);
}
PAPZInputBridgeParent*
-GPUParent::AllocPAPZInputBridgeParent(const uint64_t& aLayersId)
+GPUParent::AllocPAPZInputBridgeParent(const LayersId& aLayersId)
{
APZInputBridgeParent* parent = new APZInputBridgeParent(aLayersId);
parent->AddRef();
return parent;
}
bool
GPUParent::DeallocPAPZInputBridgeParent(PAPZInputBridgeParent* aActor)
@@ -289,17 +289,17 @@ GPUParent::RecvInitImageBridge(Endpoint<
mozilla::ipc::IPCResult
GPUParent::RecvInitVRManager(Endpoint<PVRManagerParent>&& aEndpoint)
{
VRManagerParent::CreateForGPUProcess(Move(aEndpoint));
return IPC_OK();
}
mozilla::ipc::IPCResult
-GPUParent::RecvInitUiCompositorController(const uint64_t& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint)
+GPUParent::RecvInitUiCompositorController(const LayersId& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint)
{
UiCompositorControllerParent::Start(aRootLayerTreeId, Move(aEndpoint));
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvInitProfiler(Endpoint<PProfilerChild>&& aEndpoint)
{
--- a/gfx/ipc/GPUParent.h
+++ b/gfx/ipc/GPUParent.h
@@ -26,28 +26,28 @@ public:
static GPUParent* GetSingleton();
bool Init(base::ProcessId aParentPid,
MessageLoop* aIOLoop,
IPC::Channel* aChannel);
void NotifyDeviceReset();
- PAPZInputBridgeParent* AllocPAPZInputBridgeParent(const uint64_t& aLayersId) override;
+ PAPZInputBridgeParent* AllocPAPZInputBridgeParent(const LayersId& aLayersId) override;
bool DeallocPAPZInputBridgeParent(PAPZInputBridgeParent* aActor) override;
mozilla::ipc::IPCResult RecvInit(nsTArray<GfxPrefSetting>&& prefs,
nsTArray<GfxVarUpdate>&& vars,
const DevicePrefs& devicePrefs,
nsTArray<LayerTreeIdMapping>&& mappings) override;
mozilla::ipc::IPCResult RecvInitCompositorManager(Endpoint<PCompositorManagerParent>&& aEndpoint) override;
mozilla::ipc::IPCResult RecvInitVsyncBridge(Endpoint<PVsyncBridgeParent>&& aVsyncEndpoint) override;
mozilla::ipc::IPCResult RecvInitImageBridge(Endpoint<PImageBridgeParent>&& aEndpoint) override;
mozilla::ipc::IPCResult RecvInitVRManager(Endpoint<PVRManagerParent>&& aEndpoint) override;
- mozilla::ipc::IPCResult RecvInitUiCompositorController(const uint64_t& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint) override;
+ mozilla::ipc::IPCResult RecvInitUiCompositorController(const LayersId& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint) override;
mozilla::ipc::IPCResult RecvInitProfiler(Endpoint<PProfilerChild>&& aEndpoint) override;
mozilla::ipc::IPCResult RecvUpdatePref(const GfxPrefSetting& pref) override;
mozilla::ipc::IPCResult RecvUpdateVar(const GfxVarUpdate& pref) override;
mozilla::ipc::IPCResult RecvNewContentCompositorManager(Endpoint<PCompositorManagerParent>&& aEndpoint) override;
mozilla::ipc::IPCResult RecvNewContentImageBridge(Endpoint<PImageBridgeParent>&& aEndpoint) override;
mozilla::ipc::IPCResult RecvNewContentVRManager(Endpoint<PVRManagerParent>&& aEndpoint) override;
mozilla::ipc::IPCResult RecvNewContentVideoDecoderManager(Endpoint<PVideoDecoderManagerParent>&& aEndpoint) override;
mozilla::ipc::IPCResult RecvGetDeviceStatus(GPUDeviceData* aOutStatus) override;
--- a/gfx/ipc/GPUProcessManager.cpp
+++ b/gfx/ipc/GPUProcessManager.cpp
@@ -311,17 +311,17 @@ GPUProcessManager::EnsureVRManager()
}
mGPUChild->SendInitVRManager(Move(parentPipe));
VRManagerChild::InitWithGPUProcess(Move(childPipe));
}
#if defined(MOZ_WIDGET_ANDROID)
already_AddRefed<UiCompositorControllerChild>
-GPUProcessManager::CreateUiCompositorController(nsBaseWidget* aWidget, const uint64_t aId)
+GPUProcessManager::CreateUiCompositorController(nsBaseWidget* aWidget, const LayersId aId)
{
RefPtr<UiCompositorControllerChild> result;
if (!EnsureGPUReady()) {
result = UiCompositorControllerChild::CreateForSameProcess(aId);
} else {
ipc::Endpoint<PUiCompositorControllerParent> parentPipe;
ipc::Endpoint<PUiCompositorControllerChild> childPipe;
@@ -731,17 +731,17 @@ GPUProcessManager::CreateTopLevelComposi
CSSToLayoutDeviceScale aScale,
const CompositorOptions& aOptions,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize,
bool* aRetryOut)
{
MOZ_ASSERT(aRetryOut);
- uint64_t layerTreeId = AllocateLayerTreeId();
+ LayersId layerTreeId = AllocateLayerTreeId();
EnsureProtocolsReady();
RefPtr<CompositorSession> session;
if (EnsureGPUReady()) {
session = CreateRemoteSession(
aWidget,
@@ -779,17 +779,17 @@ GPUProcessManager::CreateTopLevelComposi
*aRetryOut = false;
return session.forget();
}
RefPtr<CompositorSession>
GPUProcessManager::CreateRemoteSession(nsBaseWidget* aWidget,
LayerManager* aLayerManager,
- const uint64_t& aRootLayerTreeId,
+ const LayersId& aRootLayerTreeId,
CSSToLayoutDeviceScale aScale,
const CompositorOptions& aOptions,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize)
{
#ifdef MOZ_WIDGET_SUPPORTS_OOP_COMPOSITING
CompositorWidgetInitData initData;
aWidget->GetCompositorWidgetInitData(&initData);
@@ -817,17 +817,17 @@ GPUProcessManager::CreateRemoteSession(n
return nullptr;
}
if (!child->SendInitialize(aRootLayerTreeId)) {
return nullptr;
}
RefPtr<APZCTreeManagerChild> apz = nullptr;
if (aOptions.UseAPZ()) {
- PAPZCTreeManagerChild* papz = child->SendPAPZCTreeManagerConstructor(0);
+ PAPZCTreeManagerChild* papz = child->SendPAPZCTreeManagerConstructor(LayersId{0});
if (!papz) {
return nullptr;
}
apz = static_cast<APZCTreeManagerChild*>(papz);
PAPZInputBridgeChild* pinput = mGPUChild->SendPAPZInputBridgeConstructor(aRootLayerTreeId);
if (!pinput) {
return nullptr;
@@ -1000,76 +1000,76 @@ GPUProcessManager::CreateContentVideoDec
}
mGPUChild->SendNewContentVideoDecoderManager(Move(parentPipe));
*aOutEndpoint = Move(childPipe);
}
void
-GPUProcessManager::MapLayerTreeId(uint64_t aLayersId, base::ProcessId aOwningId)
+GPUProcessManager::MapLayerTreeId(LayersId aLayersId, base::ProcessId aOwningId)
{
LayerTreeOwnerTracker::Get()->Map(aLayersId, aOwningId);
if (EnsureGPUReady()) {
mGPUChild->SendAddLayerTreeIdMapping(LayerTreeIdMapping(aLayersId, aOwningId));
}
}
void
-GPUProcessManager::UnmapLayerTreeId(uint64_t aLayersId, base::ProcessId aOwningId)
+GPUProcessManager::UnmapLayerTreeId(LayersId aLayersId, base::ProcessId aOwningId)
{
LayerTreeOwnerTracker::Get()->Unmap(aLayersId, aOwningId);
if (EnsureGPUReady()) {
mGPUChild->SendRemoveLayerTreeIdMapping(LayerTreeIdMapping(aLayersId, aOwningId));
return;
}
CompositorBridgeParent::DeallocateLayerTreeId(aLayersId);
}
bool
-GPUProcessManager::IsLayerTreeIdMapped(uint64_t aLayersId, base::ProcessId aRequestingId)
+GPUProcessManager::IsLayerTreeIdMapped(LayersId aLayersId, base::ProcessId aRequestingId)
{
return LayerTreeOwnerTracker::Get()->IsMapped(aLayersId, aRequestingId);
}
-uint64_t
+LayersId
GPUProcessManager::AllocateLayerTreeId()
{
// Allocate tree id by using id namespace.
// By it, tree id does not conflict with external image id and
// async image pipeline id.
MOZ_ASSERT(NS_IsMainThread());
++mResourceId;
if (mResourceId == UINT32_MAX) {
// Move to next id namespace.
mIdNamespace = AllocateNamespace();
mResourceId = 1;
}
uint64_t layerTreeId = mIdNamespace;
layerTreeId = (layerTreeId << 32) | mResourceId;
- return layerTreeId;
+ return LayersId{layerTreeId};
}
uint32_t
GPUProcessManager::AllocateNamespace()
{
MOZ_ASSERT(NS_IsMainThread());
return ++mNextNamespace;
}
bool
GPUProcessManager::AllocateAndConnectLayerTreeId(PCompositorBridgeChild* aCompositorBridge,
base::ProcessId aOtherPid,
- uint64_t* aOutLayersId,
+ LayersId* aOutLayersId,
CompositorOptions* aOutCompositorOptions)
{
- uint64_t layersId = AllocateLayerTreeId();
+ LayersId layersId = AllocateLayerTreeId();
*aOutLayersId = layersId;
if (!mGPUChild || !aCompositorBridge) {
// If we're not remoting to another process, or there is no compositor,
// then we'll send at most one message. In this case we can just keep
// the old behavior of making sure the mapping occurs, and maybe sending
// a creation notification.
MapLayerTreeId(layersId, aOtherPid);
--- a/gfx/ipc/GPUProcessManager.h
+++ b/gfx/ipc/GPUProcessManager.h
@@ -11,16 +11,17 @@
#include "Units.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/dom/ipc/IdType.h"
#include "mozilla/gfx/GPUProcessHost.h"
#include "mozilla/gfx/Point.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/TaskFactory.h"
#include "mozilla/ipc/Transport.h"
+#include "mozilla/layers/LayersTypes.h"
#include "mozilla/webrender/WebRenderTypes.h"
#include "nsIObserverService.h"
#include "nsThreadUtils.h"
class nsBaseWidget;
namespace mozilla {
class MemoryReportingProcess;
@@ -63,16 +64,17 @@ class GPUProcessManager final : public G
friend class layers::RemoteCompositorSession;
friend class layers::InProcessCompositorSession;
typedef layers::CompositorOptions CompositorOptions;
typedef layers::CompositorSession CompositorSession;
typedef layers::CompositorUpdateObserver CompositorUpdateObserver;
typedef layers::IAPZCTreeManager IAPZCTreeManager;
typedef layers::LayerManager LayerManager;
+ typedef layers::LayersId LayersId;
typedef layers::PCompositorBridgeChild PCompositorBridgeChild;
typedef layers::PCompositorManagerChild PCompositorManagerChild;
typedef layers::PImageBridgeChild PImageBridgeChild;
typedef layers::RemoteCompositorSession RemoteCompositorSession;
typedef layers::InProcessCompositorSession InProcessCompositorSession;
typedef layers::UiCompositorControllerChild UiCompositorControllerChild;
public:
@@ -104,45 +106,45 @@ public:
mozilla::ipc::Endpoint<PCompositorManagerChild>* aOutCompositor,
mozilla::ipc::Endpoint<PImageBridgeChild>* aOutImageBridge,
mozilla::ipc::Endpoint<PVRManagerChild>* aOutVRBridge,
mozilla::ipc::Endpoint<dom::PVideoDecoderManagerChild>* aOutVideoManager,
nsTArray<uint32_t>* aNamespaces);
// Maps the layer tree and process together so that aOwningPID is allowed
// to access aLayersId across process.
- void MapLayerTreeId(uint64_t aLayersId, base::ProcessId aOwningId);
+ void MapLayerTreeId(LayersId aLayersId, base::ProcessId aOwningId);
// Release compositor-thread resources referred to by |aID|.
//
// Must run on the content main thread.
- void UnmapLayerTreeId(uint64_t aLayersId, base::ProcessId aOwningId);
+ void UnmapLayerTreeId(LayersId aLayersId, base::ProcessId aOwningId);
// Checks to see if aLayersId and aRequestingPID have been mapped by MapLayerTreeId
- bool IsLayerTreeIdMapped(uint64_t aLayersId, base::ProcessId aRequestingId);
+ bool IsLayerTreeIdMapped(LayersId aLayersId, base::ProcessId aRequestingId);
// Allocate an ID that can be used to refer to a layer tree and
// associated resources that live only on the compositor thread.
//
// Must run on the browser main thread.
- uint64_t AllocateLayerTreeId();
+ LayersId AllocateLayerTreeId();
// Allocate an ID that can be used as Namespace and
// Must run on the browser main thread.
uint32_t AllocateNamespace();
// Allocate a layers ID and connect it to a compositor. If the compositor is null,
// the connect operation will not be performed, but an ID will still be allocated.
// This must be called from the browser main thread.
//
// Note that a layer tree id is always allocated, even if this returns false.
bool AllocateAndConnectLayerTreeId(
PCompositorBridgeChild* aCompositorBridge,
base::ProcessId aOtherPid,
- uint64_t* aOutLayersId,
+ LayersId* aOutLayersId,
CompositorOptions* aOutCompositorOptions);
// Destroy and recreate all of the compositors
void ResetCompositors();
void OnProcessLaunchComplete(GPUProcessHost* aHost) override;
void OnProcessUnexpectedShutdown(GPUProcessHost* aHost) override;
void SimulateDeviceReset();
@@ -225,23 +227,23 @@ private:
void ShutdownVsyncIOThread();
void EnsureProtocolsReady();
void EnsureCompositorManagerChild();
void EnsureImageBridgeChild();
void EnsureVRManager();
#if defined(MOZ_WIDGET_ANDROID)
- already_AddRefed<UiCompositorControllerChild> CreateUiCompositorController(nsBaseWidget* aWidget, const uint64_t aId);
+ already_AddRefed<UiCompositorControllerChild> CreateUiCompositorController(nsBaseWidget* aWidget, const LayersId aId);
#endif // defined(MOZ_WIDGET_ANDROID)
RefPtr<CompositorSession> CreateRemoteSession(
nsBaseWidget* aWidget,
LayerManager* aLayerManager,
- const uint64_t& aRootLayerTreeId,
+ const LayersId& aRootLayerTreeId,
CSSToLayoutDeviceScale aScale,
const CompositorOptions& aOptions,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize);
DISALLOW_COPY_AND_ASSIGN(GPUProcessManager);
class Observer final : public nsIObserver {
--- a/gfx/ipc/InProcessCompositorSession.cpp
+++ b/gfx/ipc/InProcessCompositorSession.cpp
@@ -22,17 +22,17 @@ InProcessCompositorSession::InProcessCom
mCompositorWidget(aWidget)
{
GPUProcessManager::Get()->RegisterInProcessSession(this);
}
/* static */ RefPtr<InProcessCompositorSession>
InProcessCompositorSession::Create(nsBaseWidget* aWidget,
LayerManager* aLayerManager,
- const uint64_t& aRootLayerTreeId,
+ const LayersId& aRootLayerTreeId,
CSSToLayoutDeviceScale aScale,
const CompositorOptions& aOptions,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize,
uint32_t aNamespace)
{
CompositorWidgetInitData initData;
aWidget->GetCompositorWidgetInitData(&initData);
--- a/gfx/ipc/InProcessCompositorSession.h
+++ b/gfx/ipc/InProcessCompositorSession.h
@@ -18,17 +18,17 @@ class CompositorOptions;
// A CompositorSession where both the child and parent CompositorBridge reside
// in the same process.
class InProcessCompositorSession final : public CompositorSession
{
public:
static RefPtr<InProcessCompositorSession> Create(
nsBaseWidget* baseWidget,
LayerManager* aLayerManager,
- const uint64_t& aRootLayerTreeId,
+ const LayersId& aRootLayerTreeId,
CSSToLayoutDeviceScale aScale,
const CompositorOptions& aOptions,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize,
uint32_t aNamespace);
CompositorBridgeParent* GetInProcessBridge() const override;
void SetContentController(GeckoContentController* aController) override;
--- a/gfx/ipc/PGPU.ipdl
+++ b/gfx/ipc/PGPU.ipdl
@@ -20,16 +20,17 @@ using mozilla::dom::NativeThreadId from
using mozilla::Telemetry::HistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedHistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ScalarAction from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedScalarAction from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ChildEventData from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::DiscardedData from "mozilla/TelemetryComms.h";
using mozilla::gfx::Feature from "gfxFeature.h";
using mozilla::gfx::Fallback from "gfxFallback.h";
+using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
namespace mozilla {
namespace gfx {
union GfxPrefValue {
bool;
int32_t;
uint32_t;
@@ -38,43 +39,43 @@ union GfxPrefValue {
};
struct GfxPrefSetting {
int32_t index;
GfxPrefValue value;
};
struct LayerTreeIdMapping {
- uint64_t layersId;
+ LayersId layersId;
ProcessId ownerId;
};
// This protocol allows the UI process to talk to the GPU process. There is one
// instance of this protocol, with the GPUParent living on the main thread of
// the GPU process and the GPUChild living on the main thread of the UI process.
sync protocol PGPU
{
manages PAPZInputBridge;
parent:
// Sent from the UI process to initialize a new APZ input bridge when a new
// top-level compositor is created.
- async PAPZInputBridge(uint64_t aLayersId);
+ async PAPZInputBridge(LayersId aLayersId);
// Sent by the UI process to initiate core settings.
async Init(GfxPrefSetting[] prefs,
GfxVarUpdate[] vars,
DevicePrefs devicePrefs,
LayerTreeIdMapping[] mapping);
async InitCompositorManager(Endpoint<PCompositorManagerParent> endpoint);
async InitVsyncBridge(Endpoint<PVsyncBridgeParent> endpoint);
async InitImageBridge(Endpoint<PImageBridgeParent> endpoint);
async InitVRManager(Endpoint<PVRManagerParent> endpoint);
- async InitUiCompositorController(uint64_t rootLayerTreeId, Endpoint<PUiCompositorControllerParent> endpoint);
+ async InitUiCompositorController(LayersId rootLayerTreeId, Endpoint<PUiCompositorControllerParent> endpoint);
async InitProfiler(Endpoint<PProfilerChild> endpoint);
// Called to update a gfx preference or variable.
async UpdatePref(GfxPrefSetting pref);
async UpdateVar(GfxVarUpdate var);
// Create a new content-process compositor bridge.
async NewContentCompositorManager(Endpoint<PCompositorManagerParent> endpoint);
--- a/gfx/ipc/PVsyncBridge.ipdl
+++ b/gfx/ipc/PVsyncBridge.ipdl
@@ -1,22 +1,23 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
using class mozilla::TimeStamp from "mozilla/TimeStamp.h";
+using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
namespace mozilla {
namespace gfx {
// This protocol only serves one purpose: deliver vsync notifications from a
// dedicated thread in the UI process to the compositor thread in the
// compositor process. The child side exists in the UI process, and the
// parent side in the GPU process.
sync protocol PVsyncBridge
{
parent:
- async NotifyVsync(TimeStamp vsyncTimeStamp, uint64_t layersId);
+ async NotifyVsync(TimeStamp vsyncTimeStamp, LayersId layersId);
};
} // namespace gfx
} // namespace mozilla
--- a/gfx/ipc/RemoteCompositorSession.cpp
+++ b/gfx/ipc/RemoteCompositorSession.cpp
@@ -19,17 +19,17 @@ namespace layers {
using namespace gfx;
using namespace widget;
RemoteCompositorSession::RemoteCompositorSession(nsBaseWidget* aWidget,
CompositorBridgeChild* aChild,
CompositorWidgetDelegate* aWidgetDelegate,
APZCTreeManagerChild* aAPZ,
- const uint64_t& aRootLayerTreeId)
+ const LayersId& aRootLayerTreeId)
: CompositorSession(aWidgetDelegate, aChild, aRootLayerTreeId),
mWidget(aWidget),
mAPZ(aAPZ)
{
MOZ_ASSERT(!gfxPlatform::IsHeadless());
GPUProcessManager::Get()->RegisterRemoteProcessSession(this);
if (mAPZ) {
mAPZ->SetCompositorSession(this);
@@ -59,17 +59,17 @@ RemoteCompositorSession::GetInProcessBri
{
return nullptr;
}
void
RemoteCompositorSession::SetContentController(GeckoContentController* aController)
{
mContentController = aController;
- mCompositorBridgeChild->SendPAPZConstructor(new APZChild(aController), 0);
+ mCompositorBridgeChild->SendPAPZConstructor(new APZChild(aController), LayersId{0});
}
GeckoContentController*
RemoteCompositorSession::GetContentController()
{
return mContentController.get();
}
--- a/gfx/ipc/RemoteCompositorSession.h
+++ b/gfx/ipc/RemoteCompositorSession.h
@@ -15,17 +15,17 @@ namespace layers {
class RemoteCompositorSession final : public CompositorSession
{
public:
RemoteCompositorSession(nsBaseWidget* aWidget,
CompositorBridgeChild* aChild,
CompositorWidgetDelegate* aWidgetDelegate,
APZCTreeManagerChild* aAPZ,
- const uint64_t& aRootLayerTreeId);
+ const LayersId& aRootLayerTreeId);
~RemoteCompositorSession() override;
CompositorBridgeParent* GetInProcessBridge() const override;
void SetContentController(GeckoContentController* aController) override;
GeckoContentController* GetContentController();
nsIWidget* GetWidget() const;
RefPtr<IAPZCTreeManager> GetAPZCTreeManager() const override;
void Shutdown() override;
--- a/gfx/ipc/VsyncBridgeChild.cpp
+++ b/gfx/ipc/VsyncBridgeChild.cpp
@@ -55,52 +55,52 @@ VsyncBridgeChild::Open(Endpoint<PVsyncBr
AddRef();
}
class NotifyVsyncTask : public Runnable
{
public:
NotifyVsyncTask(RefPtr<VsyncBridgeChild> aVsyncBridge,
TimeStamp aTimeStamp,
- const uint64_t& aLayersId)
+ const layers::LayersId& aLayersId)
: Runnable("gfx::NotifyVsyncTask")
, mVsyncBridge(aVsyncBridge)
, mTimeStamp(aTimeStamp)
, mLayersId(aLayersId)
{}
NS_IMETHOD Run() override {
mVsyncBridge->NotifyVsyncImpl(mTimeStamp, mLayersId);
return NS_OK;
}
private:
RefPtr<VsyncBridgeChild> mVsyncBridge;
TimeStamp mTimeStamp;
- uint64_t mLayersId;
+ layers::LayersId mLayersId;
};
bool
VsyncBridgeChild::IsOnVsyncIOThread() const
{
return MessageLoop::current() == mLoop;
}
void
-VsyncBridgeChild::NotifyVsync(TimeStamp aTimeStamp, const uint64_t& aLayersId)
+VsyncBridgeChild::NotifyVsync(TimeStamp aTimeStamp, const layers::LayersId& aLayersId)
{
// This should be on the Vsync thread (not the Vsync I/O thread).
MOZ_ASSERT(!IsOnVsyncIOThread());
RefPtr<NotifyVsyncTask> task = new NotifyVsyncTask(this, aTimeStamp, aLayersId);
mLoop->PostTask(task.forget());
}
void
-VsyncBridgeChild::NotifyVsyncImpl(TimeStamp aTimeStamp, const uint64_t& aLayersId)
+VsyncBridgeChild::NotifyVsyncImpl(TimeStamp aTimeStamp, const layers::LayersId& aLayersId)
{
// This should be on the Vsync I/O thread.
MOZ_ASSERT(IsOnVsyncIOThread());
if (!mProcessToken) {
return;
}
SendNotifyVsync(aTimeStamp, aLayersId);
--- a/gfx/ipc/VsyncBridgeChild.h
+++ b/gfx/ipc/VsyncBridgeChild.h
@@ -26,27 +26,27 @@ public:
Endpoint<PVsyncBridgeChild>&& aEndpoint);
void Close();
void ActorDestroy(ActorDestroyReason aWhy) override;
void DeallocPVsyncBridgeChild() override;
void ProcessingError(Result aCode, const char* aReason) override;
- void NotifyVsync(TimeStamp aTimeStamp, const uint64_t& aLayersId);
+ void NotifyVsync(TimeStamp aTimeStamp, const layers::LayersId& aLayersId);
virtual void HandleFatalError(const char* aName, const char* aMsg) const override;
private:
VsyncBridgeChild(RefPtr<VsyncIOThreadHolder>, const uint64_t& aProcessToken);
~VsyncBridgeChild();
void Open(Endpoint<PVsyncBridgeChild>&& aEndpoint);
- void NotifyVsyncImpl(TimeStamp aTimeStamp, const uint64_t& aLayersId);
+ void NotifyVsyncImpl(TimeStamp aTimeStamp, const layers::LayersId& aLayersId);
bool IsOnVsyncIOThread() const;
private:
RefPtr<VsyncIOThreadHolder> mThread;
MessageLoop* mLoop;
uint64_t mProcessToken;
};
--- a/gfx/ipc/VsyncBridgeParent.cpp
+++ b/gfx/ipc/VsyncBridgeParent.cpp
@@ -43,17 +43,17 @@ VsyncBridgeParent::Open(Endpoint<PVsyncB
// We can't recover from this.
MOZ_CRASH("Failed to bind VsyncBridgeParent to endpoint");
}
AddRef();
mOpen = true;
}
mozilla::ipc::IPCResult
-VsyncBridgeParent::RecvNotifyVsync(const TimeStamp& aTimeStamp, const uint64_t& aLayersId)
+VsyncBridgeParent::RecvNotifyVsync(const TimeStamp& aTimeStamp, const LayersId& aLayersId)
{
CompositorBridgeParent::NotifyVsync(aTimeStamp, aLayersId);
return IPC_OK();
}
void
VsyncBridgeParent::Shutdown()
{
--- a/gfx/ipc/VsyncBridgeParent.h
+++ b/gfx/ipc/VsyncBridgeParent.h
@@ -18,17 +18,17 @@ namespace gfx {
class VsyncBridgeParent final : public PVsyncBridgeParent
{
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VsyncBridgeParent)
static RefPtr<VsyncBridgeParent> Start(Endpoint<PVsyncBridgeParent>&& aEndpoint);
- mozilla::ipc::IPCResult RecvNotifyVsync(const TimeStamp& vsyncTimeStamp, const uint64_t& aLayersId) override;
+ mozilla::ipc::IPCResult RecvNotifyVsync(const TimeStamp& vsyncTimeStamp, const LayersId& aLayersId) override;
void ActorDestroy(ActorDestroyReason aWhy) override;
void DeallocPVsyncBridgeParent() override;
void Shutdown();
private:
VsyncBridgeParent();
~VsyncBridgeParent();
--- a/gfx/layers/FrameMetrics.h
+++ b/gfx/layers/FrameMetrics.h
@@ -1035,36 +1035,36 @@ private:
* This class allows us to uniquely identify a scrollable layer. The
* mLayersId identifies the layer tree (corresponding to a child process
* and/or tab) that the scrollable layer belongs to. The mPresShellId
* is a temporal identifier (corresponding to the document loaded that
* contains the scrollable layer, which may change over time). The
* mScrollId corresponds to the actual frame that is scrollable.
*/
struct ScrollableLayerGuid {
- uint64_t mLayersId;
+ LayersId mLayersId;
uint32_t mPresShellId;
FrameMetrics::ViewID mScrollId;
ScrollableLayerGuid()
- : mLayersId(0)
+ : mLayersId{0}
, mPresShellId(0)
, mScrollId(0)
{
}
- ScrollableLayerGuid(uint64_t aLayersId, uint32_t aPresShellId,
+ ScrollableLayerGuid(LayersId aLayersId, uint32_t aPresShellId,
FrameMetrics::ViewID aScrollId)
: mLayersId(aLayersId)
, mPresShellId(aPresShellId)
, mScrollId(aScrollId)
{
}
- ScrollableLayerGuid(uint64_t aLayersId, const FrameMetrics& aMetrics)
+ ScrollableLayerGuid(LayersId aLayersId, const FrameMetrics& aMetrics)
: mLayersId(aLayersId)
, mPresShellId(aMetrics.GetPresShellId())
, mScrollId(aMetrics.GetScrollId())
{
}
ScrollableLayerGuid(const ScrollableLayerGuid& other)
: mLayersId(other.mLayersId)
@@ -1102,23 +1102,23 @@ struct ScrollableLayerGuid {
return mScrollId < other.mScrollId;
}
}
return false;
}
PLDHashNumber Hash() const
{
- return HashGeneric(mLayersId, mPresShellId, mScrollId);
+ return HashGeneric(uint64_t(mLayersId), mPresShellId, mScrollId);
}
};
template <int LogLevel>
gfx::Log<LogLevel>& operator<<(gfx::Log<LogLevel>& log, const ScrollableLayerGuid& aGuid) {
- return log << '(' << aGuid.mLayersId << ',' << aGuid.mPresShellId << ',' << aGuid.mScrollId << ')';
+ return log << '(' << uint64_t(aGuid.mLayersId) << ',' << aGuid.mPresShellId << ',' << aGuid.mScrollId << ')';
}
struct ZoomConstraints {
bool mAllowZoom;
bool mAllowDoubleTapZoom;
CSSToParentLayerScale mMinZoom;
CSSToParentLayerScale mMaxZoom;
--- a/gfx/layers/LayerMetricsWrapper.h
+++ b/gfx/layers/LayerMetricsWrapper.h
@@ -350,17 +350,17 @@ public:
MOZ_ASSERT(IsValid());
if (AtBottomLayer()) {
return mLayer->AsRefLayer();
}
return nullptr;
}
- Maybe<uint64_t> GetReferentId() const
+ Maybe<LayersId> GetReferentId() const
{
MOZ_ASSERT(IsValid());
if (AtBottomLayer()) {
return mLayer->AsRefLayer()
? Some(mLayer->AsRefLayer()->GetReferentId())
: Nothing();
}
--- a/gfx/layers/Layers.cpp
+++ b/gfx/layers/Layers.cpp
@@ -2184,18 +2184,18 @@ ImageLayer::DumpPacket(layerscope::Layer
layer->set_type(LayersPacket::Layer::ImageLayer);
DumpFilter(layer, mSamplingFilter);
}
void
RefLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
{
ContainerLayer::PrintInfo(aStream, aPrefix);
- if (0 != mId) {
- AppendToString(aStream, mId, " [id=", "]");
+ if (mId.IsValid()) {
+ AppendToString(aStream, uint64_t(mId), " [id=", "]");
}
if (mEventRegionsOverride & EventRegionsOverride::ForceDispatchToContent) {
aStream << " [force-dtc]";
}
if (mEventRegionsOverride & EventRegionsOverride::ForceEmptyHitRegion) {
aStream << " [force-ehr]";
}
}
@@ -2203,17 +2203,17 @@ RefLayer::PrintInfo(std::stringstream& a
void
RefLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
{
Layer::DumpPacket(aPacket, aParent);
// Get this layer data
using namespace layerscope;
LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
layer->set_type(LayersPacket::Layer::RefLayer);
- layer->set_refid(mId);
+ layer->set_refid(uint64_t(mId));
}
void
ReadbackLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
{
Layer::PrintInfo(aStream, aPrefix);
AppendToString(aStream, mSize, " [size=", "]");
if (mBackgroundLayer) {
--- a/gfx/layers/Layers.h
+++ b/gfx/layers/Layers.h
@@ -2631,19 +2631,19 @@ private:
virtual bool RepositionChild(Layer* aChild, Layer* aAfter) override
{ MOZ_CRASH("GFX: RefLayer"); return false; }
public:
/**
* CONSTRUCTION PHASE ONLY
* Set the ID of the layer's referent.
*/
- void SetReferentId(uint64_t aId)
+ void SetReferentId(LayersId aId)
{
- MOZ_ASSERT(aId != 0);
+ MOZ_ASSERT(aId.IsValid());
if (mId != aId) {
MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ReferentId", this));
mId = aId;
Mutated();
}
}
/**
* CONSTRUCTION PHASE ONLY
@@ -2695,38 +2695,38 @@ public:
{
mFirstChild = mLastChild = nullptr;
aLayer->SetParent(nullptr);
}
// These getters can be used anytime.
virtual RefLayer* AsRefLayer() override { return this; }
- virtual uint64_t GetReferentId() { return mId; }
+ virtual LayersId GetReferentId() { return mId; }
/**
* DRAWING PHASE ONLY
*/
virtual void FillSpecificAttributes(SpecificLayerAttributes& aAttrs) override;
MOZ_LAYER_DECL_NAME("RefLayer", TYPE_REF)
protected:
RefLayer(LayerManager* aManager, void* aImplData)
: ContainerLayer(aManager, aImplData)
- , mId(0)
+ , mId{0}
, mEventRegionsOverride(EventRegionsOverride::NoOverride)
{}
virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
virtual void DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent) override;
// 0 is a special value that means "no ID".
- uint64_t mId;
+ LayersId mId;
EventRegionsOverride mEventRegionsOverride;
};
void SetAntialiasingFlags(Layer* aLayer, gfx::DrawTarget* aTarget);
#ifdef MOZ_DUMP_PAINTING
void WriteSnapshotToDumpFile(Layer* aLayer, gfx::DataSourceSurface* aSurf);
void WriteSnapshotToDumpFile(LayerManager* aManager, gfx::DataSourceSurface* aSurf);
--- a/gfx/layers/LayersLogging.cpp
+++ b/gfx/layers/LayersLogging.cpp
@@ -269,17 +269,17 @@ AppendToString(std::stringstream& aStrea
aStream << sfx;
}
void
AppendToString(std::stringstream& aStream, const ScrollableLayerGuid& s,
const char* pfx, const char* sfx)
{
aStream << pfx
- << nsPrintfCString("{ l=0x%" PRIx64 ", p=%u, v=%" PRIu64 " }", s.mLayersId, s.mPresShellId, s.mScrollId).get()
+ << nsPrintfCString("{ l=0x%" PRIx64 ", p=%u, v=%" PRIu64 " }", uint64_t(s.mLayersId), s.mPresShellId, s.mScrollId).get()
<< sfx;
}
void
AppendToString(std::stringstream& aStream, const ZoomConstraints& z,
const char* pfx, const char* sfx)
{
aStream << pfx
--- a/gfx/layers/LayersTypes.h
+++ b/gfx/layers/LayersTypes.h
@@ -42,16 +42,63 @@ class MOZ_EXPORT GraphicBuffer;
namespace mozilla {
namespace layers {
class TextureHost;
#undef NONE
#undef OPAQUE
+struct LayersId {
+ uint64_t mId;
+
+ bool IsValid() const {
+ return mId != 0;
+ }
+
+ // Allow explicit cast to a uint64_t for now
+ explicit operator uint64_t() const
+ {
+ return mId;
+ }
+
+ // Implement some operators so this class can be used as a key in
+ // stdlib classes.
+ bool operator<(const LayersId& aOther) const
+ {
+ return mId < aOther.mId;
+ }
+
+ bool operator==(const LayersId& aOther) const
+ {
+ return mId == aOther.mId;
+ }
+
+ bool operator!=(const LayersId& aOther) const
+ {
+ return !(*this == aOther);
+ }
+
+ // Helper operators that allow this class to be used as a key in
+ // std::unordered_map like so:
+ // std::unordered_map<LayersId, ValueType, LayersId::HashFn, LayersId::EqualFn> myMap;
+ struct HashFn {
+ std::size_t operator()(const LayersId& aKey) const
+ {
+ return std::hash<uint64_t>{}(aKey.mId);
+ }
+ };
+ struct EqualFn {
+ bool operator()(const LayersId& lhs, const LayersId& rhs) const
+ {
+ return lhs.mId == rhs.mId;
+ }
+ };
+};
+
enum class LayersBackend : int8_t {
LAYERS_NONE = 0,
LAYERS_BASIC,
LAYERS_OPENGL,
LAYERS_D3D11,
LAYERS_CLIENT,
LAYERS_WR,
LAYERS_LAST
--- a/gfx/layers/apz/public/APZSampler.h
+++ b/gfx/layers/apz/public/APZSampler.h
@@ -39,44 +39,44 @@ class WebRenderScrollData;
*/
class APZSampler {
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(APZSampler)
public:
explicit APZSampler(const RefPtr<APZCTreeManager>& aApz);
void ClearTree();
- void UpdateFocusState(uint64_t aRootLayerTreeId,
- uint64_t aOriginatingLayersId,
+ void UpdateFocusState(LayersId aRootLayerTreeId,
+ LayersId aOriginatingLayersId,
const FocusTarget& aFocusTarget);
- void UpdateHitTestingTree(uint64_t aRootLayerTreeId,
+ void UpdateHitTestingTree(LayersId aRootLayerTreeId,
Layer* aRoot,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber);
- void UpdateHitTestingTree(uint64_t aRootLayerTreeId,
+ void UpdateHitTestingTree(LayersId aRootLayerTreeId,
const WebRenderScrollData& aScrollData,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber);
- void NotifyLayerTreeAdopted(uint64_t aLayersId,
+ void NotifyLayerTreeAdopted(LayersId aLayersId,
const RefPtr<APZSampler>& aOldSampler);
- void NotifyLayerTreeRemoved(uint64_t aLayersId);
+ void NotifyLayerTreeRemoved(LayersId aLayersId);
bool PushStateToWR(wr::TransactionBuilder& aTxn,
const TimeStamp& aSampleTime,
nsTArray<wr::WrTransformProperty>& aTransformArray);
- bool GetAPZTestData(uint64_t aLayersId, APZTestData* aOutData);
+ bool GetAPZTestData(LayersId aLayersId, APZTestData* aOutData);
- void SetTestAsyncScrollOffset(uint64_t aLayersId,
+ void SetTestAsyncScrollOffset(LayersId aLayersId,
const FrameMetrics::ViewID& aScrollId,
const CSSPoint& aOffset);
- void SetTestAsyncZoom(uint64_t aLayersId,
+ void SetTestAsyncZoom(LayersId aLayersId,
const FrameMetrics::ViewID& aScrollId,
const LayerToParentLayerScale& aZoom);
bool SampleAnimations(const LayerMetricsWrapper& aLayer,
const TimeStamp& aSampleTime);
/**
* Compute the updated shadow transform for a scroll thumb layer that
--- a/gfx/layers/apz/public/MetricsSharingController.h
+++ b/gfx/layers/apz/public/MetricsSharingController.h
@@ -18,17 +18,17 @@ namespace layers {
class MetricsSharingController
{
public:
NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
virtual base::ProcessId RemotePid() = 0;
virtual bool StartSharingMetrics(mozilla::ipc::SharedMemoryBasic::Handle aHandle,
CrossProcessMutexHandle aMutexHandle,
- uint64_t aLayersId,
+ LayersId aLayersId,
uint32_t aApzcId) = 0;
virtual bool StopSharingMetrics(FrameMetrics::ViewID aScrollId,
uint32_t aApzcId) = 0;
protected:
virtual ~MetricsSharingController() {}
};
--- a/gfx/layers/apz/src/APZCTreeManager.cpp
+++ b/gfx/layers/apz/src/APZCTreeManager.cpp
@@ -62,18 +62,18 @@ using mozilla::gfx::CompositorHitTestInf
typedef mozilla::gfx::Point Point;
typedef mozilla::gfx::Point4D Point4D;
typedef mozilla::gfx::Matrix4x4 Matrix4x4;
typedef CompositorBridgeParent::LayerTreeState LayerTreeState;
struct APZCTreeManager::TreeBuildingState {
- TreeBuildingState(uint64_t aRootLayersId,
- bool aIsFirstPaint, uint64_t aOriginatingLayersId,
+ TreeBuildingState(LayersId aRootLayersId,
+ bool aIsFirstPaint, LayersId aOriginatingLayersId,
APZTestData* aTestData, uint32_t aPaintSequence)
: mIsFirstPaint(aIsFirstPaint)
, mOriginatingLayersId(aOriginatingLayersId)
, mPaintLogger(aTestData, aPaintSequence)
{
CompositorBridgeParent::CallWithIndirectShadowTree(aRootLayersId,
[this](LayerTreeState& aState) -> void {
mCompositorController = aState.GetCompositorController();
@@ -82,17 +82,17 @@ struct APZCTreeManager::TreeBuildingStat
}
typedef std::unordered_map<AsyncPanZoomController*, gfx::Matrix4x4> DeferredTransformMap;
// State that doesn't change as we recurse in the tree building
RefPtr<CompositorController> mCompositorController;
RefPtr<MetricsSharingController> mInProcessSharingController;
const bool mIsFirstPaint;
- const uint64_t mOriginatingLayersId;
+ const LayersId mOriginatingLayersId;
const APZPaintLogHelper mPaintLogger;
// State that is updated as we perform the tree build
// A list of nodes that need to be destroyed at the end of the tree building.
// This is initialized with all nodes in the old tree, and nodes are removed
// from it as we reuse them in the new tree.
nsTArray<RefPtr<HitTestingTreeNode>> mNodesToDestroy;
@@ -216,17 +216,17 @@ public:
}
private:
FocusState& mFocusState;
InputData& mEvent;
bool mMayChangeFocus;
};
-APZCTreeManager::APZCTreeManager(uint64_t aRootLayersId)
+APZCTreeManager::APZCTreeManager(LayersId aRootLayersId)
: mInputQueue(new InputQueue()),
mRootLayersId(aRootLayersId),
mTreeLock("APZCTreeLock"),
mHitResultForInputBlock(CompositorHitTestInfo::eInvisibleToHitTest),
mRetainedTouchIdentifier(-1),
mInScrollbarTouchDrag(false),
mApzcTreeLog("apzctree"),
mTestDataLock("APZTestDataLock"),
@@ -244,17 +244,17 @@ APZCTreeManager::APZCTreeManager(uint64_
#endif // (MOZ_WIDGET_ANDROID)
}
APZCTreeManager::~APZCTreeManager()
{
}
void
-APZCTreeManager::NotifyLayerTreeAdopted(uint64_t aLayersId,
+APZCTreeManager::NotifyLayerTreeAdopted(LayersId aLayersId,
const RefPtr<APZCTreeManager>& aOldApzcTreeManager)
{
APZThreadUtils::AssertOnSamplerThread();
if (aOldApzcTreeManager) {
aOldApzcTreeManager->mFocusState.RemoveFocusTarget(aLayersId);
// While we could move the focus target information from the old APZC tree
// manager into this one, it's safer to not do that, as we'll probably have
@@ -272,30 +272,30 @@ APZCTreeManager::NotifyLayerTreeAdopted(
}
if (adoptedData) {
MutexAutoLock lock(mTestDataLock);
mTestData[aLayersId] = Move(adoptedData);
}
}
void
-APZCTreeManager::NotifyLayerTreeRemoved(uint64_t aLayersId)
+APZCTreeManager::NotifyLayerTreeRemoved(LayersId aLayersId)
{
APZThreadUtils::AssertOnSamplerThread();
mFocusState.RemoveFocusTarget(aLayersId);
{ // scope lock
MutexAutoLock lock(mTestDataLock);
mTestData.erase(aLayersId);
}
}
AsyncPanZoomController*
-APZCTreeManager::NewAPZCInstance(uint64_t aLayersId,
+APZCTreeManager::NewAPZCInstance(LayersId aLayersId,
GeckoContentController* aController)
{
return new AsyncPanZoomController(aLayersId, this, mInputQueue,
aController, AsyncPanZoomController::USE_GESTURE_DETECTOR);
}
TimeStamp
APZCTreeManager::GetFrameTime()
@@ -308,20 +308,20 @@ APZCTreeManager::SetAllowedTouchBehavior
const nsTArray<TouchBehaviorFlags> &aValues)
{
APZThreadUtils::AssertOnControllerThread();
mInputQueue->SetAllowedTouchBehavior(aInputBlockId, aValues);
}
template<class ScrollNode> void // ScrollNode is a LayerMetricsWrapper or a WebRenderScrollDataWrapper
-APZCTreeManager::UpdateHitTestingTreeImpl(uint64_t aRootLayerTreeId,
+APZCTreeManager::UpdateHitTestingTreeImpl(LayersId aRootLayerTreeId,
const ScrollNode& aRoot,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber)
{
RecursiveMutexAutoLock lock(mTreeLock);
// For testing purposes, we log some data to the APZTestData associated with
// the layers id that originated this update.
APZTestData* testData = nullptr;
if (gfxPrefs::APZTestLoggingEnabled()) {
@@ -354,17 +354,17 @@ APZCTreeManager::UpdateHitTestingTreeImp
});
mRootNode = nullptr;
if (aRoot) {
std::stack<gfx::TreeAutoIndent> indents;
std::stack<AncestorTransform> ancestorTransforms;
HitTestingTreeNode* parent = nullptr;
HitTestingTreeNode* next = nullptr;
- uint64_t layersId = aRootLayerTreeId;
+ LayersId layersId = aRootLayerTreeId;
ancestorTransforms.push(AncestorTransform());
state.mParentHasPerspective.push(false);
mApzcTreeLog << "[start]\n";
mTreeLock.AssertCurrentThreadIn();
ForEachNode<ReverseIterator>(aRoot,
[&](ScrollNode aLayerMetrics)
@@ -396,17 +396,17 @@ APZCTreeManager::UpdateHitTestingTreeImp
// Note that |node| at this point will not have any children, otherwise we
// we would have to set next to node->GetFirstChild().
MOZ_ASSERT(!node->GetFirstChild());
parent = node;
next = nullptr;
// Update the layersId if we have a new one
- if (Maybe<uint64_t> newLayersId = aLayerMetrics.GetReferentId()) {
+ if (Maybe<LayersId> newLayersId = aLayerMetrics.GetReferentId()) {
layersId = *newLayersId;
}
indents.push(gfx::TreeAutoIndent(mApzcTreeLog));
state.mParentHasPerspective.push(aLayerMetrics.TransformIsPerspective());
},
[&](ScrollNode aLayerMetrics)
{
@@ -465,50 +465,50 @@ APZCTreeManager::UpdateHitTestingTreeImp
#if ENABLE_APZCTM_LOGGING
// Make the hit-test tree line up with the layer dump
printf_stderr("APZCTreeManager (%p)\n", this);
mRootNode->Dump(" ");
#endif
}
void
-APZCTreeManager::UpdateFocusState(uint64_t aRootLayerTreeId,
- uint64_t aOriginatingLayersId,
+APZCTreeManager::UpdateFocusState(LayersId aRootLayerTreeId,
+ LayersId aOriginatingLayersId,
const FocusTarget& aFocusTarget)
{
APZThreadUtils::AssertOnSamplerThread();
if (!gfxPrefs::APZKeyboardEnabled()) {
return;
}
mFocusState.Update(aRootLayerTreeId,
aOriginatingLayersId,
aFocusTarget);
}
void
-APZCTreeManager::UpdateHitTestingTree(uint64_t aRootLayerTreeId,
+APZCTreeManager::UpdateHitTestingTree(LayersId aRootLayerTreeId,
Layer* aRoot,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber)
{
APZThreadUtils::AssertOnSamplerThread();
LayerMetricsWrapper root(aRoot);
UpdateHitTestingTreeImpl(aRootLayerTreeId, root, aIsFirstPaint,
aOriginatingLayersId, aPaintSequenceNumber);
}
void
-APZCTreeManager::UpdateHitTestingTree(uint64_t aRootLayerTreeId,
+APZCTreeManager::UpdateHitTestingTree(LayersId aRootLayerTreeId,
const WebRenderScrollData& aScrollData,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber)
{
APZThreadUtils::AssertOnSamplerThread();
WebRenderScrollDataWrapper wrapper(&aScrollData);
UpdateHitTestingTreeImpl(aRootLayerTreeId, wrapper, aIsFirstPaint,
aOriginatingLayersId, aPaintSequenceNumber);
}
@@ -525,17 +525,17 @@ APZCTreeManager::PushStateToWR(wr::Trans
// During the first pass through the tree, we build a cache of guid->HTTN so
// that we can find the relevant APZC instances quickly in subsequent passes,
// such as the one below to generate scrollbar transforms. Without this, perf
// could end up being O(n^2) instead of O(n log n) because we'd have to search
// the tree to find the corresponding APZC every time we hit a thumb node.
std::unordered_map<ScrollableLayerGuid, HitTestingTreeNode*, ScrollableLayerGuidHash> httnMap;
bool activeAnimations = false;
- uint64_t lastLayersId = -1;
+ LayersId lastLayersId{(uint64_t)-1};
wr::WrPipelineId lastPipelineId;
// We iterate backwards here because the HitTestingTreeNode is optimized
// for backwards iteration. The equivalent code in AsyncCompositionManager
// iterates forwards, but the direction shouldn't really matter in practice
// so we do what's faster. In the future, if we need to start doing the
// equivalent of AlignFixedAndStickyLayers here, then the order will become
// important and we'll need to take that into consideration.
@@ -689,17 +689,17 @@ GetEventRegions(const ScrollNode& aLayer
return aLayer.GetEventRegions();
}
already_AddRefed<HitTestingTreeNode>
APZCTreeManager::RecycleOrCreateNode(TreeBuildingState& aState,
AsyncPanZoomController* aApzc,
- uint64_t aLayersId)
+ LayersId aLayersId)
{
// Find a node without an APZC and return it. Note that unless the layer tree
// actually changes, this loop should generally do an early-return on the
// first iteration, so it should be cheap in the common case.
for (size_t i = 0; i < aState.mNodesToDestroy.Length(); i++) {
RefPtr<HitTestingTreeNode> node = aState.mNodesToDestroy[i];
if (!node->IsPrimaryHolder()) {
aState.mNodesToDestroy.RemoveElement(node);
@@ -794,17 +794,17 @@ APZCTreeManager::NotifyAutoscrollRejecte
GetContentController(aGuid.mLayersId);
MOZ_ASSERT(controller);
controller->NotifyAsyncAutoscrollRejected(aGuid.mScrollId);
}
template<class ScrollNode> HitTestingTreeNode*
APZCTreeManager::PrepareNodeForLayer(const ScrollNode& aLayer,
const FrameMetrics& aMetrics,
- uint64_t aLayersId,
+ LayersId aLayersId,
const AncestorTransform& aAncestorTransform,
HitTestingTreeNode* aParent,
HitTestingTreeNode* aNextSibling,
TreeBuildingState& aState)
{
mTreeLock.AssertCurrentThreadIn();
bool needsApzc = true;
@@ -1077,17 +1077,17 @@ WillHandleInput(const PanGestureOrScroll
return true;
}
WidgetWheelEvent wheelEvent = aPanInput.ToWidgetWheelEvent(nullptr);
return APZInputBridge::WillHandleWheelEvent(&wheelEvent);
}
void
-APZCTreeManager::FlushApzRepaints(uint64_t aLayersId)
+APZCTreeManager::FlushApzRepaints(LayersId aLayersId)
{
// Previously, paints were throttled and therefore this method was used to
// ensure any pending paints were flushed. Now, paints are flushed
// immediately, so it is safe to simply send a notification now.
APZCTM_LOG("Flushing repaints for layers id 0x%" PRIx64 "\n", aLayersId);
RefPtr<GeckoContentController> controller = GetContentController(aLayersId);
MOZ_ASSERT(controller);
controller->DispatchToRepaintThread(
@@ -2314,17 +2314,17 @@ APZCTreeManager::GetTargetAPZC(const Scr
static bool
GuidComparatorIgnoringPresShell(const ScrollableLayerGuid& aOne, const ScrollableLayerGuid& aTwo)
{
return aOne.mLayersId == aTwo.mLayersId
&& aOne.mScrollId == aTwo.mScrollId;
}
already_AddRefed<AsyncPanZoomController>
-APZCTreeManager::GetTargetAPZC(const uint64_t& aLayersId,
+APZCTreeManager::GetTargetAPZC(const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId)
{
RecursiveMutexAutoLock lock(mTreeLock);
ScrollableLayerGuid guid(aLayersId, 0, aScrollId);
RefPtr<HitTestingTreeNode> node = GetTargetNode(guid, &GuidComparatorIgnoringPresShell);
MOZ_ASSERT(!node || node->GetApzc()); // any node returned must have an APZC
RefPtr<AsyncPanZoomController> apzc = node ? node->GetApzc() : nullptr;
return apzc.forget();
@@ -2402,17 +2402,17 @@ APZCTreeManager::GetAPZCAtPointWR(const
FrameMetrics::ViewID scrollId;
gfx::CompositorHitTestInfo hitInfo;
bool hitSomething = wr->HitTest(wr::ToWorldPoint(aHitTestPoint),
pipelineId, scrollId, hitInfo);
if (!hitSomething) {
return result.forget();
}
- uint64_t layersId = wr::AsUint64(pipelineId);
+ LayersId layersId = wr::AsLayersId(pipelineId);
RefPtr<HitTestingTreeNode> node = GetTargetNode(
ScrollableLayerGuid(layersId, 0, scrollId),
&GuidComparatorIgnoringPresShell);
MOZ_ASSERT(!node || node->GetApzc()); // any node returned must have an APZC
result = node ? node->GetApzc() : nullptr;
if (!result) {
// It falls back to the root
// Re-enable these assertions once bug 1391318 is fixed. For now there are
@@ -2651,32 +2651,32 @@ APZCTreeManager::GetAPZCAtPoint(HitTesti
result, resultNode, (int)*aOutHitResult);
return result;
}
return nullptr;
}
AsyncPanZoomController*
-APZCTreeManager::FindRootApzcForLayersId(uint64_t aLayersId) const
+APZCTreeManager::FindRootApzcForLayersId(LayersId aLayersId) const
{
mTreeLock.AssertCurrentThreadIn();
HitTestingTreeNode* resultNode = BreadthFirstSearch<ReverseIterator>(mRootNode.get(),
[aLayersId](HitTestingTreeNode* aNode) {
AsyncPanZoomController* apzc = aNode->GetApzc();
return apzc
&& apzc->GetLayersId() == aLayersId
&& apzc->IsRootForLayersId();
});
return resultNode ? resultNode->GetApzc() : nullptr;
}
AsyncPanZoomController*
-APZCTreeManager::FindRootContentApzcForLayersId(uint64_t aLayersId) const
+APZCTreeManager::FindRootContentApzcForLayersId(LayersId aLayersId) const
{
mTreeLock.AssertCurrentThreadIn();
HitTestingTreeNode* resultNode = BreadthFirstSearch<ReverseIterator>(mRootNode.get(),
[aLayersId](HitTestingTreeNode* aNode) {
AsyncPanZoomController* apzc = aNode->GetApzc();
return apzc
&& apzc->GetLayersId() == aLayersId
@@ -2997,28 +2997,28 @@ APZCTreeManager::GetWebRenderAPI() const
if (aState.mWrBridge) {
api = aState.mWrBridge->GetWebRenderAPI();
}
});
return api.forget();
}
already_AddRefed<GeckoContentController>
-APZCTreeManager::GetContentController(uint64_t aLayersId) const
+APZCTreeManager::GetContentController(LayersId aLayersId) const
{
RefPtr<GeckoContentController> controller;
CompositorBridgeParent::CallWithIndirectShadowTree(aLayersId,
[&](LayerTreeState& aState) -> void {
controller = aState.mController;
});
return controller.forget();
}
bool
-APZCTreeManager::GetAPZTestData(uint64_t aLayersId,
+APZCTreeManager::GetAPZTestData(LayersId aLayersId,
APZTestData* aOutData)
{
APZThreadUtils::AssertOnSamplerThread();
MutexAutoLock lock(mTestDataLock);
auto it = mTestData.find(aLayersId);
if (it == mTestData.end()) {
return false;
}
--- a/gfx/layers/apz/src/APZCTreeManager.h
+++ b/gfx/layers/apz/src/APZCTreeManager.h
@@ -13,16 +13,17 @@
#include "gfxPoint.h" // for gfxPoint
#include "mozilla/Assertions.h" // for MOZ_ASSERT_HELPER2
#include "mozilla/gfx/CompositorHitTestInfo.h"
#include "mozilla/gfx/Logging.h" // for gfx::TreeLog
#include "mozilla/gfx/Matrix.h" // for Matrix4x4
#include "mozilla/layers/APZInputBridge.h" // for APZInputBridge
#include "mozilla/layers/APZTestData.h" // for APZTestData
#include "mozilla/layers/IAPZCTreeManager.h" // for IAPZCTreeManager
+#include "mozilla/layers/LayersTypes.h"
#include "mozilla/layers/KeyboardMap.h" // for KeyboardMap
#include "mozilla/RecursiveMutex.h" // for RecursiveMutex
#include "mozilla/RefPtr.h" // for RefPtr
#include "mozilla/TimeStamp.h" // for mozilla::TimeStamp
#include "mozilla/UniquePtr.h" // for UniquePtr
#include "nsCOMPtr.h" // for already_AddRefed
#include "TouchCounter.h" // for TouchCounter
@@ -108,50 +109,50 @@ class APZCTreeManager : public IAPZCTree
// Helper struct to hold some state while we build the hit-testing tree. The
// sole purpose of this struct is to shorten the argument list to
// UpdateHitTestingTree. All the state that we don't need to
// push on the stack during recursion and pop on unwind is stored here.
struct TreeBuildingState;
public:
- explicit APZCTreeManager(uint64_t aRootLayersId);
+ explicit APZCTreeManager(LayersId aRootLayersId);
/**
* Notifies this APZCTreeManager that the associated compositor is now
* responsible for managing another layers id, which got moved over from
* some other compositor. That other compositor's APZCTreeManager is also
* provided. This allows APZCTreeManager to transfer any necessary state
* from the old APZCTreeManager related to that layers id.
* This function must be called on the sampler thread.
*/
- void NotifyLayerTreeAdopted(uint64_t aLayersId,
+ void NotifyLayerTreeAdopted(LayersId aLayersId,
const RefPtr<APZCTreeManager>& aOldTreeManager);
/**
* Notifies this APZCTreeManager that a layer tree being managed by the
* associated compositor has been removed/destroyed. Note that this does
* NOT get called during shutdown situations, when the root layer tree is
* also getting destroyed.
* This function must be called on the sampler thread.
*/
- void NotifyLayerTreeRemoved(uint64_t aLayersId);
+ void NotifyLayerTreeRemoved(LayersId aLayersId);
/**
* Rebuild the focus state based on the focus target from the layer tree update
* that just occurred.
* This must be called on the sampler thread.
*
* @param aRootLayerTreeId The layer tree ID of the root layer corresponding
* to this APZCTreeManager
* @param aOriginatingLayersId The layer tree ID of the layer corresponding to
* this layer tree update.
*/
- void UpdateFocusState(uint64_t aRootLayerTreeId,
- uint64_t aOriginatingLayersId,
+ void UpdateFocusState(LayersId aRootLayerTreeId,
+ LayersId aOriginatingLayersId,
const FocusTarget& aFocusTarget);
/**
* Rebuild the hit-testing tree based on the layer update that just came up.
* Preserve nodes and APZC instances where possible, but retire those whose
* layers are no longer in the layer tree.
*
* This must be called on the sampler thread as it walks the layer tree.
@@ -165,32 +166,32 @@ public:
* to included a first-paint. If this is true, the part of
* the tree that is affected by the first-paint flag is
* indicated by the aFirstPaintLayersId parameter.
* @param aPaintSequenceNumber The sequence number of the paint that triggered
* this layer update. Note that every layer child
* process' layer subtree has its own sequence
* numbers.
*/
- void UpdateHitTestingTree(uint64_t aRootLayerTreeId,
+ void UpdateHitTestingTree(LayersId aRootLayerTreeId,
Layer* aRoot,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber);
/**
* Same as the above UpdateHitTestingTree, except slightly modified to take
* the scrolling data passed over PWebRenderBridge instead of the raw layer
* tree. This version is used when WebRender is enabled because we don't have
* shadow layers in that scenario.
*/
- void UpdateHitTestingTree(uint64_t aRootLayerTreeId,
+ void UpdateHitTestingTree(LayersId aRootLayerTreeId,
const WebRenderScrollData& aScrollData,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber);
/**
* Called when webrender is enabled, from the sampler thread. This function
* walks through the tree of APZC instances and tells webrender about the
* async scroll position. It also advances APZ animations to the specified
* sample time. In effect it is the webrender equivalent of (part of) the
* code in AsyncCompositionManager. If scrollbar transforms need updating
@@ -203,17 +204,17 @@ public:
const TimeStamp& aSampleTime,
nsTArray<wr::WrTransformProperty>& aTransformArray);
/**
* Walk the tree of APZCs and flushes the repaint requests for all the APZCS
* corresponding to the given layers id. Finally, sends a flush complete
* notification to the GeckoContentController for the layers id.
*/
- void FlushApzRepaints(uint64_t aLayersId);
+ void FlushApzRepaints(LayersId aLayersId);
/**
* General handler for incoming input events. Manipulates the frame metrics
* based on what type of input it is. For example, a PinchGestureEvent will
* cause scaling. This should only be called externally to this class, and
* must be called on the controller thread.
*
* This function transforms |aEvent| to have its coordinates in DOM space.
@@ -483,17 +484,17 @@ public:
LayoutDeviceIntPoint* aRefPoint,
ScrollableLayerGuid* aOutTargetGuid,
uint64_t* aOutFocusSequenceNumber) override;
void UpdateWheelTransaction(
LayoutDeviceIntPoint aRefPoint,
EventMessage aEventMessage) override;
- bool GetAPZTestData(uint64_t aLayersId, APZTestData* aOutData);
+ bool GetAPZTestData(LayersId aLayersId, APZTestData* aOutData);
/**
* Compute the updated shadow transform for a scroll thumb layer that
* reflects async scrolling of the associated scroll frame.
*
* @param aCurrentTransform The current shadow transform on the scroll thumb
* layer, as returned by Layer::GetLocalTransform() or similar.
* @param aScrollableContentTransform The current content transform on the
@@ -522,34 +523,34 @@ public:
bool aScrollbarIsDescendant,
AsyncTransformComponentMatrix* aOutClipTransform);
protected:
// Protected destructor, to discourage deletion outside of Release():
virtual ~APZCTreeManager();
// Protected hooks for gtests subclass
- virtual AsyncPanZoomController* NewAPZCInstance(uint64_t aLayersId,
+ virtual AsyncPanZoomController* NewAPZCInstance(LayersId aLayersId,
GeckoContentController* aController);
public:
// Public hooks for gtests subclass
virtual TimeStamp GetFrameTime();
public:
/* Some helper functions to find an APZC given some identifying input. These functions
lock the tree of APZCs while they find the right one, and then return an addref'd
pointer to it. This allows caller code to just use the target APZC without worrying
about it going away. These are public for testing code and generally should not be
used by other production code.
*/
RefPtr<HitTestingTreeNode> GetRootNode() const;
already_AddRefed<AsyncPanZoomController> GetTargetAPZC(const ScreenPoint& aPoint,
gfx::CompositorHitTestInfo* aOutHitResult,
RefPtr<HitTestingTreeNode>* aOutScrollbarNode = nullptr);
- already_AddRefed<AsyncPanZoomController> GetTargetAPZC(const uint64_t& aLayersId,
+ already_AddRefed<AsyncPanZoomController> GetTargetAPZC(const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId);
ScreenToParentLayerMatrix4x4 GetScreenToApzcTransform(const AsyncPanZoomController *aApzc) const;
ParentLayerToScreenMatrix4x4 GetApzcToGeckoTransform(const AsyncPanZoomController *aApzc) const;
ScreenPoint GetCurrentMousePosition() const;
/**
* Process touch velocity.
* Sometimes the touch move event will have a velocity even though no scrolling
@@ -557,20 +558,20 @@ public:
* This function can be called to have the y axis' velocity queue updated.
*/
void ProcessTouchVelocity(uint32_t aTimestampMs, float aSpeedY);
private:
typedef bool (*GuidComparator)(const ScrollableLayerGuid&, const ScrollableLayerGuid&);
/* Helpers */
template<class ScrollNode>
- void UpdateHitTestingTreeImpl(uint64_t aRootLayerTreeId,
+ void UpdateHitTestingTreeImpl(LayersId aRootLayerTreeId,
const ScrollNode& aRoot,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber);
void AttachNodeToTree(HitTestingTreeNode* aNode,
HitTestingTreeNode* aParent,
HitTestingTreeNode* aNextSibling);
already_AddRefed<AsyncPanZoomController> GetTargetAPZC(const ScrollableLayerGuid& aGuid);
already_AddRefed<HitTestingTreeNode> GetTargetNode(const ScrollableLayerGuid& aGuid,
GuidComparator aComparator) const;
@@ -580,18 +581,18 @@ private:
AsyncPanZoomController* GetTargetApzcForNode(HitTestingTreeNode* aNode);
AsyncPanZoomController* GetAPZCAtPoint(HitTestingTreeNode* aNode,
const ScreenPoint& aHitTestPoint,
gfx::CompositorHitTestInfo* aOutHitResult,
HitTestingTreeNode** aOutScrollbarNode);
already_AddRefed<AsyncPanZoomController> GetAPZCAtPointWR(const ScreenPoint& aHitTestPoint,
gfx::CompositorHitTestInfo* aOutHitResult,
HitTestingTreeNode** aOutScrollbarNode);
- AsyncPanZoomController* FindRootApzcForLayersId(uint64_t aLayersId) const;
- AsyncPanZoomController* FindRootContentApzcForLayersId(uint64_t aLayersId) const;
+ AsyncPanZoomController* FindRootApzcForLayersId(LayersId aLayersId) const;
+ AsyncPanZoomController* FindRootContentApzcForLayersId(LayersId aLayersId) const;
AsyncPanZoomController* FindRootContentOrRootApzc() const;
already_AddRefed<AsyncPanZoomController> GetMultitouchTarget(AsyncPanZoomController* aApzc1, AsyncPanZoomController* aApzc2) const;
already_AddRefed<AsyncPanZoomController> CommonAncestor(AsyncPanZoomController* aApzc1, AsyncPanZoomController* aApzc2) const;
/**
* Perform hit testing for a touch-start event.
*
* @param aEvent The touch-start event.
*
@@ -648,21 +649,21 @@ private:
nsEventStatus ProcessTouchInputForScrollbarDrag(MultiTouchInput& aInput,
const HitTestingTreeNode* aScrollThumbNode,
ScrollableLayerGuid* aOutTargetGuid,
uint64_t* aOutInputBlockId);
void FlushRepaintsToClearScreenToGeckoTransform();
already_AddRefed<HitTestingTreeNode> RecycleOrCreateNode(TreeBuildingState& aState,
AsyncPanZoomController* aApzc,
- uint64_t aLayersId);
+ LayersId aLayersId);
template<class ScrollNode>
HitTestingTreeNode* PrepareNodeForLayer(const ScrollNode& aLayer,
const FrameMetrics& aMetrics,
- uint64_t aLayersId,
+ LayersId aLayersId,
const AncestorTransform& aAncestorTransform,
HitTestingTreeNode* aParent,
HitTestingTreeNode* aNextSibling,
TreeBuildingState& aState);
template<class ScrollNode>
void PrintAPZCInfo(const ScrollNode& aLayer,
const AsyncPanZoomController* apzc);
@@ -673,27 +674,27 @@ private:
// Requires the caller to hold mTreeLock.
LayerToParentLayerMatrix4x4 ComputeTransformForNode(const HitTestingTreeNode* aNode) const;
// Returns a pointer to the WebRenderAPI for the root layers id this APZCTreeManager
// is for. This might be null (for example, if WebRender is not enabled).
already_AddRefed<wr::WebRenderAPI> GetWebRenderAPI() const;
// Returns a pointer to the GeckoContentController for the given layers id.
- already_AddRefed<GeckoContentController> GetContentController(uint64_t aLayersId) const;
+ already_AddRefed<GeckoContentController> GetContentController(LayersId aLayersId) const;
protected:
/* The input queue where input events are held until we know enough to
* figure out where they're going. Protected so gtests can access it.
*/
RefPtr<InputQueue> mInputQueue;
private:
/* Layers id for the root CompositorBridgeParent that owns this APZCTreeManager. */
- uint64_t mRootLayersId;
+ LayersId mRootLayersId;
/* Whenever walking or mutating the tree rooted at mRootNode, mTreeLock must be held.
* This lock does not need to be held while manipulating a single APZC instance in
* isolation (that is, if its tree pointers are not being accessed or mutated). The
* lock also needs to be held when accessing the mRootNode instance variable, as that
* is considered part of the APZC tree management state.
* IMPORTANT: See the note about lock ordering at the top of this file. */
mutable mozilla::RecursiveMutex mTreeLock;
@@ -745,17 +746,20 @@ private:
gfx::TreeLog mApzcTreeLog;
class CheckerboardFlushObserver;
friend class CheckerboardFlushObserver;
RefPtr<CheckerboardFlushObserver> mFlushObserver;
// Map from layers id to APZTestData. Accesses and mutations must be
// protected by the mTestDataLock.
- std::unordered_map<uint64_t, UniquePtr<APZTestData>> mTestData;
+ std::unordered_map<LayersId,
+ UniquePtr<APZTestData>,
+ LayersId::HashFn,
+ LayersId::EqualFn> mTestData;
mutable mozilla::Mutex mTestDataLock;
// This must only be touched on the controller thread.
float mDPI;
#if defined(MOZ_WIDGET_ANDROID)
public:
AndroidDynamicToolbarAnimator* GetAndroidDynamicToolbarAnimator();
--- a/gfx/layers/apz/src/APZSampler.cpp
+++ b/gfx/layers/apz/src/APZSampler.cpp
@@ -27,97 +27,97 @@ APZSampler::~APZSampler()
void
APZSampler::ClearTree()
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
mApz->ClearTree();
}
void
-APZSampler::UpdateFocusState(uint64_t aRootLayerTreeId,
- uint64_t aOriginatingLayersId,
+APZSampler::UpdateFocusState(LayersId aRootLayerTreeId,
+ LayersId aOriginatingLayersId,
const FocusTarget& aFocusTarget)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
mApz->UpdateFocusState(aRootLayerTreeId, aOriginatingLayersId, aFocusTarget);
}
void
-APZSampler::UpdateHitTestingTree(uint64_t aRootLayerTreeId,
+APZSampler::UpdateHitTestingTree(LayersId aRootLayerTreeId,
Layer* aRoot,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
mApz->UpdateHitTestingTree(aRootLayerTreeId, aRoot, aIsFirstPaint,
aOriginatingLayersId, aPaintSequenceNumber);
}
void
-APZSampler::UpdateHitTestingTree(uint64_t aRootLayerTreeId,
+APZSampler::UpdateHitTestingTree(LayersId aRootLayerTreeId,
const WebRenderScrollData& aScrollData,
bool aIsFirstPaint,
- uint64_t aOriginatingLayersId,
+ LayersId aOriginatingLayersId,
uint32_t aPaintSequenceNumber)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
mApz->UpdateHitTestingTree(aRootLayerTreeId, aScrollData, aIsFirstPaint,
aOriginatingLayersId, aPaintSequenceNumber);
}
void
-APZSampler::NotifyLayerTreeAdopted(uint64_t aLayersId,
+APZSampler::NotifyLayerTreeAdopted(LayersId aLayersId,
const RefPtr<APZSampler>& aOldSampler)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
mApz->NotifyLayerTreeAdopted(aLayersId, aOldSampler ? aOldSampler->mApz : nullptr);
}
void
-APZSampler::NotifyLayerTreeRemoved(uint64_t aLayersId)
+APZSampler::NotifyLayerTreeRemoved(LayersId aLayersId)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
mApz->NotifyLayerTreeRemoved(aLayersId);
}
bool
APZSampler::PushStateToWR(wr::TransactionBuilder& aTxn,
const TimeStamp& aSampleTime,
nsTArray<wr::WrTransformProperty>& aTransformArray)
{
// This function will be removed eventually since we'll have WR pull
// the transforms from APZ instead.
return mApz->PushStateToWR(aTxn, aSampleTime, aTransformArray);
}
bool
-APZSampler::GetAPZTestData(uint64_t aLayersId,
+APZSampler::GetAPZTestData(LayersId aLayersId,
APZTestData* aOutData)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
return mApz->GetAPZTestData(aLayersId, aOutData);
}
void
-APZSampler::SetTestAsyncScrollOffset(uint64_t aLayersId,
+APZSampler::SetTestAsyncScrollOffset(LayersId aLayersId,
const FrameMetrics::ViewID& aScrollId,
const CSSPoint& aOffset)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
RefPtr<AsyncPanZoomController> apzc = mApz->GetTargetAPZC(aLayersId, aScrollId);
if (apzc) {
apzc->SetTestAsyncScrollOffset(aOffset);
} else {
NS_WARNING("Unable to find APZC in SetTestAsyncScrollOffset");
}
}
void
-APZSampler::SetTestAsyncZoom(uint64_t aLayersId,
+APZSampler::SetTestAsyncZoom(LayersId aLayersId,
const FrameMetrics::ViewID& aScrollId,
const LayerToParentLayerScale& aZoom)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
RefPtr<AsyncPanZoomController> apzc = mApz->GetTargetAPZC(aLayersId, aScrollId);
if (apzc) {
apzc->SetTestAsyncZoom(aZoom);
} else {
--- a/gfx/layers/apz/src/AndroidDynamicToolbarAnimator.cpp
+++ b/gfx/layers/apz/src/AndroidDynamicToolbarAnimator.cpp
@@ -35,17 +35,17 @@ static const int32_t MOVE_TOOLBAR_UP
static const float SHRINK_FACTOR = 0.95f; // Amount to shrink the either the full content for small pages or the amount left
// See: PageTooSmallEnsureToolbarVisible()
} // namespace
namespace mozilla {
namespace layers {
AndroidDynamicToolbarAnimator::AndroidDynamicToolbarAnimator(APZCTreeManager* aApz)
- : mRootLayerTreeId(0)
+ : mRootLayerTreeId{0}
, mApz(aApz)
// Read/Write Compositor Thread, Read only Controller thread
, mToolbarState(eToolbarVisible)
, mPinnedFlags(0)
// Controller thread only
, mControllerScrollingRootContent(false)
, mControllerDragThresholdReached(false)
, mControllerCancelTouchTracking(false)
@@ -76,17 +76,17 @@ AndroidDynamicToolbarAnimator::AndroidDy
, mCompositorMaxToolbarHeight(0)
, mCompositorToolbarHeight(0)
, mCompositorSurfaceHeight(0)
, mCompositorAnimationDirection(0)
, mCompositorAnimationStartHeight(0)
{}
void
-AndroidDynamicToolbarAnimator::Initialize(uint64_t aRootLayerTreeId)
+AndroidDynamicToolbarAnimator::Initialize(LayersId aRootLayerTreeId)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
mRootLayerTreeId = aRootLayerTreeId;
RefPtr<UiCompositorControllerParent> uiController = UiCompositorControllerParent::GetFromRootLayerTreeId(mRootLayerTreeId);
MOZ_ASSERT(uiController);
uiController->RegisterAndroidDynamicToolbarAnimator(this);
// Send queued messages that were posted before Initialize() was called.
@@ -739,17 +739,17 @@ AndroidDynamicToolbarAnimator::HandleTou
StartCompositorAnimation(direction, eAnimate, mControllerToolbarHeight, ScrollOffsetNearBottom());
}
void
AndroidDynamicToolbarAnimator::PostMessage(int32_t aMessage) {
// if the root layer tree id is zero then Initialize() has not been called yet
// so queue the message until Initialize() is called.
- if (mRootLayerTreeId == 0) {
+ if (!mRootLayerTreeId.IsValid()) {
QueueMessage(aMessage);
return;
}
RefPtr<UiCompositorControllerParent> uiController = UiCompositorControllerParent::GetFromRootLayerTreeId(mRootLayerTreeId);
if (!uiController) {
// Looks like IPC may be shutdown.
return;
@@ -1170,17 +1170,17 @@ AndroidDynamicToolbarAnimator::QueueMess
if (!CompositorThreadHolder::IsInCompositorThread()) {
CompositorThreadHolder::Loop()->PostTask(NewRunnableMethod<int32_t>("AndroidDynamicToolbarAnimator::QueueMessage",
this, &AndroidDynamicToolbarAnimator::QueueMessage, aMessage));
return;
}
// If the root layer tree id is no longer zero, Initialize() was called before QueueMessage was processed
// so just post the message now.
- if (mRootLayerTreeId != 0) {
+ if (mRootLayerTreeId.IsValid()) {
PostMessage(aMessage);
return;
}
mCompositorQueuedMessages.insertBack(new QueuedMessage(aMessage));
}
} // namespace layers
--- a/gfx/layers/apz/src/AndroidDynamicToolbarAnimator.h
+++ b/gfx/layers/apz/src/AndroidDynamicToolbarAnimator.h
@@ -48,17 +48,17 @@ class CompositorOGL;
*
* See Bug 1335895 for more details.
*/
class AndroidDynamicToolbarAnimator {
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AndroidDynamicToolbarAnimator);
explicit AndroidDynamicToolbarAnimator(APZCTreeManager* aApz);
- void Initialize(uint64_t aRootLayerTreeId);
+ void Initialize(LayersId aRootLayerTreeId);
void ClearTreeManager();
// Used to intercept events to determine if the event affects the toolbar.
// May apply translation to touch events if the toolbar is visible.
// Returns nsEventStatus_eIgnore when the event is not consumed and
// nsEventStatus_eConsumeNoDefault when the event was used to translate the
// toolbar.
nsEventStatus ReceiveInputEvent(InputData& aEvent, const ScreenPoint& aScrollOffset);
void SetMaxToolbarHeight(ScreenIntCoord aHeight);
@@ -163,17 +163,17 @@ protected:
void CheckForResetOnNextMove(ScreenIntCoord aCurrentTouch);
// Returns true if the page scroll offset is near the bottom.
bool ScrollOffsetNearBottom() const;
// Returns true if toolbar is not completely visible nor completely hidden.
bool ToolbarInTransition();
void QueueMessage(int32_t aMessage);
// Read only Compositor and Controller threads after Initialize()
- uint64_t mRootLayerTreeId;
+ LayersId mRootLayerTreeId;
MOZ_NON_OWNING_REF APZCTreeManager* mApz;
// Read/Write Compositor Thread, Read only Controller thread
Atomic<StaticToolbarState> mToolbarState; // Current toolbar state.
Atomic<uint32_t> mPinnedFlags; // The toolbar should not be moved or animated unless no flags are set
// Controller thread only
bool mControllerScrollingRootContent; // Set to true when the root content is being scrolled
--- a/gfx/layers/apz/src/AsyncPanZoomController.cpp
+++ b/gfx/layers/apz/src/AsyncPanZoomController.cpp
@@ -765,17 +765,17 @@ AsyncPanZoomController::InitializeGlobal
gfxPrefs::APZCurveFunctionY2()));
ClearOnShutdown(&gVelocityCurveFunction);
uint64_t sysmem = PR_GetPhysicalMemorySize();
uint64_t threshold = 1LL << 32; // 4 GB in bytes
gIsHighMemSystem = sysmem >= threshold;
}
-AsyncPanZoomController::AsyncPanZoomController(uint64_t aLayersId,
+AsyncPanZoomController::AsyncPanZoomController(LayersId aLayersId,
APZCTreeManager* aTreeManager,
const RefPtr<InputQueue>& aInputQueue,
GeckoContentController* aGeckoContentController,
GestureBehavior aGestures)
: mLayersId(aLayersId),
mGeckoContentController(aGeckoContentController),
mRefPtrMonitor("RefPtrMonitor"),
// mTreeManager must be initialized before GetFrameTime() is called
--- a/gfx/layers/apz/src/AsyncPanZoomController.h
+++ b/gfx/layers/apz/src/AsyncPanZoomController.h
@@ -174,17 +174,17 @@ public:
ScreenCoord GetTouchMoveTolerance() const;
/**
* Same as GetTouchStartTolerance, but the tolerance for how close the second
* tap has to be to the first tap in order to be counted as part of a multi-tap
* gesture (double-tap or one-touch-pinch).
*/
ScreenCoord GetSecondTapTolerance() const;
- AsyncPanZoomController(uint64_t aLayersId,
+ AsyncPanZoomController(LayersId aLayersId,
APZCTreeManager* aTreeManager,
const RefPtr<InputQueue>& aInputQueue,
GeckoContentController* aController,
GestureBehavior aGestures = DEFAULT_GESTURES);
// --------------------------------------------------------------------------
// These methods must only be called on the gecko thread.
//
@@ -781,17 +781,17 @@ protected:
// OnLongPressUp().
nsEventStatus GenerateSingleTap(GeckoContentController::TapType aType,
const ScreenIntPoint& aPoint,
mozilla::Modifiers aModifiers);
// Common processing at the end of a touch block.
void OnTouchEndOrCancel();
- uint64_t mLayersId;
+ LayersId mLayersId;
RefPtr<CompositorController> mCompositorController;
RefPtr<MetricsSharingController> mMetricsSharingController;
/* Access to the following two fields is protected by the mRefPtrMonitor,
since they are accessed on the UI thread but can be cleared on the
sampler thread. */
RefPtr<GeckoContentController> mGeckoContentController;
RefPtr<GestureEventListener> mGestureEventListener;
@@ -1361,17 +1361,17 @@ public:
mAsyncTransformAppliedToContent = true;
}
bool GetAsyncTransformAppliedToContent() const
{
return mAsyncTransformAppliedToContent;
}
- uint64_t GetLayersId() const
+ LayersId GetLayersId() const
{
return mLayersId;
}
private:
// Extra offset to add to the async scroll position for testing
CSSPoint mTestAsyncScrollOffset;
// Extra zoom to include in the aync zoom for testing
--- a/gfx/layers/apz/src/FocusState.cpp
+++ b/gfx/layers/apz/src/FocusState.cpp
@@ -15,17 +15,17 @@ namespace mozilla {
namespace layers {
FocusState::FocusState()
: mMutex("FocusStateMutex")
, mLastAPZProcessedEvent(1)
, mLastContentProcessedEvent(0)
, mFocusHasKeyEventListeners(false)
, mReceivedUpdate(false)
- , mFocusLayersId(0)
+ , mFocusLayersId{0}
, mFocusHorizontalTarget(FrameMetrics::NULL_SCROLL_ID)
, mFocusVerticalTarget(FrameMetrics::NULL_SCROLL_ID)
{
}
uint64_t
FocusState::LastAPZProcessedEvent() const
{
@@ -61,18 +61,18 @@ FocusState::ReceiveFocusChangingEvent()
return;
}
mLastAPZProcessedEvent += 1;
FS_LOG("Focus changing event incremented aseq to %" PRIu64 "\n",
mLastAPZProcessedEvent);
}
void
-FocusState::Update(uint64_t aRootLayerTreeId,
- uint64_t aOriginatingLayersId,
+FocusState::Update(LayersId aRootLayerTreeId,
+ LayersId aOriginatingLayersId,
const FocusTarget& aState)
{
APZThreadUtils::AssertOnSamplerThread();
MutexAutoLock lock(mMutex);
FS_LOG("Update with rlt=%" PRIu64 ", olt=%" PRIu64 ", ft=(%s, %" PRIu64 ")\n",
aRootLayerTreeId,
aOriginatingLayersId,
@@ -127,17 +127,17 @@ FocusState::Update(uint64_t aRootLayerTr
// numbers.
if (mFocusState.mLastAPZProcessedEvent == 1 &&
mFocusState.mLastContentProcessedEvent > mFocusState.mLastAPZProcessedEvent) {
mFocusState.mLastAPZProcessedEvent = mFocusState.mLastContentProcessedEvent;
}
return true;
}
- bool match(const FocusTarget::RefLayerId aRefLayerId) {
+ bool match(const LayersId& aRefLayerId) {
// Guard against infinite loops
MOZ_ASSERT(mFocusState.mFocusLayersId != aRefLayerId);
if (mFocusState.mFocusLayersId == aRefLayerId) {
FS_LOG("Setting target to nil (bailing out of infinite loop, lt=%" PRIu64 ")\n",
mFocusState.mFocusLayersId);
return true;
}
@@ -175,17 +175,17 @@ FocusState::Update(uint64_t aRootLayerTr
if (target.mData.match(FocusTargetDataMatcher{*this, target.mSequenceNumber})) {
return;
}
}
}
void
-FocusState::RemoveFocusTarget(uint64_t aLayersId)
+FocusState::RemoveFocusTarget(LayersId aLayersId)
{
APZThreadUtils::AssertOnSamplerThread();
MutexAutoLock lock(mMutex);
mFocusTree.erase(aLayersId);
}
Maybe<ScrollableLayerGuid>
--- a/gfx/layers/apz/src/FocusState.h
+++ b/gfx/layers/apz/src/FocusState.h
@@ -90,24 +90,24 @@ public:
* Update the internal focus tree and recalculate the global focus target for
* a focus target update received from chrome or content.
*
* @param aRootLayerTreeId the layer tree ID of the root layer for the
parent APZCTreeManager
* @param aOriginatingLayersId the layer tree ID that this focus target
belongs to
*/
- void Update(uint64_t aRootLayerTreeId,
- uint64_t aOriginatingLayersId,
+ void Update(LayersId aRootLayerTreeId,
+ LayersId aOriginatingLayersId,
const FocusTarget& aTarget);
/**
* Removes a focus target by its layer tree ID.
*/
- void RemoveFocusTarget(uint64_t aLayersId);
+ void RemoveFocusTarget(LayersId aLayersId);
/**
* Gets the scrollable layer that should be horizontally scrolled for a key
* event, if any. The returned ScrollableLayerGuid doesn't contain a presShellId,
* and so it should not be used in comparisons.
*
* No scrollable layer is returned if any of the following are true:
* 1. We don't have a current focus target
@@ -137,17 +137,20 @@ private:
bool IsCurrent(const MutexAutoLock& aLock) const;
private:
// All methods should hold this lock, since this class is accessed via both
// the sampler and controller threads.
mutable Mutex mMutex;
// The set of focus targets received indexed by their layer tree ID
- std::unordered_map<uint64_t, FocusTarget> mFocusTree;
+ std::unordered_map<LayersId,
+ FocusTarget,
+ LayersId::HashFn,
+ LayersId::EqualFn> mFocusTree;
// The focus sequence number of the last potentially focus changing event
// processed by APZ. This number starts at one and increases monotonically.
// We don't worry about wrap around here because at a pace of 100 increments/sec,
// it would take 5.85*10^9 years before we would wrap around. This number will
// never be zero as that is used to catch uninitialized focus sequence numbers
// on input events.
uint64_t mLastAPZProcessedEvent;
@@ -156,17 +159,17 @@ private:
// A flag whether there is a key listener on the event target chain for the
// focused element
bool mFocusHasKeyEventListeners;
// A flag that is false until the first call to Update().
bool mReceivedUpdate;
// The layer tree ID which contains the scrollable frame of the focused element
- uint64_t mFocusLayersId;
+ LayersId mFocusLayersId;
// The scrollable layer corresponding to the scrollable frame that is used to
// scroll the focused element. This depends on the direction the user is
// scrolling.
FrameMetrics::ViewID mFocusHorizontalTarget;
FrameMetrics::ViewID mFocusVerticalTarget;
};
} // namespace layers
--- a/gfx/layers/apz/src/FocusTarget.cpp
+++ b/gfx/layers/apz/src/FocusTarget.cpp
@@ -169,17 +169,17 @@ FocusTarget::FocusTarget(nsIPresShell* a
// The globally focused element for scrolling is in a remote layer tree
if (rfp) {
FT_LOG("Creating reflayer target with seq=%" PRIu64 ", kl=%d, lt=%" PRIu64 "\n",
aFocusSequenceNumber,
mFocusHasKeyEventListeners,
rfp->GetLayersId());
- mData = AsVariant<RefLayerId>(rfp->GetLayersId());
+ mData = AsVariant<LayersId>(rfp->GetLayersId());
return;
}
FT_LOG("Creating nil target with seq=%" PRIu64 ", kl=%d (remote browser missing layers id)\n",
aFocusSequenceNumber,
mFocusHasKeyEventListeners);
return;
@@ -229,18 +229,18 @@ FocusTarget::operator==(const FocusTarge
return mSequenceNumber == aRhs.mSequenceNumber &&
mFocusHasKeyEventListeners == aRhs.mFocusHasKeyEventListeners &&
mData == aRhs.mData;
}
const char*
FocusTarget::Type() const
{
- if (mData.is<RefLayerId>()) {
- return "RefLayerId";
+ if (mData.is<LayersId>()) {
+ return "LayersId";
}
if (mData.is<ScrollTargets>()) {
return "ScrollTargets";
}
if (mData.is<NoFocusTarget>()) {
return "NoFocusTarget";
}
return "<unknown>";
--- a/gfx/layers/apz/src/FocusTarget.h
+++ b/gfx/layers/apz/src/FocusTarget.h
@@ -34,18 +34,16 @@ public:
bool operator==(const ScrollTargets& aRhs) const
{
return mHorizontal == aRhs.mHorizontal &&
mVertical == aRhs.mVertical;
}
};
- typedef uint64_t RefLayerId;
-
// We need this to represent the case where mData has no focus target data
// because we can't have an empty variant
struct NoFocusTarget {
bool operator==(const NoFocusTarget& aRhs) const
{
return true;
}
};
@@ -65,15 +63,15 @@ public:
public:
// The content sequence number recorded at the time of this class's creation
uint64_t mSequenceNumber;
// Whether there are keydown, keypress, or keyup event listeners
// in the event target chain of the focused element
bool mFocusHasKeyEventListeners;
- mozilla::Variant<RefLayerId, ScrollTargets, NoFocusTarget> mData;
+ mozilla::Variant<LayersId, ScrollTargets, NoFocusTarget> mData;
};
} // namespace layers
} // namespace mozilla
#endif // mozilla_layers_FocusTarget_h
--- a/gfx/layers/apz/src/HitTestingTreeNode.cpp
+++ b/gfx/layers/apz/src/HitTestingTreeNode.cpp
@@ -19,34 +19,34 @@
namespace mozilla {
namespace layers {
using gfx::CompositorHitTestInfo;
HitTestingTreeNode::HitTestingTreeNode(AsyncPanZoomController* aApzc,
bool aIsPrimaryHolder,
- uint64_t aLayersId)
+ LayersId aLayersId)
: mApzc(aApzc)
, mIsPrimaryApzcHolder(aIsPrimaryHolder)
, mLayersId(aLayersId)
, mScrollViewId(FrameMetrics::NULL_SCROLL_ID)
, mScrollbarAnimationId(0)
, mFixedPosTarget(FrameMetrics::NULL_SCROLL_ID)
, mOverride(EventRegionsOverride::NoOverride)
{
if (mIsPrimaryApzcHolder) {
MOZ_ASSERT(mApzc);
}
MOZ_ASSERT(!mApzc || mApzc->GetLayersId() == mLayersId);
}
void
HitTestingTreeNode::RecycleWith(AsyncPanZoomController* aApzc,
- uint64_t aLayersId)
+ LayersId aLayersId)
{
MOZ_ASSERT(!mIsPrimaryApzcHolder);
Destroy(); // clear out tree pointers
mApzc = aApzc;
mLayersId = aLayersId;
MOZ_ASSERT(!mApzc || mApzc->GetLayersId() == mLayersId);
// The caller is expected to call SetHitTestData to repopulate the hit-test
// fields.
@@ -67,17 +67,17 @@ HitTestingTreeNode::Destroy()
if (mApzc) {
if (mIsPrimaryApzcHolder) {
mApzc->Destroy();
}
mApzc = nullptr;
}
- mLayersId = 0;
+ mLayersId = LayersId{0};
}
void
HitTestingTreeNode::SetLastChild(HitTestingTreeNode* aChild)
{
mLastChild = aChild;
if (aChild) {
aChild->mParent = this;
@@ -247,17 +247,17 @@ HitTestingTreeNode::GetNearestContaining
}
bool
HitTestingTreeNode::IsPrimaryHolder() const
{
return mIsPrimaryApzcHolder;
}
-uint64_t
+LayersId
HitTestingTreeNode::GetLayersId() const
{
return mLayersId;
}
void
HitTestingTreeNode::SetHitTestData(const EventRegions& aRegions,
const LayerIntRegion& aVisibleRegion,
@@ -372,17 +372,17 @@ HitTestingTreeNode::GetVisibleRegion() c
void
HitTestingTreeNode::Dump(const char* aPrefix) const
{
if (mPrevSibling) {
mPrevSibling->Dump(aPrefix);
}
printf_stderr("%sHitTestingTreeNode (%p) APZC (%p) g=(%s) %s%s%sr=(%s) t=(%s) c=(%s)%s%s\n",
aPrefix, this, mApzc.get(),
- mApzc ? Stringify(mApzc->GetGuid()).c_str() : nsPrintfCString("l=0x%" PRIx64, mLayersId).get(),
+ mApzc ? Stringify(mApzc->GetGuid()).c_str() : nsPrintfCString("l=0x%" PRIx64, uint64_t(mLayersId)).get(),
(mOverride & EventRegionsOverride::ForceDispatchToContent) ? "fdtc " : "",
(mOverride & EventRegionsOverride::ForceEmptyHitRegion) ? "fehr " : "",
(mFixedPosTarget != FrameMetrics::NULL_SCROLL_ID) ? nsPrintfCString("fixed=%" PRIu64 " ", mFixedPosTarget).get() : "",
Stringify(mEventRegions).c_str(), Stringify(mTransform).c_str(),
mClipRegion ? Stringify(mClipRegion.ref()).c_str() : "none",
mScrollbarContainerDirection.isSome() ? " scrollbar" : "",
IsScrollThumbNode() ? " scrollthumb" : "");
if (mLastChild) {
--- a/gfx/layers/apz/src/HitTestingTreeNode.h
+++ b/gfx/layers/apz/src/HitTestingTreeNode.h
@@ -51,18 +51,18 @@ class AsyncPanZoomController;
*/
class HitTestingTreeNode {
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(HitTestingTreeNode);
private:
~HitTestingTreeNode();
public:
HitTestingTreeNode(AsyncPanZoomController* aApzc, bool aIsPrimaryHolder,
- uint64_t aLayersId);
- void RecycleWith(AsyncPanZoomController* aApzc, uint64_t aLayersId);
+ LayersId aLayersId);
+ void RecycleWith(AsyncPanZoomController* aApzc, LayersId aLayersId);
void Destroy();
/* Tree construction methods */
void SetLastChild(HitTestingTreeNode* aChild);
void SetPrevSibling(HitTestingTreeNode* aSibling);
void MakeRoot();
@@ -76,17 +76,17 @@ public:
bool IsAncestorOf(const HitTestingTreeNode* aOther) const;
/* APZC related methods */
AsyncPanZoomController* GetApzc() const;
AsyncPanZoomController* GetNearestContainingApzc() const;
bool IsPrimaryHolder() const;
- uint64_t GetLayersId() const;
+ LayersId GetLayersId() const;
/* Hit test related methods */
void SetHitTestData(const EventRegions& aRegions,
const LayerIntRegion& aVisibleRegion,
const CSSTransformMatrix& aTransform,
const Maybe<ParentLayerIntRegion>& aClipRegion,
const EventRegionsOverride& aOverride);
@@ -133,17 +133,17 @@ private:
RefPtr<HitTestingTreeNode> mLastChild;
RefPtr<HitTestingTreeNode> mPrevSibling;
RefPtr<HitTestingTreeNode> mParent;
RefPtr<AsyncPanZoomController> mApzc;
bool mIsPrimaryApzcHolder;
- uint64_t mLayersId;
+ LayersId mLayersId;
// This is set for both scroll track and scroll thumb Container layers, and
// represents the scroll id of the scroll frame scrolled by the scrollbar.
FrameMetrics::ViewID mScrollViewId;
// This is only set to non-zero if WebRender is enabled, and only for HTTNs
// where IsScrollThumbNode() returns true. It holds the animation id that we
// use to move the thumb node to reflect async scrolling.
--- a/gfx/layers/apz/test/gtest/APZCBasicTester.h
+++ b/gfx/layers/apz/test/gtest/APZCBasicTester.h
@@ -24,17 +24,17 @@ public:
protected:
virtual void SetUp()
{
gfxPrefs::GetSingleton();
APZThreadUtils::SetThreadAssertionsEnabled(false);
APZThreadUtils::SetControllerThread(MessageLoop::current());
tm = new TestAPZCTreeManager(mcc);
- apzc = new TestAsyncPanZoomController(0, mcc, tm, mGestureBehavior);
+ apzc = new TestAsyncPanZoomController(LayersId{0}, mcc, tm, mGestureBehavior);
apzc->SetFrameMetrics(TestFrameMetrics());
apzc->GetScrollMetadata().SetIsLayersIdRoot(true);
}
/**
* Get the APZC's scroll range in CSS pixels.
*/
CSSRect GetScrollRange() const
--- a/gfx/layers/apz/test/gtest/APZTestCommon.h
+++ b/gfx/layers/apz/test/gtest/APZTestCommon.h
@@ -168,43 +168,43 @@ private:
// timestamp).
nsTArray<std::pair<RefPtr<Runnable>, TimeStamp>> mTaskQueue;
TimeStamp mTime;
};
class TestAPZCTreeManager : public APZCTreeManager {
public:
explicit TestAPZCTreeManager(MockContentControllerDelayed* aMcc)
- : APZCTreeManager(0)
+ : APZCTreeManager(LayersId{0})
, mcc(aMcc)
{}
RefPtr<InputQueue> GetInputQueue() const {
return mInputQueue;
}
void ClearContentController() {
mcc = nullptr;
}
protected:
- AsyncPanZoomController* NewAPZCInstance(uint64_t aLayersId,
+ AsyncPanZoomController* NewAPZCInstance(LayersId aLayersId,
GeckoContentController* aController) override;
TimeStamp GetFrameTime() override {
return mcc->Time();
}
private:
RefPtr<MockContentControllerDelayed> mcc;
};
class TestAsyncPanZoomController : public AsyncPanZoomController {
public:
- TestAsyncPanZoomController(uint64_t aLayersId, MockContentControllerDelayed* aMcc,
+ TestAsyncPanZoomController(LayersId aLayersId, MockContentControllerDelayed* aMcc,
TestAPZCTreeManager* aTreeManager,
GestureBehavior aBehavior = DEFAULT_GESTURES)
: AsyncPanZoomController(aLayersId, aTreeManager, aTreeManager->GetInputQueue(),
aMcc, aBehavior)
, mWaitForMainThread(false)
, mcc(aMcc)
{}
@@ -630,17 +630,17 @@ APZCTesterBase::DoubleTapAndCheckStatus(
DoubleTap(aTarget, aPoint, &statuses, aOutInputBlockIds);
EXPECT_EQ(nsEventStatus_eConsumeDoDefault, statuses[0]);
EXPECT_EQ(nsEventStatus_eConsumeDoDefault, statuses[1]);
EXPECT_EQ(nsEventStatus_eConsumeDoDefault, statuses[2]);
EXPECT_EQ(nsEventStatus_eConsumeDoDefault, statuses[3]);
}
AsyncPanZoomController*
-TestAPZCTreeManager::NewAPZCInstance(uint64_t aLayersId,
+TestAPZCTreeManager::NewAPZCInstance(LayersId aLayersId,
GeckoContentController* aController)
{
MockContentControllerDelayed* mcc = static_cast<MockContentControllerDelayed*>(aController);
return new TestAsyncPanZoomController(aLayersId, mcc, this,
AsyncPanZoomController::USE_GESTURE_DETECTOR);
}
FrameMetrics
--- a/gfx/layers/apz/test/gtest/TestBasic.cpp
+++ b/gfx/layers/apz/test/gtest/TestBasic.cpp
@@ -55,17 +55,17 @@ TEST_F(APZCBasicTester, ComplexTransform
// CSS transforms, the two layers are the same size in screen
// pixels.
//
// The screen itself is 24x24 in screen pixels (therefore 4x4 in
// CSS pixels). The displayport is 1 extra CSS pixel on all
// sides.
RefPtr<TestAsyncPanZoomController> childApzc =
- new TestAsyncPanZoomController(0, mcc, tm);
+ new TestAsyncPanZoomController(LayersId{0}, mcc, tm);
const char* layerTreeSyntax = "c(c)";
// LayerID 0 1
nsIntRegion layerVisibleRegion[] = {
nsIntRegion(IntRect(0, 0, 300, 300)),
nsIntRegion(IntRect(0, 0, 150, 300)),
};
Matrix4x4 transforms[] = {
--- a/gfx/layers/apz/test/gtest/TestEventRegions.cpp
+++ b/gfx/layers/apz/test/gtest/TestEventRegions.cpp
@@ -36,18 +36,18 @@ protected:
EventRegions regions(nsIntRegion(IntRect(0, 0, 200, 200)));
root->SetEventRegions(regions);
regions.mDispatchToContentHitRegion = nsIntRegion(IntRect(0, 100, 100, 100));
regions.mHitRegion = nsIntRegion(IntRect(0, 0, 100, 200));
layers[1]->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 100, 200, 100));
layers[2]->SetEventRegions(regions);
- registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
rootApzc = ApzcOf(root);
}
void CreateEventRegionsLayerTree2() {
const char* layerTreeSyntax = "c(t)";
nsIntRegion layerVisibleRegions[] = {
nsIntRegion(IntRect(0, 0, 100, 500)),
nsIntRegion(IntRect(0, 150, 100, 100)),
@@ -57,18 +57,18 @@ protected:
// Set up the event regions so that the child thebes layer is positioned far
// away from the scrolling container layer.
EventRegions regions(nsIntRegion(IntRect(0, 0, 100, 100)));
root->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 150, 100, 100));
layers[1]->SetEventRegions(regions);
- registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
rootApzc = ApzcOf(root);
}
void CreateObscuringLayerTree() {
const char* layerTreeSyntax = "c(c(t)t)";
// LayerID 0 1 2 3
// 0 is the root.
// 1 is a parent scrollable layer.
@@ -91,18 +91,18 @@ protected:
EventRegions regions(nsIntRegion(IntRect(0, 0, 200, 200)));
root->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 0, 200, 300));
layers[1]->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 100, 200, 100));
layers[2]->SetEventRegions(regions);
- registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
rootApzc = ApzcOf(root);
}
void CreateBug1119497LayerTree() {
const char* layerTreeSyntax = "c(tt)";
// LayerID 0 12
// 0 is the root and has an APZC
// 1 is behind 2 and has an APZC
@@ -113,18 +113,18 @@ protected:
nsIntRegion(IntRect(0, 0, 100, 100)),
nsIntRegion(IntRect(0, 0, 100, 100)),
};
root = CreateLayerTree(layerTreeSyntax, layerVisibleRegions, nullptr, lm, layers);
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID);
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 1);
- registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
}
void CreateBug1117712LayerTree() {
const char* layerTreeSyntax = "c(c(t)t)";
// LayerID 0 1 2 3
// 0 is the root
// 1 is a container layer whose sole purpose to make a non-empty ancestor
// transform for 2, so that 2's screen-to-apzc and apzc-to-gecko
@@ -150,18 +150,18 @@ protected:
SetScrollHandoff(layers[3], layers[2]);
EventRegions regions(nsIntRegion(IntRect(0, 0, 10, 10)));
layers[2]->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 0, 100, 100));
regions.mDispatchToContentHitRegion = nsIntRegion(IntRect(0, 0, 100, 100));
layers[3]->SetEventRegions(regions);
- registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
}
};
TEST_F(APZEventRegionsTester, HitRegionImmediateResponse) {
SCOPED_GFX_PREF(WebRenderHitTest, bool, false);
CreateEventRegionsLayerTree1();
@@ -226,19 +226,19 @@ TEST_F(APZEventRegionsTester, HitRegionA
EXPECT_CALL(*mcc, HandleTap(TapType::eSingleTap, _, _, rootApzc->GetGuid(), _)).Times(1);
Tap(manager, ScreenIntPoint(10, 160), TimeDuration::FromMilliseconds(100));
}
TEST_F(APZEventRegionsTester, Obscuration) {
SCOPED_GFX_PREF(WebRenderHitTest, bool, false);
CreateObscuringLayerTree();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
TestAsyncPanZoomController* parent = ApzcOf(layers[1]);
TestAsyncPanZoomController* child = ApzcOf(layers[2]);
ApzcPanNoFling(parent, 75, 25);
gfx::CompositorHitTestInfo result;
RefPtr<AsyncPanZoomController> hit = manager->GetTargetAPZC(ScreenPoint(50, 75), &result);
--- a/gfx/layers/apz/test/gtest/TestHitTesting.cpp
+++ b/gfx/layers/apz/test/gtest/TestHitTesting.cpp
@@ -102,54 +102,54 @@ protected:
}
};
// A simple hit testing test that doesn't involve any transforms on layers.
TEST_F(APZHitTestingTester, HitTesting1) {
SCOPED_GFX_PREF(WebRenderHitTest, bool, false);
CreateHitTesting1LayerTree();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
// No APZC attached so hit testing will return no APZC at (20,20)
RefPtr<AsyncPanZoomController> hit = GetTargetAPZC(ScreenPoint(20, 20));
TestAsyncPanZoomController* nullAPZC = nullptr;
EXPECT_EQ(nullAPZC, hit.get());
EXPECT_EQ(ScreenToParentLayerMatrix4x4(), transformToApzc);
EXPECT_EQ(ParentLayerToScreenMatrix4x4(), transformToGecko);
uint32_t paintSequenceNumber = 0;
// Now we have a root APZC that will match the page
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID);
- manager->UpdateHitTestingTree(0, root, false, 0, paintSequenceNumber++);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, paintSequenceNumber++);
hit = GetTargetAPZC(ScreenPoint(15, 15));
EXPECT_EQ(ApzcOf(root), hit.get());
// expect hit point at LayerIntPoint(15, 15)
EXPECT_EQ(ParentLayerPoint(15, 15), transformToApzc.TransformPoint(ScreenPoint(15, 15)));
EXPECT_EQ(ScreenPoint(15, 15), transformToGecko.TransformPoint(ParentLayerPoint(15, 15)));
// Now we have a sub APZC with a better fit
SetScrollableFrameMetrics(layers[3], FrameMetrics::START_SCROLL_ID + 1);
- manager->UpdateHitTestingTree(0, root, false, 0, paintSequenceNumber++);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, paintSequenceNumber++);
EXPECT_NE(ApzcOf(root), ApzcOf(layers[3]));
hit = GetTargetAPZC(ScreenPoint(25, 25));
EXPECT_EQ(ApzcOf(layers[3]), hit.get());
// expect hit point at LayerIntPoint(25, 25)
EXPECT_EQ(ParentLayerPoint(25, 25), transformToApzc.TransformPoint(ScreenPoint(25, 25)));
EXPECT_EQ(ScreenPoint(25, 25), transformToGecko.TransformPoint(ParentLayerPoint(25, 25)));
// At this point, layers[4] obscures layers[3] at the point (15, 15) so
// hitting there should hit the root APZC
hit = GetTargetAPZC(ScreenPoint(15, 15));
EXPECT_EQ(ApzcOf(root), hit.get());
// Now test hit testing when we have two scrollable layers
SetScrollableFrameMetrics(layers[4], FrameMetrics::START_SCROLL_ID + 2);
- manager->UpdateHitTestingTree(0, root, false, 0, paintSequenceNumber++);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, paintSequenceNumber++);
hit = GetTargetAPZC(ScreenPoint(15, 15));
EXPECT_EQ(ApzcOf(layers[4]), hit.get());
// expect hit point at LayerIntPoint(15, 15)
EXPECT_EQ(ParentLayerPoint(15, 15), transformToApzc.TransformPoint(ScreenPoint(15, 15)));
EXPECT_EQ(ScreenPoint(15, 15), transformToGecko.TransformPoint(ParentLayerPoint(15, 15)));
// Hit test ouside the reach of layer[3,4] but inside root
hit = GetTargetAPZC(ScreenPoint(90, 90));
@@ -170,19 +170,19 @@ TEST_F(APZHitTestingTester, HitTesting1)
}
// A more involved hit testing test that involves css and async transforms.
TEST_F(APZHitTestingTester, HitTesting2) {
SCOPED_GFX_PREF(WebRenderHitTest, bool, false);
SCOPED_GFX_PREF(APZVelocityBias, float, 0.0); // Velocity bias can cause extra repaint requests
CreateHitTesting2LayerTree();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
// At this point, the following holds (all coordinates in screen pixels):
// layers[0] has content from (0,0)-(200,200), clipped by composition bounds (0,0)-(100,100)
// layers[1] has content from (10,10)-(90,90), clipped by composition bounds (10,10)-(50,50)
// layers[2] has content from (20,60)-(100,100). no clipping as it's not a scrollable layer
// layers[3] has content from (20,60)-(180,140), clipped by composition bounds (20,60)-(100,100)
TestAsyncPanZoomController* apzcroot = ApzcOf(root);
@@ -294,30 +294,30 @@ TEST_F(APZHitTestingTester, HitTesting3)
Matrix4x4(),
Matrix4x4::Scaling(2, 2, 1)
};
root = CreateLayerTree(layerTreeSyntax, layerVisibleRegions, transforms, lm, layers);
// No actual room to scroll
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID, CSSRect(0, 0, 200, 200));
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 1, CSSRect(0, 0, 50, 50));
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
RefPtr<AsyncPanZoomController> hit = GetTargetAPZC(ScreenPoint(75, 75));
EXPECT_EQ(ApzcOf(layers[1]), hit.get());
}
TEST_F(APZHitTestingTester, ComplexMultiLayerTree) {
SCOPED_GFX_PREF(WebRenderHitTest, bool, false);
CreateComplexMultiLayerTree();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
/* The layer tree looks like this:
0
|----|--+--|----|
1 2 4 5
| /|\
3 6 8 9
@@ -396,18 +396,18 @@ TEST_F(APZHitTestingTester, TestRepaintF
SCOPED_GFX_PREF(TouchActionEnabled, bool, false);
// The main purpose of this test is to verify that touch-start events (or anything
// that starts a new input block) don't ever get untransformed. This should always
// hold because the APZ code should flush repaints when we start a new input block
// and the transform to gecko space should be empty.
CreateSimpleScrollingLayer();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
TestAsyncPanZoomController* apzcroot = ApzcOf(root);
// At this point, the following holds (all coordinates in screen pixels):
// layers[0] has content from (0,0)-(500,500), clipped by composition bounds (0,0)-(200,200)
MockFunction<void(std::string checkPointName)> check;
{
@@ -461,18 +461,18 @@ TEST_F(APZHitTestingTester, TestRepaintF
EXPECT_EQ(touchPoint, mti.mTouches[0].mScreenPoint);
}
TEST_F(APZHitTestingTester, TestRepaintFlushOnWheelEvents) {
// The purpose of this test is to ensure that wheel events trigger a repaint
// flush as per bug 1166871, and that the wheel event untransform is a no-op.
CreateSimpleScrollingLayer();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
TestAsyncPanZoomController* apzcroot = ApzcOf(root);
EXPECT_CALL(*mcc, RequestContentRepaint(_)).Times(AtLeast(3));
ScreenPoint origin(100, 50);
for (int i = 0; i < 3; i++) {
ScrollWheelInput swi(MillisecondsSinceStartup(mcc->Time()), mcc->Time(), 0,
ScrollWheelInput::SCROLLMODE_INSTANT, ScrollWheelInput::SCROLLDELTA_PIXEL,
origin, 0, 10, false);
@@ -489,18 +489,18 @@ TEST_F(APZHitTestingTester, TestRepaintF
mcc->AdvanceByMillis(5);
}
}
TEST_F(APZHitTestingTester, TestForceDisableApz) {
CreateSimpleScrollingLayer();
DisableApzOn(root);
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
TestAsyncPanZoomController* apzcroot = ApzcOf(root);
ScreenPoint origin(100, 50);
ScrollWheelInput swi(MillisecondsSinceStartup(mcc->Time()), mcc->Time(), 0,
ScrollWheelInput::SCROLLMODE_INSTANT, ScrollWheelInput::SCROLLDELTA_PIXEL,
origin, 0, 10, false);
EXPECT_EQ(nsEventStatus_eConsumeDoDefault, manager->ReceiveInputEvent(swi, nullptr, nullptr));
EXPECT_EQ(origin, swi.mOrigin);
@@ -530,18 +530,18 @@ TEST_F(APZHitTestingTester, TestForceDis
ScrollWheelInput::SCROLLMODE_INSTANT, ScrollWheelInput::SCROLLDELTA_PIXEL,
origin, 0, 0, false);
EXPECT_EQ(nsEventStatus_eConsumeDoDefault, manager->ReceiveInputEvent(swi, nullptr, nullptr));
EXPECT_EQ(origin, swi.mOrigin);
}
TEST_F(APZHitTestingTester, Bug1148350) {
CreateBug1148350LayerTree();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
MockFunction<void(std::string checkPointName)> check;
{
InSequence s;
EXPECT_CALL(*mcc, HandleTap(TapType::eSingleTap, LayoutDevicePoint(100, 100), 0, ApzcOf(layers[1])->GetGuid(), _)).Times(1);
EXPECT_CALL(check, Call("Tapped without transform"));
EXPECT_CALL(*mcc, HandleTap(TapType::eSingleTap, LayoutDevicePoint(100, 100), 0, ApzcOf(layers[1])->GetGuid(), _)).Times(1);
EXPECT_CALL(check, Call("Tapped with interleaved transform"));
@@ -555,17 +555,17 @@ TEST_F(APZHitTestingTester, Bug1148350)
TouchDown(manager, ScreenIntPoint(100, 100), mcc->Time(), &blockId);
if (gfxPrefs::TouchActionEnabled()) {
SetDefaultAllowedTouchBehavior(manager, blockId);
}
mcc->AdvanceByMillis(100);
layers[0]->SetVisibleRegion(LayerIntRegion(LayerIntRect(0,50,200,150)));
layers[0]->SetBaseTransform(Matrix4x4::Translation(0, 50, 0));
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
TouchUp(manager, ScreenIntPoint(100, 100), mcc->Time());
mcc->RunThroughDelayedTasks();
check.Call("Tapped with interleaved transform");
}
TEST_F(APZHitTestingTester, HitTestingRespectsScrollClip_Bug1257288) {
// Create the layer tree.
@@ -593,18 +593,18 @@ TEST_F(APZHitTestingTester, HitTestingRe
FrameMetrics::START_SCROLL_ID + 1, CSSRect(0,0,200,200),
ParentLayerRect(0,0,200,100));
subframeMetadata.SetScrollClip(Some(LayerClip(ParentLayerIntRect(0,0,200,100))));
layers[2]->SetScrollMetadata({subframeMetadata, rootMetadata});
layers[2]->SetClipRect(Some(ParentLayerIntRect(0,0,200,200)));
SetEventRegionsBasedOnBottommostMetrics(layers[2]);
// Build the hit testing tree.
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
// Pan on a region that's inside layers[2]'s layer clip, but outside
// its subframe metadata's scroll clip.
Pan(manager, 120, 110);
// Test that the subframe hasn't scrolled.
EXPECT_EQ(CSSPoint(0,0), ApzcOf(layers[2], 0)->GetFrameMetrics().GetScrollOffset());
}
--- a/gfx/layers/apz/test/gtest/TestInputQueue.cpp
+++ b/gfx/layers/apz/test/gtest/TestInputQueue.cpp
@@ -8,18 +8,18 @@
#include "APZTestCommon.h"
#include "InputUtils.h"
// Test of scenario described in bug 1269067 - that a continuing mouse drag
// doesn't interrupt a wheel scrolling animation
TEST_F(APZCTreeManagerTester, WheelInterruptedByMouseDrag) {
// Set up a scrollable layer
CreateSimpleScrollingLayer();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
RefPtr<TestAsyncPanZoomController> apzc = ApzcOf(root);
uint64_t dragBlockId = 0;
uint64_t wheelBlockId = 0;
uint64_t tmpBlockId = 0;
// First start the mouse drag
MouseDown(apzc, ScreenIntPoint(5, 5), mcc->Time(), &dragBlockId);
--- a/gfx/layers/apz/test/gtest/TestScrollHandoff.cpp
+++ b/gfx/layers/apz/test/gtest/TestScrollHandoff.cpp
@@ -18,18 +18,18 @@ protected:
nsIntRegion layerVisibleRegion[] = {
nsIntRegion(IntRect(0, 0, 100, 100)),
nsIntRegion(IntRect(0, 50, 100, 50))
};
root = CreateLayerTree(layerTreeSyntax, layerVisibleRegion, nullptr, lm, layers);
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID, CSSRect(0, 0, 200, 200));
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 1, CSSRect(0, 0, 100, 100));
SetScrollHandoff(layers[1], root);
- registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
rootApzc = ApzcOf(root);
rootApzc->GetFrameMetrics().SetIsRootContent(true); // make root APZC zoomable
}
void CreateScrollHandoffLayerTree2() {
const char* layerTreeSyntax = "c(c(t))";
nsIntRegion layerVisibleRegion[] = {
nsIntRegion(IntRect(0, 0, 100, 100)),
@@ -40,17 +40,17 @@ protected:
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID, CSSRect(0, 0, 200, 200));
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 2, CSSRect(-100, -100, 200, 200));
SetScrollableFrameMetrics(layers[2], FrameMetrics::START_SCROLL_ID + 1, CSSRect(0, 0, 100, 100));
SetScrollHandoff(layers[1], root);
SetScrollHandoff(layers[2], layers[1]);
// No ScopedLayerTreeRegistration as that just needs to be done once per test
// and this is the second layer tree for a particular test.
MOZ_ASSERT(registration);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
rootApzc = ApzcOf(root);
}
void CreateScrollHandoffLayerTree3() {
const char* layerTreeSyntax = "c(c(t)c(t))";
nsIntRegion layerVisibleRegion[] = {
nsIntRegion(IntRect(0, 0, 100, 100)), // root
nsIntRegion(IntRect(0, 0, 100, 50)), // scrolling parent 1
@@ -63,50 +63,50 @@ protected:
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 1, CSSRect(0, 0, 100, 100));
SetScrollableFrameMetrics(layers[2], FrameMetrics::START_SCROLL_ID + 2, CSSRect(0, 0, 100, 100));
SetScrollableFrameMetrics(layers[3], FrameMetrics::START_SCROLL_ID + 3, CSSRect(0, 50, 100, 100));
SetScrollableFrameMetrics(layers[4], FrameMetrics::START_SCROLL_ID + 4, CSSRect(0, 50, 100, 100));
SetScrollHandoff(layers[1], layers[0]);
SetScrollHandoff(layers[3], layers[0]);
SetScrollHandoff(layers[2], layers[1]);
SetScrollHandoff(layers[4], layers[3]);
- registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
}
// Creates a layer tree with a parent layer that is only scrollable
// horizontally, and a child layer that is only scrollable vertically.
void CreateScrollHandoffLayerTree4() {
const char* layerTreeSyntax = "c(t)";
nsIntRegion layerVisibleRegion[] = {
nsIntRegion(IntRect(0, 0, 100, 100)),
nsIntRegion(IntRect(0, 0, 100, 100))
};
root = CreateLayerTree(layerTreeSyntax, layerVisibleRegion, nullptr, lm, layers);
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID, CSSRect(0, 0, 200, 100));
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 1, CSSRect(0, 0, 100, 200));
SetScrollHandoff(layers[1], root);
- registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
rootApzc = ApzcOf(root);
}
void CreateScrollgrabLayerTree(bool makeParentScrollable = true) {
const char* layerTreeSyntax = "c(t)";
nsIntRegion layerVisibleRegion[] = {
nsIntRegion(IntRect(0, 0, 100, 100)), // scroll-grabbing parent
nsIntRegion(IntRect(0, 20, 100, 80)) // child
};
root = CreateLayerTree(layerTreeSyntax, layerVisibleRegion, nullptr, lm, layers);
float parentHeight = makeParentScrollable ? 120 : 100;
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID, CSSRect(0, 0, 100, parentHeight));
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 1, CSSRect(0, 0, 100, 200));
SetScrollHandoff(layers[1], root);
- registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
rootApzc = ApzcOf(root);
rootApzc->GetScrollMetadata().SetHasScrollgrab(true);
}
void TestFlingAcceleration() {
// Jack up the fling acceleration multiplier so we can easily determine
// whether acceleration occured.
const float kAcceleration = 100.0f;
--- a/gfx/layers/apz/test/gtest/TestSnapping.cpp
+++ b/gfx/layers/apz/test/gtest/TestSnapping.cpp
@@ -30,18 +30,18 @@ TEST_F(APZCSnappingTester, Bug1265510)
ScrollSnapInfo snap;
snap.mScrollSnapTypeY = NS_STYLE_SCROLL_SNAP_TYPE_MANDATORY;
snap.mScrollSnapIntervalY = Some(100 * AppUnitsPerCSSPixel());
ScrollMetadata metadata = root->GetScrollMetadata(0);
metadata.SetSnapInfo(ScrollSnapInfo(snap));
root->SetScrollMetadata(metadata);
- UniquePtr<ScopedLayerTreeRegistration> registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ UniquePtr<ScopedLayerTreeRegistration> registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
TestAsyncPanZoomController* outer = ApzcOf(layers[0]);
TestAsyncPanZoomController* inner = ApzcOf(layers[1]);
// Position the mouse near the bottom of the outer frame and scroll by 60px.
// (6 lines of 10px each). APZC will actually scroll to y=100 because of the
// mandatory snap coordinate there.
TimeStamp now = mcc->Time();
@@ -85,18 +85,18 @@ TEST_F(APZCSnappingTester, Snap_After_Pi
// Save the scroll snap info on the root APZC.
// Also mark the root APZC as "root content", since APZC only allows
// zooming on the root content APZC.
ScrollMetadata metadata = root->GetScrollMetadata(0);
metadata.SetSnapInfo(ScrollSnapInfo(snap));
metadata.GetMetrics().SetIsRootContent(true);
root->SetScrollMetadata(metadata);
- UniquePtr<ScopedLayerTreeRegistration> registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ UniquePtr<ScopedLayerTreeRegistration> registration = MakeUnique<ScopedLayerTreeRegistration>(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
RefPtr<TestAsyncPanZoomController> apzc = ApzcOf(root);
// Allow zooming
apzc->UpdateZoomConstraints(ZoomConstraints(true, true, CSSToParentLayerScale(0.25f), CSSToParentLayerScale(4.0f)));
PinchWithPinchInput(apzc, ScreenIntPoint(50, 50), ScreenIntPoint(50, 50), 1.2f);
--- a/gfx/layers/apz/test/gtest/TestTreeManager.cpp
+++ b/gfx/layers/apz/test/gtest/TestTreeManager.cpp
@@ -5,47 +5,47 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "APZCTreeManagerTester.h"
#include "APZTestCommon.h"
#include "InputUtils.h"
TEST_F(APZCTreeManagerTester, ScrollablePaintedLayers) {
CreateSimpleMultiLayerTree();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
// both layers have the same scrollId
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID);
SetScrollableFrameMetrics(layers[2], FrameMetrics::START_SCROLL_ID);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
TestAsyncPanZoomController* nullAPZC = nullptr;
// so they should have the same APZC
EXPECT_FALSE(layers[0]->HasScrollableFrameMetrics());
EXPECT_NE(nullAPZC, ApzcOf(layers[1]));
EXPECT_NE(nullAPZC, ApzcOf(layers[2]));
EXPECT_EQ(ApzcOf(layers[1]), ApzcOf(layers[2]));
// Change the scrollId of layers[1], and verify the APZC changes
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 1);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
EXPECT_NE(ApzcOf(layers[1]), ApzcOf(layers[2]));
// Change the scrollId of layers[2] to match that of layers[1], ensure we get the same
// APZC for both again
SetScrollableFrameMetrics(layers[2], FrameMetrics::START_SCROLL_ID + 1);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
EXPECT_EQ(ApzcOf(layers[1]), ApzcOf(layers[2]));
}
TEST_F(APZCTreeManagerTester, Bug1068268) {
CreatePotentiallyLeakingTree();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
RefPtr<HitTestingTreeNode> root = manager->GetRootNode();
RefPtr<HitTestingTreeNode> node2 = root->GetFirstChild()->GetFirstChild();
RefPtr<HitTestingTreeNode> node5 = root->GetLastChild()->GetLastChild();
EXPECT_EQ(ApzcOf(layers[2]), node5->GetApzc());
EXPECT_EQ(ApzcOf(layers[2]), node2->GetApzc());
EXPECT_EQ(ApzcOf(layers[0]), ApzcOf(layers[2])->GetParent());
EXPECT_EQ(ApzcOf(layers[2]), ApzcOf(layers[5]));
@@ -55,18 +55,18 @@ TEST_F(APZCTreeManagerTester, Bug1068268
EXPECT_EQ(node5->GetFirstChild(), node5->GetLastChild());
EXPECT_EQ(ApzcOf(layers[6]), node5->GetLastChild()->GetApzc());
EXPECT_EQ(ApzcOf(layers[2]), ApzcOf(layers[3])->GetParent());
EXPECT_EQ(ApzcOf(layers[5]), ApzcOf(layers[6])->GetParent());
}
TEST_F(APZCTreeManagerTester, Bug1194876) {
CreateBug1194876Tree();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
uint64_t blockId;
nsTArray<ScrollableLayerGuid> targets;
// First touch goes down, APZCTM will hit layers[1] because it is on top of
// layers[0], but we tell it the real target APZC is layers[0].
MultiTouchInput mti;
mti = CreateMultiTouchInput(MultiTouchInput::MULTITOUCH_START, mcc->Time());
@@ -93,18 +93,18 @@ TEST_F(APZCTreeManagerTester, Bug1194876
EXPECT_CALL(*mcc, HandleTap(TapType::eLongTap, _, _, _, _)).Times(0);
}
TEST_F(APZCTreeManagerTester, Bug1198900) {
// This is just a test that cancels a wheel event to make sure it doesn't
// crash.
CreateSimpleDTCScrollingLayer();
- ScopedLayerTreeRegistration registration(manager, 0, root, mcc);
- manager->UpdateHitTestingTree(0, root, false, 0, 0);
+ ScopedLayerTreeRegistration registration(manager, LayersId{0}, root, mcc);
+ manager->UpdateHitTestingTree(LayersId{0}, root, false, LayersId{0}, 0);
ScreenPoint origin(100, 50);
ScrollWheelInput swi(MillisecondsSinceStartup(mcc->Time()), mcc->Time(), 0,
ScrollWheelInput::SCROLLMODE_INSTANT, ScrollWheelInput::SCROLLDELTA_PIXEL,
origin, 0, 10, false);
uint64_t blockId;
manager->ReceiveInputEvent(swi, nullptr, &blockId);
manager->ContentReceivedInputBlock(blockId, /* preventDefault= */ true);
--- a/gfx/layers/ipc/APZCTreeManagerParent.cpp
+++ b/gfx/layers/ipc/APZCTreeManagerParent.cpp
@@ -7,17 +7,17 @@
#include "mozilla/layers/APZCTreeManagerParent.h"
#include "apz/src/APZCTreeManager.h"
#include "mozilla/layers/APZThreadUtils.h"
namespace mozilla {
namespace layers {
-APZCTreeManagerParent::APZCTreeManagerParent(uint64_t aLayersId, RefPtr<APZCTreeManager> aAPZCTreeManager)
+APZCTreeManagerParent::APZCTreeManagerParent(LayersId aLayersId, RefPtr<APZCTreeManager> aAPZCTreeManager)
: mLayersId(aLayersId)
, mTreeManager(aAPZCTreeManager)
{
MOZ_ASSERT(aAPZCTreeManager != nullptr);
}
APZCTreeManagerParent::~APZCTreeManagerParent()
{
--- a/gfx/layers/ipc/APZCTreeManagerParent.h
+++ b/gfx/layers/ipc/APZCTreeManagerParent.h
@@ -14,20 +14,20 @@ namespace layers {
class APZCTreeManager;
class APZCTreeManagerParent
: public PAPZCTreeManagerParent
{
public:
- explicit APZCTreeManagerParent(uint64_t aLayersId, RefPtr<APZCTreeManager> aAPZCTreeManager);
+ explicit APZCTreeManagerParent(LayersId aLayersId, RefPtr<APZCTreeManager> aAPZCTreeManager);
virtual ~APZCTreeManagerParent();
- uint64_t LayersId() const { return mLayersId; }
+ LayersId GetLayersId() const { return mLayersId; }
/**
* Called when the layer tree that this protocol is connected to
* is adopted by another compositor, and we need to switch APZCTreeManagers.
*/
void ChildAdopted(RefPtr<APZCTreeManager> aAPZCTreeManager);
mozilla::ipc::IPCResult
@@ -77,16 +77,16 @@ public:
mozilla::ipc::IPCResult
RecvSetLongTapEnabled(const bool& aTapGestureEnabled) override;
void
ActorDestroy(ActorDestroyReason aWhy) override { }
private:
- uint64_t mLayersId;
+ LayersId mLayersId;
RefPtr<APZCTreeManager> mTreeManager;
};
} // namespace layers
} // namespace mozilla
#endif // mozilla_layers_APZCTreeManagerParent_h
--- a/gfx/layers/ipc/APZInputBridgeParent.cpp
+++ b/gfx/layers/ipc/APZInputBridgeParent.cpp
@@ -8,17 +8,17 @@
#include "mozilla/layers/APZInputBridge.h"
#include "mozilla/layers/CompositorBridgeParent.h"
#include "mozilla/layers/IAPZCTreeManager.h"
namespace mozilla {
namespace layers {
-APZInputBridgeParent::APZInputBridgeParent(const uint64_t& aLayersId)
+APZInputBridgeParent::APZInputBridgeParent(const LayersId& aLayersId)
{
MOZ_ASSERT(XRE_IsGPUProcess());
MOZ_ASSERT(NS_IsMainThread());
mTreeManager = CompositorBridgeParent::GetAPZCTreeManager(aLayersId);
MOZ_ASSERT(mTreeManager);
}
--- a/gfx/layers/ipc/APZInputBridgeParent.h
+++ b/gfx/layers/ipc/APZInputBridgeParent.h
@@ -14,17 +14,17 @@ namespace layers {
class IAPZCTreeManager;
class APZInputBridgeParent : public PAPZInputBridgeParent
{
NS_INLINE_DECL_REFCOUNTING(APZInputBridgeParent)
public:
- explicit APZInputBridgeParent(const uint64_t& aLayersId);
+ explicit APZInputBridgeParent(const LayersId& aLayersId);
mozilla::ipc::IPCResult
RecvReceiveMultiTouchInputEvent(
const MultiTouchInput& aEvent,
nsEventStatus* aOutStatus,
MultiTouchInput* aOutEvent,
ScrollableLayerGuid* aOutTargetGuid,
uint64_t* aOutInputBlockId) override;
--- a/gfx/layers/ipc/CompositorBridgeChild.cpp
+++ b/gfx/layers/ipc/CompositorBridgeChild.cpp
@@ -300,17 +300,17 @@ CompositorBridgeChild::CompositorIsInGPU
if (!bridge) {
return false;
}
return bridge->OtherPid() != dom::ContentChild::GetSingleton()->OtherPid();
}
PLayerTransactionChild*
-CompositorBridgeChild::AllocPLayerTransactionChild(const nsTArray<LayersBackend>& aBackendHints, const uint64_t& aId)
+CompositorBridgeChild::AllocPLayerTransactionChild(const nsTArray<LayersBackend>& aBackendHints, const LayersId& aId)
{
LayerTransactionChild* c = new LayerTransactionChild(aId);
c->AddIPDLReference();
TabChild* tabChild = TabChild::GetFrom(c->GetId());
// Do the DOM Labeling.
if (tabChild) {
@@ -321,35 +321,35 @@ CompositorBridgeChild::AllocPLayerTransa
}
return c;
}
bool
CompositorBridgeChild::DeallocPLayerTransactionChild(PLayerTransactionChild* actor)
{
- uint64_t childId = static_cast<LayerTransactionChild*>(actor)->GetId();
+ LayersId childId = static_cast<LayerTransactionChild*>(actor)->GetId();
for (auto iter = mFrameMetricsTable.Iter(); !iter.Done(); iter.Next()) {
nsAutoPtr<SharedFrameMetricsData>& data = iter.Data();
if (data->GetLayersId() == childId) {
iter.Remove();
}
}
static_cast<LayerTransactionChild*>(actor)->ReleaseIPDLReference();
return true;
}
mozilla::ipc::IPCResult
-CompositorBridgeChild::RecvInvalidateLayers(const uint64_t& aLayersId)
+CompositorBridgeChild::RecvInvalidateLayers(const LayersId& aLayersId)
{
if (mLayerManager) {
- MOZ_ASSERT(aLayersId == 0);
+ MOZ_ASSERT(!aLayersId.IsValid());
FrameLayerBuilder::InvalidateAllLayers(mLayerManager);
- } else if (aLayersId != 0) {
+ } else if (aLayersId.IsValid()) {
if (dom::TabChild* child = dom::TabChild::GetFrom(aLayersId)) {
child->InvalidateLayers();
}
}
return IPC_OK();
}
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
@@ -522,32 +522,32 @@ CompositorBridgeChild::RecvHideAllPlugin
return IPC_OK();
}
SendRemotePluginsReady();
return IPC_OK();
#endif // !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
}
mozilla::ipc::IPCResult
-CompositorBridgeChild::RecvDidComposite(const uint64_t& aId,
+CompositorBridgeChild::RecvDidComposite(const LayersId& aId,
const uint64_t& aTransactionId,
const TimeStamp& aCompositeStart,
const TimeStamp& aCompositeEnd)
{
// Hold a reference to keep texture pools alive. See bug 1387799
AutoTArray<RefPtr<TextureClientPool>,2> texturePools = mTexturePools;
if (mLayerManager) {
- MOZ_ASSERT(aId == 0);
+ MOZ_ASSERT(!aId.IsValid());
MOZ_ASSERT(mLayerManager->GetBackendType() == LayersBackend::LAYERS_CLIENT ||
mLayerManager->GetBackendType() == LayersBackend::LAYERS_WR);
// Hold a reference to keep LayerManager alive. See Bug 1242668.
RefPtr<LayerManager> m = mLayerManager;
m->DidComposite(aTransactionId, aCompositeStart, aCompositeEnd);
- } else if (aId != 0) {
+ } else if (aId.IsValid()) {
RefPtr<dom::TabChild> child = dom::TabChild::GetFrom(aId);
if (child) {
child->DidComposite(aTransactionId, aCompositeStart, aCompositeEnd);
}
}
for (size_t i = 0; i < texturePools.Length(); i++) {
texturePools[i]->ReturnDeferredClients();
@@ -585,17 +585,17 @@ CompositorBridgeChild::ActorDestroy(Acto
GPUProcessManager::Get()->NotifyRemoteActorDestroyed(mProcessToken);
}
}
mozilla::ipc::IPCResult
CompositorBridgeChild::RecvSharedCompositorFrameMetrics(
const mozilla::ipc::SharedMemoryBasic::Handle& metrics,
const CrossProcessMutexHandle& handle,
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
const uint32_t& aAPZCId)
{
SharedFrameMetricsData* data = new SharedFrameMetricsData(
metrics, handle, aLayersId, aAPZCId);
mFrameMetricsTable.Put(data->GetViewID(), data);
return IPC_OK();
}
@@ -613,17 +613,17 @@ CompositorBridgeChild::RecvReleaseShared
}
}
return IPC_OK();
}
CompositorBridgeChild::SharedFrameMetricsData::SharedFrameMetricsData(
const ipc::SharedMemoryBasic::Handle& metrics,
const CrossProcessMutexHandle& handle,
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
const uint32_t& aAPZCId)
: mMutex(nullptr)
, mLayersId(aLayersId)
, mAPZCId(aAPZCId)
{
mBuffer = new ipc::SharedMemoryBasic;
mBuffer->SetHandle(metrics, ipc::SharedMemory::RightsReadOnly);
mBuffer->Map(sizeof(FrameMetrics));
@@ -657,17 +657,17 @@ CompositorBridgeChild::SharedFrameMetric
const FrameMetrics* frame =
static_cast<const FrameMetrics*>(mBuffer->memory());
MOZ_ASSERT(frame);
// Not locking to read of mScrollId since it should not change after being
// initially set.
return frame->GetScrollId();
}
-uint64_t
+LayersId
CompositorBridgeChild::SharedFrameMetricsData::GetLayersId() const
{
return mLayersId;
}
uint32_t
CompositorBridgeChild::SharedFrameMetricsData::GetAPZCId()
{
@@ -744,27 +744,27 @@ CompositorBridgeChild::SendResume()
{
if (!mCanSend) {
return false;
}
return PCompositorBridgeChild::SendResume();
}
bool
-CompositorBridgeChild::SendNotifyChildCreated(const uint64_t& id,
+CompositorBridgeChild::SendNotifyChildCreated(const LayersId& id,
CompositorOptions* aOptions)
{
if (!mCanSend) {
return false;
}
return PCompositorBridgeChild::SendNotifyChildCreated(id, aOptions);
}
bool
-CompositorBridgeChild::SendAdoptChild(const uint64_t& id)
+CompositorBridgeChild::SendAdoptChild(const LayersId& id)
{
if (!mCanSend) {
return false;
}
return PCompositorBridgeChild::SendAdoptChild(id);
}
bool
@@ -830,17 +830,17 @@ CompositorBridgeChild::SendAllPluginsCap
return PCompositorBridgeChild::SendAllPluginsCaptured();
}
PTextureChild*
CompositorBridgeChild::AllocPTextureChild(const SurfaceDescriptor&,
const ReadLockDescriptor&,
const LayersBackend&,
const TextureFlags&,
- const uint64_t&,
+ const LayersId&,
const uint64_t& aSerial,
const wr::MaybeExternalImageId& aExternalImageId)
{
return TextureClient::CreateIPDLActor();
}
bool
CompositorBridgeChild::DeallocPTextureChild(PTextureChild* actor)
@@ -864,23 +864,23 @@ CompositorBridgeChild::RecvParentAsyncMe
NS_ERROR("unknown AsyncParentMessageData type");
return IPC_FAIL_NO_REASON(this);
}
}
return IPC_OK();
}
mozilla::ipc::IPCResult
-CompositorBridgeChild::RecvObserveLayerUpdate(const uint64_t& aLayersId,
+CompositorBridgeChild::RecvObserveLayerUpdate(const LayersId& aLayersId,
const uint64_t& aEpoch,
const bool& aActive)
{
// This message is sent via the window compositor, not the tab compositor -
// however it still has a layers id.
- MOZ_ASSERT(aLayersId);
+ MOZ_ASSERT(aLayersId.IsValid());
MOZ_ASSERT(XRE_IsParentProcess());
if (RefPtr<dom::TabParent> tab = dom::TabParent::GetTabParentFromLayersId(aLayersId)) {
tab->LayerTreeUpdate(aEpoch, aActive);
}
return IPC_OK();
}
@@ -988,25 +988,25 @@ CompositorBridgeChild::CreateTexture(con
const ReadLockDescriptor& aReadLock,
LayersBackend aLayersBackend,
TextureFlags aFlags,
uint64_t aSerial,
wr::MaybeExternalImageId& aExternalImageId,
nsIEventTarget* aTarget)
{
PTextureChild* textureChild = AllocPTextureChild(
- aSharedData, aReadLock, aLayersBackend, aFlags, 0 /* FIXME */, aSerial, aExternalImageId);
+ aSharedData, aReadLock, aLayersBackend, aFlags, LayersId{0} /* FIXME */, aSerial, aExternalImageId);
// Do the DOM labeling.
if (aTarget) {
SetEventTargetForActor(textureChild, aTarget);
}
return SendPTextureConstructor(
- textureChild, aSharedData, aReadLock, aLayersBackend, aFlags, 0 /* FIXME? */, aSerial, aExternalImageId);
+ textureChild, aSharedData, aReadLock, aLayersBackend, aFlags, LayersId{0} /* FIXME? */, aSerial, aExternalImageId);
}
bool
CompositorBridgeChild::AllocUnsafeShmem(size_t aSize,
ipc::SharedMemory::SharedMemoryType aType,
ipc::Shmem* aShmem)
{
ShmemAllocated(this);
@@ -1046,34 +1046,34 @@ CompositorBridgeChild::DeallocPComposito
delete aActor;
return true;
#else
return false;
#endif
}
PAPZCTreeManagerChild*
-CompositorBridgeChild::AllocPAPZCTreeManagerChild(const uint64_t& aLayersId)
+CompositorBridgeChild::AllocPAPZCTreeManagerChild(const LayersId& aLayersId)
{
APZCTreeManagerChild* child = new APZCTreeManagerChild();
child->AddRef();
- if (aLayersId != 0) {
+ if (aLayersId.IsValid()) {
TabChild* tabChild = TabChild::GetFrom(aLayersId);
if (tabChild) {
SetEventTargetForActor(
child, tabChild->TabGroup()->EventTargetFor(TaskCategory::Other));
MOZ_ASSERT(child->GetActorEventTarget());
}
}
return child;
}
PAPZChild*
-CompositorBridgeChild::AllocPAPZChild(const uint64_t& aLayersId)
+CompositorBridgeChild::AllocPAPZChild(const LayersId& aLayersId)
{
// We send the constructor manually.
MOZ_CRASH("Should not be called");
return nullptr;
}
bool
CompositorBridgeChild::DeallocPAPZChild(PAPZChild* aActor)
--- a/gfx/layers/ipc/CompositorBridgeChild.h
+++ b/gfx/layers/ipc/CompositorBridgeChild.h
@@ -80,39 +80,39 @@ public:
static bool ChildProcessHasCompositorBridge();
// Returns whether the compositor is in the GPU process (false if in the UI
// process). This may only be called on the main thread.
static bool CompositorIsInGPUProcess();
virtual mozilla::ipc::IPCResult
- RecvDidComposite(const uint64_t& aId, const uint64_t& aTransactionId,
+ RecvDidComposite(const LayersId& aId, const uint64_t& aTransactionId,
const TimeStamp& aCompositeStart,
const TimeStamp& aCompositeEnd) override;
virtual mozilla::ipc::IPCResult
- RecvInvalidateLayers(const uint64_t& aLayersId) override;
+ RecvInvalidateLayers(const LayersId& aLayersId) override;
virtual mozilla::ipc::IPCResult
RecvUpdatePluginConfigurations(const LayoutDeviceIntPoint& aContentOffset,
const LayoutDeviceIntRegion& aVisibleRegion,
nsTArray<PluginWindowData>&& aPlugins) override;
virtual mozilla::ipc::IPCResult
RecvCaptureAllPlugins(const uintptr_t& aParentWidget) override;
virtual mozilla::ipc::IPCResult
RecvHideAllPlugins(const uintptr_t& aParentWidget) override;
virtual PTextureChild* AllocPTextureChild(const SurfaceDescriptor& aSharedData,
const ReadLockDescriptor& aReadLock,
const LayersBackend& aLayersBackend,
const TextureFlags& aFlags,
- const uint64_t& aId,
+ const LayersId& aId,
const uint64_t& aSerial,
const wr::MaybeExternalImageId& aExternalImageId) override;
virtual bool DeallocPTextureChild(PTextureChild* actor) override;
virtual mozilla::ipc::IPCResult
RecvParentAsyncMessages(InfallibleTArray<AsyncParentMessageData>&& aMessages) override;
virtual PTextureChild* CreateTexture(const SurfaceDescriptor& aSharedData,
@@ -137,18 +137,18 @@ public:
// are not virtual), they just overload them.
// All of these Send* methods just add a sanity check (that it is not too late
// send a message) and forward the call to the super-class's equivalent method.
// This means that it is correct to call directly the super-class methods, but
// you won't get the extra safety provided here.
bool SendWillClose();
bool SendPause();
bool SendResume();
- bool SendNotifyChildCreated(const uint64_t& id, CompositorOptions* aOptions);
- bool SendAdoptChild(const uint64_t& id);
+ bool SendNotifyChildCreated(const LayersId& id, CompositorOptions* aOptions);
+ bool SendAdoptChild(const LayersId& id);
bool SendMakeSnapshot(const SurfaceDescriptor& inSnapshot, const gfx::IntRect& dirtyRect);
bool SendFlushRendering();
bool SendGetTileSize(int32_t* tileWidth, int32_t* tileHeight);
bool SendStartFrameTimeRecording(const int32_t& bufferSize, uint32_t* startIndex);
bool SendStopFrameTimeRecording(const uint32_t& startIndex, nsTArray<float>* intervals);
bool SendNotifyRegionInvalidated(const nsIntRegion& region);
bool SendRequestNotifyAfterRemotePaint();
bool SendAllPluginsCaptured();
@@ -194,20 +194,20 @@ public:
virtual bool AllocShmem(size_t aSize,
mozilla::ipc::SharedMemory::SharedMemoryType aShmType,
mozilla::ipc::Shmem* aShmem) override;
virtual bool DeallocShmem(mozilla::ipc::Shmem& aShmem) override;
PCompositorWidgetChild* AllocPCompositorWidgetChild(const CompositorWidgetInitData& aInitData) override;
bool DeallocPCompositorWidgetChild(PCompositorWidgetChild* aActor) override;
- PAPZCTreeManagerChild* AllocPAPZCTreeManagerChild(const uint64_t& aLayersId) override;
+ PAPZCTreeManagerChild* AllocPAPZCTreeManagerChild(const LayersId& aLayersId) override;
bool DeallocPAPZCTreeManagerChild(PAPZCTreeManagerChild* aActor) override;
- PAPZChild* AllocPAPZChild(const uint64_t& aLayersId) override;
+ PAPZChild* AllocPAPZChild(const LayersId& aLayersId) override;
bool DeallocPAPZChild(PAPZChild* aActor) override;
void WillEndTransaction();
PWebRenderBridgeChild* AllocPWebRenderBridgeChild(const wr::PipelineId& aPipelineId,
const LayoutDeviceIntSize&,
TextureFactoryIdentifier*,
wr::IdNamespace*) override;
@@ -292,64 +292,64 @@ private:
// IPC messages, this forwards all such delayed IPC messages to the I/O thread
// and resumes IPC.
void ResumeIPCAfterAsyncPaint();
void AfterDestroy();
virtual PLayerTransactionChild*
AllocPLayerTransactionChild(const nsTArray<LayersBackend>& aBackendHints,
- const uint64_t& aId) override;
+ const LayersId& aId) override;
virtual bool DeallocPLayerTransactionChild(PLayerTransactionChild *aChild) override;
virtual void ActorDestroy(ActorDestroyReason aWhy) override;
virtual mozilla::ipc::IPCResult RecvSharedCompositorFrameMetrics(const mozilla::ipc::SharedMemoryBasic::Handle& metrics,
const CrossProcessMutexHandle& handle,
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
const uint32_t& aAPZCId) override;
virtual mozilla::ipc::IPCResult RecvReleaseSharedCompositorFrameMetrics(const ViewID& aId,
const uint32_t& aAPZCId) override;
virtual mozilla::ipc::IPCResult
RecvRemotePaintIsReady() override;
- mozilla::ipc::IPCResult RecvObserveLayerUpdate(const uint64_t& aLayersId,
+ mozilla::ipc::IPCResult RecvObserveLayerUpdate(const LayersId& aLayersId,
const uint64_t& aEpoch,
const bool& aActive) override;
virtual mozilla::ipc::IPCResult
RecvNotifyWebRenderError(const WebRenderError& aError) override;
uint64_t GetNextResourceId();
// Class used to store the shared FrameMetrics, mutex, and APZCId in a hash table
class SharedFrameMetricsData {
public:
SharedFrameMetricsData(
const mozilla::ipc::SharedMemoryBasic::Handle& metrics,
const CrossProcessMutexHandle& handle,
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
const uint32_t& aAPZCId);
~SharedFrameMetricsData();
void CopyFrameMetrics(FrameMetrics* aFrame);
FrameMetrics::ViewID GetViewID();
- uint64_t GetLayersId() const;
+ LayersId GetLayersId() const;
uint32_t GetAPZCId();
private:
// Pointer to the class that allows access to the shared memory that contains
// the shared FrameMetrics
RefPtr<mozilla::ipc::SharedMemoryBasic> mBuffer;
CrossProcessMutex* mMutex;
- uint64_t mLayersId;
+ LayersId mLayersId;
// Unique ID of the APZC that is sharing the FrameMetrics
uint32_t mAPZCId;
};
RefPtr<CompositorManagerChild> mCompositorManager;
RefPtr<LayerManager> mLayerManager;
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -180,17 +180,17 @@ base::ProcessId
CompositorBridgeParentBase::RemotePid()
{
return OtherPid();
}
bool
CompositorBridgeParentBase::StartSharingMetrics(ipc::SharedMemoryBasic::Handle aHandle,
CrossProcessMutexHandle aMutexHandle,
- uint64_t aLayersId,
+ LayersId aLayersId,
uint32_t aApzcId)
{
if (!mCanSend) {
return false;
}
return PCompositorBridgeParent::SendSharedCompositorFrameMetrics(
aHandle, aMutexHandle, aLayersId, aApzcId);
}
@@ -218,17 +218,17 @@ CompositorBridgeParent::LayerTreeState::
CompositorBridgeParent::LayerTreeState::~LayerTreeState()
{
if (mController) {
mController->Destroy();
}
}
-typedef map<uint64_t, CompositorBridgeParent::LayerTreeState> LayerTreeMap;
+typedef map<LayersId, CompositorBridgeParent::LayerTreeState> LayerTreeMap;
LayerTreeMap sIndirectLayerTrees;
StaticAutoPtr<mozilla::Monitor> sIndirectLayerTreesLock;
static void EnsureLayerTreeMapReady()
{
MOZ_ASSERT(NS_IsMainThread());
if (!sIndirectLayerTreesLock) {
sIndirectLayerTreesLock = new Monitor("IndirectLayerTree");
@@ -329,45 +329,45 @@ CompositorBridgeParent::CompositorBridge
, mVsyncRate(aVsyncRate)
, mPendingTransaction(0)
, mPaused(false)
, mUseExternalSurfaceSize(aUseExternalSurfaceSize)
, mEGLSurfaceSize(aSurfaceSize)
, mOptions(aOptions)
, mPauseCompositionMonitor("PauseCompositionMonitor")
, mResumeCompositionMonitor("ResumeCompositionMonitor")
- , mRootLayerTreeID(0)
+ , mRootLayerTreeID{0}
, mOverrideComposeReadiness(false)
, mForceCompositionTask(nullptr)
, mCompositorScheduler(nullptr)
, mAnimationStorage(nullptr)
, mPaintTime(TimeDuration::Forever())
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
- , mLastPluginUpdateLayerTreeId(0)
+ , mLastPluginUpdateLayerTreeId{0}
, mDeferPluginWindows(false)
, mPluginWindowsHidden(false)
#endif
{
}
void
CompositorBridgeParent::InitSameProcess(widget::CompositorWidget* aWidget,
- const uint64_t& aLayerTreeId)
+ const LayersId& aLayerTreeId)
{
MOZ_ASSERT(XRE_IsParentProcess());
MOZ_ASSERT(NS_IsMainThread());
mWidget = aWidget;
mRootLayerTreeID = aLayerTreeId;
Initialize();
}
mozilla::ipc::IPCResult
-CompositorBridgeParent::RecvInitialize(const uint64_t& aRootLayerTreeId)
+CompositorBridgeParent::RecvInitialize(const LayersId& aRootLayerTreeId)
{
MOZ_ASSERT(XRE_IsGPUProcess());
mRootLayerTreeID = aRootLayerTreeId;
Initialize();
return IPC_OK();
}
@@ -405,20 +405,20 @@ CompositorBridgeParent::Initialize()
LayerScope::SetPixelScale(mScale.scale);
if (!mOptions.UseWebRender()) {
mCompositorScheduler = new CompositorVsyncScheduler(this, mWidget);
}
}
-uint64_t
+LayersId
CompositorBridgeParent::RootLayerTreeId()
{
- MOZ_ASSERT(mRootLayerTreeID);
+ MOZ_ASSERT(mRootLayerTreeID.IsValid());
return mRootLayerTreeID;
}
CompositorBridgeParent::~CompositorBridgeParent()
{
InfallibleTArray<PTextureParent*> textures;
ManagedPTextureParent(textures);
// We expect all textures to be destroyed by now.
@@ -444,29 +444,29 @@ CompositorBridgeParent::StopAndClearReso
mForceCompositionTask = nullptr;
}
mPaused = true;
// Ensure that the layer manager is destroyed before CompositorBridgeChild.
if (mLayerManager) {
MonitorAutoLock lock(*sIndirectLayerTreesLock);
- ForEachIndirectLayerTree([this] (LayerTreeState* lts, uint64_t) -> void {
+ ForEachIndirectLayerTree([this] (LayerTreeState* lts, LayersId) -> void {
mLayerManager->ClearCachedResources(lts->mRoot);
lts->mLayerManager = nullptr;
lts->mParent = nullptr;
});
mLayerManager->Destroy();
mLayerManager = nullptr;
mCompositionManager = nullptr;
}
if (mWrBridge) {
MonitorAutoLock lock(*sIndirectLayerTreesLock);
- ForEachIndirectLayerTree([] (LayerTreeState* lts, uint64_t) -> void {
+ ForEachIndirectLayerTree([] (LayerTreeState* lts, LayersId) -> void {
if (lts->mWrBridge) {
lts->mWrBridge->Destroy();
lts->mWrBridge = nullptr;
}
lts->mParent = nullptr;
});
mWrBridge->Destroy();
mWrBridge = nullptr;
@@ -832,17 +832,17 @@ CompositorBridgeParent::UpdatePaintTime(
if (!mLayerManager || aPaintTime.ToMilliseconds() < 1.0) {
return;
}
mLayerManager->SetPaintTime(aPaintTime);
}
void
-CompositorBridgeParent::NotifyShadowTreeTransaction(uint64_t aId, bool aIsFirstPaint,
+CompositorBridgeParent::NotifyShadowTreeTransaction(LayersId aId, bool aIsFirstPaint,
const FocusTarget& aFocusTarget,
bool aScheduleComposite, uint32_t aPaintSequenceNumber,
bool aIsRepeatTransaction, bool aHitTestUpdate)
{
if (!aIsRepeatTransaction &&
mLayerManager &&
mLayerManager->GetRoot()) {
// Process plugin data here to give time for them to update before the next
@@ -1085,26 +1085,26 @@ CompositorBridgeParent::ForceComposeToTa
AUTO_PROFILER_LABEL("CompositorBridgeParent::ForceComposeToTarget", GRAPHICS);
AutoRestore<bool> override(mOverrideComposeReadiness);
mOverrideComposeReadiness = true;
mCompositorScheduler->ForceComposeToTarget(aTarget, aRect);
}
PAPZCTreeManagerParent*
-CompositorBridgeParent::AllocPAPZCTreeManagerParent(const uint64_t& aLayersId)
+CompositorBridgeParent::AllocPAPZCTreeManagerParent(const LayersId& aLayersId)
{
// This should only ever get called in the GPU process.
MOZ_ASSERT(XRE_IsGPUProcess());
// We should only ever get this if APZ is enabled in this compositor.
MOZ_ASSERT(mOptions.UseAPZ());
// The mApzcTreeManager should have been created via RecvInitialize()
MOZ_ASSERT(mApzcTreeManager);
// The main process should pass in 0 because we assume mRootLayerTreeID
- MOZ_ASSERT(aLayersId == 0);
+ MOZ_ASSERT(!aLayersId.IsValid());
MonitorAutoLock lock(*sIndirectLayerTreesLock);
CompositorBridgeParent::LayerTreeState& state = sIndirectLayerTrees[mRootLayerTreeID];
MOZ_ASSERT(state.mParent.get() == this);
MOZ_ASSERT(!state.mApzcTreeManagerParent);
state.mApzcTreeManagerParent = new APZCTreeManagerParent(mRootLayerTreeID, mApzcTreeManager);
return state.mApzcTreeManagerParent;
@@ -1114,30 +1114,30 @@ bool
CompositorBridgeParent::DeallocPAPZCTreeManagerParent(PAPZCTreeManagerParent* aActor)
{
delete aActor;
return true;
}
void
CompositorBridgeParent::AllocateAPZCTreeManagerParent(const MonitorAutoLock& aProofOfLayerTreeStateLock,
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
LayerTreeState& aState)
{
MOZ_ASSERT(aState.mParent == this);
MOZ_ASSERT(mApzcTreeManager);
MOZ_ASSERT(!aState.mApzcTreeManagerParent);
aState.mApzcTreeManagerParent = new APZCTreeManagerParent(aLayersId, mApzcTreeManager);
}
PAPZParent*
-CompositorBridgeParent::AllocPAPZParent(const uint64_t& aLayersId)
+CompositorBridgeParent::AllocPAPZParent(const LayersId& aLayersId)
{
// The main process should pass in 0 because we assume mRootLayerTreeID
- MOZ_ASSERT(aLayersId == 0);
+ MOZ_ASSERT(!aLayersId.IsValid());
RemoteContentController* controller = new RemoteContentController();
// Increment the controller's refcount before we return it. This will keep the
// controller alive until it is released by IPDL in DeallocPAPZParent.
controller->AddRef();
MonitorAutoLock lock(*sIndirectLayerTreesLock);
@@ -1166,17 +1166,17 @@ CompositorBridgeParent::GetAndroidDynami
RefPtr<APZSampler>
CompositorBridgeParent::GetAPZSampler()
{
return mApzSampler;
}
CompositorBridgeParent*
-CompositorBridgeParent::GetCompositorBridgeParentFromLayersId(const uint64_t& aLayersId)
+CompositorBridgeParent::GetCompositorBridgeParentFromLayersId(const LayersId& aLayersId)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
return sIndirectLayerTrees[aLayersId].mParent;
}
bool
CompositorBridgeParent::CanComposite()
{
@@ -1265,17 +1265,17 @@ CompositorBridgeParent::ShadowLayersUpda
void
CompositorBridgeParent::ScheduleComposite(LayerTransactionParent* aLayerTree)
{
ScheduleComposition();
}
bool
-CompositorBridgeParent::SetTestSampleTime(const uint64_t& aId,
+CompositorBridgeParent::SetTestSampleTime(const LayersId& aId,
const TimeStamp& aTime)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
if (aTime.IsNull()) {
return false;
}
@@ -1300,17 +1300,17 @@ CompositorBridgeParent::SetTestSampleTim
DidComposite(now, now);
}
}
return true;
}
void
-CompositorBridgeParent::LeaveTestMode(const uint64_t& aId)
+CompositorBridgeParent::LeaveTestMode(const LayersId& aId)
{
mTestTime = Nothing();
}
void
CompositorBridgeParent::ApplyAsyncProperties(LayerTransactionParent* aLayerTree)
{
// NOTE: This should only be used for testing. For example, when mTestTime is
@@ -1348,61 +1348,61 @@ mozilla::ipc::IPCResult
CompositorBridgeParent::RecvGetFrameUniformity(FrameUniformityData* aOutData)
{
mCompositionManager->GetFrameUniformity(aOutData);
return IPC_OK();
}
void
CompositorBridgeParent::SetTestAsyncScrollOffset(
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const CSSPoint& aPoint)
{
if (mApzSampler) {
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
mApzSampler->SetTestAsyncScrollOffset(aLayersId, aScrollId, aPoint);
}
}
void
CompositorBridgeParent::SetTestAsyncZoom(
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const LayerToParentLayerScale& aZoom)
{
if (mApzSampler) {
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
mApzSampler->SetTestAsyncZoom(aLayersId, aScrollId, aZoom);
}
}
void
-CompositorBridgeParent::FlushApzRepaints(const uint64_t& aLayersId)
+CompositorBridgeParent::FlushApzRepaints(const LayersId& aLayersId)
{
MOZ_ASSERT(mApzcTreeManager);
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
RefPtr<CompositorBridgeParent> self = this;
APZThreadUtils::RunOnControllerThread(NS_NewRunnableFunction(
"layers::CompositorBridgeParent::FlushApzRepaints",
[=]() { self->mApzcTreeManager->FlushApzRepaints(aLayersId); }));
}
void
-CompositorBridgeParent::GetAPZTestData(const uint64_t& aLayersId,
+CompositorBridgeParent::GetAPZTestData(const LayersId& aLayersId,
APZTestData* aOutData)
{
if (mApzSampler) {
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
mApzSampler->GetAPZTestData(aLayersId, aOutData);
}
}
void
-CompositorBridgeParent::SetConfirmedTargetAPZC(const uint64_t& aLayersId,
+CompositorBridgeParent::SetConfirmedTargetAPZC(const LayersId& aLayersId,
const uint64_t& aInputBlockId,
const nsTArray<ScrollableLayerGuid>& aTargets)
{
if (!mApzcTreeManager) {
return;
}
// Need to specifically bind this since it's overloaded.
void (APZCTreeManager::*setTargetApzcFunc)
@@ -1541,19 +1541,19 @@ CompositorBridgeParent::NewCompositor(co
#endif
}
return nullptr;
}
PLayerTransactionParent*
CompositorBridgeParent::AllocPLayerTransactionParent(const nsTArray<LayersBackend>& aBackendHints,
- const uint64_t& aId)
+ const LayersId& aId)
{
- MOZ_ASSERT(aId == 0);
+ MOZ_ASSERT(!aId.IsValid());
InitializeLayerManager(aBackendHints);
if (!mLayerManager) {
NS_WARNING("Failed to initialise Compositor");
LayerTransactionParent* p = new LayerTransactionParent(/* aManager */ nullptr, this, /* aAnimStorage */ nullptr, mRootLayerTreeID);
p->AddIPDLReference();
return p;
@@ -1601,17 +1601,17 @@ CompositorBridgeParent* CompositorBridge
return nullptr;
}
CompositorBridgeParent *retval = it->second;
sCompositorMap->erase(it);
return retval;
}
void
-CompositorBridgeParent::NotifyVsync(const TimeStamp& aTimeStamp, const uint64_t& aLayersId)
+CompositorBridgeParent::NotifyVsync(const TimeStamp& aTimeStamp, const LayersId& aLayersId)
{
MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_GPU);
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
MonitorAutoLock lock(*sIndirectLayerTreesLock);
auto it = sIndirectLayerTrees.find(aLayersId);
if (it == sIndirectLayerTrees.end())
return;
@@ -1623,68 +1623,68 @@ CompositorBridgeParent::NotifyVsync(cons
RefPtr<VsyncObserver> obs = cbp->mWidget->GetVsyncObserver();
if (!obs)
return;
obs->NotifyVsync(aTimeStamp);
}
mozilla::ipc::IPCResult
-CompositorBridgeParent::RecvNotifyChildCreated(const uint64_t& child,
+CompositorBridgeParent::RecvNotifyChildCreated(const LayersId& child,
CompositorOptions* aOptions)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
NotifyChildCreated(child);
*aOptions = mOptions;
return IPC_OK();
}
mozilla::ipc::IPCResult
-CompositorBridgeParent::RecvNotifyChildRecreated(const uint64_t& aChild,
+CompositorBridgeParent::RecvNotifyChildRecreated(const LayersId& aChild,
CompositorOptions* aOptions)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
if (sIndirectLayerTrees.find(aChild) != sIndirectLayerTrees.end()) {
NS_WARNING("Invalid to register the same layer tree twice");
return IPC_FAIL_NO_REASON(this);
}
NotifyChildCreated(aChild);
*aOptions = mOptions;
return IPC_OK();
}
void
-CompositorBridgeParent::NotifyChildCreated(uint64_t aChild)
+CompositorBridgeParent::NotifyChildCreated(LayersId aChild)
{
sIndirectLayerTreesLock->AssertCurrentThreadOwns();
sIndirectLayerTrees[aChild].mParent = this;
sIndirectLayerTrees[aChild].mLayerManager = mLayerManager;
}
mozilla::ipc::IPCResult
-CompositorBridgeParent::RecvMapAndNotifyChildCreated(const uint64_t& aChild,
+CompositorBridgeParent::RecvMapAndNotifyChildCreated(const LayersId& aChild,
const base::ProcessId& aOwnerPid,
CompositorOptions* aOptions)
{
// We only use this message when the remote compositor is in the GPU process.
// It is harmless to call it, though.
MOZ_ASSERT(XRE_IsGPUProcess());
LayerTreeOwnerTracker::Get()->Map(aChild, aOwnerPid);
MonitorAutoLock lock(*sIndirectLayerTreesLock);
NotifyChildCreated(aChild);
*aOptions = mOptions;
return IPC_OK();
}
mozilla::ipc::IPCResult
-CompositorBridgeParent::RecvAdoptChild(const uint64_t& child)
+CompositorBridgeParent::RecvAdoptChild(const LayersId& child)
{
RefPtr<APZSampler> oldApzSampler;
APZCTreeManagerParent* parent;
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
if (sIndirectLayerTrees[child].mParent) {
// We currently don't support adopting children from one compositor to
// another if the two compositors don't have the same options.
@@ -1740,17 +1740,17 @@ CompositorBridgeParent::AllocPWebRenderB
TextureFactoryIdentifier* aTextureFactoryIdentifier,
wr::IdNamespace* aIdNamespace)
{
#ifndef MOZ_BUILD_WEBRENDER
// Extra guard since this in the parent process and we don't want a malicious
// child process invoking this codepath before it's ready
MOZ_RELEASE_ASSERT(false);
#endif
- MOZ_ASSERT(wr::AsUint64(aPipelineId) == mRootLayerTreeID);
+ MOZ_ASSERT(wr::AsLayersId(aPipelineId) == mRootLayerTreeID);
MOZ_ASSERT(!mWrBridge);
MOZ_ASSERT(!mCompositor);
MOZ_ASSERT(!mCompositorScheduler);
MOZ_ASSERT(mWidget);
RefPtr<widget::CompositorWidget> widget = mWidget;
RefPtr<wr::WebRenderAPI> api = wr::WebRenderAPI::Create(this, Move(widget), aSize);
@@ -1786,17 +1786,17 @@ CompositorBridgeParent::DeallocPWebRende
#ifndef MOZ_BUILD_WEBRENDER
// Extra guard since this in the parent process and we don't want a malicious
// child process invoking this codepath before it's ready
MOZ_RELEASE_ASSERT(false);
#endif
WebRenderBridgeParent* parent = static_cast<WebRenderBridgeParent*>(aActor);
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
- auto it = sIndirectLayerTrees.find(parent->PipelineId().mHandle);
+ auto it = sIndirectLayerTrees.find(wr::AsLayersId(parent->PipelineId()));
if (it != sIndirectLayerTrees.end()) {
it->second.mWrBridge = nullptr;
}
}
parent->Release(); // IPDL reference
return true;
}
@@ -1808,17 +1808,17 @@ CompositorBridgeParent::GetWebRenderBrid
Maybe<TimeStamp>
CompositorBridgeParent::GetTestingTimeStamp() const
{
return mTestTime;
}
void
-EraseLayerState(uint64_t aId)
+EraseLayerState(LayersId aId)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
auto iter = sIndirectLayerTrees.find(aId);
if (iter != sIndirectLayerTrees.end()) {
CompositorBridgeParent* parent = iter->second.mParent;
if (parent) {
if (RefPtr<APZSampler> apz = parent->GetAPZSampler()) {
@@ -1826,42 +1826,42 @@ EraseLayerState(uint64_t aId)
}
}
sIndirectLayerTrees.erase(iter);
}
}
/*static*/ void
-CompositorBridgeParent::DeallocateLayerTreeId(uint64_t aId)
+CompositorBridgeParent::DeallocateLayerTreeId(LayersId aId)
{
MOZ_ASSERT(NS_IsMainThread());
// Here main thread notifies compositor to remove an element from
// sIndirectLayerTrees. This removed element might be queried soon.
// Checking the elements of sIndirectLayerTrees exist or not before using.
if (!CompositorLoop()) {
gfxCriticalError() << "Attempting to post to a invalid Compositor Loop";
return;
}
CompositorLoop()->PostTask(NewRunnableFunction("EraseLayerStateRunnable",
&EraseLayerState, aId));
}
static void
-UpdateControllerForLayersId(uint64_t aLayersId,
+UpdateControllerForLayersId(LayersId aLayersId,
GeckoContentController* aController)
{
// Adopt ref given to us by SetControllerForLayerTree()
MonitorAutoLock lock(*sIndirectLayerTreesLock);
sIndirectLayerTrees[aLayersId].mController =
already_AddRefed<GeckoContentController>(aController);
}
ScopedLayerTreeRegistration::ScopedLayerTreeRegistration(APZCTreeManager* aApzctm,
- uint64_t aLayersId,
+ LayersId aLayersId,
Layer* aRoot,
GeckoContentController* aController)
: mLayersId(aLayersId)
{
EnsureLayerTreeMapReady();
MonitorAutoLock lock(*sIndirectLayerTreesLock);
sIndirectLayerTrees[aLayersId].mRoot = aRoot;
sIndirectLayerTrees[aLayersId].mController = aController;
@@ -1869,29 +1869,29 @@ ScopedLayerTreeRegistration::ScopedLayer
ScopedLayerTreeRegistration::~ScopedLayerTreeRegistration()
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
sIndirectLayerTrees.erase(mLayersId);
}
/*static*/ void
-CompositorBridgeParent::SetControllerForLayerTree(uint64_t aLayersId,
+CompositorBridgeParent::SetControllerForLayerTree(LayersId aLayersId,
GeckoContentController* aController)
{
// This ref is adopted by UpdateControllerForLayersId().
aController->AddRef();
CompositorLoop()->PostTask(NewRunnableFunction("UpdateControllerForLayersIdRunnable",
&UpdateControllerForLayersId,
aLayersId,
aController));
}
/*static*/ already_AddRefed<IAPZCTreeManager>
-CompositorBridgeParent::GetAPZCTreeManager(uint64_t aLayersId)
+CompositorBridgeParent::GetAPZCTreeManager(LayersId aLayersId)
{
EnsureLayerTreeMapReady();
MonitorAutoLock lock(*sIndirectLayerTreesLock);
LayerTreeMap::iterator cit = sIndirectLayerTrees.find(aLayersId);
if (sIndirectLayerTrees.end() == cit) {
return nullptr;
}
LayerTreeState* lts = &cit->second;
@@ -2039,42 +2039,42 @@ CompositorBridgeParent::NotifyDidComposi
mAsyncImageManager->PipelineRendered(aPipelineId, aEpoch);
if (mPaused) {
return;
}
if (mWrBridge->PipelineId() == aPipelineId) {
uint64_t transactionId = mWrBridge->FlushTransactionIdsForEpoch(aEpoch, aCompositeEnd);
- Unused << SendDidComposite(0, transactionId, aCompositeStart, aCompositeEnd);
+ Unused << SendDidComposite(LayersId{0}, transactionId, aCompositeStart, aCompositeEnd);
nsTArray<ImageCompositeNotificationInfo> notifications;
mWrBridge->ExtractImageCompositeNotifications(¬ifications);
if (!notifications.IsEmpty()) {
Unused << ImageBridgeParent::NotifyImageComposites(notifications);
}
return;
}
MonitorAutoLock lock(*sIndirectLayerTreesLock);
- ForEachIndirectLayerTree([&] (LayerTreeState* lts, const uint64_t& aLayersId) -> void {
+ ForEachIndirectLayerTree([&] (LayerTreeState* lts, const LayersId& aLayersId) -> void {
if (lts->mCrossProcessParent &&
lts->mWrBridge &&
lts->mWrBridge->PipelineId() == aPipelineId) {
CrossProcessCompositorBridgeParent* cpcp = lts->mCrossProcessParent;
uint64_t transactionId = lts->mWrBridge->FlushTransactionIdsForEpoch(aEpoch, aCompositeEnd);
Unused << cpcp->SendDidComposite(aLayersId, transactionId, aCompositeStart, aCompositeEnd);
}
});
}
void
CompositorBridgeParent::NotifyDidComposite(uint64_t aTransactionId, TimeStamp& aCompositeStart, TimeStamp& aCompositeEnd)
{
- Unused << SendDidComposite(0, aTransactionId, aCompositeStart, aCompositeEnd);
+ Unused << SendDidComposite(LayersId{0}, aTransactionId, aCompositeStart, aCompositeEnd);
if (mLayerManager) {
nsTArray<ImageCompositeNotificationInfo> notifications;
mLayerManager->ExtractImageCompositeNotifications(¬ifications);
if (!notifications.IsEmpty()) {
Unused << ImageBridgeParent::NotifyImageComposites(notifications);
}
}
@@ -2083,64 +2083,64 @@ CompositorBridgeParent::NotifyDidComposi
nsTArray<ImageCompositeNotificationInfo> notifications;
mWrBridge->ExtractImageCompositeNotifications(¬ifications);
if (!notifications.IsEmpty()) {
Unused << ImageBridgeParent::NotifyImageComposites(notifications);
}
}
MonitorAutoLock lock(*sIndirectLayerTreesLock);
- ForEachIndirectLayerTree([&] (LayerTreeState* lts, const uint64_t& aLayersId) -> void {
+ ForEachIndirectLayerTree([&] (LayerTreeState* lts, const LayersId& aLayersId) -> void {
if (lts->mCrossProcessParent && lts->mParent == this) {
CrossProcessCompositorBridgeParent* cpcp = lts->mCrossProcessParent;
cpcp->DidCompositeLocked(aLayersId, aCompositeStart, aCompositeEnd);
}
});
}
void
CompositorBridgeParent::InvalidateRemoteLayers()
{
MOZ_ASSERT(CompositorLoop() == MessageLoop::current());
- Unused << PCompositorBridgeParent::SendInvalidateLayers(0);
+ Unused << PCompositorBridgeParent::SendInvalidateLayers(LayersId{0});
MonitorAutoLock lock(*sIndirectLayerTreesLock);
- ForEachIndirectLayerTree([] (LayerTreeState* lts, const uint64_t& aLayersId) -> void {
+ ForEachIndirectLayerTree([] (LayerTreeState* lts, const LayersId& aLayersId) -> void {
if (lts->mCrossProcessParent) {
CrossProcessCompositorBridgeParent* cpcp = lts->mCrossProcessParent;
Unused << cpcp->SendInvalidateLayers(aLayersId);
}
});
}
void
-UpdateIndirectTree(uint64_t aId, Layer* aRoot, const TargetConfig& aTargetConfig)
+UpdateIndirectTree(LayersId aId, Layer* aRoot, const TargetConfig& aTargetConfig)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
sIndirectLayerTrees[aId].mRoot = aRoot;
sIndirectLayerTrees[aId].mTargetConfig = aTargetConfig;
}
/* static */ CompositorBridgeParent::LayerTreeState*
-CompositorBridgeParent::GetIndirectShadowTree(uint64_t aId)
+CompositorBridgeParent::GetIndirectShadowTree(LayersId aId)
{
// Only the compositor thread should use this method variant
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
MonitorAutoLock lock(*sIndirectLayerTreesLock);
LayerTreeMap::iterator cit = sIndirectLayerTrees.find(aId);
if (sIndirectLayerTrees.end() == cit) {
return nullptr;
}
return &cit->second;
}
/* static */ bool
-CompositorBridgeParent::CallWithIndirectShadowTree(uint64_t aId,
+CompositorBridgeParent::CallWithIndirectShadowTree(LayersId aId,
const std::function<void(CompositorBridgeParent::LayerTreeState&)>& aFunc)
{
// Note that this does not make things universally threadsafe just because the
// sIndirectLayerTreesLock mutex is held. This is because the compositor
// thread can mutate the LayerTreeState outside the lock. It does however
// ensure that the *storage* for the LayerTreeState remains stable, since we
// should always hold the lock when adding/removing entries to the map.
MonitorAutoLock lock(*sIndirectLayerTreesLock);
@@ -2148,63 +2148,63 @@ CompositorBridgeParent::CallWithIndirect
if (sIndirectLayerTrees.end() == cit) {
return false;
}
aFunc(cit->second);
return true;
}
static CompositorBridgeParent::LayerTreeState*
-GetStateForRoot(uint64_t aContentLayersId, const MonitorAutoLock& aProofOfLock)
+GetStateForRoot(LayersId aContentLayersId, const MonitorAutoLock& aProofOfLock)
{
CompositorBridgeParent::LayerTreeState* state = nullptr;
LayerTreeMap::iterator itr = sIndirectLayerTrees.find(aContentLayersId);
if (sIndirectLayerTrees.end() != itr) {
state = &itr->second;
}
// |state| is the state for the content process, but we want the APZCTMParent
// for the parent process owning that content process. So we have to jump to
// the LayerTreeState for the root layer tree id for that layer tree, and use
// the mApzcTreeManagerParent from that. This should also work with nested
// content processes, because RootLayerTreeId() will bypass any intermediate
// processes' ids and go straight to the root.
if (state) {
- uint64_t rootLayersId = state->mParent->RootLayerTreeId();
+ LayersId rootLayersId = state->mParent->RootLayerTreeId();
itr = sIndirectLayerTrees.find(rootLayersId);
state = (sIndirectLayerTrees.end() != itr) ? &itr->second : nullptr;
}
return state;
}
/* static */ APZCTreeManagerParent*
-CompositorBridgeParent::GetApzcTreeManagerParentForRoot(uint64_t aContentLayersId)
+CompositorBridgeParent::GetApzcTreeManagerParentForRoot(LayersId aContentLayersId)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
CompositorBridgeParent::LayerTreeState* state =
GetStateForRoot(aContentLayersId, lock);
return state ? state->mApzcTreeManagerParent : nullptr;
}
/* static */ GeckoContentController*
-CompositorBridgeParent::GetGeckoContentControllerForRoot(uint64_t aContentLayersId)
+CompositorBridgeParent::GetGeckoContentControllerForRoot(LayersId aContentLayersId)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
CompositorBridgeParent::LayerTreeState* state =
GetStateForRoot(aContentLayersId, lock);
return state ? state->mController.get() : nullptr;
}
PTextureParent*
CompositorBridgeParent::AllocPTextureParent(const SurfaceDescriptor& aSharedData,
const ReadLockDescriptor& aReadLock,
const LayersBackend& aLayersBackend,
const TextureFlags& aFlags,
- const uint64_t& aId,
+ const LayersId& aId,
const uint64_t& aSerial,
const wr::MaybeExternalImageId& aExternalImageId)
{
return TextureHost::CreateIPDLActor(this, aSharedData, aReadLock, aLayersBackend, aFlags, aSerial, aExternalImageId);
}
bool
CompositorBridgeParent::DeallocPTextureParent(PTextureParent* actor)
@@ -2227,17 +2227,17 @@ CompositorBridgeParent::NotifyWebRenderE
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
//#define PLUGINS_LOG(...) printf_stderr("CP [%s]: ", __FUNCTION__);
// printf_stderr(__VA_ARGS__);
// printf_stderr("\n");
#define PLUGINS_LOG(...)
bool
-CompositorBridgeParent::UpdatePluginWindowState(uint64_t aId)
+CompositorBridgeParent::UpdatePluginWindowState(LayersId aId)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
CompositorBridgeParent::LayerTreeState& lts = sIndirectLayerTrees[aId];
if (!lts.mParent) {
PLUGINS_LOG("[%" PRIu64 "] layer tree compositor parent pointer is null", aId);
return false;
}
--- a/gfx/layers/ipc/CompositorBridgeParent.h
+++ b/gfx/layers/ipc/CompositorBridgeParent.h
@@ -78,23 +78,23 @@ class PAPZParent;
class CrossProcessCompositorBridgeParent;
class CompositorThreadHolder;
class InProcessCompositorSession;
class WebRenderBridgeParent;
struct ScopedLayerTreeRegistration
{
ScopedLayerTreeRegistration(APZCTreeManager* aApzctm,
- uint64_t aLayersId,
+ LayersId aLayersId,
Layer* aRoot,
GeckoContentController* aController);
~ScopedLayerTreeRegistration();
private:
- uint64_t mLayersId;
+ LayersId mLayersId;
};
class CompositorBridgeParentBase : public PCompositorBridgeParent,
public HostIPCAllocator,
public ShmemAllocator,
public MetricsSharingController
{
public:
@@ -104,45 +104,45 @@ public:
const TransactionInfo& aInfo,
bool aHitTestUpdate) = 0;
virtual AsyncCompositionManager* GetCompositionManager(LayerTransactionParent* aLayerTree) { return nullptr; }
virtual void NotifyClearCachedResources(LayerTransactionParent* aLayerTree) { }
virtual void ScheduleComposite(LayerTransactionParent* aLayerTree) { }
- virtual bool SetTestSampleTime(const uint64_t& aId,
+ virtual bool SetTestSampleTime(const LayersId& aId,
const TimeStamp& aTime) { return true; }
- virtual void LeaveTestMode(const uint64_t& aId) { }
+ virtual void LeaveTestMode(const LayersId& aId) { }
virtual void ApplyAsyncProperties(LayerTransactionParent* aLayerTree) = 0;
- virtual void SetTestAsyncScrollOffset(const uint64_t& aLayersId,
+ virtual void SetTestAsyncScrollOffset(const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const CSSPoint& aPoint) = 0;
- virtual void SetTestAsyncZoom(const uint64_t& aLayersId,
+ virtual void SetTestAsyncZoom(const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const LayerToParentLayerScale& aZoom) = 0;
- virtual void FlushApzRepaints(const uint64_t& aLayersId) = 0;
- virtual void GetAPZTestData(const uint64_t& aLayersId,
+ virtual void FlushApzRepaints(const LayersId& aLayersId) = 0;
+ virtual void GetAPZTestData(const LayersId& aLayersId,
APZTestData* aOutData) { }
- virtual void SetConfirmedTargetAPZC(const uint64_t& aLayersId,
+ virtual void SetConfirmedTargetAPZC(const LayersId& aLayersId,
const uint64_t& aInputBlockId,
const nsTArray<ScrollableLayerGuid>& aTargets) = 0;
virtual void UpdatePaintTime(LayerTransactionParent* aLayerTree, const TimeDuration& aPaintTime) {}
ShmemAllocator* AsShmemAllocator() override { return this; }
CompositorBridgeParentBase* AsCompositorBridgeParentBase() override { return this; }
mozilla::ipc::IPCResult RecvSyncWithCompositor() override { return IPC_OK(); }
mozilla::ipc::IPCResult Recv__delete__() override { return IPC_OK(); }
- virtual void ObserveLayerUpdate(uint64_t aLayersId, uint64_t aEpoch, bool aActive) = 0;
+ virtual void ObserveLayerUpdate(LayersId aLayersId, uint64_t aEpoch, bool aActive) = 0;
- virtual void DidComposite(uint64_t aId, TimeStamp& aCompositeStart, TimeStamp& aCompositeEnd) {}
+ virtual void DidComposite(LayersId aId, TimeStamp& aCompositeStart, TimeStamp& aCompositeEnd) {}
virtual void NotifyDidCompositeToPipeline(const wr::PipelineId& aPipelineId,
const wr::Epoch& aEpoch,
TimeStamp& aCompositeStart,
TimeStamp& aCompositeEnd) { MOZ_ASSERT_UNREACHABLE("WebRender only"); }
virtual void NotifyPipelineRemoved(const wr::PipelineId& aPipelineId) { MOZ_ASSERT_UNREACHABLE("WebRender only"); }
// HostIPCAllocator
@@ -160,17 +160,17 @@ public:
void DeallocShmem(mozilla::ipc::Shmem& aShmem) override;
// MetricsSharingController
NS_IMETHOD_(MozExternalRefCountType) AddRef() override { return HostIPCAllocator::AddRef(); }
NS_IMETHOD_(MozExternalRefCountType) Release() override { return HostIPCAllocator::Release(); }
base::ProcessId RemotePid() override;
bool StartSharingMetrics(mozilla::ipc::SharedMemoryBasic::Handle aHandle,
CrossProcessMutexHandle aMutexHandle,
- uint64_t aLayersId,
+ LayersId aLayersId,
uint32_t aApzcId) override;
bool StopSharingMetrics(FrameMetrics::ViewID aScrollId,
uint32_t aApzcId) override;
virtual bool IsRemote() const {
return false;
}
@@ -200,27 +200,27 @@ public:
explicit CompositorBridgeParent(CompositorManagerParent* aManager,
CSSToLayoutDeviceScale aScale,
const TimeDuration& aVsyncRate,
const CompositorOptions& aOptions,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize);
- void InitSameProcess(widget::CompositorWidget* aWidget, const uint64_t& aLayerTreeId);
+ void InitSameProcess(widget::CompositorWidget* aWidget, const LayersId& aLayerTreeId);
- mozilla::ipc::IPCResult RecvInitialize(const uint64_t& aRootLayerTreeId) override;
+ mozilla::ipc::IPCResult RecvInitialize(const LayersId& aRootLayerTreeId) override;
mozilla::ipc::IPCResult RecvGetFrameUniformity(FrameUniformityData* aOutData) override;
mozilla::ipc::IPCResult RecvWillClose() override;
mozilla::ipc::IPCResult RecvPause() override;
mozilla::ipc::IPCResult RecvResume() override;
- mozilla::ipc::IPCResult RecvNotifyChildCreated(const uint64_t& child, CompositorOptions* aOptions) override;
- mozilla::ipc::IPCResult RecvMapAndNotifyChildCreated(const uint64_t& child, const base::ProcessId& pid, CompositorOptions* aOptions) override;
- mozilla::ipc::IPCResult RecvNotifyChildRecreated(const uint64_t& child, CompositorOptions* aOptions) override;
- mozilla::ipc::IPCResult RecvAdoptChild(const uint64_t& child) override;
+ mozilla::ipc::IPCResult RecvNotifyChildCreated(const LayersId& child, CompositorOptions* aOptions) override;
+ mozilla::ipc::IPCResult RecvMapAndNotifyChildCreated(const LayersId& child, const base::ProcessId& pid, CompositorOptions* aOptions) override;
+ mozilla::ipc::IPCResult RecvNotifyChildRecreated(const LayersId& child, CompositorOptions* aOptions) override;
+ mozilla::ipc::IPCResult RecvAdoptChild(const LayersId& child) override;
mozilla::ipc::IPCResult RecvMakeSnapshot(const SurfaceDescriptor& aInSnapshot,
const gfx::IntRect& aRect) override;
mozilla::ipc::IPCResult RecvFlushRendering() override;
mozilla::ipc::IPCResult RecvFlushRenderingAsync() override;
mozilla::ipc::IPCResult RecvWaitOnTransactionProcessed() override;
mozilla::ipc::IPCResult RecvForcePresent() override;
mozilla::ipc::IPCResult RecvNotifyRegionInvalidated(const nsIntRegion& aRegion) override;
@@ -236,81 +236,81 @@ public:
mozilla::ipc::IPCResult RecvAllPluginsCaptured() override;
void ActorDestroy(ActorDestroyReason why) override;
void ShadowLayersUpdated(LayerTransactionParent* aLayerTree,
const TransactionInfo& aInfo,
bool aHitTestUpdate) override;
void ScheduleComposite(LayerTransactionParent* aLayerTree) override;
- bool SetTestSampleTime(const uint64_t& aId,
+ bool SetTestSampleTime(const LayersId& aId,
const TimeStamp& aTime) override;
- void LeaveTestMode(const uint64_t& aId) override;
+ void LeaveTestMode(const LayersId& aId) override;
void ApplyAsyncProperties(LayerTransactionParent* aLayerTree) override;
CompositorAnimationStorage* GetAnimationStorage();
- void SetTestAsyncScrollOffset(const uint64_t& aLayersId,
+ void SetTestAsyncScrollOffset(const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const CSSPoint& aPoint) override;
- void SetTestAsyncZoom(const uint64_t& aLayersId,
+ void SetTestAsyncZoom(const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const LayerToParentLayerScale& aZoom) override;
- void FlushApzRepaints(const uint64_t& aLayersId) override;
- void GetAPZTestData(const uint64_t& aLayersId,
+ void FlushApzRepaints(const LayersId& aLayersId) override;
+ void GetAPZTestData(const LayersId& aLayersId,
APZTestData* aOutData) override;
- void SetConfirmedTargetAPZC(const uint64_t& aLayersId,
+ void SetConfirmedTargetAPZC(const LayersId& aLayersId,
const uint64_t& aInputBlockId,
const nsTArray<ScrollableLayerGuid>& aTargets) override;
AsyncCompositionManager* GetCompositionManager(LayerTransactionParent* aLayerTree) override { return mCompositionManager; }
PTextureParent* AllocPTextureParent(const SurfaceDescriptor& aSharedData,
const ReadLockDescriptor& aReadLock,
const LayersBackend& aLayersBackend,
const TextureFlags& aFlags,
- const uint64_t& aId,
+ const LayersId& aId,
const uint64_t& aSerial,
const wr::MaybeExternalImageId& aExternalImageId) override;
bool DeallocPTextureParent(PTextureParent* actor) override;
bool IsSameProcess() const override;
void NotifyWebRenderError(wr::WebRenderError aError) override;
PCompositorWidgetParent* AllocPCompositorWidgetParent(const CompositorWidgetInitData& aInitData) override;
bool DeallocPCompositorWidgetParent(PCompositorWidgetParent* aActor) override;
- void ObserveLayerUpdate(uint64_t aLayersId, uint64_t aEpoch, bool aActive) override { }
+ void ObserveLayerUpdate(LayersId aLayersId, uint64_t aEpoch, bool aActive) override { }
/**
* This forces the is-first-paint flag to true. This is intended to
* be called by the widget code when it loses its viewport information
* (or for whatever reason wants to refresh the viewport information).
* The information refresh happens because the compositor will call
* SetFirstPaintViewport on the next frame of composition.
*/
mozilla::ipc::IPCResult RecvForceIsFirstPaint() override;
static void SetShadowProperties(Layer* aLayer);
- void NotifyChildCreated(uint64_t aChild);
+ void NotifyChildCreated(LayersId aChild);
void AsyncRender();
// Can be called from any thread
void ScheduleRenderOnCompositorThread() override;
void SchedulePauseOnCompositorThread();
void InvalidateOnCompositorThread();
/**
* Returns true if a surface was obtained and the resume succeeded; false
* otherwise.
*/
bool ScheduleResumeOnCompositorThread();
bool ScheduleResumeOnCompositorThread(int width, int height);
void ScheduleComposition();
- void NotifyShadowTreeTransaction(uint64_t aId, bool aIsFirstPaint,
+ void NotifyShadowTreeTransaction(LayersId aId, bool aIsFirstPaint,
const FocusTarget& aFocusTarget,
bool aScheduleComposite, uint32_t aPaintSequenceNumber,
bool aIsRepeatTransaction, bool aHitTestUpdate);
void UpdatePaintTime(LayerTransactionParent* aLayerTree,
const TimeDuration& aPaintTime) override;
/**
@@ -318,17 +318,17 @@ public:
* Only can be called from compositor thread.
*/
void ScheduleRotationOnCompositorThread(const TargetConfig& aTargetConfig, bool aIsFirstPaint);
/**
* Returns the unique layer tree identifier that corresponds to the root
* tree of this compositor.
*/
- uint64_t RootLayerTreeId();
+ LayersId RootLayerTreeId();
/**
* Notify local and remote layer trees connected to this compositor that
* the compositor's local device is being reset. All layers must be
* invalidated to clear any cached TextureSources.
*
* This must be called on the compositor thread.
*/
@@ -337,25 +337,25 @@ public:
/**
* Returns a pointer to the CompositorBridgeParent corresponding to the given ID.
*/
static CompositorBridgeParent* GetCompositorBridgeParent(uint64_t id);
/**
* Notify the compositor for the given layer tree that vsync has occurred.
*/
- static void NotifyVsync(const TimeStamp& aTimeStamp, const uint64_t& aLayersId);
+ static void NotifyVsync(const TimeStamp& aTimeStamp, const LayersId& aLayersId);
/**
* Set aController as the pan/zoom callback for the subtree referred
* to by aLayersId.
*
* Must run on content main thread.
*/
- static void SetControllerForLayerTree(uint64_t aLayersId,
+ static void SetControllerForLayerTree(LayersId aLayersId,
GeckoContentController* aController);
struct LayerTreeState {
LayerTreeState();
~LayerTreeState();
RefPtr<Layer> mRoot;
RefPtr<GeckoContentController> mController;
APZCTreeManagerParent* mApzcTreeManagerParent;
@@ -377,50 +377,50 @@ public:
RefPtr<UiCompositorControllerParent> mUiControllerParent;
};
/**
* Lookup the indirect shadow tree for |aId| and return it if it
* exists. Otherwise null is returned. This must only be called on
* the compositor thread.
*/
- static LayerTreeState* GetIndirectShadowTree(uint64_t aId);
+ static LayerTreeState* GetIndirectShadowTree(LayersId aId);
/**
* Lookup the indirect shadow tree for |aId|, call the function object and
* return true if found. If not found, return false.
*/
static bool CallWithIndirectShadowTree(
- uint64_t aId,
+ LayersId aId,
const std::function<void(LayerTreeState&)>& aFunc);
/**
* Given the layers id for a content process, get the APZCTreeManagerParent
* for the corresponding *root* layers id. That is, the APZCTreeManagerParent,
* if one is found, will always be connected to the parent process rather
* than a content process. Note that unless the compositor process is
* separated this is expected to return null, because if the compositor is
* living in the gecko parent process then there is no APZCTreeManagerParent
* for the parent process.
*/
static APZCTreeManagerParent* GetApzcTreeManagerParentForRoot(
- uint64_t aContentLayersId);
+ LayersId aContentLayersId);
/**
* Same as the GetApzcTreeManagerParentForRoot function, but returns
* the GeckoContentController for the parent process.
*/
static GeckoContentController* GetGeckoContentControllerForRoot(
- uint64_t aContentLayersId);
+ LayersId aContentLayersId);
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
/**
* Calculates and requests the main thread update plugin positioning, clip,
* and visibility via ipc.
*/
- bool UpdatePluginWindowState(uint64_t aId);
+ bool UpdatePluginWindowState(LayersId aId);
/**
* Plugin visibility helpers for the apz (main thread) and compositor
* thread.
*/
void ScheduleShowAllPluginWindows() override;
void ScheduleHideAllPluginWindows() override;
void ShowAllPluginWindows();
@@ -440,26 +440,26 @@ public:
* Used by the profiler to denote when a vsync occured
*/
static void PostInsertVsyncProfilerMarker(mozilla::TimeStamp aVsyncTimestamp);
widget::CompositorWidget* GetWidget() { return mWidget; }
void ForceComposeToTarget(gfx::DrawTarget* aTarget, const gfx::IntRect* aRect = nullptr);
- PAPZCTreeManagerParent* AllocPAPZCTreeManagerParent(const uint64_t& aLayersId) override;
+ PAPZCTreeManagerParent* AllocPAPZCTreeManagerParent(const LayersId& aLayersId) override;
bool DeallocPAPZCTreeManagerParent(PAPZCTreeManagerParent* aActor) override;
// Helper method so that we don't have to expose mApzcTreeManager to
// CrossProcessCompositorBridgeParent.
void AllocateAPZCTreeManagerParent(const MonitorAutoLock& aProofOfLayerTreeStateLock,
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
LayerTreeState& aLayerTreeStateToUpdate);
- PAPZParent* AllocPAPZParent(const uint64_t& aLayersId) override;
+ PAPZParent* AllocPAPZParent(const LayersId& aLayersId) override;
bool DeallocPAPZParent(PAPZParent* aActor) override;
#if defined(MOZ_WIDGET_ANDROID)
AndroidDynamicToolbarAnimator* GetAndroidDynamicToolbarAnimator();
#endif
RefPtr<APZSampler> GetAPZSampler();
CompositorOptions GetOptions() const {
@@ -474,24 +474,24 @@ public:
PWebRenderBridgeParent* AllocPWebRenderBridgeParent(const wr::PipelineId& aPipelineId,
const LayoutDeviceIntSize& aSize,
TextureFactoryIdentifier* aTextureFactoryIdentifier,
wr::IdNamespace* aIdNamespace) override;
bool DeallocPWebRenderBridgeParent(PWebRenderBridgeParent* aActor) override;
RefPtr<WebRenderBridgeParent> GetWebRenderBridgeParent() const;
Maybe<TimeStamp> GetTestingTimeStamp() const;
- static CompositorBridgeParent* GetCompositorBridgeParentFromLayersId(const uint64_t& aLayersId);
+ static CompositorBridgeParent* GetCompositorBridgeParentFromLayersId(const LayersId& aLayersId);
/**
* This returns a reference to the IAPZCTreeManager "controller subinterface"
* to which pan/zoom-related events can be sent. The controller subinterface
* doesn't expose any sampler-thread APZCTreeManager methods.
*/
- static already_AddRefed<IAPZCTreeManager> GetAPZCTreeManager(uint64_t aLayersId);
+ static already_AddRefed<IAPZCTreeManager> GetAPZCTreeManager(LayersId aLayersId);
#if defined(MOZ_WIDGET_ANDROID)
gfx::IntSize GetEGLSurfaceSize() {
return mEGLSurfaceSize;
}
#endif // defined(MOZ_WIDGET_ANDROID)
private:
@@ -503,27 +503,27 @@ private:
*/
void StopAndClearResources();
/**
* Release compositor-thread resources referred to by |aID|.
*
* Must run on the content main thread.
*/
- static void DeallocateLayerTreeId(uint64_t aId);
+ static void DeallocateLayerTreeId(LayersId aId);
protected:
// Protected destructor, to discourage deletion outside of Release():
virtual ~CompositorBridgeParent();
void DeferredDestroy();
PLayerTransactionParent* AllocPLayerTransactionParent(
const nsTArray<LayersBackend>& aBackendHints,
- const uint64_t& aId) override;
+ const LayersId& aId) override;
bool DeallocPLayerTransactionParent(PLayerTransactionParent* aLayers) override;
virtual void ScheduleTask(already_AddRefed<CancelableRunnable>, int);
void SetEGLSurfaceSize(int width, int height);
void InitializeLayerManager(const nsTArray<LayersBackend>& aBackendHints);
public:
@@ -582,17 +582,17 @@ protected:
const wr::Epoch& aEpoch,
TimeStamp& aCompositeStart,
TimeStamp& aCompositeEnd) override;
void NotifyPipelineRemoved(const wr::PipelineId& aPipelineId) override;
void NotifyDidComposite(uint64_t aTransactionId, TimeStamp& aCompositeStart, TimeStamp& aCompositeEnd);
// The indirect layer tree lock must be held before calling this function.
- // Callback should take (LayerTreeState* aState, const uint64_t& aLayersId)
+ // Callback should take (LayerTreeState* aState, const LayersId& aLayersId)
template <typename Lambda>
inline void ForEachIndirectLayerTree(const Lambda& aCallback);
RefPtr<HostLayerManager> mLayerManager;
RefPtr<Compositor> mCompositor;
RefPtr<AsyncCompositionManager> mCompositionManager;
RefPtr<AsyncImagePipelineManager> mAsyncImageManager;
RefPtr<WebRenderBridgeParent> mWrBridge;
@@ -611,17 +611,17 @@ protected:
gfx::IntSize mEGLSurfaceSize;
CompositorOptions mOptions;
mozilla::Monitor mPauseCompositionMonitor;
mozilla::Monitor mResumeCompositionMonitor;
uint64_t mCompositorBridgeID;
- uint64_t mRootLayerTreeID;
+ LayersId mRootLayerTreeID;
bool mOverrideComposeReadiness;
RefPtr<CancelableRunnable> mForceCompositionTask;
RefPtr<APZCTreeManager> mApzcTreeManager;
RefPtr<APZSampler> mApzSampler;
RefPtr<CompositorVsyncScheduler> mCompositorScheduler;
@@ -630,17 +630,17 @@ protected:
// mSelfRef is cleared in DeferredDestroy which is scheduled by ActorDestroy.
RefPtr<CompositorBridgeParent> mSelfRef;
RefPtr<CompositorAnimationStorage> mAnimationStorage;
TimeDuration mPaintTime;
#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
// cached plugin data used to reduce the number of updates we request.
- uint64_t mLastPluginUpdateLayerTreeId;
+ LayersId mLastPluginUpdateLayerTreeId;
nsIntPoint mPluginsLayerOffset;
nsIntRegion mPluginsLayerVisibleRegion;
nsTArray<PluginWindowData> mCachedPluginData;
// Time until which we will block composition to wait for plugin updates.
TimeStamp mWaitForPluginsUntil;
// Indicates that we have actually blocked a composition waiting for plugins.
bool mHaveBlockedForPlugins = false;
// indicates if plugin window visibility and metric updates are currently
--- a/gfx/layers/ipc/CompositorManagerChild.cpp
+++ b/gfx/layers/ipc/CompositorManagerChild.cpp
@@ -256,17 +256,17 @@ CompositorManagerChild::ProcessingError(
gfxDevCrash(gfx::LogReason::ProcessingError) << "Processing error in CompositorBridgeChild: " << int(aCode);
}
}
already_AddRefed<nsIEventTarget>
CompositorManagerChild::GetSpecificMessageEventTarget(const Message& aMsg)
{
if (aMsg.type() == PCompositorBridge::Msg_DidComposite__ID) {
- uint64_t layersId;
+ LayersId layersId;
PickleIterator iter(aMsg);
if (!IPC::ReadParam(&aMsg, &iter, &layersId)) {
return nullptr;
}
TabChild* tabChild = TabChild::GetFrom(layersId);
if (!tabChild) {
return nullptr;
--- a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
@@ -37,21 +37,21 @@
using namespace std;
namespace mozilla {
namespace layers {
// defined in CompositorBridgeParent.cpp
-typedef map<uint64_t, CompositorBridgeParent::LayerTreeState> LayerTreeMap;
+typedef map<LayersId, CompositorBridgeParent::LayerTreeState> LayerTreeMap;
extern LayerTreeMap sIndirectLayerTrees;
extern StaticAutoPtr<mozilla::Monitor> sIndirectLayerTreesLock;
-void UpdateIndirectTree(uint64_t aId, Layer* aRoot, const TargetConfig& aTargetConfig);
-void EraseLayerState(uint64_t aId);
+void UpdateIndirectTree(LayersId aId, Layer* aRoot, const TargetConfig& aTargetConfig);
+void EraseLayerState(LayersId aId);
mozilla::ipc::IPCResult
CrossProcessCompositorBridgeParent::RecvRequestNotifyAfterRemotePaint()
{
mNotifyAfterRemotePaint = true;
return IPC_OK();
}
@@ -66,19 +66,19 @@ CrossProcessCompositorBridgeParent::Acto
"layers::CrossProcessCompositorBridgeParent::DeferredDestroy",
this,
&CrossProcessCompositorBridgeParent::DeferredDestroy));
}
PLayerTransactionParent*
CrossProcessCompositorBridgeParent::AllocPLayerTransactionParent(
const nsTArray<LayersBackend>&,
- const uint64_t& aId)
+ const LayersId& aId)
{
- MOZ_ASSERT(aId != 0);
+ MOZ_ASSERT(aId.IsValid());
// Check to see if this child process has access to this layer tree.
if (!LayerTreeOwnerTracker::Get()->IsMapped(aId, OtherPid())) {
NS_ERROR("Unexpected layers id in AllocPLayerTransactionParent; dropping message...");
return nullptr;
}
MonitorAutoLock lock(*sIndirectLayerTreesLock);
@@ -110,61 +110,61 @@ CrossProcessCompositorBridgeParent::Deal
{
LayerTransactionParent* slp = static_cast<LayerTransactionParent*>(aLayers);
EraseLayerState(slp->GetId());
static_cast<LayerTransactionParent*>(aLayers)->ReleaseIPDLReference();
return true;
}
PAPZCTreeManagerParent*
-CrossProcessCompositorBridgeParent::AllocPAPZCTreeManagerParent(const uint64_t& aLayersId)
+CrossProcessCompositorBridgeParent::AllocPAPZCTreeManagerParent(const LayersId& aLayersId)
{
// Check to see if this child process has access to this layer tree.
if (!LayerTreeOwnerTracker::Get()->IsMapped(aLayersId, OtherPid())) {
NS_ERROR("Unexpected layers id in AllocPAPZCTreeManagerParent; dropping message...");
return nullptr;
}
MonitorAutoLock lock(*sIndirectLayerTreesLock);
CompositorBridgeParent::LayerTreeState& state = sIndirectLayerTrees[aLayersId];
// If the widget has shutdown its compositor, we may not have had a chance yet
// to unmap our layers id, and we could get here without a parent compositor.
// In this case return an empty APZCTM.
if (!state.mParent) {
// Note: we immediately call ClearTree since otherwise the APZCTM will
// retain a reference to itself, through the checkerboard observer.
- RefPtr<APZCTreeManager> temp = new APZCTreeManager(0);
+ RefPtr<APZCTreeManager> temp = new APZCTreeManager(LayersId{0});
temp->ClearTree();
return new APZCTreeManagerParent(aLayersId, temp);
}
state.mParent->AllocateAPZCTreeManagerParent(lock, aLayersId, state);
return state.mApzcTreeManagerParent;
}
bool
CrossProcessCompositorBridgeParent::DeallocPAPZCTreeManagerParent(PAPZCTreeManagerParent* aActor)
{
APZCTreeManagerParent* parent = static_cast<APZCTreeManagerParent*>(aActor);
MonitorAutoLock lock(*sIndirectLayerTreesLock);
- auto iter = sIndirectLayerTrees.find(parent->LayersId());
+ auto iter = sIndirectLayerTrees.find(parent->GetLayersId());
if (iter != sIndirectLayerTrees.end()) {
CompositorBridgeParent::LayerTreeState& state = iter->second;
MOZ_ASSERT(state.mApzcTreeManagerParent == parent);
state.mApzcTreeManagerParent = nullptr;
}
delete parent;
return true;
}
PAPZParent*
-CrossProcessCompositorBridgeParent::AllocPAPZParent(const uint64_t& aLayersId)
+CrossProcessCompositorBridgeParent::AllocPAPZParent(const LayersId& aLayersId)
{
// Check to see if this child process has access to this layer tree.
if (!LayerTreeOwnerTracker::Get()->IsMapped(aLayersId, OtherPid())) {
NS_ERROR("Unexpected layers id in AllocPAPZParent; dropping message...");
return nullptr;
}
RemoteContentController* controller = new RemoteContentController();
@@ -195,17 +195,17 @@ CrossProcessCompositorBridgeParent::Allo
TextureFactoryIdentifier* aTextureFactoryIdentifier,
wr::IdNamespace *aIdNamespace)
{
#ifndef MOZ_BUILD_WEBRENDER
// Extra guard since this in the parent process and we don't want a malicious
// child process invoking this codepath before it's ready
MOZ_RELEASE_ASSERT(false);
#endif
- uint64_t layersId = wr::AsUint64(aPipelineId);
+ LayersId layersId = wr::AsLayersId(aPipelineId);
// Check to see if this child process has access to this layer tree.
if (!LayerTreeOwnerTracker::Get()->IsMapped(layersId, OtherPid())) {
NS_ERROR("Unexpected layers id in AllocPAPZCTreeManagerParent; dropping message...");
return nullptr;
}
MonitorAutoLock lock(*sIndirectLayerTreesLock);
MOZ_ASSERT(sIndirectLayerTrees.find(layersId) != sIndirectLayerTrees.end());
@@ -251,40 +251,40 @@ bool
CrossProcessCompositorBridgeParent::DeallocPWebRenderBridgeParent(PWebRenderBridgeParent* aActor)
{
#ifndef MOZ_BUILD_WEBRENDER
// Extra guard since this in the parent process and we don't want a malicious
// child process invoking this codepath before it's ready
MOZ_RELEASE_ASSERT(false);
#endif
WebRenderBridgeParent* parent = static_cast<WebRenderBridgeParent*>(aActor);
- EraseLayerState(wr::AsUint64(parent->PipelineId()));
+ EraseLayerState(wr::AsLayersId(parent->PipelineId()));
parent->Release(); // IPDL reference
return true;
}
mozilla::ipc::IPCResult
-CrossProcessCompositorBridgeParent::RecvNotifyChildCreated(const uint64_t& child,
+CrossProcessCompositorBridgeParent::RecvNotifyChildCreated(const LayersId& child,
CompositorOptions* aOptions)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
for (LayerTreeMap::iterator it = sIndirectLayerTrees.begin();
it != sIndirectLayerTrees.end(); it++) {
CompositorBridgeParent::LayerTreeState* lts = &it->second;
if (lts->mParent && lts->mCrossProcessParent == this) {
lts->mParent->NotifyChildCreated(child);
*aOptions = lts->mParent->GetOptions();
return IPC_OK();
}
}
return IPC_FAIL_NO_REASON(this);
}
mozilla::ipc::IPCResult
-CrossProcessCompositorBridgeParent::RecvMapAndNotifyChildCreated(const uint64_t& child,
+CrossProcessCompositorBridgeParent::RecvMapAndNotifyChildCreated(const LayersId& child,
const base::ProcessId& pid,
CompositorOptions* aOptions)
{
// This can only be called from the browser process, as the mapping
// ensures proper window ownership of layer trees.
return IPC_FAIL_NO_REASON(this);
}
@@ -312,19 +312,19 @@ CrossProcessCompositorBridgeParent::Recv
};
void
CrossProcessCompositorBridgeParent::ShadowLayersUpdated(
LayerTransactionParent* aLayerTree,
const TransactionInfo& aInfo,
bool aHitTestUpdate)
{
- uint64_t id = aLayerTree->GetId();
+ LayersId id = aLayerTree->GetId();
- MOZ_ASSERT(id != 0);
+ MOZ_ASSERT(id.IsValid());
CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(id);
if (!state) {
return;
}
MOZ_ASSERT(state->mParent);
state->mParent->ScheduleRotationOnCompositorThread(
@@ -362,27 +362,27 @@ CrossProcessCompositorBridgeParent::Shad
Unused << state->mParent->SendObserveLayerUpdate(id, aLayerTree->GetChildEpoch(), true);
}
aLayerTree->SetPendingTransactionId(aInfo.id(), aInfo.transactionStart(), aInfo.fwdTime());
}
void
CrossProcessCompositorBridgeParent::DidComposite(
- uint64_t aId,
+ LayersId aId,
TimeStamp& aCompositeStart,
TimeStamp& aCompositeEnd)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
DidCompositeLocked(aId, aCompositeStart, aCompositeEnd);
}
void
CrossProcessCompositorBridgeParent::DidCompositeLocked(
- uint64_t aId,
+ LayersId aId,
TimeStamp& aCompositeStart,
TimeStamp& aCompositeEnd)
{
sIndirectLayerTreesLock->AssertCurrentThreadOwns();
if (LayerTransactionParent *layerTree = sIndirectLayerTrees[aId].mLayerTree) {
uint64_t transactionId = layerTree->FlushTransactionId(aCompositeEnd);
if (transactionId) {
Unused << SendDidComposite(aId, transactionId, aCompositeStart, aCompositeEnd);
@@ -393,171 +393,171 @@ CrossProcessCompositorBridgeParent::DidC
Unused << SendDidComposite(aId, transactionId, aCompositeStart, aCompositeEnd);
}
}
}
void
CrossProcessCompositorBridgeParent::ScheduleComposite(LayerTransactionParent* aLayerTree)
{
- uint64_t id = aLayerTree->GetId();
- MOZ_ASSERT(id != 0);
+ LayersId id = aLayerTree->GetId();
+ MOZ_ASSERT(id.IsValid());
CompositorBridgeParent* parent;
{ // scope lock
MonitorAutoLock lock(*sIndirectLayerTreesLock);
parent = sIndirectLayerTrees[id].mParent;
}
if (parent) {
parent->ScheduleComposite(aLayerTree);
}
}
void
CrossProcessCompositorBridgeParent::NotifyClearCachedResources(LayerTransactionParent* aLayerTree)
{
- uint64_t id = aLayerTree->GetId();
- MOZ_ASSERT(id != 0);
+ LayersId id = aLayerTree->GetId();
+ MOZ_ASSERT(id.IsValid());
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(id);
if (state && state->mParent) {
// Note that we send this through the window compositor, since this needs
// to reach the widget owning the tab.
Unused << state->mParent->SendObserveLayerUpdate(id, aLayerTree->GetChildEpoch(), false);
}
}
bool
-CrossProcessCompositorBridgeParent::SetTestSampleTime(const uint64_t& aId,
+CrossProcessCompositorBridgeParent::SetTestSampleTime(const LayersId& aId,
const TimeStamp& aTime)
{
- MOZ_ASSERT(aId != 0);
+ MOZ_ASSERT(aId.IsValid());
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(aId);
if (!state) {
return false;
}
MOZ_ASSERT(state->mParent);
return state->mParent->SetTestSampleTime(aId, aTime);
}
void
-CrossProcessCompositorBridgeParent::LeaveTestMode(const uint64_t& aId)
+CrossProcessCompositorBridgeParent::LeaveTestMode(const LayersId& aId)
{
- MOZ_ASSERT(aId != 0);
+ MOZ_ASSERT(aId.IsValid());
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(aId);
if (!state) {
return;
}
MOZ_ASSERT(state->mParent);
state->mParent->LeaveTestMode(aId);
}
void
CrossProcessCompositorBridgeParent::ApplyAsyncProperties(
LayerTransactionParent* aLayerTree)
{
- uint64_t id = aLayerTree->GetId();
- MOZ_ASSERT(id != 0);
+ LayersId id = aLayerTree->GetId();
+ MOZ_ASSERT(id.IsValid());
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(id);
if (!state) {
return;
}
MOZ_ASSERT(state->mParent);
state->mParent->ApplyAsyncProperties(aLayerTree);
}
void
CrossProcessCompositorBridgeParent::SetTestAsyncScrollOffset(
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const CSSPoint& aPoint)
{
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
if (!state) {
return;
}
MOZ_ASSERT(state->mParent);
state->mParent->SetTestAsyncScrollOffset(aLayersId, aScrollId, aPoint);
}
void
CrossProcessCompositorBridgeParent::SetTestAsyncZoom(
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const LayerToParentLayerScale& aZoom)
{
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
if (!state) {
return;
}
MOZ_ASSERT(state->mParent);
state->mParent->SetTestAsyncZoom(aLayersId, aScrollId, aZoom);
}
void
-CrossProcessCompositorBridgeParent::FlushApzRepaints(const uint64_t& aLayersId)
+CrossProcessCompositorBridgeParent::FlushApzRepaints(const LayersId& aLayersId)
{
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
if (!state) {
return;
}
MOZ_ASSERT(state->mParent);
state->mParent->FlushApzRepaints(aLayersId);
}
void
CrossProcessCompositorBridgeParent::GetAPZTestData(
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
APZTestData* aOutData)
{
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
if (!state || !state->mParent) {
return;
}
state->mParent->GetAPZTestData(aLayersId, aOutData);
}
void
CrossProcessCompositorBridgeParent::SetConfirmedTargetAPZC(
- const uint64_t& aLayersId,
+ const LayersId& aLayersId,
const uint64_t& aInputBlockId,
const nsTArray<ScrollableLayerGuid>& aTargets)
{
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
if (!state || !state->mParent) {
return;
}
state->mParent->SetConfirmedTargetAPZC(aLayersId, aInputBlockId, aTargets);
}
AsyncCompositionManager*
CrossProcessCompositorBridgeParent::GetCompositionManager(LayerTransactionParent* aLayerTree)
{
- uint64_t id = aLayerTree->GetId();
+ LayersId id = aLayerTree->GetId();
const CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(id);
if (!state) {
return nullptr;
}
MOZ_ASSERT(state->mParent);
return state->mParent->GetCompositionManager(aLayerTree);
@@ -574,17 +574,17 @@ CrossProcessCompositorBridgeParent::~Cro
MOZ_ASSERT(XRE_GetIOMessageLoop());
}
PTextureParent*
CrossProcessCompositorBridgeParent::AllocPTextureParent(const SurfaceDescriptor& aSharedData,
const ReadLockDescriptor& aReadLock,
const LayersBackend& aLayersBackend,
const TextureFlags& aFlags,
- const uint64_t& aId,
+ const LayersId& aId,
const uint64_t& aSerial,
const wr::MaybeExternalImageId& aExternalImageId)
{
CompositorBridgeParent::LayerTreeState* state = nullptr;
LayerTreeMap::iterator itr = sIndirectLayerTrees.find(aId);
if (sIndirectLayerTrees.end() != itr) {
state = &itr->second;
@@ -621,32 +621,32 @@ bool
CrossProcessCompositorBridgeParent::IsSameProcess() const
{
return OtherPid() == base::GetCurrentProcId();
}
void
CrossProcessCompositorBridgeParent::UpdatePaintTime(LayerTransactionParent* aLayerTree, const TimeDuration& aPaintTime)
{
- uint64_t id = aLayerTree->GetId();
- MOZ_ASSERT(id != 0);
+ LayersId id = aLayerTree->GetId();
+ MOZ_ASSERT(id.IsValid());
CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(id);
if (!state || !state->mParent) {
return;
}
state->mParent->UpdatePaintTime(aLayerTree, aPaintTime);
}
void
-CrossProcessCompositorBridgeParent::ObserveLayerUpdate(uint64_t aLayersId, uint64_t aEpoch, bool aActive)
+CrossProcessCompositorBridgeParent::ObserveLayerUpdate(LayersId aLayersId, uint64_t aEpoch, bool aActive)
{
- MOZ_ASSERT(aLayersId != 0);
+ MOZ_ASSERT(aLayersId.IsValid());
CompositorBridgeParent::LayerTreeState* state =
CompositorBridgeParent::GetIndirectShadowTree(aLayersId);
if (!state || !state->mParent) {
return;
}
Unused << state->mParent->SendObserveLayerUpdate(aLayersId, aEpoch, aActive);
--- a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
+++ b/gfx/layers/ipc/CrossProcessCompositorBridgeParent.h
@@ -32,25 +32,25 @@ public:
, mNotifyAfterRemotePaint(false)
, mDestroyCalled(false)
{
}
void ActorDestroy(ActorDestroyReason aWhy) override;
// FIXME/bug 774388: work out what shutdown protocol we need.
- mozilla::ipc::IPCResult RecvInitialize(const uint64_t& aRootLayerTreeId) override { return IPC_FAIL_NO_REASON(this); }
+ mozilla::ipc::IPCResult RecvInitialize(const LayersId& aRootLayerTreeId) override { return IPC_FAIL_NO_REASON(this); }
mozilla::ipc::IPCResult RecvWillClose() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvPause() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvResume() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvForceIsFirstPaint() override { return IPC_OK(); }
- mozilla::ipc::IPCResult RecvNotifyChildCreated(const uint64_t& child, CompositorOptions* aOptions) override;
- mozilla::ipc::IPCResult RecvMapAndNotifyChildCreated(const uint64_t& child, const base::ProcessId& pid, CompositorOptions* aOptions) override;
- mozilla::ipc::IPCResult RecvNotifyChildRecreated(const uint64_t& child, CompositorOptions* aOptions) override { return IPC_FAIL_NO_REASON(this); }
- mozilla::ipc::IPCResult RecvAdoptChild(const uint64_t& child) override { return IPC_FAIL_NO_REASON(this); }
+ mozilla::ipc::IPCResult RecvNotifyChildCreated(const LayersId& child, CompositorOptions* aOptions) override;
+ mozilla::ipc::IPCResult RecvMapAndNotifyChildCreated(const LayersId& child, const base::ProcessId& pid, CompositorOptions* aOptions) override;
+ mozilla::ipc::IPCResult RecvNotifyChildRecreated(const LayersId& child, CompositorOptions* aOptions) override { return IPC_FAIL_NO_REASON(this); }
+ mozilla::ipc::IPCResult RecvAdoptChild(const LayersId& child) override { return IPC_FAIL_NO_REASON(this); }
mozilla::ipc::IPCResult RecvMakeSnapshot(const SurfaceDescriptor& aInSnapshot,
const gfx::IntRect& aRect) override
{ return IPC_OK(); }
mozilla::ipc::IPCResult RecvFlushRendering() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvFlushRenderingAsync() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvForcePresent() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvWaitOnTransactionProcessed() override { return IPC_OK(); }
mozilla::ipc::IPCResult RecvNotifyRegionInvalidated(const nsIntRegion& aRegion) override { return IPC_OK(); }
@@ -71,91 +71,91 @@ public:
/**
* Tells this CompositorBridgeParent to send a message when the compositor has received the transaction.
*/
mozilla::ipc::IPCResult RecvRequestNotifyAfterRemotePaint() override;
PLayerTransactionParent* AllocPLayerTransactionParent(
const nsTArray<LayersBackend>& aBackendHints,
- const uint64_t& aId) override;
+ const LayersId& aId) override;
bool DeallocPLayerTransactionParent(PLayerTransactionParent* aLayers) override;
void ShadowLayersUpdated(LayerTransactionParent* aLayerTree,
const TransactionInfo& aInfo,
bool aHitTestUpdate) override;
void ScheduleComposite(LayerTransactionParent* aLayerTree) override;
void NotifyClearCachedResources(LayerTransactionParent* aLayerTree) override;
- bool SetTestSampleTime(const uint64_t& aId,
+ bool SetTestSampleTime(const LayersId& aId,
const TimeStamp& aTime) override;
- void LeaveTestMode(const uint64_t& aId) override;
+ void LeaveTestMode(const LayersId& aId) override;
void ApplyAsyncProperties(LayerTransactionParent* aLayerTree) override;
- void SetTestAsyncScrollOffset(const uint64_t& aLayersId,
+ void SetTestAsyncScrollOffset(const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const CSSPoint& aPoint) override;
- void SetTestAsyncZoom(const uint64_t& aLayersId,
+ void SetTestAsyncZoom(const LayersId& aLayersId,
const FrameMetrics::ViewID& aScrollId,
const LayerToParentLayerScale& aZoom) override;
- void FlushApzRepaints(const uint64_t& aLayersId) override;
- void GetAPZTestData(const uint64_t& aLayersId,
+ void FlushApzRepaints(const LayersId& aLayersId) override;
+ void GetAPZTestData(const LayersId& aLayersId,
APZTestData* aOutData) override;
- void SetConfirmedTargetAPZC(const uint64_t& aLayersId,
+ void SetConfirmedTargetAPZC(const LayersId& aLayersId,
const uint64_t& aInputBlockId,
const nsTArray<ScrollableLayerGuid>& aTargets) override;
AsyncCompositionManager* GetCompositionManager(LayerTransactionParent* aParent) override;
mozilla::ipc::IPCResult RecvRemotePluginsReady() override { return IPC_FAIL_NO_REASON(this); }
// Use DidCompositeLocked if you already hold a lock on
// sIndirectLayerTreesLock; Otherwise use DidComposite, which would request
// the lock automatically.
- void DidCompositeLocked(uint64_t aId,
+ void DidCompositeLocked(LayersId aId,
TimeStamp& aCompositeStart,
TimeStamp& aCompositeEnd);
- void DidComposite(uint64_t aId,
+ void DidComposite(LayersId aId,
TimeStamp& aCompositeStart,
TimeStamp& aCompositeEnd) override;
PTextureParent* AllocPTextureParent(const SurfaceDescriptor& aSharedData,
const ReadLockDescriptor& aReadLock,
const LayersBackend& aLayersBackend,
const TextureFlags& aFlags,
- const uint64_t& aId,
+ const LayersId& aId,
const uint64_t& aSerial,
const wr::MaybeExternalImageId& aExternalImageId) override;
bool DeallocPTextureParent(PTextureParent* actor) override;
bool IsSameProcess() const override;
PCompositorWidgetParent* AllocPCompositorWidgetParent(const CompositorWidgetInitData& aInitData) override {
// Not allowed.
return nullptr;
}
bool DeallocPCompositorWidgetParent(PCompositorWidgetParent* aActor) override {
// Not allowed.
return false;
}
- PAPZCTreeManagerParent* AllocPAPZCTreeManagerParent(const uint64_t& aLayersId) override;
+ PAPZCTreeManagerParent* AllocPAPZCTreeManagerParent(const LayersId& aLayersId) override;
bool DeallocPAPZCTreeManagerParent(PAPZCTreeManagerParent* aActor) override;
- PAPZParent* AllocPAPZParent(const uint64_t& aLayersId) override;
+ PAPZParent* AllocPAPZParent(const LayersId& aLayersId) override;
bool DeallocPAPZParent(PAPZParent* aActor) override;
void UpdatePaintTime(LayerTransactionParent* aLayerTree, const TimeDuration& aPaintTime) override;
PWebRenderBridgeParent* AllocPWebRenderBridgeParent(const wr::PipelineId& aPipelineId,
const LayoutDeviceIntSize& aSize,
TextureFactoryIdentifier* aTextureFactoryIdentifier,
wr::IdNamespace* aIdNamespace) override;
bool DeallocPWebRenderBridgeParent(PWebRenderBridgeParent* aActor) override;
- void ObserveLayerUpdate(uint64_t aLayersId, uint64_t aEpoch, bool aActive) override;
+ void ObserveLayerUpdate(LayersId aLayersId, uint64_t aEpoch, bool aActive) override;
bool IsRemote() const override {
return true;
}
private:
// Private destructor, to discourage deletion outside of Release():
virtual ~CrossProcessCompositorBridgeParent();
--- a/gfx/layers/ipc/LayerTransactionChild.h
+++ b/gfx/layers/ipc/LayerTransactionChild.h
@@ -40,24 +40,24 @@ public:
bool IPCOpen() const { return mIPCOpen && !mDestroyed; }
bool IsDestroyed() const { return mDestroyed; }
void SetForwarder(ShadowLayerForwarder* aForwarder)
{
mForwarder = aForwarder;
}
- uint64_t GetId() const { return mId; }
+ LayersId GetId() const { return mId; }
void MarkDestroyed() {
mDestroyed = true;
}
protected:
- explicit LayerTransactionChild(const uint64_t& aId)
+ explicit LayerTransactionChild(const LayersId& aId)
: mForwarder(nullptr)
, mIPCOpen(false)
, mDestroyed(false)
, mId(aId)
{}
~LayerTransactionChild() { }
void ActorDestroy(ActorDestroyReason why) override;
@@ -73,15 +73,15 @@ protected:
Release();
}
friend class CompositorBridgeChild;
friend class layout::RenderFrameChild;
ShadowLayerForwarder* mForwarder;
bool mIPCOpen;
bool mDestroyed;
- uint64_t mId;
+ LayersId mId;
};
} // namespace layers
} // namespace mozilla
#endif // MOZILLA_LAYERS_LAYERTRANSACTIONCHILD_H
--- a/gfx/layers/ipc/LayerTransactionParent.cpp
+++ b/gfx/layers/ipc/LayerTransactionParent.cpp
@@ -43,28 +43,28 @@ using mozilla::layout::RenderFrameParent
namespace mozilla {
namespace layers {
//--------------------------------------------------
// LayerTransactionParent
LayerTransactionParent::LayerTransactionParent(HostLayerManager* aManager,
CompositorBridgeParentBase* aBridge,
CompositorAnimationStorage* aAnimStorage,
- uint64_t aId)
+ LayersId aId)
: mLayerManager(aManager)
, mCompositorBridge(aBridge)
, mAnimStorage(aAnimStorage)
, mId(aId)
, mChildEpoch(0)
, mParentEpoch(0)
, mPendingTransaction(0)
, mDestroyed(false)
, mIPCOpen(false)
{
- MOZ_ASSERT(mId != 0);
+ MOZ_ASSERT(mId.IsValid());
}
LayerTransactionParent::~LayerTransactionParent()
{
}
void
LayerTransactionParent::SetLayerManager(HostLayerManager* aLayerManager, CompositorAnimationStorage* aAnimStorage)
--- a/gfx/layers/ipc/LayerTransactionParent.h
+++ b/gfx/layers/ipc/LayerTransactionParent.h
@@ -43,27 +43,27 @@ class LayerTransactionParent final : pub
typedef InfallibleTArray<Edit> EditArray;
typedef InfallibleTArray<OpDestroy> OpDestroyArray;
typedef InfallibleTArray<PluginWindowData> PluginsArray;
public:
LayerTransactionParent(HostLayerManager* aManager,
CompositorBridgeParentBase* aBridge,
CompositorAnimationStorage* aAnimStorage,
- uint64_t aId);
+ LayersId aId);
protected:
~LayerTransactionParent();
public:
void Destroy();
void SetLayerManager(HostLayerManager* aLayerManager, CompositorAnimationStorage* aAnimStorage);
- uint64_t GetId() const { return mId; }
+ LayersId GetId() const { return mId; }
Layer* GetRoot() const { return mRoot; }
uint64_t GetChildEpoch() const { return mChildEpoch; }
bool ShouldParentObserveEpoch();
ShmemAllocator* AsShmemAllocator() override { return this; }
bool AllocShmem(size_t aSize,
@@ -180,17 +180,17 @@ private:
// Hold the root because it might be grafted under various
// containers in the "real" layer tree
RefPtr<Layer> mRoot;
// Mapping from LayerHandles to Layers.
nsRefPtrHashtable<nsUint64HashKey, Layer> mLayerMap;
- uint64_t mId;
+ LayersId mId;
// These fields keep track of the latest epoch values in the child and the
// parent. mChildEpoch is the latest epoch value received from the child.
// mParentEpoch is the latest epoch value that we have told TabParent about
// (via ObserveLayerUpdate).
uint64_t mChildEpoch;
uint64_t mParentEpoch;
--- a/gfx/layers/ipc/LayerTreeOwnerTracker.cpp
+++ b/gfx/layers/ipc/LayerTreeOwnerTracker.cpp
@@ -39,44 +39,44 @@ LayerTreeOwnerTracker::Shutdown()
LayerTreeOwnerTracker*
LayerTreeOwnerTracker::Get()
{
return sSingleton;
}
void
-LayerTreeOwnerTracker::Map(uint64_t aLayersId, base::ProcessId aProcessId)
+LayerTreeOwnerTracker::Map(LayersId aLayersId, base::ProcessId aProcessId)
{
MutexAutoLock lock(mLayerIdsLock);
// Add the mapping to the list
mLayerIds[aLayersId] = aProcessId;
}
void
-LayerTreeOwnerTracker::Unmap(uint64_t aLayersId, base::ProcessId aProcessId)
+LayerTreeOwnerTracker::Unmap(LayersId aLayersId, base::ProcessId aProcessId)
{
MutexAutoLock lock(mLayerIdsLock);
MOZ_ASSERT(mLayerIds[aLayersId] == aProcessId);
mLayerIds.erase(aLayersId);
}
bool
-LayerTreeOwnerTracker::IsMapped(uint64_t aLayersId, base::ProcessId aProcessId)
+LayerTreeOwnerTracker::IsMapped(LayersId aLayersId, base::ProcessId aProcessId)
{
MutexAutoLock lock(mLayerIdsLock);
auto iter = mLayerIds.find(aLayersId);
return iter != mLayerIds.end() && iter->second == aProcessId;
}
void
-LayerTreeOwnerTracker::Iterate(const std::function<void(uint64_t aLayersId, base::ProcessId aProcessId)>& aCallback)
+LayerTreeOwnerTracker::Iterate(const std::function<void(LayersId aLayersId, base::ProcessId aProcessId)>& aCallback)
{
MutexAutoLock lock(mLayerIdsLock);
for (const auto& iter : mLayerIds) {
aCallback(iter.first, iter.second);
}
}
--- a/gfx/layers/ipc/LayerTreeOwnerTracker.h
+++ b/gfx/layers/ipc/LayerTreeOwnerTracker.h
@@ -39,33 +39,33 @@ public:
static void Initialize();
static void Shutdown();
static LayerTreeOwnerTracker* Get();
/**
* Map aLayersId and aProcessId together so that that process
* can access that layer tree.
*/
- void Map(uint64_t aLayersId, base::ProcessId aProcessId);
+ void Map(LayersId aLayersId, base::ProcessId aProcessId);
/**
* Remove an existing mapping.
*/
- void Unmap(uint64_t aLayersId, base::ProcessId aProcessId);
+ void Unmap(LayersId aLayersId, base::ProcessId aProcessId);
/**
* Checks whether it is okay for aProcessId to access aLayersId.
*/
- bool IsMapped(uint64_t aLayersId, base::ProcessId aProcessId);
+ bool IsMapped(LayersId aLayersId, base::ProcessId aProcessId);
- void Iterate(const std::function<void(uint64_t aLayersId, base::ProcessId aProcessId)>& aCallback);
+ void Iterate(const std::function<void(LayersId aLayersId, base::ProcessId aProcessId)>& aCallback);
private:
LayerTreeOwnerTracker();
mozilla::Mutex mLayerIdsLock;
- std::map<uint64_t, base::ProcessId> mLayerIds;
+ std::map<LayersId, base::ProcessId> mLayerIds;
};
} // namespace layers
} // namespace mozilla
#endif // mozilla_layers_LayerTreeOwnerTracker_h
--- a/gfx/layers/ipc/LayersMessageUtils.h
+++ b/gfx/layers/ipc/LayersMessageUtils.h
@@ -29,16 +29,21 @@
#ifdef _MSC_VER
#pragma warning( disable : 4800 )
#endif
namespace IPC {
template <>
+struct ParamTraits<mozilla::layers::LayersId>
+ : public PlainOldDataSerializer<mozilla::layers::LayersId>
+{};
+
+template <>
struct ParamTraits<mozilla::layers::LayersBackend>
: public ContiguousEnumSerializer<
mozilla::layers::LayersBackend,
mozilla::layers::LayersBackend::LAYERS_NONE,
mozilla::layers::LayersBackend::LAYERS_LAST>
{};
template <>
--- a/gfx/layers/ipc/LayersMessages.ipdlh
+++ b/gfx/layers/ipc/LayersMessages.ipdlh
@@ -49,16 +49,17 @@ using mozilla::gfx::Glyph from "Layers.h
using mozilla::layers::BorderColors from "mozilla/layers/LayersTypes.h";
using mozilla::layers::BorderCorners from "mozilla/layers/LayersTypes.h";
using mozilla::layers::BorderWidths from "mozilla/layers/LayersTypes.h";
using mozilla::layers::LayerHandle from "mozilla/layers/LayersTypes.h";
using mozilla::layers::CompositableHandle from "mozilla/layers/LayersTypes.h";
using mozilla::layers::SimpleLayerAttributes from "mozilla/layers/LayerAttributes.h";
using mozilla::CrossProcessSemaphoreHandle from "mozilla/ipc/CrossProcessSemaphore.h";
using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
+using mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
namespace mozilla {
namespace layers {
struct TargetConfig {
IntRect naturalBounds;
ScreenRotation rotation;
ScreenOrientationInternal orientation;
@@ -300,17 +301,17 @@ struct GlyphArray
{
LayerColor color;
Glyph[] glyphs;
};
struct ColorLayerAttributes { LayerColor color; IntRect bounds; };
struct CanvasLayerAttributes { SamplingFilter samplingFilter; IntRect bounds; };
struct RefLayerAttributes {
- uint64_t id;
+ LayersId id;
EventRegionsOverride eventRegionsOverride;
};
struct ImageLayerAttributes { SamplingFilter samplingFilter; IntSize scaleToSize; ScaleMode scaleMode; };
struct BorderLayerAttributes {
LayerRect rect;
BorderColors colors;
BorderCorners corners;
BorderWidths widths;
--- a/gfx/layers/ipc/PCompositorBridge.ipdl
+++ b/gfx/layers/ipc/PCompositorBridge.ipdl
@@ -16,16 +16,17 @@ include protocol PCompositorWidget;
include protocol PLayerTransaction;
include protocol PTexture;
include protocol PWebRenderBridge;
include "mozilla/GfxMessageUtils.h";
include "mozilla/layers/LayersMessageUtils.h";
include "mozilla/layers/WebRenderMessageUtils.h";
using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
+using struct mozilla::layers::LayersId from "mozilla/layers/LayersTypes.h";
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
using struct mozilla::layers::FrameMetrics from "FrameMetrics.h";
using mozilla::layers::FrameMetrics::ViewID from "FrameMetrics.h";
using mozilla::layers::MaybeZoomConstraints from "FrameMetrics.h";
using struct mozilla::layers::ScrollableLayerGuid from "FrameMetrics.h";
using mozilla::layers::LayersBackend from "mozilla/layers/LayersTypes.h";
using mozilla::CrossProcessMutexHandle from "mozilla/ipc/CrossProcessMutex.h";
using mozilla::ipc::SharedMemoryBasic::Handle from "mozilla/ipc/SharedMemoryBasic.h";
@@ -83,24 +84,24 @@ sync protocol PCompositorBridge
manages PTexture;
manages PCompositorWidget;
manages PWebRenderBridge;
child:
// The child should invalidate retained layers. This is used for local
// compositor device resets, such as in CompositorD3D9, and ensures that
// TextureSources are recreated.
- async InvalidateLayers(uint64_t layersId);
+ async InvalidateLayers(LayersId layersId);
// The compositor completed a layers transaction. id is the layers id
// of the child layer tree that was composited (or 0 when notifying
// the root layer tree).
// transactionId is the id of the transaction before this composite, or 0
// if there was no transaction since the last composite.
- async DidComposite(uint64_t id, uint64_t transactionId,
+ async DidComposite(LayersId id, uint64_t transactionId,
TimeStamp compositeStart, TimeStamp compositeEnd);
/**
* Parent informs the child that the graphics objects are ready for
* compositing. This usually means that the graphics objects (textures
* and the like) are available on the GPU. This is used for chrome UI.
* @see RequestNotifyAfterRemotePaint
* @see PBrowser
@@ -126,30 +127,30 @@ child:
/**
* Hides all registered plugin widgets associated with a particular chrome
* widget.
*/
async HideAllPlugins(uintptr_t aParentWidget);
async ParentAsyncMessages(AsyncParentMessageData[] aMessages);
- async ObserveLayerUpdate(uint64_t aLayersId, uint64_t aEpoch, bool aActive);
+ async ObserveLayerUpdate(LayersId aLayersId, uint64_t aEpoch, bool aActive);
parent:
async __delete__();
// Must be called before Initialize().
async PCompositorWidget(CompositorWidgetInitData aInitData);
// When out-of-process, this must be called to finish initialization.
- sync Initialize(uint64_t rootLayerTreeId);
+ sync Initialize(LayersId rootLayerTreeId);
// Must be called after Initialize(), and only succeeds if AsyncPanZoomEnabled() is true.
- async PAPZ(uint64_t layersId);
- async PAPZCTreeManager(uint64_t layersId);
+ async PAPZ(LayersId layersId);
+ async PAPZCTreeManager(LayersId layersId);
/**
* Confirmation callback for UpdatePluginConfigurations and HideAllPlugins.
*/
async RemotePluginsReady();
// Child requests frame uniformity measurements
sync GetFrameUniformity() returns (FrameUniformityData data);
@@ -160,33 +161,33 @@ parent:
// Pause/resume the compositor. These are intended to be used on mobile, when
// the compositor needs to pause/resume in lockstep with the application.
sync Pause();
sync Resume();
async ForceIsFirstPaint();
// See bug 1316632 comment #33 for why this has to be sync. Otherwise,
// there are ordering issues with SendPLayerTransactionConstructor.
- sync NotifyChildCreated(uint64_t id)
+ sync NotifyChildCreated(LayersId id)
returns (CompositorOptions compositorOptions);
// This version of NotifyChildCreated also performs a layer tree mapping.
//
// See bug 1316632 comment #33 for why this has to be sync. Otherwise,
// there are ordering issues with SendPLayerTransactionConstructor.
- sync MapAndNotifyChildCreated(uint64_t id, ProcessId owner)
+ sync MapAndNotifyChildCreated(LayersId id, ProcessId owner)
returns (CompositorOptions compositorOptions);
- async AdoptChild(uint64_t id);
+ async AdoptChild(LayersId id);
// Same as NotifyChildCreated, but used when child processes need to
// reassociate layers. This must be synchronous to ensure that the
// association happens before PLayerTransactions are sent over the
// cross-process bridge.
- sync NotifyChildRecreated(uint64_t id)
+ sync NotifyChildRecreated(LayersId id)
returns (CompositorOptions compositorOptions);
// Make a snapshot of the content that would have been drawn to our
// render target at the time this message is received. If the size
// or format of |inSnapshot| doesn't match our render target,
// results are undefined.
//
// NB: this message will result in animations, transforms, effects,
@@ -212,17 +213,17 @@ parent:
returns (uint32_t startIndex);
sync StopFrameTimeRecording(uint32_t startIndex)
returns (float[] intervals);
// layersBackendHints is an ordered list of preffered backends where
// layersBackendHints[0] is the best backend. If any hints are LayersBackend::LAYERS_NONE
// that hint is ignored.
- async PLayerTransaction(LayersBackend[] layersBackendHints, uint64_t id);
+ async PLayerTransaction(LayersBackend[] layersBackendHints, LayersId id);
// Notify the compositor that a region of the screen has been invalidated.
async NotifyRegionInvalidated(nsIntRegion region);
/**
* The child (content/chrome thread) requests that the parent inform it when
* the graphics objects are ready to display.
* @see PBrowser
@@ -230,29 +231,29 @@ parent:
*/
async RequestNotifyAfterRemotePaint();
/**
* Sent when the child has finished CaptureAllPlugins.
*/
async AllPluginsCaptured();
- async PTexture(SurfaceDescriptor aSharedData, ReadLockDescriptor aReadLock, LayersBackend aBackend, TextureFlags aTextureFlags, uint64_t id, uint64_t aSerial, MaybeExternalImageId aExternalImageId);
+ async PTexture(SurfaceDescriptor aSharedData, ReadLockDescriptor aReadLock, LayersBackend aBackend, TextureFlags aTextureFlags, LayersId id, uint64_t aSerial, MaybeExternalImageId aExternalImageId);
sync SyncWithCompositor();
// The pipelineId is the same as the layersId
sync PWebRenderBridge(PipelineId pipelineId, LayoutDeviceIntSize aSize)
returns (TextureFactoryIdentifier textureFactoryIdentifier, IdNamespace idNamespace);
sync CheckContentOnlyTDR(uint32_t sequenceNum)
returns (bool isContentOnlyTDR);
child:
// Send back Compositor Frame Metrics from APZCs so tiled layers can
// update progressively.
- async SharedCompositorFrameMetrics(Handle metrics, CrossProcessMutexHandle mutex, uint64_t aLayersId, uint32_t aAPZCId);
+ async SharedCompositorFrameMetrics(Handle metrics, CrossProcessMutexHandle mutex, LayersId aLayersId, uint32_t aAPZCId);
async ReleaseSharedCompositorFrameMetrics(ViewID aId, uint32_t aAPZCId);
async NotifyWebRenderError(WebRenderError error);
};
} // layers
} // mozilla
--- a/gfx/layers/ipc/UiCompositorControllerChild.cpp
+++ b/gfx/layers/ipc/UiCompositorControllerChild.cpp
@@ -39,17 +39,17 @@ IsOnUiThread()
}
namespace mozilla {
namespace layers {
// public:
/* static */ RefPtr<UiCompositorControllerChild>
-UiCompositorControllerChild::CreateForSameProcess(const int64_t& aRootLayerTreeId)
+UiCompositorControllerChild::CreateForSameProcess(const LayersId& aRootLayerTreeId)
{
RefPtr<UiCompositorControllerChild> child = new UiCompositorControllerChild(0);
child->mParent = new UiCompositorControllerParent(aRootLayerTreeId);
GetUiThread()->Dispatch(
NewRunnableMethod("layers::UiCompositorControllerChild::OpenForSameProcess",
child,
&UiCompositorControllerChild::OpenForSameProcess),
nsIThread::DISPATCH_NORMAL);
--- a/gfx/layers/ipc/UiCompositorControllerChild.h
+++ b/gfx/layers/ipc/UiCompositorControllerChild.h
@@ -20,17 +20,17 @@ class nsBaseWidget;
namespace mozilla {
namespace layers {
class UiCompositorControllerChild final : protected PUiCompositorControllerChild
{
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(UiCompositorControllerChild)
- static RefPtr<UiCompositorControllerChild> CreateForSameProcess(const int64_t& aRootLayerTreeId);
+ static RefPtr<UiCompositorControllerChild> CreateForSameProcess(const LayersId& aRootLayerTreeId);
static RefPtr<UiCompositorControllerChild> CreateForGPUProcess(const uint64_t& aProcessToken,
Endpoint<PUiCompositorControllerChild>&& aEndpoint);
bool Pause();
bool Resume();
bool ResumeAndResize(const int32_t& aHeight, const int32_t& aWidth);
bool InvalidateAndRender();
bool SetMaxToolbarHeight(const int32_t& aHeight);
--- a/gfx/layers/ipc/UiCompositorControllerParent.cpp
+++ b/gfx/layers/ipc/UiCompositorControllerParent.cpp
@@ -17,28 +17,28 @@
#include "mozilla/Unused.h"
namespace mozilla {
namespace layers {
typedef CompositorBridgeParent::LayerTreeState LayerTreeState;
/* static */ RefPtr<UiCompositorControllerParent>
-UiCompositorControllerParent::GetFromRootLayerTreeId(const uint64_t& aRootLayerTreeId)
+UiCompositorControllerParent::GetFromRootLayerTreeId(const LayersId& aRootLayerTreeId)
{
RefPtr<UiCompositorControllerParent> controller;
CompositorBridgeParent::CallWithIndirectShadowTree(aRootLayerTreeId,
[&](LayerTreeState& aState) -> void {
controller = aState.mUiControllerParent;
});
return Move(controller);
}
/* static */ RefPtr<UiCompositorControllerParent>
-UiCompositorControllerParent::Start(const uint64_t& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint)
+UiCompositorControllerParent::Start(const LayersId& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint)
{
RefPtr<UiCompositorControllerParent> parent = new UiCompositorControllerParent(aRootLayerTreeId);
RefPtr<Runnable> task =
NewRunnableMethod<Endpoint<PUiCompositorControllerParent>&&>(
"layers::UiCompositorControllerParent::Open",
parent,
&UiCompositorControllerParent::Open,
@@ -230,17 +230,17 @@ UiCompositorControllerParent::ToolbarAni
bool
UiCompositorControllerParent::AllocPixelBuffer(const int32_t aSize, ipc::Shmem* aMem)
{
MOZ_ASSERT(aSize > 0);
return AllocShmem(aSize, ipc::SharedMemory::TYPE_BASIC, aMem);
}
-UiCompositorControllerParent::UiCompositorControllerParent(const uint64_t& aRootLayerTreeId)
+UiCompositorControllerParent::UiCompositorControllerParent(const LayersId& aRootLayerTreeId)
: mRootLayerTreeId(aRootLayerTreeId)
, mMaxToolbarHeight(0)
{
MOZ_COUNT_CTOR(UiCompositorControllerParent);
}
UiCompositorControllerParent::~UiCompositorControllerParent()
{
--- a/gfx/layers/ipc/UiCompositorControllerParent.h
+++ b/gfx/layers/ipc/UiCompositorControllerParent.h
@@ -18,18 +18,18 @@ namespace layers {
class UiCompositorControllerParent final : public PUiCompositorControllerParent
{
// UiCompositorControllerChild needs to call the private constructor when running in process.
friend class UiCompositorControllerChild;
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(UiCompositorControllerParent)
- static RefPtr<UiCompositorControllerParent> GetFromRootLayerTreeId(const uint64_t& aRootLayerTreeId);
- static RefPtr<UiCompositorControllerParent> Start(const uint64_t& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint);
+ static RefPtr<UiCompositorControllerParent> GetFromRootLayerTreeId(const LayersId& aRootLayerTreeId);
+ static RefPtr<UiCompositorControllerParent> Start(const LayersId& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint);
// PUiCompositorControllerParent functions
mozilla::ipc::IPCResult RecvPause() override;
mozilla::ipc::IPCResult RecvResume() override;
mozilla::ipc::IPCResult RecvResumeAndResize(const int32_t& aHeight,
const int32_t& aWidth) override;
mozilla::ipc::IPCResult RecvInvalidateAndRender() override;
mozilla::ipc::IPCResult RecvMaxToolbarHeight(const int32_t& aHeight) override;
@@ -45,25 +45,25 @@ public:
// Class specific functions
#if defined(MOZ_WIDGET_ANDROID)
void RegisterAndroidDynamicToolbarAnimator(AndroidDynamicToolbarAnimator* aAnimator);
#endif // MOZ_WIDGET_ANDROID
void ToolbarAnimatorMessageFromCompositor(int32_t aMessage);
bool AllocPixelBuffer(const int32_t aSize, Shmem* aMem);
private:
- explicit UiCompositorControllerParent(const uint64_t& aRootLayerTreeId);
+ explicit UiCompositorControllerParent(const LayersId& aRootLayerTreeId);
~UiCompositorControllerParent();
void InitializeForSameProcess();
void InitializeForOutOfProcess();
void Initialize();
void Open(Endpoint<PUiCompositorControllerParent>&& aEndpoint);
void Shutdown();
- uint64_t mRootLayerTreeId;
+ LayersId mRootLayerTreeId;
#if defined(MOZ_WIDGET_ANDROID)
RefPtr<AndroidDynamicToolbarAnimator> mAnimator;
#endif // defined(MOZ_WIDGET_ANDROID)
int32_t mMaxToolbarHeight;
};
--- a/gfx/layers/wr/WebRenderBridgeParent.cpp
+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
@@ -506,17 +506,17 @@ WebRenderBridgeParent::GetRootCompositor
void
WebRenderBridgeParent::UpdateAPZ(bool aUpdateHitTestingTree)
{
CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
if (!cbp) {
return;
}
- uint64_t rootLayersId = cbp->RootLayerTreeId();
+ LayersId rootLayersId = cbp->RootLayerTreeId();
RefPtr<WebRenderBridgeParent> rootWrbp = cbp->GetWebRenderBridgeParent();
if (!rootWrbp) {
return;
}
if (RefPtr<APZSampler> apz = cbp->GetAPZSampler()) {
apz->UpdateFocusState(rootLayersId, GetLayersId(),
mScrollData.GetFocusTarget());
if (aUpdateHitTestingTree) {
@@ -629,17 +629,17 @@ WebRenderBridgeParent::RecvSetDisplayLis
mScrollData = aScrollData;
UpdateAPZ(true);
if (mIdNamespace != aIdNamespace) {
// Pretend we composited since someone is wating for this event,
// though DisplayList was not pushed to webrender.
TimeStamp now = TimeStamp::Now();
- mCompositorBridge->DidComposite(wr::AsUint64(mPipelineId), now, now);
+ mCompositorBridge->DidComposite(GetLayersId(), now, now);
}
wr::IpcResourceUpdateQueue::ReleaseShmems(this, aSmallShmems);
wr::IpcResourceUpdateQueue::ReleaseShmems(this, aLargeShmems);
return IPC_OK();
}
mozilla::ipc::IPCResult
@@ -687,17 +687,17 @@ WebRenderBridgeParent::RecvEmptyTransact
if (mPendingTransactionIds.empty()) {
sendDidComposite = true;
}
HoldPendingTransactionId(mWrEpoch, aTransactionId, aTxnStartTime, aFwdTime);
// If WebRenderBridgeParent does not have pending DidComposites,
// send DidComposite now.
if (sendDidComposite) {
TimeStamp now = TimeStamp::Now();
- mCompositorBridge->DidComposite(wr::AsUint64(mPipelineId), now, now);
+ mCompositorBridge->DidComposite(GetLayersId(), now, now);
}
}
return IPC_OK();
}
mozilla::ipc::IPCResult
WebRenderBridgeParent::RecvSetFocusTarget(const FocusTarget& aFocusTarget)
@@ -1289,20 +1289,20 @@ WebRenderBridgeParent::FlushTransactionI
}
#endif
id = mPendingTransactionIds.front().mId;
mPendingTransactionIds.pop();
}
return id;
}
-uint64_t
+LayersId
WebRenderBridgeParent::GetLayersId() const
{
- return wr::AsUint64(mPipelineId);
+ return wr::AsLayersId(mPipelineId);
}
void
WebRenderBridgeParent::ScheduleGenerateFrame()
{
if (mCompositorScheduler) {
mAsyncImageManager->SetWillGenerateFrame();
mCompositorScheduler->ScheduleComposition();
--- a/gfx/layers/wr/WebRenderBridgeParent.h
+++ b/gfx/layers/wr/WebRenderBridgeParent.h
@@ -200,17 +200,17 @@ private:
bool UpdateResources(const nsTArray<OpUpdateResource>& aResourceUpdates,
const nsTArray<RefCountedShmem>& aSmallShmems,
const nsTArray<ipc::Shmem>& aLargeShmems,
wr::TransactionBuilder& aUpdates);
bool AddExternalImage(wr::ExternalImageId aExtId, wr::ImageKey aKey,
wr::TransactionBuilder& aResources);
- uint64_t GetLayersId() const;
+ LayersId GetLayersId() const;
void ProcessWebRenderParentCommands(const InfallibleTArray<WebRenderParentCommand>& aCommands);
void ClearResources();
uint64_t GetChildLayerObserverEpoch() const { return mChildLayerObserverEpoch; }
bool ShouldParentObserveEpoch();
mozilla::ipc::IPCResult HandleShutdown();
void AdvanceAnimations();
--- a/gfx/layers/wr/WebRenderScrollData.cpp
+++ b/gfx/layers/wr/WebRenderScrollData.cpp
@@ -109,17 +109,19 @@ WebRenderLayerScrollData::Dump(const Web
for (size_t i : mScrollIds) {
printf_stderr(" metadata: %s\n", Stringify(aOwner.GetScrollMetadata(i)).c_str());
}
printf_stderr(" transform: %s perspective: %d visible: %s\n",
Stringify(mTransform).c_str(), mTransformIsPerspective,
Stringify(mVisibleRegion).c_str());
printf_stderr(" event regions: %s override: 0x%x\n",
Stringify(mEventRegions).c_str(), mEventRegionsOverride);
- printf_stderr(" ref layers id: 0x%" PRIx64 "\n", mReferentId.valueOr(0));
+ if (mReferentId) {
+ printf_stderr(" ref layers id: 0x%" PRIx64 "\n", uint64_t(*mReferentId));
+ }
//printf_stderr(" scroll thumb: %s animation: %" PRIu64 "\n",
// Stringify(mScrollThumbData).c_str(), mScrollbarAnimationId);
printf_stderr(" scroll container: %d target: %" PRIu64 "\n",
mScrollbarContainerDirection.isSome(), mScrollbarTargetContainerId);
printf_stderr(" fixed pos container: %" PRIu64 "\n",
mFixedPosScrollContainerId);
}
--- a/gfx/layers/wr/WebRenderScrollData.h
+++ b/gfx/layers/wr/WebRenderScrollData.h
@@ -68,18 +68,18 @@ public:
bool GetTransformIsPerspective() const { return mTransformIsPerspective; }
void AddEventRegions(const EventRegions& aRegions) { mEventRegions.OrWith(aRegions); }
EventRegions GetEventRegions() const { return mEventRegions; }
void SetEventRegionsOverride(const EventRegionsOverride& aOverride) { mEventRegionsOverride = aOverride; }
EventRegionsOverride GetEventRegionsOverride() const { return mEventRegionsOverride; }
const LayerIntRegion& GetVisibleRegion() const { return mVisibleRegion; }
- void SetReferentId(uint64_t aReferentId) { mReferentId = Some(aReferentId); }
- Maybe<uint64_t> GetReferentId() const { return mReferentId; }
+ void SetReferentId(LayersId aReferentId) { mReferentId = Some(aReferentId); }
+ Maybe<LayersId> GetReferentId() const { return mReferentId; }
void SetScrollThumbData(const ScrollThumbData& aData) { mScrollThumbData = aData; }
const ScrollThumbData& GetScrollThumbData() const { return mScrollThumbData; }
void SetScrollbarAnimationId(const uint64_t& aId) { mScrollbarAnimationId = aId; }
const uint64_t& GetScrollbarAnimationId() const { return mScrollbarAnimationId; }
void SetScrollbarTargetContainerId(FrameMetrics::ViewID aId) { mScrollbarTargetContainerId = aId; }
FrameMetrics::ViewID GetScrollbarTargetContainerId() const { return mScrollbarTargetContainerId; }
void SetScrollbarContainerDirection(ScrollDirection aDirection) { mScrollbarContainerDirection = Some(aDirection); }
@@ -107,17 +107,17 @@ private:
// Various data that we collect from the Layer in Initialize(), serialize
// over IPC, and use on the parent side in APZ.
gfx::Matrix4x4 mTransform;
bool mTransformIsPerspective;
EventRegions mEventRegions;
LayerIntRegion mVisibleRegion;
- Maybe<uint64_t> mReferentId;
+ Maybe<LayersId> mReferentId;
EventRegionsOverride mEventRegionsOverride;
ScrollThumbData mScrollThumbData;
uint64_t mScrollbarAnimationId;
FrameMetrics::ViewID mScrollbarTargetContainerId;
Maybe<ScrollDirection> mScrollbarContainerDirection;
FrameMetrics::ViewID mFixedPosScrollContainerId;
};
--- a/gfx/layers/wr/WebRenderScrollDataWrapper.h
+++ b/gfx/layers/wr/WebRenderScrollDataWrapper.h
@@ -258,17 +258,17 @@ public:
return mLayer->GetVisibleRegion();
}
return ViewAs<LayerPixel>(
TransformBy(mLayer->GetTransformTyped(), mLayer->GetVisibleRegion()),
PixelCastJustification::MovingDownToChildren);
}
- Maybe<uint64_t> GetReferentId() const
+ Maybe<LayersId> GetReferentId() const
{
MOZ_ASSERT(IsValid());
if (AtBottomLayer()) {
return mLayer->GetReferentId();
}
return Nothing();
}
--- a/gfx/webrender_bindings/WebRenderTypes.h
+++ b/gfx/webrender_bindings/WebRenderTypes.h
@@ -189,16 +189,24 @@ inline uint64_t AsUint64(const PipelineI
inline PipelineId AsPipelineId(const uint64_t& aId) {
PipelineId pipeline;
pipeline.mNamespace = aId >> 32;
pipeline.mHandle = aId;
return pipeline;
}
+inline mozilla::layers::LayersId AsLayersId(const PipelineId& aId) {
+ return mozilla::layers::LayersId { AsUint64(aId) };
+}
+
+inline PipelineId AsPipelineId(const mozilla::layers::LayersId& aId) {
+ return AsPipelineId(uint64_t(aId));
+}
+
inline ImageRendering ToImageRendering(gfx::SamplingFilter aFilter)
{
return aFilter == gfx::SamplingFilter::POINT ? ImageRendering::Pixelated
: ImageRendering::Auto;
}
static inline FontRenderMode ToFontRenderMode(gfx::AntialiasMode aMode, bool aPermitSubpixelAA = true)
{
--- a/layout/base/ZoomConstraintsClient.cpp
+++ b/layout/base/ZoomConstraintsClient.cpp
@@ -239,17 +239,17 @@ ZoomConstraintsClient::RefreshZoomConstr
// We only ever create a ZoomConstraintsClient for an RCD, so the RSF of
// the presShell must be the RCD-RSF (if it exists).
MOZ_ASSERT(mPresShell->GetPresContext()->IsRootContentDocument());
if (nsIScrollableFrame* rcdrsf = mPresShell->GetRootScrollFrameAsScrollable()) {
ZCC_LOG("Notifying RCD-RSF that it is zoomable: %d\n", zoomConstraints.mAllowZoom);
rcdrsf->SetZoomableByAPZ(zoomConstraints.mAllowZoom);
}
- ScrollableLayerGuid newGuid(0, presShellId, viewId);
+ ScrollableLayerGuid newGuid(LayersId{0}, presShellId, viewId);
if (mGuid && mGuid.value() != newGuid) {
ZCC_LOG("Clearing old constraints in %p for { %u, %" PRIu64 " }\n",
this, mGuid->mPresShellId, mGuid->mScrollId);
// If the guid changes, send a message to clear the old one
widget->UpdateZoomConstraints(mGuid->mPresShellId, mGuid->mScrollId, Nothing());
}
mGuid = Some(newGuid);
ZCC_LOG("Sending constraints %s in %p for { %u, %" PRIu64 " }\n",
--- a/layout/ipc/RenderFrameParent.cpp
+++ b/layout/ipc/RenderFrameParent.cpp
@@ -87,17 +87,17 @@ GetLayerManager(nsFrameLoader* aFrameLoa
nsIDocument* doc = aFrameLoader->GetOwnerDoc();
if (!doc) {
return nullptr;
}
return nsContentUtils::LayerManagerForDocument(doc);
}
RenderFrameParent::RenderFrameParent(nsFrameLoader* aFrameLoader)
- : mLayersId(0)
+ : mLayersId{0}
, mLayersConnected(false)
, mFrameLoader(aFrameLoader)
, mFrameLoaderDestroyed(false)
, mAsyncPanZoomEnabled(false)
, mInitted(false)
{
mInitted = Init(aFrameLoader);
}
@@ -178,17 +178,17 @@ RenderFrameParent::BuildLayer(nsDisplayL
// MOZ_ASSERT() above will flag it. Returning nullptr here will just
// cause the shadow subtree not to be rendered.
if (!aContainerParameters.mForEventsAndPluginsOnly) {
NS_WARNING("Remote iframe not rendered");
}
return nullptr;
}
- if (!mLayersId) {
+ if (!mLayersId.IsValid()) {
return nullptr;
}
RefPtr<Layer> layer =
(aManager->GetLayerBuilder()->GetLeafLayerFor(aBuilder, aItem));
if (!layer) {
layer = aManager->CreateRefLayer();
}
@@ -237,17 +237,17 @@ RenderFrameParent::OwnerContentChanged(n
"Don't build new map if owner is same!");
Unused << AttachLayerManager();
}
void
RenderFrameParent::ActorDestroy(ActorDestroyReason why)
{
- if (mLayersId != 0) {
+ if (mLayersId.IsValid()) {
if (XRE_IsParentProcess()) {
GPUProcessManager::Get()->UnmapLayerTreeId(mLayersId, OtherPid());
} else if (XRE_IsContentProcess()) {
TabParent* browser = TabParent::GetFrom(mFrameLoader);
ContentChild::GetSingleton()->SendDeallocateLayerTreeId(browser->Manager()->ChildID(), mLayersId);
}
}
@@ -405,13 +405,13 @@ nsDisplayRemote::UpdateScrollData(mozill
if (aLayerData) {
aLayerData->SetReferentId(GetRemoteLayersId());
aLayerData->SetTransform(mozilla::gfx::Matrix4x4::Translation(mOffset.x, mOffset.y, 0.0));
aLayerData->SetEventRegionsOverride(mEventRegionsOverride);
}
return true;
}
-uint64_t
+LayersId
nsDisplayRemote::GetRemoteLayersId() const
{
return mRemoteFrame->GetLayersId();
}
--- a/layout/ipc/RenderFrameParent.h
+++ b/layout/ipc/RenderFrameParent.h
@@ -35,16 +35,17 @@ namespace layout {
class RenderFrameParent : public PRenderFrameParent
{
typedef mozilla::layers::AsyncDragMetrics AsyncDragMetrics;
typedef mozilla::layers::FrameMetrics FrameMetrics;
typedef mozilla::layers::CompositorOptions CompositorOptions;
typedef mozilla::layers::ContainerLayer ContainerLayer;
typedef mozilla::layers::Layer Layer;
typedef mozilla::layers::LayerManager LayerManager;
+ typedef mozilla::layers::LayersId LayersId;
typedef mozilla::layers::TargetConfig TargetConfig;
typedef mozilla::ContainerLayerParameters ContainerLayerParameters;
typedef mozilla::layers::TextureFactoryIdentifier TextureFactoryIdentifier;
typedef mozilla::layers::ScrollableLayerGuid ScrollableLayerGuid;
typedef mozilla::layers::TouchBehaviorFlags TouchBehaviorFlags;
typedef mozilla::layers::ZoomConstraints ZoomConstraints;
typedef FrameMetrics::ViewID ViewID;
@@ -74,17 +75,17 @@ public:
const ContainerLayerParameters& aContainerParameters);
void OwnerContentChanged(nsIContent* aContent);
bool HitTest(const nsRect& aRect);
void GetTextureFactoryIdentifier(TextureFactoryIdentifier* aTextureFactoryIdentifier);
- inline uint64_t GetLayersId() const { return mLayersId; }
+ inline LayersId GetLayersId() const { return mLayersId; }
inline bool IsLayersConnected() const { return mLayersConnected; }
inline CompositorOptions GetCompositorOptions() const { return mCompositorOptions; }
void TakeFocusForClickFromTap();
void EnsureLayersConnected(CompositorOptions* aCompositorOptions);
LayerManager* AttachLayerManager();
@@ -96,17 +97,17 @@ protected:
private:
void TriggerRepaint();
void DispatchEventForPanZoomController(const InputEvent& aEvent);
// When our child frame is pushing transactions directly to the
// compositor, this is the ID of its layer tree in the compositor's
// context.
- uint64_t mLayersId;
+ LayersId mLayersId;
// A flag that indicates whether or not the compositor knows about the
// layers id. In some cases this RenderFrameParent is not connected to the
// compositor and so this flag is false.
bool mLayersConnected;
// The compositor options for this layers id. This is only meaningful if
// the compositor actually knows about this layers id (i.e. when mLayersConnected
// is true).
CompositorOptions mCompositorOptions;
@@ -163,17 +164,17 @@ public:
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
virtual bool UpdateScrollData(mozilla::layers::WebRenderScrollData* aData,
mozilla::layers::WebRenderLayerScrollData* aLayerData) override;
- uint64_t GetRemoteLayersId() const;
+ mozilla::layers::LayersId GetRemoteLayersId() const;
NS_DISPLAY_DECL_NAME("Remote", TYPE_REMOTE)
private:
RenderFrameParent* mRemoteFrame;
mozilla::LayoutDeviceIntPoint mOffset;
mozilla::layers::EventRegionsOverride mEventRegionsOverride;
};
--- a/widget/android/nsWindow.cpp
+++ b/widget/android/nsWindow.cpp
@@ -1484,20 +1484,20 @@ nsWindow::RedrawAll()
RefPtr<UiCompositorControllerChild>
nsWindow::GetUiCompositorControllerChild()
{
return mCompositorSession ? mCompositorSession->GetUiCompositorControllerChild() : nullptr;
}
-int64_t
+mozilla::layers::LayersId
nsWindow::GetRootLayerId() const
{
- return mCompositorSession ? mCompositorSession->RootLayerTreeId() : 0;
+ return mCompositorSession ? mCompositorSession->RootLayerTreeId() : mozilla::layers::LayersId{0};
}
void
nsWindow::OnGeckoViewReady()
{
if (!mGeckoViewSupport) {
return;
}
--- a/widget/android/nsWindow.h
+++ b/widget/android/nsWindow.h
@@ -339,17 +339,17 @@ protected:
static void DumpWindows();
static void DumpWindows(const nsTArray<nsWindow*>& wins, int indent = 0);
static void LogWindow(nsWindow *win, int index, int indent);
private:
void CreateLayerManager(int aCompositorWidth, int aCompositorHeight);
void RedrawAll();
- int64_t GetRootLayerId() const;
+ mozilla::layers::LayersId GetRootLayerId() const;
RefPtr<mozilla::layers::UiCompositorControllerChild> GetUiCompositorControllerChild();
};
// Explicit template declarations to make clang be quiet.
template<> const char nsWindow::NativePtr<nsWindow::LayerViewSupport>::sName[];
template<> const char nsWindow::NativePtr<mozilla::widget::GeckoEditableSupport>::sName[];
template<> const char nsWindow::NativePtr<nsWindow::NPZCSupport>::sName[];
--- a/widget/nsBaseWidget.cpp
+++ b/widget/nsBaseWidget.cpp
@@ -1038,17 +1038,17 @@ nsBaseWidget::UpdateZoomConstraints(cons
if (aConstraints) {
// We have some constraints, but the compositor and APZC aren't created yet.
// Save these so we can use them later.
mInitialZoomConstraints = Some(InitialZoomConstraints(aPresShellId, aViewId, aConstraints.ref()));
}
return;
}
- uint64_t layersId = mCompositorSession->RootLayerTreeId();
+ LayersId layersId = mCompositorSession->RootLayerTreeId();
mAPZC->UpdateZoomConstraints(ScrollableLayerGuid(layersId, aPresShellId, aViewId),
aConstraints);
}
bool
nsBaseWidget::AsyncPanZoomEnabled() const
{
return !!mAPZC;
@@ -1425,17 +1425,17 @@ void nsBaseWidget::CreateCompositor(int
PLayerTransactionChild* shadowManager = nullptr;
nsTArray<LayersBackend> backendHints;
gfxPlatform::GetPlatform()->GetCompositorBackends(ComputeShouldAccelerate(), backendHints);
bool success = false;
if (!backendHints.IsEmpty()) {
shadowManager =
- mCompositorBridgeChild->SendPLayerTransactionConstructor(backendHints, 0);
+ mCompositorBridgeChild->SendPLayerTransactionConstructor(backendHints, LayersId{0});
if (shadowManager->SendGetTextureFactoryIdentifier(&textureFactoryIdentifier) &&
textureFactoryIdentifier.mParentBackend != LayersBackend::LAYERS_NONE)
{
success = true;
}
}
if (!success) {
@@ -1928,17 +1928,17 @@ void
nsBaseWidget::ZoomToRect(const uint32_t& aPresShellId,
const FrameMetrics::ViewID& aViewId,
const CSSRect& aRect,
const uint32_t& aFlags)
{
if (!mCompositorSession || !mAPZC) {
return;
}
- uint64_t layerId = mCompositorSession->RootLayerTreeId();
+ LayersId layerId = mCompositorSession->RootLayerTreeId();
APZThreadUtils::RunOnControllerThread(
NewRunnableMethod<ScrollableLayerGuid, CSSRect, uint32_t>(
"layers::IAPZCTreeManager::ZoomToRect",
mAPZC,
&IAPZCTreeManager::ZoomToRect,
ScrollableLayerGuid(layerId, aPresShellId, aViewId),
aRect,
aFlags));
@@ -1975,17 +1975,17 @@ void
nsBaseWidget::StartAsyncScrollbarDrag(const AsyncDragMetrics& aDragMetrics)
{
if (!AsyncPanZoomEnabled()) {
return;
}
MOZ_ASSERT(XRE_IsParentProcess() && mCompositorSession);
- uint64_t layersId = mCompositorSession->RootLayerTreeId();
+ LayersId layersId = mCompositorSession->RootLayerTreeId();
ScrollableLayerGuid guid(layersId, aDragMetrics.mPresShellId, aDragMetrics.mViewId);
APZThreadUtils::RunOnControllerThread(
NewRunnableMethod<ScrollableLayerGuid, AsyncDragMetrics>(
"layers::IAPZCTreeManager::StartScrollbarDrag",
mAPZC,
&IAPZCTreeManager::StartScrollbarDrag,
guid,