WebRenderBridgeParent.h (21009B)
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */ 3 /* This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this 5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #ifndef mozilla_layers_WebRenderBridgeParent_h 8 #define mozilla_layers_WebRenderBridgeParent_h 9 10 #include <unordered_map> 11 12 #include "CompositableHost.h" // for CompositableHost, ImageCompositeNotificationInfo 13 #include "GLContextProvider.h" 14 #include "mozilla/DataMutex.h" 15 #include "mozilla/layers/CompositableTransactionParent.h" 16 #include "mozilla/layers/CompositorVsyncSchedulerOwner.h" 17 #include "mozilla/layers/PWebRenderBridgeParent.h" 18 #include "mozilla/Maybe.h" 19 #include "mozilla/UniquePtr.h" 20 #include "mozilla/webrender/WebRenderTypes.h" 21 #include "mozilla/webrender/WebRenderAPI.h" 22 #include "nsTArrayForwardDeclare.h" 23 #include "WindowRenderer.h" 24 25 namespace mozilla { 26 27 namespace gl { 28 class GLContext; 29 } 30 31 namespace widget { 32 class CompositorWidget; 33 } 34 35 namespace wr { 36 class WebRenderAPI; 37 class WebRenderPipelineInfo; 38 } // namespace wr 39 40 namespace layers { 41 42 class AsyncImagePipelineManager; 43 class Compositor; 44 class CompositorBridgeParentBase; 45 class CompositorVsyncScheduler; 46 class OMTASampler; 47 class RemoteTextureTxnScheduler; 48 class UiCompositorControllerParent; 49 class WebRenderBridgeParentRef; 50 class WebRenderImageHost; 51 struct WrAnimations; 52 53 struct CompositorAnimationIdsForEpoch { 54 CompositorAnimationIdsForEpoch(const wr::Epoch& aEpoch, 55 nsTArray<uint64_t>&& aIds) 56 : mEpoch(aEpoch), mIds(std::move(aIds)) {} 57 58 wr::Epoch mEpoch; 59 nsTArray<uint64_t> mIds; 60 }; 61 62 class WebRenderBridgeParent final : public PWebRenderBridgeParent, 63 public CompositorVsyncSchedulerOwner, 64 public CompositableParentManager, 65 public FrameRecorder { 66 public: 67 WebRenderBridgeParent(CompositorBridgeParentBase* aCompositorBridge, 68 const wr::PipelineId& aPipelineId, 69 widget::CompositorWidget* aWidget, 70 CompositorVsyncScheduler* aScheduler, 71 RefPtr<wr::WebRenderAPI>&& aApi, 72 RefPtr<AsyncImagePipelineManager>&& aImageMgr, 73 TimeDuration aVsyncRate); 74 75 static WebRenderBridgeParent* CreateDestroyed( 76 const wr::PipelineId& aPipelineId, nsCString&& aError); 77 78 wr::PipelineId PipelineId() { return mPipelineId; } 79 already_AddRefed<wr::WebRenderAPI> GetWebRenderAPI() { 80 return do_AddRef(mApi); 81 } 82 AsyncImagePipelineManager* AsyncImageManager() { return mAsyncImageManager; } 83 CompositorVsyncScheduler* CompositorScheduler() { 84 return mCompositorScheduler.get(); 85 } 86 CompositorBridgeParentBase* GetCompositorBridge() { 87 return mCompositorBridge; 88 } 89 90 void UpdateQualitySettings(); 91 void UpdateDebugFlags(); 92 void UpdateParameters(); 93 void UpdateBoolParameters(); 94 void UpdateProfilerUI(); 95 96 mozilla::ipc::IPCResult RecvEnsureConnected( 97 TextureFactoryIdentifier* aTextureFactoryIdentifier, 98 MaybeIdNamespace* aMaybeIdNamespace, nsCString* aError) override; 99 100 mozilla::ipc::IPCResult RecvNewCompositable( 101 const CompositableHandle& aHandle, const TextureInfo& aInfo) override; 102 mozilla::ipc::IPCResult RecvReleaseCompositable( 103 const CompositableHandle& aHandle) override; 104 105 mozilla::ipc::IPCResult RecvShutdown() override; 106 mozilla::ipc::IPCResult RecvShutdownSync() override; 107 mozilla::ipc::IPCResult RecvDeleteCompositorAnimations( 108 nsTArray<uint64_t>&& aIds) override; 109 mozilla::ipc::IPCResult RecvUpdateResources( 110 const wr::IdNamespace& aIdNamespace, 111 nsTArray<OpUpdateResource>&& aUpdates, 112 nsTArray<RefCountedShmem>&& aSmallShmems, 113 nsTArray<ipc::Shmem>&& aLargeShmems) override; 114 mozilla::ipc::IPCResult RecvSetDisplayList( 115 DisplayListData&& aDisplayList, nsTArray<OpDestroy>&& aToDestroy, 116 const uint64_t& aFwdTransactionId, const TransactionId& aTransactionId, 117 const bool& aContainsSVGGroup, const VsyncId& aVsyncId, 118 const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime, 119 const TimeStamp& aTxnStartTime, const nsACString& aTxnURL, 120 const TimeStamp& aFwdTime, nsTArray<CompositionPayload>&& aPayloads, 121 const bool& aRenderOffscreen) override; 122 mozilla::ipc::IPCResult RecvEmptyTransaction( 123 const FocusTarget& aFocusTarget, 124 Maybe<TransactionData>&& aTransactionData, 125 nsTArray<OpDestroy>&& aToDestroy, const uint64_t& aFwdTransactionId, 126 const TransactionId& aTransactionId, const VsyncId& aVsyncId, 127 const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime, 128 const TimeStamp& aTxnStartTime, const nsACString& aTxnURL, 129 const TimeStamp& aFwdTime, 130 nsTArray<CompositionPayload>&& aPayloads) override; 131 mozilla::ipc::IPCResult RecvSetFocusTarget( 132 const FocusTarget& aFocusTarget) override; 133 mozilla::ipc::IPCResult RecvParentCommands( 134 const wr::IdNamespace& aIdNamespace, 135 nsTArray<WebRenderParentCommand>&& commands) override; 136 mozilla::ipc::IPCResult RecvGetSnapshot(NotNull<PTextureParent*> aTexture, 137 bool* aNeedsYFlip) override; 138 139 mozilla::ipc::IPCResult RecvClearCachedResources() override; 140 mozilla::ipc::IPCResult RecvInvalidateRenderedFrame() override; 141 mozilla::ipc::IPCResult RecvScheduleComposite( 142 const wr::RenderReasons& aReasons) override; 143 mozilla::ipc::IPCResult RecvCapture() override; 144 mozilla::ipc::IPCResult RecvStartCaptureSequence( 145 const nsACString& path, const uint32_t& aFlags) override; 146 mozilla::ipc::IPCResult RecvStopCaptureSequence() override; 147 mozilla::ipc::IPCResult RecvSyncWithCompositor() override; 148 149 mozilla::ipc::IPCResult RecvSetConfirmedTargetAPZC( 150 const uint64_t& aBlockId, 151 nsTArray<ScrollableLayerGuid>&& aTargets) override; 152 153 mozilla::ipc::IPCResult RecvSetTestSampleTime( 154 const TimeStamp& aTime) override; 155 mozilla::ipc::IPCResult RecvLeaveTestMode() override; 156 mozilla::ipc::IPCResult RecvGetAnimationValue( 157 const uint64_t& aCompositorAnimationsId, OMTAValue* aValue) override; 158 mozilla::ipc::IPCResult RecvSetAsyncScrollOffset( 159 const ScrollableLayerGuid::ViewID& aScrollId, const float& aX, 160 const float& aY) override; 161 mozilla::ipc::IPCResult RecvSetAsyncZoom( 162 const ScrollableLayerGuid::ViewID& aScrollId, 163 const float& aZoom) override; 164 mozilla::ipc::IPCResult RecvFlushApzRepaints() override; 165 mozilla::ipc::IPCResult RecvGetAPZTestData(APZTestData* data) override; 166 mozilla::ipc::IPCResult RecvGetFrameUniformity( 167 FrameUniformityData* aOutData) override; 168 mozilla::ipc::IPCResult RecvEndWheelTransaction( 169 PWebRenderBridgeParent::EndWheelTransactionResolver&& aResolve) override; 170 171 void ActorDestroy(ActorDestroyReason aWhy) override; 172 173 mozilla::ipc::IPCResult RecvSetDefaultClearColor( 174 const uint32_t& aColor) override; 175 void SetClearColor(const gfx::DeviceColor& aColor); 176 177 void Pause(); 178 bool Resume(); 179 180 void Destroy(); 181 182 // CompositorVsyncSchedulerOwner 183 bool IsPendingComposite() override { return false; } 184 void FinishPendingComposite() override {} 185 void CompositeToTarget(VsyncId aId, wr::RenderReasons aReasons, 186 gfx::DrawTarget* aTarget, 187 const gfx::IntRect* aRect = nullptr) override; 188 TimeDuration GetVsyncInterval() const override; 189 190 // CompositableParentManager 191 bool IsSameProcess() const override; 192 base::ProcessId GetChildProcessId() override; 193 dom::ContentParentId GetContentId() override; 194 void NotifyNotUsed(PTextureParent* aTexture, 195 uint64_t aTransactionId) override; 196 void SendAsyncMessage( 197 const nsTArray<AsyncParentMessageData>& aMessage) override; 198 void SendPendingAsyncMessages() override; 199 void SetAboutToSendAsyncMessages() override; 200 201 void HoldPendingTransactionId( 202 const wr::Epoch& aWrEpoch, TransactionId aTransactionId, 203 bool aContainsSVGGroup, const VsyncId& aVsyncId, 204 const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime, 205 const TimeStamp& aTxnStartTime, const nsACString& aTxnURL, 206 const TimeStamp& aFwdTime, const bool aIsFirstPaint, 207 nsTArray<CompositionPayload>&& aPayloads, 208 const bool aUseForTelemetry = true); 209 TransactionId LastPendingTransactionId(); 210 void FlushTransactionIdsForEpoch( 211 const wr::Epoch& aEpoch, const VsyncId& aCompositeStartId, 212 const TimeStamp& aCompositeStartTime, const TimeStamp& aRenderStartTime, 213 const TimeStamp& aEndTime, UiCompositorControllerParent* aUiController, 214 wr::RendererStats* aStats, nsTArray<FrameStats>& aOutputStats, 215 nsTArray<TransactionId>& aOutputTransactions); 216 void NotifySceneBuiltForEpoch(const wr::Epoch& aEpoch, 217 const TimeStamp& aEndTime); 218 219 void RetrySkippedComposite(); 220 221 TextureFactoryIdentifier GetTextureFactoryIdentifier(); 222 223 void ExtractImageCompositeNotifications( 224 nsTArray<ImageCompositeNotificationInfo>* aNotifications); 225 226 wr::Epoch GetCurrentEpoch() const { return mWrEpoch; } 227 wr::IdNamespace GetIdNamespace() { return mIdNamespace; } 228 229 bool MatchesNamespace(const wr::ImageKey& aImageKey) const { 230 return aImageKey.mNamespace == mIdNamespace; 231 } 232 233 bool MatchesNamespace(const wr::BlobImageKey& aBlobKey) const { 234 return MatchesNamespace(wr::AsImageKey(aBlobKey)); 235 } 236 237 bool MatchesNamespace(const wr::SnapshotImageKey& aSnapshotKey) const { 238 return MatchesNamespace(wr::AsImageKey(aSnapshotKey)); 239 } 240 241 bool MatchesNamespace(const wr::FontKey& aFontKey) const { 242 return aFontKey.mNamespace == mIdNamespace; 243 } 244 245 bool MatchesNamespace(const wr::FontInstanceKey& aFontKey) const { 246 return aFontKey.mNamespace == mIdNamespace; 247 } 248 249 void FlushRendering(wr::RenderReasons aReasons, bool aBlocking); 250 251 /** 252 * Schedule generating WebRender frame definitely at next composite timing. 253 * 254 * WebRenderBridgeParent uses composite timing to check if there is an update 255 * to AsyncImagePipelines. If there is no update, WebRenderBridgeParent skips 256 * to generate frame. If we need to generate new frame at next composite 257 * timing, call this method. 258 * 259 * Call CompositorVsyncScheduler::ScheduleComposition() directly, if we just 260 * want to trigger AsyncImagePipelines update checks. 261 */ 262 void ScheduleGenerateFrame(wr::RenderReasons aReason); 263 264 /** 265 * Invalidate rendered frame. 266 * 267 * WebRender could skip frame rendering if there is no update. 268 * This function is used to force invalidating even when there is no update. 269 */ 270 void InvalidateRenderedFrame(wr::RenderReasons aReasons); 271 272 /** 273 * Schedule forced frame rendering at next composite timing. 274 * 275 * WebRender could skip frame rendering if there is no update. 276 * This function is used to force rendering even when there is no update. 277 */ 278 void ScheduleForcedGenerateFrame(wr::RenderReasons aReasons); 279 280 void ScheduleFrameAfterSceneBuild( 281 RefPtr<const wr::WebRenderPipelineInfo> aInfo); 282 283 wr::Epoch UpdateWebRender( 284 CompositorVsyncScheduler* aScheduler, RefPtr<wr::WebRenderAPI>&& aApi, 285 AsyncImagePipelineManager* aImageMgr, 286 const TextureFactoryIdentifier& aTextureFactoryIdentifier); 287 288 void RemoveEpochDataPriorTo(const wr::Epoch& aRenderedEpoch); 289 290 bool IsRootWebRenderBridgeParent() const; 291 LayersId GetLayersId() const; 292 293 void BeginRecording(const TimeStamp& aRecordingStart); 294 295 #if defined(MOZ_WIDGET_ANDROID) 296 /** 297 * Request a screengrab for android 298 */ 299 void RequestScreenPixels(UiCompositorControllerParent* aController); 300 void MaybeCaptureScreenPixels(); 301 #endif 302 /** 303 * Stop recording and the frames collected since the call to BeginRecording 304 */ 305 RefPtr<wr::WebRenderAPI::EndRecordingPromise> EndRecording(); 306 307 void DisableNativeCompositor(); 308 void AddPendingScrollPayload(CompositionPayload& aPayload, 309 const VsyncId& aCompositeStartId); 310 311 nsTArray<CompositionPayload> TakePendingScrollPayload( 312 const VsyncId& aCompositeStartId); 313 314 RefPtr<WebRenderBridgeParentRef> GetWebRenderBridgeParentRef(); 315 316 void FlushPendingWrTransactionEventsWithWait(); 317 318 private: 319 class ScheduleSharedSurfaceRelease; 320 321 WebRenderBridgeParent(const wr::PipelineId& aPipelineId, nsCString&& aError); 322 virtual ~WebRenderBridgeParent(); 323 324 bool ProcessEmptyTransactionUpdates(TransactionData& aData, 325 bool* aScheduleComposite); 326 327 bool ProcessDisplayListData(DisplayListData& aDisplayList, wr::Epoch aWrEpoch, 328 const TimeStamp& aTxnStartTime, 329 bool aValidTransaction, bool aRenderOffscreen, 330 const VsyncId& aVsyncId); 331 332 bool SetDisplayList(const LayoutDeviceRect& aRect, ipc::ByteBuf&& aDLItems, 333 ipc::ByteBuf&& aDLCache, ipc::ByteBuf&& aSpatialTreeDL, 334 const wr::BuiltDisplayListDescriptor& aDLDesc, 335 const nsTArray<OpUpdateResource>& aResourceUpdates, 336 const nsTArray<RefCountedShmem>& aSmallShmems, 337 const nsTArray<ipc::Shmem>& aLargeShmems, 338 const TimeStamp& aTxnStartTime, 339 wr::TransactionBuilder& aTxn, wr::Epoch aWrEpoch, 340 const VsyncId& aVsyncId, bool aRenderOffscreen); 341 342 void UpdateAPZFocusState(const FocusTarget& aFocus); 343 void UpdateAPZScrollData(const wr::Epoch& aEpoch, 344 WebRenderScrollData&& aData); 345 void UpdateAPZScrollOffsets(ScrollUpdatesMap&& aUpdates, 346 uint32_t aPaintSequenceNumber); 347 348 bool UpdateResources(const nsTArray<OpUpdateResource>& aResourceUpdates, 349 const nsTArray<RefCountedShmem>& aSmallShmems, 350 const nsTArray<ipc::Shmem>& aLargeShmems, 351 wr::TransactionBuilder& aUpdates); 352 bool AddSharedExternalImage(wr::ExternalImageId aExtId, wr::ImageKey aKey, 353 wr::TransactionBuilder& aResources); 354 bool UpdateSharedExternalImage( 355 wr::ExternalImageId aExtId, wr::ImageKey aKey, 356 const ImageIntRect& aDirtyRect, wr::TransactionBuilder& aResources, 357 UniquePtr<ScheduleSharedSurfaceRelease>& aScheduleRelease); 358 void ObserveSharedSurfaceRelease( 359 const nsTArray<wr::ExternalImageKeyPair>& aPairs, 360 const bool& aFromCheckpoint); 361 362 bool PushExternalImageForTexture(wr::ExternalImageId aExtId, 363 wr::ImageKey aKey, TextureHost* aTexture, 364 bool aIsUpdate, 365 wr::TransactionBuilder& aResources); 366 367 void AddPipelineIdForCompositable(const wr::PipelineId& aPipelineIds, 368 const CompositableHandle& aHandle, 369 const CompositableHandleOwner& aOwner, 370 wr::TransactionBuilder& aTxn, 371 wr::TransactionBuilder& aTxnForImageBridge); 372 void RemovePipelineIdForCompositable(const wr::PipelineId& aPipelineId, 373 AsyncImagePipelineOps* aPendingOps, 374 wr::TransactionBuilder& aTxn); 375 376 void DeleteImage(const wr::ImageKey& aKey, wr::TransactionBuilder& aUpdates); 377 void ReleaseTextureOfImage(const wr::ImageKey& aKey); 378 379 bool ProcessWebRenderParentCommands( 380 const nsTArray<WebRenderParentCommand>& aCommands, 381 wr::TransactionBuilder& aTxn); 382 383 void ClearResources(); 384 void ClearAnimationResources(); 385 mozilla::ipc::IPCResult HandleShutdown(); 386 387 void MaybeNotifyOfLayers(wr::TransactionBuilder&, bool aWillHaveLayers); 388 389 void ResetPreviousSampleTime(); 390 391 void SetOMTASampleTime(); 392 RefPtr<OMTASampler> GetOMTASampler() const; 393 394 CompositorBridgeParent* GetRootCompositorBridgeParent() const; 395 396 RefPtr<WebRenderBridgeParent> GetRootWebRenderBridgeParent() const; 397 398 // Tell APZ what the subsequent sampling's timestamp should be. 399 void SetAPZSampleTime(); 400 401 wr::Epoch GetNextWrEpoch(); 402 // This function is expected to be used when GetNextWrEpoch() is called, 403 // but TransactionBuilder does not have resource updates nor display list. 404 // In this case, ScheduleGenerateFrame is not triggered via SceneBuilder. 405 // Then we want to rollback WrEpoch. See Bug 1490117. 406 void RollbackWrEpoch(); 407 408 void FlushSceneBuilds(); 409 void FlushFrameGeneration(wr::RenderReasons aReasons); 410 void FlushFramePresentation(); 411 412 void MaybeGenerateFrame(VsyncId aId, bool aForceGenerateFrame, 413 wr::RenderReasons aReasons); 414 415 VsyncId GetVsyncIdForEpoch(const wr::Epoch& aEpoch) { 416 for (auto& id : mPendingTransactionIds) { 417 if (id.mEpoch.mHandle == aEpoch.mHandle) { 418 return id.mVsyncId; 419 } 420 } 421 return VsyncId(); 422 } 423 424 private: 425 struct PendingTransactionId { 426 PendingTransactionId(const wr::Epoch& aEpoch, TransactionId aId, 427 bool aContainsSVGGroup, const VsyncId& aVsyncId, 428 const TimeStamp& aVsyncStartTime, 429 const TimeStamp& aRefreshStartTime, 430 const TimeStamp& aTxnStartTime, 431 const nsACString& aTxnURL, const TimeStamp& aFwdTime, 432 const bool aIsFirstPaint, const bool aUseForTelemetry, 433 nsTArray<CompositionPayload>&& aPayloads) 434 : mEpoch(aEpoch), 435 mId(aId), 436 mVsyncId(aVsyncId), 437 mVsyncStartTime(aVsyncStartTime), 438 mRefreshStartTime(aRefreshStartTime), 439 mTxnStartTime(aTxnStartTime), 440 mTxnURL(aTxnURL), 441 mFwdTime(aFwdTime), 442 mSkippedComposites(0), 443 mContainsSVGGroup(aContainsSVGGroup), 444 mIsFirstPaint(aIsFirstPaint), 445 mUseForTelemetry(aUseForTelemetry), 446 mPayloads(std::move(aPayloads)) {} 447 wr::Epoch mEpoch; 448 TransactionId mId; 449 VsyncId mVsyncId; 450 TimeStamp mVsyncStartTime; 451 TimeStamp mRefreshStartTime; 452 TimeStamp mTxnStartTime; 453 nsCString mTxnURL; 454 TimeStamp mFwdTime; 455 TimeStamp mSceneBuiltTime; 456 uint32_t mSkippedComposites; 457 bool mContainsSVGGroup; 458 bool mIsFirstPaint; 459 bool mUseForTelemetry; 460 nsTArray<CompositionPayload> mPayloads; 461 }; 462 463 CompositorBridgeParentBase* MOZ_NON_OWNING_REF mCompositorBridge; 464 wr::PipelineId mPipelineId; 465 RefPtr<widget::CompositorWidget> mWidget; 466 RefPtr<wr::WebRenderAPI> mApi; 467 RefPtr<AsyncImagePipelineManager> mAsyncImageManager; 468 RefPtr<CompositorVsyncScheduler> mCompositorScheduler; 469 // mActiveAnimations is used to avoid leaking animations when 470 // WebRenderBridgeParent is destroyed abnormally and Tab move between 471 // different windows. 472 std::unordered_map<uint64_t, wr::Epoch> mActiveAnimations; 473 std::unordered_map<uint64_t, RefPtr<WebRenderImageHost>> mAsyncCompositables; 474 std::unordered_map<uint64_t, CompositableTextureHostRef> mTextureHosts; 475 std::unordered_map<uint64_t, wr::ExternalImageId> mSharedSurfaceIds; 476 477 TimeDuration mVsyncRate; 478 TimeStamp mPreviousFrameTimeStamp; 479 480 std::deque<PendingTransactionId> mPendingTransactionIds; 481 std::queue<CompositorAnimationIdsForEpoch> mCompositorAnimationsToDelete; 482 wr::Epoch mWrEpoch; 483 wr::IdNamespace mIdNamespace; 484 CompositionOpportunityId mCompositionOpportunityId; 485 nsCString mInitError; 486 487 TimeStamp mMostRecentComposite; 488 489 RefPtr<WebRenderBridgeParentRef> mWebRenderBridgeRef; 490 491 #if defined(MOZ_WIDGET_ANDROID) 492 UiCompositorControllerParent* mScreenPixelsTarget; 493 #endif 494 uint32_t mBoolParameterBits; 495 uint16_t mBlobTileSize; 496 wr::RenderReasons mSkippedCompositeReasons; 497 bool mDestroyed; 498 bool mIsFirstPaint; 499 bool mLastNotifiedHasLayers = false; 500 bool mReceivedDisplayList = false; 501 bool mSkippedComposite = false; 502 bool mDisablingNativeCompositor = false; 503 // These payloads are being used for SCROLL_PRESENT_LATENCY telemetry 504 DataMutex<nsClassHashtable<nsUint64HashKey, nsTArray<CompositionPayload>>> 505 mPendingScrollPayloads; 506 507 RefPtr<RemoteTextureTxnScheduler> mRemoteTextureTxnScheduler; 508 }; 509 510 // Use this class, since WebRenderBridgeParent could not supports 511 // ThreadSafeWeakPtr. 512 // This class provides a ref of WebRenderBridgeParent when 513 // the WebRenderBridgeParent is not destroyed. Then it works similar to 514 // weak pointer. 515 class WebRenderBridgeParentRef final { 516 public: 517 NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebRenderBridgeParentRef) 518 519 explicit WebRenderBridgeParentRef(WebRenderBridgeParent* aWebRenderBridge); 520 521 RefPtr<WebRenderBridgeParent> WrBridge(); 522 void Clear(); 523 524 protected: 525 ~WebRenderBridgeParentRef(); 526 527 RefPtr<WebRenderBridgeParent> mWebRenderBridge; 528 }; 529 530 } // namespace layers 531 } // namespace mozilla 532 533 #endif // mozilla_layers_WebRenderBridgeParent_h