Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 527 insertions, 0 deletions

diff --git a/gfx/layers/wr/WebRenderBridgeParent.h b/gfx/layers/wr/WebRenderBridgeParent.h
new file mode 100644
index 0000000000..d8d80d1047
--- /dev/null
+++ b/gfx/layers/wr/WebRenderBridgeParent.h
@@ -0,0 +1,527 @@
+/* -*- 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_WebRenderBridgeParent_h
+#define mozilla_layers_WebRenderBridgeParent_h
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "CompositableHost.h"  // for CompositableHost, ImageCompositeNotificationInfo
+#include "GLContextProvider.h"
+#include "mozilla/DataMutex.h"
+#include "mozilla/layers/CompositableTransactionParent.h"
+#include "mozilla/layers/CompositorVsyncSchedulerOwner.h"
+#include "mozilla/layers/PWebRenderBridgeParent.h"
+#include "mozilla/HashTable.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Result.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "mozilla/webrender/WebRenderAPI.h"
+#include "nsTArrayForwardDeclare.h"
+#include "WindowRenderer.h"
+
+namespace mozilla {
+
+namespace gl {
+class GLContext;
+}
+
+namespace widget {
+class CompositorWidget;
+}
+
+namespace wr {
+class WebRenderAPI;
+class WebRenderPipelineInfo;
+}  // namespace wr
+
+namespace layers {
+
+class AsyncImagePipelineManager;
+class Compositor;
+class CompositorBridgeParentBase;
+class CompositorVsyncScheduler;
+class OMTASampler;
+class RemoteTextureTxnScheduler;
+class UiCompositorControllerParent;
+class WebRenderBridgeParentRef;
+class WebRenderImageHost;
+struct WrAnimations;
+
+struct CompositorAnimationIdsForEpoch {
+  CompositorAnimationIdsForEpoch(const wr::Epoch& aEpoch,
+                                 nsTArray<uint64_t>&& aIds)
+      : mEpoch(aEpoch), mIds(std::move(aIds)) {}
+
+  wr::Epoch mEpoch;
+  nsTArray<uint64_t> mIds;
+};
+
+class WebRenderBridgeParent final : public PWebRenderBridgeParent,
+                                    public CompositorVsyncSchedulerOwner,
+                                    public CompositableParentManager,
+                                    public FrameRecorder {
+ public:
+  WebRenderBridgeParent(CompositorBridgeParentBase* aCompositorBridge,
+                        const wr::PipelineId& aPipelineId,
+                        widget::CompositorWidget* aWidget,
+                        CompositorVsyncScheduler* aScheduler,
+                        RefPtr<wr::WebRenderAPI>&& aApi,
+                        RefPtr<AsyncImagePipelineManager>&& aImageMgr,
+                        TimeDuration aVsyncRate);
+
+  static WebRenderBridgeParent* CreateDestroyed(
+      const wr::PipelineId& aPipelineId, nsCString&& aError);
+
+  wr::PipelineId PipelineId() { return mPipelineId; }
+  already_AddRefed<wr::WebRenderAPI> GetWebRenderAPI() {
+    return do_AddRef(mApi);
+  }
+  AsyncImagePipelineManager* AsyncImageManager() { return mAsyncImageManager; }
+  CompositorVsyncScheduler* CompositorScheduler() {
+    return mCompositorScheduler.get();
+  }
+  CompositorBridgeParentBase* GetCompositorBridge() {
+    return mCompositorBridge;
+  }
+
+  void UpdateQualitySettings();
+  void UpdateDebugFlags();
+  void UpdateParameters();
+  void UpdateBoolParameters();
+  void UpdateProfilerUI();
+
+  mozilla::ipc::IPCResult RecvEnsureConnected(
+      TextureFactoryIdentifier* aTextureFactoryIdentifier,
+      MaybeIdNamespace* aMaybeIdNamespace, nsCString* aError) override;
+
+  mozilla::ipc::IPCResult RecvNewCompositable(
+      const CompositableHandle& aHandle, const TextureInfo& aInfo) override;
+  mozilla::ipc::IPCResult RecvReleaseCompositable(
+      const CompositableHandle& aHandle) override;
+
+  mozilla::ipc::IPCResult RecvShutdown() override;
+  mozilla::ipc::IPCResult RecvShutdownSync() override;
+  mozilla::ipc::IPCResult RecvDeleteCompositorAnimations(
+      nsTArray<uint64_t>&& aIds) override;
+  mozilla::ipc::IPCResult RecvUpdateResources(
+      const wr::IdNamespace& aIdNamespace,
+      nsTArray<OpUpdateResource>&& aUpdates,
+      nsTArray<RefCountedShmem>&& aSmallShmems,
+      nsTArray<ipc::Shmem>&& aLargeShmems) override;
+  mozilla::ipc::IPCResult RecvSetDisplayList(
+      DisplayListData&& aDisplayList, nsTArray<OpDestroy>&& aToDestroy,
+      const uint64_t& aFwdTransactionId, const TransactionId& aTransactionId,
+      const bool& aContainsSVGGroup, const VsyncId& aVsyncId,
+      const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
+      const TimeStamp& aTxnStartTime, const nsACString& aTxnURL,
+      const TimeStamp& aFwdTime,
+      nsTArray<CompositionPayload>&& aPayloads) override;
+  mozilla::ipc::IPCResult RecvEmptyTransaction(
+      const FocusTarget& aFocusTarget,
+      Maybe<TransactionData>&& aTransactionData,
+      nsTArray<OpDestroy>&& aToDestroy, const uint64_t& aFwdTransactionId,
+      const TransactionId& aTransactionId, const VsyncId& aVsyncId,
+      const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
+      const TimeStamp& aTxnStartTime, const nsACString& aTxnURL,
+      const TimeStamp& aFwdTime,
+      nsTArray<CompositionPayload>&& aPayloads) override;
+  mozilla::ipc::IPCResult RecvSetFocusTarget(
+      const FocusTarget& aFocusTarget) override;
+  mozilla::ipc::IPCResult RecvParentCommands(
+      const wr::IdNamespace& aIdNamespace,
+      nsTArray<WebRenderParentCommand>&& commands) override;
+  mozilla::ipc::IPCResult RecvGetSnapshot(NotNull<PTextureParent*> aTexture,
+                                          bool* aNeedsYFlip) override;
+
+  mozilla::ipc::IPCResult RecvClearCachedResources() override;
+  mozilla::ipc::IPCResult RecvClearAnimationResources() override;
+  mozilla::ipc::IPCResult RecvInvalidateRenderedFrame() override;
+  mozilla::ipc::IPCResult RecvScheduleComposite(
+      const wr::RenderReasons& aReasons) override;
+  mozilla::ipc::IPCResult RecvCapture() override;
+  mozilla::ipc::IPCResult RecvStartCaptureSequence(
+      const nsACString& path, const uint32_t& aFlags) override;
+  mozilla::ipc::IPCResult RecvStopCaptureSequence() override;
+  mozilla::ipc::IPCResult RecvSyncWithCompositor() override;
+
+  mozilla::ipc::IPCResult RecvSetConfirmedTargetAPZC(
+      const uint64_t& aBlockId,
+      nsTArray<ScrollableLayerGuid>&& aTargets) override;
+
+  mozilla::ipc::IPCResult RecvSetTestSampleTime(
+      const TimeStamp& aTime) override;
+  mozilla::ipc::IPCResult RecvLeaveTestMode() override;
+  mozilla::ipc::IPCResult RecvGetAnimationValue(
+      const uint64_t& aCompositorAnimationsId, OMTAValue* aValue) override;
+  mozilla::ipc::IPCResult RecvSetAsyncScrollOffset(
+      const ScrollableLayerGuid::ViewID& aScrollId, const float& aX,
+      const float& aY) override;
+  mozilla::ipc::IPCResult RecvSetAsyncZoom(
+      const ScrollableLayerGuid::ViewID& aScrollId,
+      const float& aZoom) override;
+  mozilla::ipc::IPCResult RecvFlushApzRepaints() override;
+  mozilla::ipc::IPCResult RecvGetAPZTestData(APZTestData* data) override;
+  mozilla::ipc::IPCResult RecvGetFrameUniformity(
+      FrameUniformityData* aOutData) override;
+
+  void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  mozilla::ipc::IPCResult RecvSetDefaultClearColor(
+      const uint32_t& aColor) override;
+  void SetClearColor(const gfx::DeviceColor& aColor);
+
+  void Pause();
+  bool Resume();
+
+  void Destroy();
+
+  // CompositorVsyncSchedulerOwner
+  bool IsPendingComposite() override { return false; }
+  void FinishPendingComposite() override {}
+  void CompositeToTarget(VsyncId aId, wr::RenderReasons aReasons,
+                         gfx::DrawTarget* aTarget,
+                         const gfx::IntRect* aRect = nullptr) override;
+  TimeDuration GetVsyncInterval() const override;
+
+  // CompositableParentManager
+  bool IsSameProcess() const override;
+  base::ProcessId GetChildProcessId() override;
+  dom::ContentParentId GetContentId() override;
+  void NotifyNotUsed(PTextureParent* aTexture,
+                     uint64_t aTransactionId) override;
+  void SendAsyncMessage(
+      const nsTArray<AsyncParentMessageData>& aMessage) override;
+  void SendPendingAsyncMessages() override;
+  void SetAboutToSendAsyncMessages() override;
+
+  void HoldPendingTransactionId(
+      const wr::Epoch& aWrEpoch, TransactionId aTransactionId,
+      bool aContainsSVGGroup, const VsyncId& aVsyncId,
+      const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
+      const TimeStamp& aTxnStartTime, const nsACString& aTxnURL,
+      const TimeStamp& aFwdTime, const bool aIsFirstPaint,
+      nsTArray<CompositionPayload>&& aPayloads,
+      const bool aUseForTelemetry = true);
+  TransactionId LastPendingTransactionId();
+  void FlushTransactionIdsForEpoch(
+      const wr::Epoch& aEpoch, const VsyncId& aCompositeStartId,
+      const TimeStamp& aCompositeStartTime, const TimeStamp& aRenderStartTime,
+      const TimeStamp& aEndTime, UiCompositorControllerParent* aUiController,
+      wr::RendererStats* aStats, nsTArray<FrameStats>& aOutputStats,
+      nsTArray<TransactionId>& aOutputTransactions);
+  void NotifySceneBuiltForEpoch(const wr::Epoch& aEpoch,
+                                const TimeStamp& aEndTime);
+
+  void RetrySkippedComposite();
+
+  TextureFactoryIdentifier GetTextureFactoryIdentifier();
+
+  void ExtractImageCompositeNotifications(
+      nsTArray<ImageCompositeNotificationInfo>* aNotifications);
+
+  wr::Epoch GetCurrentEpoch() const { return mWrEpoch; }
+  wr::IdNamespace GetIdNamespace() { return mIdNamespace; }
+
+  bool MatchesNamespace(const wr::ImageKey& aImageKey) const {
+    return aImageKey.mNamespace == mIdNamespace;
+  }
+
+  bool MatchesNamespace(const wr::BlobImageKey& aBlobKey) const {
+    return MatchesNamespace(wr::AsImageKey(aBlobKey));
+  }
+
+  bool MatchesNamespace(const wr::FontKey& aFontKey) const {
+    return aFontKey.mNamespace == mIdNamespace;
+  }
+
+  bool MatchesNamespace(const wr::FontInstanceKey& aFontKey) const {
+    return aFontKey.mNamespace == mIdNamespace;
+  }
+
+  void FlushRendering(wr::RenderReasons aReasons, bool aWaitForPresent = true);
+
+  /**
+   * Schedule generating WebRender frame definitely at next composite timing.
+   *
+   * WebRenderBridgeParent uses composite timing to check if there is an update
+   * to AsyncImagePipelines. If there is no update, WebRenderBridgeParent skips
+   * to generate frame. If we need to generate new frame at next composite
+   * timing, call this method.
+   *
+   * Call CompositorVsyncScheduler::ScheduleComposition() directly, if we just
+   * want to trigger AsyncImagePipelines update checks.
+   */
+  void ScheduleGenerateFrame(wr::RenderReasons aReason);
+
+  /**
+   * Invalidate rendered frame.
+   *
+   * WebRender could skip frame rendering if there is no update.
+   * This function is used to force invalidating even when there is no update.
+   */
+  void InvalidateRenderedFrame(wr::RenderReasons aReasons);
+
+  /**
+   * Schedule forced frame rendering at next composite timing.
+   *
+   * WebRender could skip frame rendering if there is no update.
+   * This function is used to force rendering even when there is no update.
+   */
+  void ScheduleForcedGenerateFrame(wr::RenderReasons aReasons);
+
+  void NotifyDidSceneBuild(RefPtr<const wr::WebRenderPipelineInfo> aInfo);
+
+  wr::Epoch UpdateWebRender(
+      CompositorVsyncScheduler* aScheduler, RefPtr<wr::WebRenderAPI>&& aApi,
+      AsyncImagePipelineManager* aImageMgr,
+      const TextureFactoryIdentifier& aTextureFactoryIdentifier);
+
+  void RemoveEpochDataPriorTo(const wr::Epoch& aRenderedEpoch);
+
+  bool IsRootWebRenderBridgeParent() const;
+  LayersId GetLayersId() const;
+
+  void BeginRecording(const TimeStamp& aRecordingStart);
+
+#if defined(MOZ_WIDGET_ANDROID)
+  /**
+   * Request a screengrab for android
+   */
+  void RequestScreenPixels(UiCompositorControllerParent* aController);
+  void MaybeCaptureScreenPixels();
+#endif
+  /**
+   * Stop recording and the frames collected since the call to BeginRecording
+   */
+  RefPtr<wr::WebRenderAPI::EndRecordingPromise> EndRecording();
+
+  void DisableNativeCompositor();
+  void AddPendingScrollPayload(CompositionPayload& aPayload,
+                               const VsyncId& aCompositeStartId);
+
+  nsTArray<CompositionPayload> TakePendingScrollPayload(
+      const VsyncId& aCompositeStartId);
+
+  RefPtr<WebRenderBridgeParentRef> GetWebRenderBridgeParentRef();
+
+  void FlushPendingWrTransactionEventsWithWait();
+
+ private:
+  class ScheduleSharedSurfaceRelease;
+
+  WebRenderBridgeParent(const wr::PipelineId& aPipelineId, nsCString&& aError);
+  virtual ~WebRenderBridgeParent();
+
+  bool ProcessEmptyTransactionUpdates(TransactionData& aData,
+                                      bool* aScheduleComposite);
+
+  bool ProcessDisplayListData(DisplayListData& aDisplayList, wr::Epoch aWrEpoch,
+                              const TimeStamp& aTxnStartTime,
+                              bool aValidTransaction);
+
+  bool SetDisplayList(const LayoutDeviceRect& aRect, ipc::ByteBuf&& aDLItems,
+                      ipc::ByteBuf&& aDLCache, ipc::ByteBuf&& aSpatialTreeDL,
+                      const wr::BuiltDisplayListDescriptor& aDLDesc,
+                      const nsTArray<OpUpdateResource>& aResourceUpdates,
+                      const nsTArray<RefCountedShmem>& aSmallShmems,
+                      const nsTArray<ipc::Shmem>& aLargeShmems,
+                      const TimeStamp& aTxnStartTime,
+                      wr::TransactionBuilder& aTxn, wr::Epoch aWrEpoch);
+
+  void UpdateAPZFocusState(const FocusTarget& aFocus);
+  void UpdateAPZScrollData(const wr::Epoch& aEpoch,
+                           WebRenderScrollData&& aData);
+  void UpdateAPZScrollOffsets(ScrollUpdatesMap&& aUpdates,
+                              uint32_t aPaintSequenceNumber);
+
+  bool UpdateResources(const nsTArray<OpUpdateResource>& aResourceUpdates,
+                       const nsTArray<RefCountedShmem>& aSmallShmems,
+                       const nsTArray<ipc::Shmem>& aLargeShmems,
+                       wr::TransactionBuilder& aUpdates);
+  bool AddSharedExternalImage(wr::ExternalImageId aExtId, wr::ImageKey aKey,
+                              wr::TransactionBuilder& aResources);
+  bool UpdateSharedExternalImage(
+      wr::ExternalImageId aExtId, wr::ImageKey aKey,
+      const ImageIntRect& aDirtyRect, wr::TransactionBuilder& aResources,
+      UniquePtr<ScheduleSharedSurfaceRelease>& aScheduleRelease);
+  void ObserveSharedSurfaceRelease(
+      const nsTArray<wr::ExternalImageKeyPair>& aPairs,
+      const bool& aFromCheckpoint);
+
+  bool PushExternalImageForTexture(wr::ExternalImageId aExtId,
+                                   wr::ImageKey aKey, TextureHost* aTexture,
+                                   bool aIsUpdate,
+                                   wr::TransactionBuilder& aResources);
+
+  void AddPipelineIdForCompositable(const wr::PipelineId& aPipelineIds,
+                                    const CompositableHandle& aHandle,
+                                    const CompositableHandleOwner& aOwner,
+                                    wr::TransactionBuilder& aTxn,
+                                    wr::TransactionBuilder& aTxnForImageBridge);
+  void RemovePipelineIdForCompositable(const wr::PipelineId& aPipelineId,
+                                       wr::TransactionBuilder& aTxn);
+
+  void DeleteImage(const wr::ImageKey& aKey, wr::TransactionBuilder& aUpdates);
+  void ReleaseTextureOfImage(const wr::ImageKey& aKey);
+
+  bool ProcessWebRenderParentCommands(
+      const nsTArray<WebRenderParentCommand>& aCommands,
+      wr::TransactionBuilder& aTxn);
+
+  void ClearResources();
+  void ClearAnimationResources();
+  mozilla::ipc::IPCResult HandleShutdown();
+
+  void MaybeNotifyOfLayers(wr::TransactionBuilder&, bool aWillHaveLayers);
+
+  void ResetPreviousSampleTime();
+
+  void SetOMTASampleTime();
+  RefPtr<OMTASampler> GetOMTASampler() const;
+
+  CompositorBridgeParent* GetRootCompositorBridgeParent() const;
+
+  RefPtr<WebRenderBridgeParent> GetRootWebRenderBridgeParent() const;
+
+  // Tell APZ what the subsequent sampling's timestamp should be.
+  void SetAPZSampleTime();
+
+  wr::Epoch GetNextWrEpoch();
+  // This function is expected to be used when GetNextWrEpoch() is called,
+  // but TransactionBuilder does not have resource updates nor display list.
+  // In this case, ScheduleGenerateFrame is not triggered via SceneBuilder.
+  // Then we want to rollback WrEpoch. See Bug 1490117.
+  void RollbackWrEpoch();
+
+  void FlushSceneBuilds();
+  void FlushFrameGeneration(wr::RenderReasons aReasons);
+  void FlushFramePresentation();
+
+  void MaybeGenerateFrame(VsyncId aId, bool aForceGenerateFrame,
+                          wr::RenderReasons aReasons);
+
+  VsyncId GetVsyncIdForEpoch(const wr::Epoch& aEpoch) {
+    for (auto& id : mPendingTransactionIds) {
+      if (id.mEpoch.mHandle == aEpoch.mHandle) {
+        return id.mVsyncId;
+      }
+    }
+    return VsyncId();
+  }
+
+ private:
+  struct PendingTransactionId {
+    PendingTransactionId(const wr::Epoch& aEpoch, TransactionId aId,
+                         bool aContainsSVGGroup, const VsyncId& aVsyncId,
+                         const TimeStamp& aVsyncStartTime,
+                         const TimeStamp& aRefreshStartTime,
+                         const TimeStamp& aTxnStartTime,
+                         const nsACString& aTxnURL, const TimeStamp& aFwdTime,
+                         const bool aIsFirstPaint, const bool aUseForTelemetry,
+                         nsTArray<CompositionPayload>&& aPayloads)
+        : mEpoch(aEpoch),
+          mId(aId),
+          mVsyncId(aVsyncId),
+          mVsyncStartTime(aVsyncStartTime),
+          mRefreshStartTime(aRefreshStartTime),
+          mTxnStartTime(aTxnStartTime),
+          mTxnURL(aTxnURL),
+          mFwdTime(aFwdTime),
+          mSkippedComposites(0),
+          mContainsSVGGroup(aContainsSVGGroup),
+          mIsFirstPaint(aIsFirstPaint),
+          mUseForTelemetry(aUseForTelemetry),
+          mPayloads(std::move(aPayloads)) {}
+    wr::Epoch mEpoch;
+    TransactionId mId;
+    VsyncId mVsyncId;
+    TimeStamp mVsyncStartTime;
+    TimeStamp mRefreshStartTime;
+    TimeStamp mTxnStartTime;
+    nsCString mTxnURL;
+    TimeStamp mFwdTime;
+    TimeStamp mSceneBuiltTime;
+    uint32_t mSkippedComposites;
+    bool mContainsSVGGroup;
+    bool mIsFirstPaint;
+    bool mUseForTelemetry;
+    nsTArray<CompositionPayload> mPayloads;
+  };
+
+  CompositorBridgeParentBase* MOZ_NON_OWNING_REF mCompositorBridge;
+  wr::PipelineId mPipelineId;
+  RefPtr<widget::CompositorWidget> mWidget;
+  RefPtr<wr::WebRenderAPI> mApi;
+  RefPtr<AsyncImagePipelineManager> mAsyncImageManager;
+  RefPtr<CompositorVsyncScheduler> mCompositorScheduler;
+  // mActiveAnimations is used to avoid leaking animations when
+  // WebRenderBridgeParent is destroyed abnormally and Tab move between
+  // different windows.
+  std::unordered_map<uint64_t, wr::Epoch> mActiveAnimations;
+  std::unordered_map<uint64_t, RefPtr<WebRenderImageHost>> mAsyncCompositables;
+  std::unordered_map<uint64_t, CompositableTextureHostRef> mTextureHosts;
+  std::unordered_map<uint64_t, wr::ExternalImageId> mSharedSurfaceIds;
+
+  TimeDuration mVsyncRate;
+  TimeStamp mPreviousFrameTimeStamp;
+
+  std::deque<PendingTransactionId> mPendingTransactionIds;
+  std::queue<CompositorAnimationIdsForEpoch> mCompositorAnimationsToDelete;
+  wr::Epoch mWrEpoch;
+  wr::IdNamespace mIdNamespace;
+  CompositionOpportunityId mCompositionOpportunityId;
+  nsCString mInitError;
+
+  TimeStamp mMostRecentComposite;
+
+  RefPtr<WebRenderBridgeParentRef> mWebRenderBridgeRef;
+
+#if defined(MOZ_WIDGET_ANDROID)
+  UiCompositorControllerParent* mScreenPixelsTarget;
+#endif
+  uint32_t mBoolParameterBits;
+  uint16_t mBlobTileSize;
+  wr::RenderReasons mSkippedCompositeReasons;
+  bool mDestroyed;
+  bool mIsFirstPaint;
+  bool mLastNotifiedHasLayers = false;
+  bool mReceivedDisplayList = false;
+  bool mSkippedComposite = false;
+  bool mDisablingNativeCompositor = false;
+  // These payloads are being used for SCROLL_PRESENT_LATENCY telemetry
+  DataMutex<nsClassHashtable<nsUint64HashKey, nsTArray<CompositionPayload>>>
+      mPendingScrollPayloads;
+
+  RefPtr<RemoteTextureTxnScheduler> mRemoteTextureTxnScheduler;
+};
+
+// Use this class, since WebRenderBridgeParent could not supports
+// ThreadSafeWeakPtr.
+// This class provides a ref of WebRenderBridgeParent when
+// the WebRenderBridgeParent is not destroyed. Then it works similar to
+// weak pointer.
+class WebRenderBridgeParentRef final {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderBridgeParentRef)
+
+  explicit WebRenderBridgeParentRef(WebRenderBridgeParent* aWebRenderBridge);
+
+  RefPtr<WebRenderBridgeParent> WrBridge();
+  void Clear();
+
+ protected:
+  ~WebRenderBridgeParentRef();
+
+  RefPtr<WebRenderBridgeParent> mWebRenderBridge;
+};
+
+}  // namespace layers
+}  // namespace mozilla
+
+#endif  // mozilla_layers_WebRenderBridgeParent_h