gfx/layers/wr/WebRenderLayerManager.cpp
changeset 591057 1b49e7328ae43c6565d167f4c391430575097fd3
parent 591044 96aa4b688465e7a822cf4012a2c1397cc3cd7e93
child 593678 4ad22daf744b49726e02bcf489591fd8edb96a25
equal deleted inserted replaced
591056:8f3a50e16abc 591057:1b49e7328ae4
    21 #include "mozilla/layers/WebRenderBridgeChild.h"
    21 #include "mozilla/layers/WebRenderBridgeChild.h"
    22 #include "mozilla/layers/UpdateImageHelper.h"
    22 #include "mozilla/layers/UpdateImageHelper.h"
    23 #include "nsDisplayList.h"
    23 #include "nsDisplayList.h"
    24 #include "nsLayoutUtils.h"
    24 #include "nsLayoutUtils.h"
    25 #include "WebRenderCanvasRenderer.h"
    25 #include "WebRenderCanvasRenderer.h"
       
    26 #include "LayerUserData.h"
    26 
    27 
    27 #ifdef XP_WIN
    28 #ifdef XP_WIN
    28 #  include "gfxDWriteFonts.h"
    29 #  include "gfxDWriteFonts.h"
    29 #endif
    30 #endif
    30 
    31 
    37 WebRenderLayerManager::WebRenderLayerManager(nsIWidget* aWidget)
    38 WebRenderLayerManager::WebRenderLayerManager(nsIWidget* aWidget)
    38     : mWidget(aWidget),
    39     : mWidget(aWidget),
    39       mLatestTransactionId{0},
    40       mLatestTransactionId{0},
    40       mNeedsComposite(false),
    41       mNeedsComposite(false),
    41       mIsFirstPaint(false),
    42       mIsFirstPaint(false),
       
    43       mDestroyed(false),
    42       mTarget(nullptr),
    44       mTarget(nullptr),
    43       mPaintSequenceNumber(0),
    45       mPaintSequenceNumber(0),
    44       mWebRenderCommandBuilder(this) {
    46       mWebRenderCommandBuilder(this) {
    45   MOZ_COUNT_CTOR(WebRenderLayerManager);
    47   MOZ_COUNT_CTOR(WebRenderLayerManager);
    46   mStateManager.mLayerManager = this;
    48   mStateManager.mLayerManager = this;
   135   if (IsDestroyed()) {
   137   if (IsDestroyed()) {
   136     return;
   138     return;
   137   }
   139   }
   138 
   140 
   139   mDLBuilder = nullptr;
   141   mDLBuilder = nullptr;
   140 
   142   mUserData.Destroy();
   141   LayerManager::Destroy();
   143   mPartialPrerenderedAnimations.Clear();
   142 
   144 
   143   mStateManager.Destroy();
   145   mStateManager.Destroy();
   144 
   146 
   145   if (WrBridge()) {
   147   if (WrBridge()) {
   146     WrBridge()->Destroy(aIsSync);
   148     WrBridge()->Destroy(aIsSync);
   164     NS_DispatchToMainThread(task.forget());
   166     NS_DispatchToMainThread(task.forget());
   165   }
   167   }
   166 
   168 
   167   // Forget the widget pointer in case we outlive our owning widget.
   169   // Forget the widget pointer in case we outlive our owning widget.
   168   mWidget = nullptr;
   170   mWidget = nullptr;
       
   171   mDestroyed = true;
   169 }
   172 }
   170 
   173 
   171 WebRenderLayerManager::~WebRenderLayerManager() {
   174 WebRenderLayerManager::~WebRenderLayerManager() {
   172   Destroy();
   175   Destroy();
   173   MOZ_COUNT_DTOR(WebRenderLayerManager);
   176   MOZ_COUNT_DTOR(WebRenderLayerManager);
   316                                   refreshStart, mTransactionStart, mURL);
   319                                   refreshStart, mTransactionStart, mURL);
   317   mTransactionStart = TimeStamp();
   320   mTransactionStart = TimeStamp();
   318 
   321 
   319   MakeSnapshotIfRequired(size);
   322   MakeSnapshotIfRequired(size);
   320   return true;
   323   return true;
   321 }
       
   322 
       
   323 void WebRenderLayerManager::EndTransaction(DrawPaintedLayerCallback aCallback,
       
   324                                            void* aCallbackData,
       
   325                                            EndTransactionFlags aFlags) {
       
   326   // This should never get called, all callers should use
       
   327   // EndTransactionWithoutLayer instead.
       
   328   MOZ_ASSERT(false);
       
   329 }
   324 }
   330 
   325 
   331 void WebRenderLayerManager::EndTransactionWithoutLayer(
   326 void WebRenderLayerManager::EndTransactionWithoutLayer(
   332     nsDisplayList* aDisplayList, nsDisplayListBuilder* aDisplayListBuilder,
   327     nsDisplayList* aDisplayList, nsDisplayListBuilder* aDisplayListBuilder,
   333     WrFiltersHolder&& aFilters, WebRenderBackgroundData* aBackground,
   328     WrFiltersHolder&& aFilters, WebRenderBackgroundData* aBackground,
   737 
   732 
   738 void WebRenderLayerManager::ScheduleComposite() {
   733 void WebRenderLayerManager::ScheduleComposite() {
   739   WrBridge()->SendScheduleComposite();
   734   WrBridge()->SendScheduleComposite();
   740 }
   735 }
   741 
   736 
   742 void WebRenderLayerManager::SetRoot(Layer* aLayer) {
       
   743   // This should never get called
       
   744   MOZ_ASSERT(false);
       
   745 }
       
   746 
       
   747 already_AddRefed<PersistentBufferProvider>
   737 already_AddRefed<PersistentBufferProvider>
   748 WebRenderLayerManager::CreatePersistentBufferProvider(
   738 WebRenderLayerManager::CreatePersistentBufferProvider(
   749     const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat) {
   739     const gfx::IntSize& aSize, gfx::SurfaceFormat aFormat) {
   750   // Ensure devices initialization for canvas 2d if not remote. The devices are
   740   // Ensure devices initialization for canvas 2d if not remote. The devices are
   751   // lazily initialized with WebRender to reduce memory usage.
   741   // lazily initialized with WebRender to reduce memory usage.
   758                                              AsKnowsCompositor());
   748                                              AsKnowsCompositor());
   759   if (provider) {
   749   if (provider) {
   760     return provider.forget();
   750     return provider.forget();
   761   }
   751   }
   762 
   752 
   763   return LayerManager::CreatePersistentBufferProvider(aSize, aFormat);
   753   return WindowRenderer::CreatePersistentBufferProvider(aSize, aFormat);
   764 }
   754 }
   765 
   755 
   766 void WebRenderLayerManager::ClearAsyncAnimations() {
   756 void WebRenderLayerManager::ClearAsyncAnimations() {
   767   mStateManager.ClearAsyncAnimations();
   757   mStateManager.ClearAsyncAnimations();
   768 }
   758 }
   774 
   764 
   775 void WebRenderLayerManager::GetFrameUniformity(FrameUniformityData* aOutData) {
   765 void WebRenderLayerManager::GetFrameUniformity(FrameUniformityData* aOutData) {
   776   WrBridge()->SendGetFrameUniformity(aOutData);
   766   WrBridge()->SendGetFrameUniformity(aOutData);
   777 }
   767 }
   778 
   768 
       
   769 /*static*/
       
   770 void WebRenderLayerManager::LayerUserDataDestroy(void* data) {
       
   771   delete static_cast<LayerUserData*>(data);
       
   772 }
       
   773 
       
   774 UniquePtr<LayerUserData> WebRenderLayerManager::RemoveUserData(void* aKey) {
       
   775   UniquePtr<LayerUserData> d(static_cast<LayerUserData*>(
       
   776       mUserData.Remove(static_cast<gfx::UserDataKey*>(aKey))));
       
   777   return d;
       
   778 }
       
   779 
       
   780 std::unordered_set<ScrollableLayerGuid::ViewID>
       
   781 WebRenderLayerManager::ClearPendingScrollInfoUpdate() {
       
   782   std::unordered_set<ScrollableLayerGuid::ViewID> scrollIds(
       
   783       mPendingScrollUpdates.Keys().cbegin(),
       
   784       mPendingScrollUpdates.Keys().cend());
       
   785   mPendingScrollUpdates.Clear();
       
   786   return scrollIds;
       
   787 }
       
   788 
   779 }  // namespace layers
   789 }  // namespace layers
   780 }  // namespace mozilla
   790 }  // namespace mozilla