summaryrefslogtreecommitdiffstats
path: root/gfx/layers/wr/WebRenderBridgeChild.h
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/layers/wr/WebRenderBridgeChild.h')
-rw-r--r--gfx/layers/wr/WebRenderBridgeChild.h269
1 files changed, 269 insertions, 0 deletions
diff --git a/gfx/layers/wr/WebRenderBridgeChild.h b/gfx/layers/wr/WebRenderBridgeChild.h
new file mode 100644
index 0000000000..2bd8dc8570
--- /dev/null
+++ b/gfx/layers/wr/WebRenderBridgeChild.h
@@ -0,0 +1,269 @@
+/* -*- 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_WebRenderBridgeChild_h
+#define mozilla_layers_WebRenderBridgeChild_h
+
+#include "mozilla/layers/CompositableForwarder.h"
+#include "mozilla/layers/PWebRenderBridgeChild.h"
+
+namespace mozilla {
+
+namespace widget {
+class CompositorWidget;
+}
+
+namespace wr {
+class DisplayListBuilder;
+class ResourceUpdateQueue;
+class IpcResourceUpdateQueue;
+} // namespace wr
+
+namespace layers {
+
+class CompositableClient;
+class CompositorBridgeChild;
+class StackingContextHelper;
+class TextureForwarder;
+class WebRenderLayerManager;
+
+template <class T>
+class ThreadSafeWeakPtrHashKey : public PLDHashEntryHdr {
+ public:
+ typedef RefPtr<T> KeyType;
+ typedef const T* KeyTypePointer;
+
+ explicit ThreadSafeWeakPtrHashKey(KeyTypePointer aKey)
+ : mKey(do_AddRef(const_cast<T*>(aKey))) {}
+
+ KeyType GetKey() const { return do_AddRef(mKey); }
+ bool KeyEquals(KeyTypePointer aKey) const { return mKey == aKey; }
+
+ static KeyTypePointer KeyToPointer(const KeyType& aKey) { return aKey.get(); }
+ static PLDHashNumber HashKey(KeyTypePointer aKey) {
+ return NS_PTR_TO_UINT32(aKey) >> 2;
+ }
+ enum { ALLOW_MEMMOVE = true };
+
+ private:
+ ThreadSafeWeakPtr<T> mKey;
+};
+
+typedef ThreadSafeWeakPtrHashKey<gfx::UnscaledFont> UnscaledFontHashKey;
+typedef ThreadSafeWeakPtrHashKey<gfx::ScaledFont> ScaledFontHashKey;
+
+class WebRenderBridgeChild final : public PWebRenderBridgeChild,
+ public CompositableForwarder {
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderBridgeChild, override)
+
+ friend class PWebRenderBridgeChild;
+
+ public:
+ explicit WebRenderBridgeChild(const wr::PipelineId& aPipelineId);
+
+ void AddWebRenderParentCommand(const WebRenderParentCommand& aCmd);
+ bool HasWebRenderParentCommands() { return !mParentCommands.IsEmpty(); }
+
+ void UpdateResources(wr::IpcResourceUpdateQueue& aResources);
+ void BeginTransaction();
+ bool EndTransaction(DisplayListData&& aDisplayListData,
+ TransactionId aTransactionId, bool aContainsSVGroup,
+ const mozilla::VsyncId& aVsyncId,
+ const mozilla::TimeStamp& aVsyncStartTime,
+ const mozilla::TimeStamp& aRefreshStartTime,
+ const mozilla::TimeStamp& aTxnStartTime,
+ const nsCString& aTxtURL);
+ void EndEmptyTransaction(const FocusTarget& aFocusTarget,
+ Maybe<TransactionData>&& aTransactionData,
+ TransactionId aTransactionId,
+ const mozilla::VsyncId& aVsyncId,
+ const mozilla::TimeStamp& aVsyncStartTime,
+ const mozilla::TimeStamp& aRefreshStartTime,
+ const mozilla::TimeStamp& aTxnStartTime,
+ const nsCString& aTxtURL);
+ void ProcessWebRenderParentCommands();
+
+ CompositorBridgeChild* GetCompositorBridgeChild();
+
+ wr::PipelineId GetPipeline() { return mPipelineId; }
+
+ // KnowsCompositor
+ TextureForwarder* GetTextureForwarder() override;
+ LayersIPCActor* GetLayersIPCActor() override;
+ void SyncWithCompositor() override;
+ ActiveResourceTracker* GetActiveResourceTracker() override {
+ return mActiveResourceTracker.get();
+ }
+
+ void AddPipelineIdForCompositable(const wr::PipelineId& aPipelineId,
+ const CompositableHandle& aHandle,
+ CompositableHandleOwner aOwner);
+ void RemovePipelineIdForCompositable(const wr::PipelineId& aPipelineId);
+
+ /// Release TextureClient that is bounded to ImageKey.
+ /// It is used for recycling TextureClient.
+ void ReleaseTextureOfImage(const wr::ImageKey& aKey);
+
+ /**
+ * Clean this up, finishing with SendShutDown() which will cause __delete__
+ * to be sent from the parent side.
+ */
+ void Destroy(bool aIsSync);
+ bool IPCOpen() const { return mIPCOpen && !mDestroyed; }
+ bool GetSentDisplayList() const { return mSentDisplayList; }
+ bool IsDestroyed() const { return mDestroyed; }
+
+ uint32_t GetNextResourceId() { return ++mResourceId; }
+ wr::IdNamespace GetNamespace() { return mIdNamespace; }
+ void SetNamespace(wr::IdNamespace aIdNamespace) {
+ mIdNamespace = aIdNamespace;
+ }
+
+ bool MatchesNamespace(const wr::ImageKey& aImageKey) const {
+ return aImageKey.mNamespace == mIdNamespace;
+ }
+
+ bool MatchesNamespace(const wr::BlobImageKey& aBlobKey) const {
+ return MatchesNamespace(aBlobKey._0);
+ }
+
+ wr::FontKey GetNextFontKey() {
+ return wr::FontKey{GetNamespace(), GetNextResourceId()};
+ }
+
+ wr::FontInstanceKey GetNextFontInstanceKey() {
+ return wr::FontInstanceKey{GetNamespace(), GetNextResourceId()};
+ }
+
+ wr::WrImageKey GetNextImageKey() {
+ return wr::WrImageKey{GetNamespace(), GetNextResourceId()};
+ }
+
+ void PushGlyphs(wr::DisplayListBuilder& aBuilder,
+ wr::IpcResourceUpdateQueue& aResources,
+ Range<const wr::GlyphInstance> aGlyphs,
+ gfx::ScaledFont* aFont, const wr::ColorF& aColor,
+ const StackingContextHelper& aSc,
+ const wr::LayoutRect& aBounds, const wr::LayoutRect& aClip,
+ bool aBackfaceVisible,
+ const wr::GlyphOptions* aGlyphOptions = nullptr);
+
+ Maybe<wr::FontInstanceKey> GetFontKeyForScaledFont(
+ gfx::ScaledFont* aScaledFont, wr::IpcResourceUpdateQueue& aResources);
+ Maybe<wr::FontKey> GetFontKeyForUnscaledFont(
+ gfx::UnscaledFont* aUnscaledFont, wr::IpcResourceUpdateQueue& aResources);
+ void RemoveExpiredFontKeys(wr::IpcResourceUpdateQueue& aResources);
+
+ void BeginClearCachedResources();
+ void EndClearCachedResources();
+
+ void SetWebRenderLayerManager(WebRenderLayerManager* aManager);
+
+ mozilla::ipc::IShmemAllocator* GetShmemAllocator();
+
+ bool IsThreadSafe() const override { return false; }
+
+ RefPtr<KnowsCompositor> GetForMedia() override;
+
+ /// Alloc a specific type of shmem that is intended for use in
+ /// IpcResourceUpdateQueue only, and cache at most one of them,
+ /// when called multiple times.
+ ///
+ /// Do not use this for anything else.
+ bool AllocResourceShmem(size_t aSize, RefCountedShmem& aShm);
+ /// Dealloc shared memory that was allocated with AllocResourceShmem.
+ ///
+ /// Do not use this for anything else.
+ void DeallocResourceShmem(RefCountedShmem& aShm);
+
+ void Capture();
+ void StartCaptureSequence(const nsCString& path, uint32_t aFlags);
+ void StopCaptureSequence();
+
+ private:
+ friend class CompositorBridgeChild;
+
+ ~WebRenderBridgeChild();
+
+ wr::ExternalImageId GetNextExternalImageId();
+
+ // CompositableForwarder
+ void Connect(CompositableClient* aCompositable,
+ ImageContainer* aImageContainer = nullptr) override;
+ void ReleaseCompositable(const CompositableHandle& aHandle) override;
+ bool DestroyInTransaction(PTextureChild* aTexture) override;
+ bool DestroyInTransaction(const CompositableHandle& aHandle);
+ void RemoveTextureFromCompositable(CompositableClient* aCompositable,
+ TextureClient* aTexture) override;
+ void UseTextures(CompositableClient* aCompositable,
+ const nsTArray<TimedTextureClient>& aTextures) override;
+ void UseRemoteTexture(CompositableClient* aCompositable,
+ const RemoteTextureId aTextureId,
+ const RemoteTextureOwnerId aOwnerId,
+ const gfx::IntSize aSize,
+ const TextureFlags aFlags) override;
+ void EnableRemoteTexturePushCallback(CompositableClient* aCompositable,
+ const RemoteTextureOwnerId aOwnerId,
+ const gfx::IntSize aSize,
+ const TextureFlags aFlags) override;
+ void UpdateFwdTransactionId() override;
+ uint64_t GetFwdTransactionId() override;
+ bool InForwarderThread() override;
+
+ void ActorDestroy(ActorDestroyReason why) override;
+
+ void DoDestroy();
+
+ mozilla::ipc::IPCResult RecvWrUpdated(
+ const wr::IdNamespace& aNewIdNamespace,
+ const TextureFactoryIdentifier& textureFactoryIdentifier);
+ mozilla::ipc::IPCResult RecvWrReleasedImages(
+ nsTArray<wr::ExternalImageKeyPair>&& aPairs);
+
+ void AddIPDLReference() {
+ MOZ_ASSERT(mIPCOpen == false);
+ mIPCOpen = true;
+ AddRef();
+ }
+ void ReleaseIPDLReference() {
+ MOZ_ASSERT(mIPCOpen == true);
+ mIPCOpen = false;
+ Release();
+ }
+
+ bool AddOpDestroy(const OpDestroy& aOp);
+
+ nsTArray<OpDestroy> mDestroyedActors;
+ nsTArray<WebRenderParentCommand> mParentCommands;
+ nsTHashMap<nsUint64HashKey, CompositableClient*> mCompositables;
+ bool mIsInTransaction;
+ bool mIsInClearCachedResources;
+ wr::IdNamespace mIdNamespace;
+ uint32_t mResourceId;
+ wr::PipelineId mPipelineId;
+ WebRenderLayerManager* mManager;
+
+ bool mIPCOpen;
+ bool mDestroyed;
+ // True iff we have called SendSetDisplayList and haven't called
+ // SendClearCachedResources since that call.
+ bool mSentDisplayList;
+
+ uint32_t mFontKeysDeleted;
+ nsTHashMap<UnscaledFontHashKey, wr::FontKey> mFontKeys;
+
+ uint32_t mFontInstanceKeysDeleted;
+ nsTHashMap<ScaledFontHashKey, wr::FontInstanceKey> mFontInstanceKeys;
+
+ UniquePtr<ActiveResourceTracker> mActiveResourceTracker;
+
+ RefCountedShmem mResourceShm;
+};
+
+} // namespace layers
+} // namespace mozilla
+
+#endif // mozilla_layers_WebRenderBridgeChild_h