summaryrefslogtreecommitdiffstats
path: root/gfx/layers/ipc/CompositorBridgeChild.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /gfx/layers/ipc/CompositorBridgeChild.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/layers/ipc/CompositorBridgeChild.h')
-rw-r--r--gfx/layers/ipc/CompositorBridgeChild.h251
1 files changed, 251 insertions, 0 deletions
diff --git a/gfx/layers/ipc/CompositorBridgeChild.h b/gfx/layers/ipc/CompositorBridgeChild.h
new file mode 100644
index 0000000000..723cbc5705
--- /dev/null
+++ b/gfx/layers/ipc/CompositorBridgeChild.h
@@ -0,0 +1,251 @@
+/* -*- 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_CompositorBridgeChild_h
+#define mozilla_layers_CompositorBridgeChild_h
+
+#include "base/basictypes.h" // for DISALLOW_EVIL_CONSTRUCTORS
+#include "mozilla/Assertions.h" // for MOZ_ASSERT_HELPER2
+#include "mozilla/Attributes.h" // for override
+#include "mozilla/Monitor.h"
+#include "mozilla/ipc/ProtocolUtils.h"
+#include "mozilla/layers/PCompositorBridgeChild.h"
+#include "mozilla/layers/TextureForwarder.h" // for TextureForwarder
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "nsClassHashtable.h" // for nsClassHashtable
+#include "nsCOMPtr.h" // for nsCOMPtr
+#include "nsHashKeys.h" // for nsUint64HashKey
+#include "nsISupportsImpl.h" // for NS_INLINE_DECL_REFCOUNTING
+#include "nsIWeakReferenceUtils.h"
+
+#include <unordered_map>
+
+namespace mozilla {
+
+namespace dom {
+class BrowserChild;
+} // namespace dom
+
+namespace widget {
+class CompositorWidget;
+} // namespace widget
+
+namespace layers {
+
+using mozilla::dom::BrowserChild;
+
+class IAPZCTreeManager;
+class APZCTreeManagerChild;
+class CanvasChild;
+class CompositorBridgeParent;
+class CompositorManagerChild;
+class CompositorOptions;
+class WebRenderLayerManager;
+class TextureClient;
+class TextureClientPool;
+struct FrameMetrics;
+
+class CompositorBridgeChild final : public PCompositorBridgeChild,
+ public TextureForwarder {
+ typedef nsTArray<AsyncParentMessageData> AsyncParentMessageArray;
+
+ friend class PCompositorBridgeChild;
+
+ public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CompositorBridgeChild, override);
+
+ explicit CompositorBridgeChild(CompositorManagerChild* aManager);
+
+ /**
+ * Initialize the singleton compositor bridge for a content process.
+ */
+ void InitForContent(uint32_t aNamespace);
+
+ void InitForWidget(uint64_t aProcessToken,
+ WebRenderLayerManager* aLayerManager, uint32_t aNamespace);
+
+ void Destroy();
+
+ static CompositorBridgeChild* Get();
+
+ // 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();
+
+ mozilla::ipc::IPCResult RecvDidComposite(
+ const LayersId& aId, const nsTArray<TransactionId>& aTransactionIds,
+ const TimeStamp& aCompositeStart, const TimeStamp& aCompositeEnd);
+
+ mozilla::ipc::IPCResult RecvNotifyFrameStats(
+ nsTArray<FrameStats>&& aFrameStats);
+
+ mozilla::ipc::IPCResult RecvNotifyJankedAnimations(
+ const LayersId& aLayersId, nsTArray<uint64_t>&& aJankedAnimations);
+
+ PTextureChild* AllocPTextureChild(
+ const SurfaceDescriptor& aSharedData, ReadLockDescriptor& aReadLock,
+ const LayersBackend& aLayersBackend, const TextureFlags& aFlags,
+ const LayersId& aId, const uint64_t& aSerial,
+ const wr::MaybeExternalImageId& aExternalImageId);
+
+ bool DeallocPTextureChild(PTextureChild* actor);
+
+ mozilla::ipc::IPCResult RecvParentAsyncMessages(
+ nsTArray<AsyncParentMessageData>&& aMessages);
+ PTextureChild* CreateTexture(
+ const SurfaceDescriptor& aSharedData, ReadLockDescriptor&& aReadLock,
+ LayersBackend aLayersBackend, TextureFlags aFlags,
+ const dom::ContentParentId& aContentId, uint64_t aSerial,
+ wr::MaybeExternalImageId& aExternalImageId) override;
+
+ already_AddRefed<CanvasChild> GetCanvasChild() final;
+
+ void EndCanvasTransaction();
+
+ // Beware that these methods don't override their super-class equivalent
+ // (which 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 SendResumeAsync();
+ bool SendAdoptChild(const LayersId& id);
+ bool SendFlushRendering(const wr::RenderReasons& aReasons);
+ bool SendStartFrameTimeRecording(const int32_t& bufferSize,
+ uint32_t* startIndex);
+ bool SendStopFrameTimeRecording(const uint32_t& startIndex,
+ nsTArray<float>* intervals);
+ bool IsSameProcess() const override;
+
+ bool IPCOpen() const override { return mCanSend; }
+
+ static void ShutDown();
+
+ void UpdateFwdTransactionId() { ++mFwdTransactionId; }
+ uint64_t GetFwdTransactionId() { return mFwdTransactionId; }
+
+ /**
+ * Hold TextureClient ref until end of usage on host side if
+ * TextureFlags::RECYCLE is set. Host side's usage is checked via
+ * CompositableRef.
+ */
+ void HoldUntilCompositableRefReleasedIfNecessary(TextureClient* aClient);
+
+ /**
+ * Notify id of Texture When host side end its use. Transaction id is used to
+ * make sure if there is no newer usage.
+ */
+ void NotifyNotUsed(uint64_t aTextureId, uint64_t aFwdTransactionId);
+
+ void CancelWaitForNotifyNotUsed(uint64_t aTextureId) override;
+
+ FixedSizeSmallShmemSectionAllocator* GetTileLockAllocator() override;
+
+ nsISerialEventTarget* GetThread() const override { return mThread; }
+
+ base::ProcessId GetParentPid() const override { return OtherPid(); }
+
+ bool AllocUnsafeShmem(size_t aSize, mozilla::ipc::Shmem* aShmem) override;
+ bool AllocShmem(size_t aSize, mozilla::ipc::Shmem* aShmem) override;
+ bool DeallocShmem(mozilla::ipc::Shmem& aShmem) override;
+
+ PCompositorWidgetChild* AllocPCompositorWidgetChild(
+ const CompositorWidgetInitData& aInitData);
+ bool DeallocPCompositorWidgetChild(PCompositorWidgetChild* aActor);
+
+ PAPZCTreeManagerChild* AllocPAPZCTreeManagerChild(const LayersId& aLayersId);
+ bool DeallocPAPZCTreeManagerChild(PAPZCTreeManagerChild* aActor);
+
+ PAPZChild* AllocPAPZChild(const LayersId& aLayersId);
+ bool DeallocPAPZChild(PAPZChild* aActor);
+
+ PWebRenderBridgeChild* AllocPWebRenderBridgeChild(
+ const wr::PipelineId& aPipelineId, const LayoutDeviceIntSize&,
+ const WindowKind&);
+ bool DeallocPWebRenderBridgeChild(PWebRenderBridgeChild* aActor);
+
+ wr::MaybeExternalImageId GetNextExternalImageId() override;
+
+ wr::PipelineId GetNextPipelineId();
+
+ private:
+ // Private destructor, to discourage deletion outside of Release():
+ virtual ~CompositorBridgeChild();
+
+ // Must only be called from the paint thread. If the main thread is delaying
+ // IPC messages, this forwards all such delayed IPC messages to the I/O thread
+ // and resumes IPC.
+ void ResumeIPCAfterAsyncPaint();
+
+ void PrepareFinalDestroy();
+ void AfterDestroy();
+
+ void ActorDestroy(ActorDestroyReason aWhy) override;
+
+ mozilla::ipc::IPCResult RecvObserveLayersUpdate(
+ const LayersId& aLayersId, const LayersObserverEpoch& aEpoch,
+ const bool& aActive);
+
+ mozilla::ipc::IPCResult RecvCompositorOptionsChanged(
+ const LayersId& aLayersId, const CompositorOptions& aNewOptions);
+
+ uint64_t GetNextResourceId();
+
+ RefPtr<CompositorManagerChild> mCompositorManager;
+
+ RefPtr<WebRenderLayerManager> mLayerManager;
+
+ uint32_t mIdNamespace;
+ uint32_t mResourceId;
+
+ // When not multi-process, hold a reference to the CompositorBridgeParent to
+ // keep it alive. This reference should be null in multi-process.
+ RefPtr<CompositorBridgeParent> mCompositorBridgeParent;
+
+ DISALLOW_EVIL_CONSTRUCTORS(CompositorBridgeChild);
+
+ // True until the beginning of the two-step shutdown sequence of this actor.
+ bool mCanSend;
+
+ // False until the actor is destroyed.
+ bool mActorDestroyed;
+
+ /**
+ * Transaction id of ShadowLayerForwarder.
+ * It is incremented by UpdateFwdTransactionId() in each BeginTransaction()
+ * call.
+ */
+ uint64_t mFwdTransactionId;
+
+ /**
+ * Hold TextureClients refs until end of their usages on host side.
+ * It defer calling of TextureClient recycle callback.
+ */
+ std::unordered_map<uint64_t, RefPtr<TextureClient>>
+ mTexturesWaitingNotifyNotUsed;
+
+ nsCOMPtr<nsISerialEventTarget> mThread;
+
+ AutoTArray<RefPtr<TextureClientPool>, 2> mTexturePools;
+
+ uint64_t mProcessToken;
+
+ FixedSizeSmallShmemSectionAllocator* mSectionAllocator;
+
+ // TextureClients that must be kept alive during async painting. This
+ // is only accessed on the main thread.
+ nsTArray<RefPtr<TextureClient>> mTextureClientsForAsyncPaint;
+
+ RefPtr<CanvasChild> mCanvasChild;
+};
+
+} // namespace layers
+} // namespace mozilla
+
+#endif // mozilla_layers_CompositorBrigedChild_h