Bug 1855742 - Part 4. Make CanvasManagerChild manage ActiveResourceTracker. r=gfx-reviewers,lsalzman

This patch makes the CanvasManagerChild creates/manager the
ActiveResourceTracker instead of the WebRenderBridgeChild. Since PCanvas
is now managed by PCanvasManager, and ActiveResourceTracker is only used
by the PCanvas recording plumbing, we need it on every thread that the
CanvasManagerChild can be created.

Differential Revision: https://phabricator.services.mozilla.com/D189529

gfx/ipc/CanvasManagerChild.cpp

@@ -10,6 +10,7 @@
 #include "mozilla/gfx/2D.h"
 #include "mozilla/gfx/Swizzle.h"
 #include "mozilla/ipc/Endpoint.h"
+#include "mozilla/layers/ActiveResource.h"
 #include "mozilla/layers/CanvasChild.h"
 #include "mozilla/layers/CompositorManagerChild.h"
 #include "mozilla/webgpu/WebGPUChild.h"
@@ -38,6 +39,11 @@ void CanvasManagerChild::ActorDestroy(ActorDestroyReason aReason) {
 }
 
 void CanvasManagerChild::Destroy() {
+  if (mActiveResourceTracker) {
+    mActiveResourceTracker->AgeAllGenerations();
+    mActiveResourceTracker.reset();
+  }
+
   if (mCanvasChild) {
     mCanvasChild->Destroy();
     mCanvasChild = nullptr;
@@ -198,6 +204,14 @@ RefPtr<webgpu::WebGPUChild> CanvasManagerChild::GetWebGPUChild() {
   return mWebGPUChild;
 }
 
+layers::ActiveResourceTracker* CanvasManagerChild::GetActiveResourceTracker() {
+  if (!mActiveResourceTracker) {
+    mActiveResourceTracker = MakeUnique<ActiveResourceTracker>(
+        1000, "CanvasManagerChild", GetCurrentSerialEventTarget());
+  }
+  return mActiveResourceTracker.get();
+}
+
 already_AddRefed<DataSourceSurface> CanvasManagerChild::GetSnapshot(
     uint32_t aManagerId, int32_t aProtocolId,
     const Maybe<RemoteTextureOwnerId>& aOwnerId, SurfaceFormat aFormat,

gfx/ipc/CanvasManagerChild.h

@@ -19,6 +19,7 @@ class WorkerPrivate;
 
 namespace layers {
 class CanvasChild;
+class ActiveResourceTracker;
 }  // namespace layers
 
 namespace webgpu {
@@ -55,6 +56,8 @@ class CanvasManagerChild final : public PCanvasManagerChild {
 
   RefPtr<webgpu::WebGPUChild> GetWebGPUChild();
 
+  layers::ActiveResourceTracker* GetActiveResourceTracker();
+
  private:
   ~CanvasManagerChild();
   void Destroy();
@@ -62,6 +65,7 @@ class CanvasManagerChild final : public PCanvasManagerChild {
   RefPtr<mozilla::dom::IPCWorkerRef> mWorkerRef;
   RefPtr<layers::CanvasChild> mCanvasChild;
   RefPtr<webgpu::WebGPUChild> mWebGPUChild;
+  UniquePtr<layers::ActiveResourceTracker> mActiveResourceTracker;
   const uint32_t mId;
   bool mActive = true;
   bool mBlocked = false;

gfx/layers/PersistentBufferProvider.cpp

@@ -6,10 +6,12 @@
 
 #include "PersistentBufferProvider.h"
 
+#include "mozilla/layers/KnowsCompositor.h"
 #include "mozilla/layers/RemoteTextureMap.h"
 #include "mozilla/layers/TextureClient.h"
 #include "mozilla/layers/TextureForwarder.h"
 #include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/CanvasManagerChild.h"
 #include "mozilla/gfx/DrawTargetWebgl.h"
 #include "mozilla/gfx/Logging.h"
 #include "mozilla/Maybe.h"
@@ -305,7 +307,11 @@ PersistentBufferProviderShared::~PersistentBufferProviderShared() {
   MOZ_COUNT_DTOR(PersistentBufferProviderShared);
 
   if (IsActivityTracked()) {
-    mKnowsCompositor->GetActiveResourceTracker()->RemoveObject(this);
+    if (auto* cm = CanvasManagerChild::Get()) {
+      cm->GetActiveResourceTracker()->RemoveObject(this);
+    } else {
+      MOZ_ASSERT_UNREACHABLE("Tracked but no CanvasManagerChild!");
+    }
   }
 
   Destroy();
@@ -325,7 +331,11 @@ bool PersistentBufferProviderShared::SetKnowsCompositor(
   }
 
   if (IsActivityTracked()) {
-    mKnowsCompositor->GetActiveResourceTracker()->RemoveObject(this);
+    if (auto* cm = CanvasManagerChild::Get()) {
+      cm->GetActiveResourceTracker()->RemoveObject(this);
+    } else {
+      MOZ_ASSERT_UNREACHABLE("Tracked but no CanvasManagerChild!");
+    }
   }
 
   if (mKnowsCompositor->GetTextureForwarder() !=
@@ -406,12 +416,17 @@ PersistentBufferProviderShared::BorrowDrawTarget(
     return nullptr;
   }
 
+  auto* cm = CanvasManagerChild::Get();
+  if (NS_WARN_IF(!cm)) {
+    return nullptr;
+  }
+
   MOZ_ASSERT(!mSnapshot);
 
   if (IsActivityTracked()) {
-    mKnowsCompositor->GetActiveResourceTracker()->MarkUsed(this);
+    cm->GetActiveResourceTracker()->MarkUsed(this);
   } else {
-    mKnowsCompositor->GetActiveResourceTracker()->AddObject(this);
+    cm->GetActiveResourceTracker()->AddObject(this);
   }
 
   if (mDrawTarget) {

gfx/layers/PersistentBufferProvider.h

@@ -9,7 +9,7 @@
 
 #include "mozilla/Assertions.h"  // for MOZ_ASSERT, etc
 #include "mozilla/RefPtr.h"      // for RefPtr, already_AddRefed, etc
-#include "mozilla/layers/KnowsCompositor.h"
+#include "mozilla/layers/ActiveResource.h"
 #include "mozilla/layers/LayersSurfaces.h"
 #include "mozilla/layers/LayersTypes.h"
 #include "mozilla/RefCounted.h"
@@ -28,6 +28,7 @@ class DrawTarget;
 
 namespace layers {
 
+class KnowsCompositor;
 struct RemoteTextureOwnerId;
 class TextureClient;
 

gfx/layers/ipc/ActiveResource.h

@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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_LAYERS_ACTIVERESOURCE
+#define MOZILLA_LAYERS_ACTIVERESOURCE
+
+#include "nsExpirationTracker.h"
+
+namespace mozilla::layers {
+
+/**
+ * See ActiveResourceTracker below.
+ */
+class ActiveResource {
+ public:
+  virtual void NotifyInactive() = 0;
+  nsExpirationState* GetExpirationState() { return &mExpirationState; }
+  bool IsActivityTracked() { return mExpirationState.IsTracked(); }
+
+ private:
+  nsExpirationState mExpirationState;
+};
+
+/**
+ * A convenience class on top of nsExpirationTracker
+ */
+class ActiveResourceTracker final
+    : public nsExpirationTracker<ActiveResource, 3> {
+ public:
+  ActiveResourceTracker(uint32_t aExpirationCycle, const char* aName,
+                        nsIEventTarget* aEventTarget)
+      : nsExpirationTracker(aExpirationCycle, aName, aEventTarget) {}
+
+  void NotifyExpired(ActiveResource* aResource) override {
+    RemoveObject(aResource);
+    aResource->NotifyInactive();
+  }
+};
+
+}  // namespace mozilla::layers
+
+#endif

gfx/layers/ipc/KnowsCompositor.cpp

@@ -9,8 +9,7 @@
 #include "mozilla/layers/ImageBridgeChild.h"
 #include "mozilla/ipc/ProtocolUtils.h"
 
-namespace mozilla {
+namespace mozilla::layers {
-namespace layers {
 
 void KnowsCompositor::IdentifyTextureHost(
     const TextureFactoryIdentifier& aIdentifier) {
@@ -47,10 +46,6 @@ LayersIPCActor* KnowsCompositorMediaProxy::GetLayersIPCActor() {
   return mThreadSafeAllocator->GetLayersIPCActor();
 }
 
-ActiveResourceTracker* KnowsCompositorMediaProxy::GetActiveResourceTracker() {
-  return mThreadSafeAllocator->GetActiveResourceTracker();
-}
-
 void KnowsCompositorMediaProxy::SyncWithCompositor() {
   mThreadSafeAllocator->SyncWithCompositor();
 }
@@ -109,5 +104,4 @@ void DestroySurfaceDescriptor(ipc::IShmemAllocator* aAllocator,
   *aSurface = SurfaceDescriptor();
 }
 
-}  // namespace layers
+}  // namespace mozilla::layers
-}  // namespace mozilla

gfx/layers/ipc/KnowsCompositor.h

@@ -9,45 +9,15 @@
 
 #include "mozilla/layers/LayersTypes.h"  // for LayersBackend
 #include "mozilla/layers/CompositorTypes.h"
-#include "nsExpirationTracker.h"
 #include "mozilla/DataMutex.h"
 #include "mozilla/layers/SyncObject.h"
 
-namespace mozilla {
+namespace mozilla::layers {
-namespace layers {
 
 class TextureForwarder;
 class LayersIPCActor;
 class ImageBridgeChild;
 
-/**
- * See ActiveResourceTracker below.
- */
-class ActiveResource {
- public:
-  virtual void NotifyInactive() = 0;
-  nsExpirationState* GetExpirationState() { return &mExpirationState; }
-  bool IsActivityTracked() { return mExpirationState.IsTracked(); }
-
- private:
-  nsExpirationState mExpirationState;
-};
-
-/**
- * A convenience class on top of nsExpirationTracker
- */
-class ActiveResourceTracker : public nsExpirationTracker<ActiveResource, 3> {
- public:
-  ActiveResourceTracker(uint32_t aExpirationCycle, const char* aName,
-                        nsIEventTarget* aEventTarget)
-      : nsExpirationTracker(aExpirationCycle, aName, aEventTarget) {}
-
-  void NotifyExpired(ActiveResource* aResource) override {
-    RemoveObject(aResource);
-    aResource->NotifyInactive();
-  }
-};
-
 /**
  * An abstract interface for classes that are tied to a specific Compositor
  * across IPDL and uses TextureFactoryIdentifier to describe this Compositor.
@@ -212,10 +182,6 @@ class KnowsCompositor {
    */
   virtual TextureForwarder* GetTextureForwarder() = 0;
   virtual LayersIPCActor* GetLayersIPCActor() = 0;
-  virtual ActiveResourceTracker* GetActiveResourceTracker() {
-    MOZ_ASSERT_UNREACHABLE("Unimplemented");
-    return nullptr;
-  }
 
  protected:
   struct SharedData {
@@ -250,8 +216,6 @@ class KnowsCompositorMediaProxy : public KnowsCompositor {
 
   LayersIPCActor* GetLayersIPCActor() override;
 
-  ActiveResourceTracker* GetActiveResourceTracker() override;
-
   void SyncWithCompositor() override;
 
  protected:
@@ -260,7 +224,6 @@ class KnowsCompositorMediaProxy : public KnowsCompositor {
   RefPtr<ImageBridgeChild> mThreadSafeAllocator;
 };
 
-}  // namespace layers
+}  // namespace mozilla::layers
-}  // namespace mozilla
 
 #endif

gfx/layers/moz.build

@@ -143,6 +143,7 @@ EXPORTS.mozilla.layers += [
     "DirectionUtils.h",
     "Effects.h",
     "ImageDataSerializer.h",
+    "ipc/ActiveResource.h",
     "ipc/APZChild.h",
     "ipc/APZCTreeManagerChild.h",
     "ipc/APZCTreeManagerParent.h",

gfx/layers/wr/WebRenderBridgeChild.cpp

@@ -66,8 +66,6 @@ void WebRenderBridgeChild::DoDestroy() {
 
   // mDestroyed is used to prevent calling Send__delete__() twice.
   // When this function is called from CompositorBridgeChild::Destroy().
-  // mActiveResourceTracker is not cleared here, since it is
-  // used by PersistentBufferProviderShared.
   mDestroyed = true;
   mManager = nullptr;
 }
@@ -519,11 +517,8 @@ void WebRenderBridgeChild::EndClearCachedResources() {
 void WebRenderBridgeChild::SetWebRenderLayerManager(
     WebRenderLayerManager* aManager) {
   MOZ_ASSERT(aManager && !mManager);
-  mManager = aManager;
-
   MOZ_ASSERT(NS_IsMainThread() || !XRE_IsContentProcess());
-  mActiveResourceTracker =
+  mManager = aManager;
-      MakeUnique<ActiveResourceTracker>(1000, "CompositableForwarder", nullptr);
 }
 
 ipc::IShmemAllocator* WebRenderBridgeChild::GetShmemAllocator() {

gfx/layers/wr/WebRenderBridgeChild.h

@@ -94,9 +94,6 @@ class WebRenderBridgeChild final : public PWebRenderBridgeChild,
   TextureForwarder* GetTextureForwarder() override;
   LayersIPCActor* GetLayersIPCActor() override;
   void SyncWithCompositor() override;
-  ActiveResourceTracker* GetActiveResourceTracker() override {
-    return mActiveResourceTracker.get();
-  }
 
   void AddPipelineIdForCompositable(const wr::PipelineId& aPipelineId,
                                     const CompositableHandle& aHandle,
@@ -258,8 +255,6 @@ class WebRenderBridgeChild final : public PWebRenderBridgeChild,
   uint32_t mFontInstanceKeysDeleted;
   nsTHashMap<ScaledFontHashKey, wr::FontInstanceKey> mFontInstanceKeys;
 
-  UniquePtr<ActiveResourceTracker> mActiveResourceTracker;
-
   RefCountedShmem mResourceShm;
 };