WebRenderLayerManager.h (10457B)
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 GFX_WEBRENDERLAYERMANAGER_H 8 #define GFX_WEBRENDERLAYERMANAGER_H 9 10 #include <cstddef> // for size_t 11 #include <cstdint> // for uint32_t, int32_t, INT32_MAX 12 #include <string> // for string 13 #include "Units.h" // for LayoutDeviceIntSize 14 #include "mozilla/AlreadyAddRefed.h" // for already_AddRefed 15 #include "mozilla/Assertions.h" // for AssertionConditionType, MOZ_ASSERT, MOZ_ASSERT_HELPER2 16 #include "mozilla/Attributes.h" // for MOZ_NON_OWNING_REF 17 #include "mozilla/RefPtr.h" // for RefPtr 18 #include "mozilla/TimeStamp.h" // for TimeStamp 19 #include "mozilla/gfx/Point.h" // for IntSize 20 #include "mozilla/gfx/Types.h" // for SurfaceFormat 21 #include "mozilla/layers/CompositorTypes.h" // for TextureFactoryIdentifier 22 #include "mozilla/layers/DisplayItemCache.h" // for DisplayItemCache 23 #include "mozilla/layers/FocusTarget.h" // for FocusTarget 24 #include "mozilla/layers/LayersTypes.h" // for TransactionId, LayersBackend, CompositionPayload (ptr only), LayersBackend::... 25 #include "mozilla/layers/RenderRootStateManager.h" // for RenderRootStateManager 26 #include "mozilla/layers/ScrollableLayerGuid.h" // for ScrollableLayerGuid, ScrollableLayerGuid::ViewID 27 #include "mozilla/layers/WebRenderCommandBuilder.h" // for WebRenderCommandBuilder 28 #include "mozilla/layers/WebRenderScrollData.h" // for WebRenderScrollData 29 #include "WindowRenderer.h" 30 #include "nsHashKeys.h" // for nsRefPtrHashKey 31 #include "nsRegion.h" // for nsIntRegion 32 #include "nsStringFwd.h" // for nsCString, nsAString 33 #include "nsTArray.h" // for nsTArray 34 #include "nsTHashSet.h" 35 36 class gfxContext; 37 class nsIWidget; 38 39 namespace mozilla { 40 41 class nsDisplayList; 42 class nsDisplayListBuilder; 43 struct ActiveScrolledRoot; 44 45 namespace layers { 46 47 class APZTestData; 48 class CompositorBridgeChild; 49 class KnowsCompositor; 50 class Layer; 51 class PCompositorBridgeChild; 52 class WebRenderBridgeChild; 53 class WebRenderParentCommand; 54 class TransactionIdAllocator; 55 class LayerUserData; 56 57 class WebRenderLayerManager final : public WindowRenderer { 58 typedef nsTHashSet<RefPtr<WebRenderUserData>> WebRenderUserDataRefTable; 59 60 NS_INLINE_DECL_REFCOUNTING(WebRenderLayerManager, final) 61 62 public: 63 explicit WebRenderLayerManager(nsIWidget* aWidget); 64 bool Initialize(PCompositorBridgeChild* aCBChild, wr::PipelineId aLayersId, 65 TextureFactoryIdentifier* aTextureFactoryIdentifier, 66 nsCString& aError); 67 68 void Destroy() override; 69 bool IsDestroyed() { return mDestroyed; } 70 71 void DoDestroy(bool aIsSync); 72 73 protected: 74 virtual ~WebRenderLayerManager(); 75 76 public: 77 KnowsCompositor* AsKnowsCompositor() override; 78 WebRenderLayerManager* AsWebRender() override { return this; } 79 CompositorBridgeChild* GetCompositorBridgeChild() override; 80 81 // WebRender can handle images larger than the max texture size via tiling. 82 int32_t GetMaxTextureSize() const override { return INT32_MAX; } 83 84 bool BeginTransactionWithTarget(gfxContext* aTarget, const nsCString& aURL); 85 bool BeginTransaction(const nsCString& aURL) override; 86 bool EndEmptyTransaction(EndTransactionFlags aFlags = END_DEFAULT) override; 87 void EndTransactionWithoutLayer(nsDisplayList* aDisplayList, 88 nsDisplayListBuilder* aDisplayListBuilder, 89 WrFiltersHolder&& aFilters, 90 WebRenderBackgroundData* aBackground, 91 const double aGeckoDLBuildTime, 92 bool aRenderOffscreen); 93 94 LayersBackend GetBackendType() override { return LayersBackend::LAYERS_WR; } 95 void GetBackendName(nsAString& name) override; 96 97 bool NeedsWidgetInvalidation() override { return false; } 98 99 bool AddPendingScrollUpdateForNextTransaction( 100 ScrollableLayerGuid::ViewID aScrollId, 101 const ScrollPositionUpdate& aUpdateInfo) override; 102 103 void DidComposite(TransactionId aTransactionId, 104 const mozilla::TimeStamp& aCompositeStart, 105 const mozilla::TimeStamp& aCompositeEnd); 106 107 void ClearCachedResources(); 108 void UpdateTextureFactoryIdentifier( 109 const TextureFactoryIdentifier& aNewIdentifier); 110 TextureFactoryIdentifier GetTextureFactoryIdentifier(); 111 112 void SetTransactionIdAllocator(TransactionIdAllocator* aAllocator); 113 TransactionId GetLastTransactionId(); 114 115 void FlushRendering(wr::RenderReasons aReasons) override; 116 void WaitOnTransactionProcessed() override; 117 118 void SendInvalidRegion(const nsIntRegion& aRegion); 119 120 void ScheduleComposite(wr::RenderReasons aReasons); 121 122 void SetNeedsComposite(bool aNeedsComposite) { 123 mNeedsComposite = aNeedsComposite; 124 } 125 bool NeedsComposite() const { return mNeedsComposite; } 126 void SetIsFirstPaint() { mIsFirstPaint = true; } 127 bool GetIsFirstPaint() const { return mIsFirstPaint; } 128 void SetFocusTarget(const FocusTarget& aFocusTarget); 129 130 already_AddRefed<PersistentBufferProvider> CreatePersistentBufferProvider( 131 const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat, 132 bool aWillReadFrequently) override; 133 134 bool AsyncPanZoomEnabled() const; 135 136 // adds an imagekey to a list of keys that will be discarded on the next 137 // transaction or destruction 138 void DiscardImages(); 139 void DiscardLocalImages(); 140 141 void ClearAsyncAnimations(); 142 void WrReleasedImages(const nsTArray<wr::ExternalImageKeyPair>& aPairs); 143 144 WebRenderBridgeChild* WrBridge() const { return mWrChild; } 145 146 // See equivalent function in ClientLayerManager 147 void LogTestDataForCurrentPaint(ScrollableLayerGuid::ViewID aScrollId, 148 const std::string& aKey, 149 const std::string& aValue); 150 void LogAdditionalTestData(const std::string& aKey, 151 const std::string& aValue); 152 153 // See equivalent function in ClientLayerManager 154 const APZTestData& GetAPZTestData() const { return *mApzTestData.get(); } 155 156 WebRenderCommandBuilder& CommandBuilder() { return mWebRenderCommandBuilder; } 157 WebRenderUserDataRefTable* GetWebRenderUserDataTable() { 158 return mWebRenderCommandBuilder.GetWebRenderUserDataTable(); 159 } 160 WebRenderScrollData& GetScrollData() { return mScrollData; } 161 162 void WrUpdated(); 163 nsIWidget* GetWidget() { return mWidget; } 164 165 uint32_t StartFrameTimeRecording(int32_t aBufferSize) override; 166 void StopFrameTimeRecording(uint32_t aStartIndex, 167 nsTArray<float>& aFrameIntervals) override; 168 169 RenderRootStateManager* GetRenderRootStateManager() { return &mStateManager; } 170 171 void TakeCompositionPayloads(nsTArray<CompositionPayload>& aPayloads); 172 173 void GetFrameUniformity(FrameUniformityData* aOutData) override; 174 175 void RegisterPayloads(nsTArray<CompositionPayload>&& aPayloads) { 176 mPayload.AppendElements(std::move(aPayloads)); 177 MOZ_ASSERT(mPayload.Length() < 10000); 178 } 179 180 static void LayerUserDataDestroy(void* data); 181 /** 182 * This setter can be used anytime. The user data for all keys is 183 * initially null. Ownership pases to the layer manager. 184 */ 185 void SetUserData(void* aKey, LayerUserData* aData) { 186 mUserData.Add(static_cast<gfx::UserDataKey*>(aKey), aData, 187 LayerUserDataDestroy); 188 } 189 /** 190 * This can be used anytime. Ownership passes to the caller! 191 */ 192 UniquePtr<LayerUserData> RemoveUserData(void* aKey); 193 194 /** 195 * This getter can be used anytime. 196 */ 197 bool HasUserData(void* aKey) { 198 return mUserData.Has(static_cast<gfx::UserDataKey*>(aKey)); 199 } 200 /** 201 * This getter can be used anytime. Ownership is retained by the layer 202 * manager. 203 */ 204 LayerUserData* GetUserData(void* aKey) const { 205 return static_cast<LayerUserData*>( 206 mUserData.Get(static_cast<gfx::UserDataKey*>(aKey))); 207 } 208 209 void ClearAndNotifyOfFullTransactionPendingScrollInfoUpdate(); 210 211 #ifdef DEBUG 212 gfxContext* GetTarget() const { return mTarget; } 213 #endif 214 215 private: 216 /** 217 * Take a snapshot of the parent context, and copy 218 * it into mTarget. 219 */ 220 void MakeSnapshotIfRequired(LayoutDeviceIntSize aSize); 221 222 private: 223 nsIWidget* MOZ_NON_OWNING_REF mWidget; 224 225 RefPtr<WebRenderBridgeChild> mWrChild; 226 bool mHasFlushedThisChild; 227 228 RefPtr<TransactionIdAllocator> mTransactionIdAllocator; 229 TransactionId mLatestTransactionId; 230 231 gfx::UserData mUserData; 232 233 // This holds the scroll data that we need to send to the compositor for 234 // APZ to do it's job 235 WebRenderScrollData mScrollData; 236 237 bool mNeedsComposite; 238 bool mIsFirstPaint; 239 bool mDestroyed; 240 FocusTarget mFocusTarget; 241 242 // The payload associated with currently pending painting work, for 243 // client layer managers that typically means payload that is part of the 244 // 'upcoming transaction', for HostLayerManagers this typically means 245 // what has been included in received transactions to be presented on the 246 // next composite. 247 // IMPORTANT: Clients should take care to clear this or risk it slowly 248 // growing out of control. 249 nsTArray<CompositionPayload> mPayload; 250 251 // When we're doing a transaction in order to draw to a non-default 252 // target, the layers transaction is only performed in order to send 253 // a PLayers:Update. We save the original non-default target to 254 // mTarget, and then perform the transaction. After the transaction ends, 255 // we send a message to our remote side to capture the actual pixels 256 // being drawn to the default target, and then copy those pixels 257 // back to mTarget. 258 gfxContext* mTarget; 259 260 // See equivalent field in ClientLayerManager 261 uint32_t mPaintSequenceNumber; 262 // See equivalent field in ClientLayerManager 263 const std::unique_ptr<APZTestData> mApzTestData; 264 265 TimeStamp mTransactionStart; 266 nsCString mURL; 267 WebRenderCommandBuilder mWebRenderCommandBuilder; 268 269 RenderRootStateManager mStateManager; 270 DisplayItemCache mDisplayItemCache; 271 UniquePtr<wr::DisplayListBuilder> mDLBuilder; 272 273 ScrollUpdatesMap mPendingScrollUpdates; 274 275 LayoutDeviceIntSize mFlushWidgetSize; 276 }; 277 278 } // namespace layers 279 } // namespace mozilla 280 281 #endif /* GFX_WEBRENDERLAYERMANAGER_H */