зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1722258 - Convert more LayerManager usage to use WindowRenderer. r=miko
Differential Revision: https://phabricator.services.mozilla.com/D120920
This commit is contained in:
Matt Woodrow
Родитель
9b81728dc2
Коммит
4b6db2ad05
|
|
@ -141,7 +141,7 @@ void BrowserBridgeParent::Destroy() {
|
|||
}
|
||||
|
||||
IPCResult BrowserBridgeParent::RecvShow(const OwnerShowInfo& aOwnerInfo) {
|
||||
mBrowserParent->AttachLayerManager();
|
||||
mBrowserParent->AttachWindowRenderer();
|
||||
Unused << mBrowserParent->SendShow(mBrowserParent->GetShowInfo(), aOwnerInfo);
|
||||
return IPC_OK();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2667,12 +2667,12 @@ mozilla::ipc::IPCResult BrowserChild::RecvRenderLayers(
|
|||
MOZ_ASSERT(mPuppetWidget);
|
||||
RefPtr<LayerManager> lm =
|
||||
mPuppetWidget->GetWindowRenderer()->AsLayerManager();
|
||||
MOZ_ASSERT(lm);
|
||||
|
||||
// We send the current layer observer epoch to the compositor so that
|
||||
// BrowserParent knows whether a layer update notification corresponds to
|
||||
// the latest RecvRenderLayers request that was made.
|
||||
lm->SetLayersObserverEpoch(mLayersObserverEpoch);
|
||||
if (lm) {
|
||||
// We send the current layer observer epoch to the compositor so that
|
||||
// BrowserParent knows whether a layer update notification corresponds to
|
||||
// the latest RecvRenderLayers request that was made.
|
||||
lm->SetLayersObserverEpoch(mLayersObserverEpoch);
|
||||
}
|
||||
}
|
||||
|
||||
mRenderLayers = aEnabled;
|
||||
|
|
@ -2850,8 +2850,9 @@ void BrowserChild::InitRenderingState(
|
|||
InitAPZState();
|
||||
RefPtr<LayerManager> lm =
|
||||
mPuppetWidget->GetWindowRenderer()->AsLayerManager();
|
||||
MOZ_ASSERT(lm);
|
||||
lm->SetLayersObserverEpoch(mLayersObserverEpoch);
|
||||
if (lm) {
|
||||
lm->SetLayersObserverEpoch(mLayersObserverEpoch);
|
||||
}
|
||||
} else {
|
||||
NS_WARNING("Fallback to BasicLayerManager");
|
||||
mLayersConnected = Some(false);
|
||||
|
|
@ -3149,7 +3150,9 @@ void BrowserChild::DidComposite(mozilla::layers::TransactionId aTransactionId,
|
|||
mPuppetWidget->GetWindowRenderer()->AsLayerManager();
|
||||
MOZ_ASSERT(lm);
|
||||
|
||||
lm->DidComposite(aTransactionId, aCompositeStart, aCompositeEnd);
|
||||
if (lm) {
|
||||
lm->DidComposite(aTransactionId, aCompositeStart, aCompositeEnd);
|
||||
}
|
||||
}
|
||||
|
||||
void BrowserChild::DidRequestComposite(const TimeStamp& aCompositeReqStart,
|
||||
|
|
@ -3180,9 +3183,9 @@ void BrowserChild::ClearCachedResources() {
|
|||
MOZ_ASSERT(mPuppetWidget);
|
||||
RefPtr<LayerManager> lm =
|
||||
mPuppetWidget->GetWindowRenderer()->AsLayerManager();
|
||||
MOZ_ASSERT(lm);
|
||||
|
||||
lm->ClearCachedResources();
|
||||
if (lm) {
|
||||
lm->ClearCachedResources();
|
||||
}
|
||||
|
||||
if (nsCOMPtr<Document> document = GetTopLevelDocument()) {
|
||||
nsPresContext* presContext = document->GetPresContext();
|
||||
|
|
@ -3196,9 +3199,9 @@ void BrowserChild::InvalidateLayers() {
|
|||
MOZ_ASSERT(mPuppetWidget);
|
||||
RefPtr<LayerManager> lm =
|
||||
mPuppetWidget->GetWindowRenderer()->AsLayerManager();
|
||||
MOZ_ASSERT(lm);
|
||||
|
||||
FrameLayerBuilder::InvalidateAllLayers(lm);
|
||||
if (lm) {
|
||||
FrameLayerBuilder::InvalidateAllLayers(lm);
|
||||
}
|
||||
}
|
||||
|
||||
void BrowserChild::SchedulePaint() {
|
||||
|
|
@ -3254,8 +3257,9 @@ void BrowserChild::ReinitRendering() {
|
|||
InitAPZState();
|
||||
RefPtr<LayerManager> lm =
|
||||
mPuppetWidget->GetWindowRenderer()->AsLayerManager();
|
||||
MOZ_ASSERT(lm);
|
||||
lm->SetLayersObserverEpoch(mLayersObserverEpoch);
|
||||
if (lm) {
|
||||
lm->SetLayersObserverEpoch(mLayersObserverEpoch);
|
||||
}
|
||||
|
||||
nsCOMPtr<Document> doc(GetTopLevelDocument());
|
||||
doc->NotifyLayerManagerRecreated();
|
||||
|
|
@ -3266,10 +3270,10 @@ void BrowserChild::ReinitRenderingForDeviceReset() {
|
|||
|
||||
RefPtr<LayerManager> lm =
|
||||
mPuppetWidget->GetWindowRenderer()->AsLayerManager();
|
||||
if (WebRenderLayerManager* wlm = lm->AsWebRenderLayerManager()) {
|
||||
wlm->DoDestroy(/* aIsSync */ true);
|
||||
} else if (ClientLayerManager* clm = lm->AsClientLayerManager()) {
|
||||
if (ShadowLayerForwarder* fwd = clm->AsShadowForwarder()) {
|
||||
if (lm && lm->AsWebRenderLayerManager()) {
|
||||
lm->AsWebRenderLayerManager()->DoDestroy(/* aIsSync */ true);
|
||||
} else if (lm && lm->AsClientLayerManager()) {
|
||||
if (ShadowLayerForwarder* fwd = lm->AsShadowForwarder()) {
|
||||
// Force the LayerTransactionChild to synchronously shutdown. It is
|
||||
// okay to do this early, we'll simply stop sending messages. This
|
||||
// step is necessary since otherwise the compositor will think we
|
||||
|
|
@ -3307,8 +3311,9 @@ void BrowserChild::NotifyJankedAnimations(
|
|||
MOZ_ASSERT(mPuppetWidget);
|
||||
RefPtr<LayerManager> lm =
|
||||
mPuppetWidget->GetWindowRenderer()->AsLayerManager();
|
||||
MOZ_ASSERT(lm);
|
||||
lm->UpdatePartialPrerenderedAnimations(aJankedAnimations);
|
||||
if (lm) {
|
||||
lm->UpdatePartialPrerenderedAnimations(aJankedAnimations);
|
||||
}
|
||||
}
|
||||
|
||||
mozilla::ipc::IPCResult BrowserChild::RecvUIResolutionChanged(
|
||||
|
|
|
|||
|
|
@ -936,8 +936,8 @@ void BrowserParent::InitRendering() {
|
|||
#endif
|
||||
}
|
||||
|
||||
bool BrowserParent::AttachLayerManager() {
|
||||
return !!mRemoteLayerTreeOwner.AttachLayerManager();
|
||||
bool BrowserParent::AttachWindowRenderer() {
|
||||
return mRemoteLayerTreeOwner.AttachWindowRenderer();
|
||||
}
|
||||
|
||||
void BrowserParent::MaybeShowFrame() {
|
||||
|
|
@ -955,7 +955,7 @@ bool BrowserParent::Show(const OwnerShowInfo& aOwnerInfo) {
|
|||
}
|
||||
|
||||
MOZ_ASSERT(mRemoteLayerTreeOwner.IsInitialized());
|
||||
if (!mRemoteLayerTreeOwner.AttachLayerManager()) {
|
||||
if (!mRemoteLayerTreeOwner.AttachWindowRenderer()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -456,7 +456,7 @@ class BrowserParent final : public PBrowserParent,
|
|||
void ResumeLoad(uint64_t aPendingSwitchID);
|
||||
|
||||
void InitRendering();
|
||||
bool AttachLayerManager();
|
||||
bool AttachWindowRenderer();
|
||||
void MaybeShowFrame();
|
||||
|
||||
bool Show(const OwnerShowInfo&);
|
||||
|
|
|
|||
|
|
@ -144,8 +144,6 @@ class DidCompositeObserver {
|
|||
* root layer, and each container layer holds a reference to its children.
|
||||
*/
|
||||
class LayerManager : public WindowRenderer {
|
||||
NS_INLINE_DECL_REFCOUNTING(LayerManager)
|
||||
|
||||
protected:
|
||||
typedef mozilla::gfx::DrawTarget DrawTarget;
|
||||
typedef mozilla::gfx::IntSize IntSize;
|
||||
|
|
@ -160,7 +158,7 @@ class LayerManager : public WindowRenderer {
|
|||
* for its widget going away. After this call, only user data calls
|
||||
* are valid on the layer manager.
|
||||
*/
|
||||
virtual void Destroy();
|
||||
void Destroy() override;
|
||||
bool IsDestroyed() { return mDestroyed; }
|
||||
|
||||
virtual LayerManager* AsLayerManager() override { return this; }
|
||||
|
|
@ -507,15 +505,6 @@ class LayerManager : public WindowRenderer {
|
|||
static bool IsLogEnabled();
|
||||
static mozilla::LogModule* GetLog();
|
||||
|
||||
bool IsCompositingCheap(LayersBackend aBackend) {
|
||||
// LayersBackend::LAYERS_NONE is an error state, but in that case we should
|
||||
// try to avoid loading the compositor!
|
||||
return LayersBackend::LAYERS_BASIC != aBackend &&
|
||||
LayersBackend::LAYERS_NONE != aBackend;
|
||||
}
|
||||
|
||||
virtual bool IsCompositingCheap() { return true; }
|
||||
|
||||
bool IsInTransaction() const { return mInTransaction; }
|
||||
|
||||
virtual void SetRegionToClear(const nsIntRegion& aRegion) {
|
||||
|
|
@ -524,8 +513,6 @@ class LayerManager : public WindowRenderer {
|
|||
|
||||
virtual float RequestProperty(const nsAString& property) { return -1; }
|
||||
|
||||
const TimeStamp& GetAnimationReadyTime() const { return mAnimationReadyTime; }
|
||||
|
||||
virtual bool AsyncPanZoomEnabled() const { return false; }
|
||||
|
||||
static void LayerUserDataDestroy(void* data);
|
||||
|
|
@ -600,9 +587,6 @@ class LayerManager : public WindowRenderer {
|
|||
|
||||
// Used for tracking CONTENT_FRAME_TIME_WITH_SVG
|
||||
bool mContainsSVG;
|
||||
// The time when painting most recently finished. This is recorded so that
|
||||
// we can time any play-pending animations from this point.
|
||||
TimeStamp mAnimationReadyTime;
|
||||
// The count of pixels that were painted in the current transaction.
|
||||
uint32_t mPaintedPixelCount;
|
||||
// The payload associated with currently pending painting work, for
|
||||
|
|
|
|||
|
|
@ -766,8 +766,10 @@ ShadowableLayer* ClientLayerManager::Hold(Layer* aLayer) {
|
|||
bool ClientLayerManager::IsCompositingCheap() {
|
||||
// Whether compositing is cheap depends on the parent backend.
|
||||
return mForwarder->mShadowManager &&
|
||||
LayerManager::IsCompositingCheap(
|
||||
mForwarder->GetCompositorBackendType());
|
||||
(mForwarder->GetCompositorBackendType() !=
|
||||
LayersBackend::LAYERS_NONE &&
|
||||
mForwarder->GetCompositorBackendType() !=
|
||||
LayersBackend::LAYERS_BASIC);
|
||||
}
|
||||
|
||||
bool ClientLayerManager::AreComponentAlphaLayersEnabled() {
|
||||
|
|
|
|||
|
|
@ -6447,6 +6447,8 @@ void PresShell::Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
|
|||
return;
|
||||
}
|
||||
|
||||
bgcolor = NS_ComposeColors(bgcolor, mCanvasBackgroundColor);
|
||||
|
||||
if (!layerManager) {
|
||||
// TODO: Once we support WindowRenderers that aren't a LayerManager,
|
||||
// then we need to handle this single color case for them.
|
||||
|
|
@ -6454,10 +6456,8 @@ void PresShell::Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
|
|||
}
|
||||
|
||||
if (layerManager->GetBackendType() == layers::LayersBackend::LAYERS_WR) {
|
||||
nsPresContext* pc = GetPresContext();
|
||||
LayoutDeviceRect bounds = LayoutDeviceRect::FromAppUnits(
|
||||
pc->GetVisibleArea(), pc->AppUnitsPerDevPixel());
|
||||
bgcolor = NS_ComposeColors(bgcolor, mCanvasBackgroundColor);
|
||||
presContext->GetVisibleArea(), presContext->AppUnitsPerDevPixel());
|
||||
WebRenderBackgroundData data(wr::ToLayoutRect(bounds),
|
||||
wr::ToColorF(ToDeviceColor(bgcolor)));
|
||||
WrFiltersHolder wrFilters;
|
||||
|
|
@ -6470,10 +6470,8 @@ void PresShell::Paint(nsView* aViewToPaint, const nsRegion& aDirtyRegion,
|
|||
|
||||
RefPtr<ColorLayer> root = layerManager->CreateColorLayer();
|
||||
if (root) {
|
||||
nsPresContext* pc = GetPresContext();
|
||||
nsIntRect bounds =
|
||||
pc->GetVisibleArea().ToOutsidePixels(pc->AppUnitsPerDevPixel());
|
||||
bgcolor = NS_ComposeColors(bgcolor, mCanvasBackgroundColor);
|
||||
nsIntRect bounds = presContext->GetVisibleArea().ToOutsidePixels(
|
||||
presContext->AppUnitsPerDevPixel());
|
||||
root->SetColor(ToDeviceColor(bgcolor));
|
||||
root->SetVisibleRegion(LayerIntRegion::FromUnknownRegion(bounds));
|
||||
layerManager->SetRoot(root);
|
||||
|
|
|
|||
|
|
@ -30,19 +30,17 @@ using namespace mozilla::layers;
|
|||
namespace mozilla {
|
||||
namespace layout {
|
||||
|
||||
static already_AddRefed<LayerManager> GetLayerManager(
|
||||
static already_AddRefed<WindowRenderer> GetWindowRenderer(
|
||||
BrowserParent* aBrowserParent) {
|
||||
RefPtr<LayerManager> lm;
|
||||
RefPtr<WindowRenderer> renderer;
|
||||
if (Element* element = aBrowserParent->GetOwnerElement()) {
|
||||
if (WindowRenderer* renderer =
|
||||
nsContentUtils::WindowRendererForContent(element)) {
|
||||
lm = renderer->AsLayerManager();
|
||||
return lm.forget();
|
||||
renderer = nsContentUtils::WindowRendererForContent(element);
|
||||
if (renderer) {
|
||||
return renderer.forget();
|
||||
}
|
||||
if (WindowRenderer* renderer =
|
||||
nsContentUtils::WindowRendererForDocument(element->OwnerDoc())) {
|
||||
lm = renderer->AsLayerManager();
|
||||
return lm.forget();
|
||||
renderer = nsContentUtils::WindowRendererForDocument(element->OwnerDoc());
|
||||
if (renderer) {
|
||||
return renderer.forget();
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
|
|
@ -51,7 +49,6 @@ static already_AddRefed<LayerManager> GetLayerManager(
|
|||
RemoteLayerTreeOwner::RemoteLayerTreeOwner()
|
||||
: mLayersId{0},
|
||||
mBrowserParent(nullptr),
|
||||
mLayerManager(nullptr),
|
||||
mInitialized(false),
|
||||
mLayersConnected(false) {}
|
||||
|
||||
|
|
@ -63,9 +60,9 @@ bool RemoteLayerTreeOwner::Initialize(BrowserParent* aBrowserParent) {
|
|||
}
|
||||
|
||||
mBrowserParent = aBrowserParent;
|
||||
RefPtr<LayerManager> lm = GetLayerManager(mBrowserParent);
|
||||
RefPtr<WindowRenderer> renderer = GetWindowRenderer(mBrowserParent);
|
||||
PCompositorBridgeChild* compositor =
|
||||
lm ? lm->GetCompositorBridgeChild() : nullptr;
|
||||
renderer ? renderer->GetCompositorBridgeChild() : nullptr;
|
||||
mTabProcessId = mBrowserParent->Manager()->OtherPid();
|
||||
|
||||
// Our remote frame will push layers updates to the compositor,
|
||||
|
|
@ -84,53 +81,56 @@ void RemoteLayerTreeOwner::Destroy() {
|
|||
}
|
||||
|
||||
mBrowserParent = nullptr;
|
||||
mLayerManager = nullptr;
|
||||
mWindowRenderer = nullptr;
|
||||
}
|
||||
|
||||
void RemoteLayerTreeOwner::EnsureLayersConnected(
|
||||
CompositorOptions* aCompositorOptions) {
|
||||
RefPtr<LayerManager> lm = GetLayerManager(mBrowserParent);
|
||||
if (!lm) {
|
||||
RefPtr<WindowRenderer> renderer = GetWindowRenderer(mBrowserParent);
|
||||
if (!renderer) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!lm->GetCompositorBridgeChild()) {
|
||||
if (!renderer->GetCompositorBridgeChild()) {
|
||||
return;
|
||||
}
|
||||
|
||||
mLayersConnected = lm->GetCompositorBridgeChild()->SendNotifyChildRecreated(
|
||||
mLayersId, &mCompositorOptions);
|
||||
mLayersConnected =
|
||||
renderer->GetCompositorBridgeChild()->SendNotifyChildRecreated(
|
||||
mLayersId, &mCompositorOptions);
|
||||
*aCompositorOptions = mCompositorOptions;
|
||||
}
|
||||
|
||||
LayerManager* RemoteLayerTreeOwner::AttachLayerManager() {
|
||||
RefPtr<LayerManager> lm;
|
||||
bool RemoteLayerTreeOwner::AttachWindowRenderer() {
|
||||
RefPtr<WindowRenderer> renderer;
|
||||
if (mBrowserParent) {
|
||||
lm = GetLayerManager(mBrowserParent);
|
||||
renderer = GetWindowRenderer(mBrowserParent);
|
||||
}
|
||||
|
||||
// Perhaps the document containing this frame currently has no presentation?
|
||||
if (lm && lm->GetCompositorBridgeChild() && lm != mLayerManager) {
|
||||
if (renderer && renderer->GetCompositorBridgeChild() &&
|
||||
renderer != mWindowRenderer) {
|
||||
mLayersConnected =
|
||||
lm->GetCompositorBridgeChild()->SendAdoptChild(mLayersId);
|
||||
FrameLayerBuilder::InvalidateAllLayers(lm);
|
||||
renderer->GetCompositorBridgeChild()->SendAdoptChild(mLayersId);
|
||||
FrameLayerBuilder::InvalidateAllLayers(renderer->AsLayerManager());
|
||||
}
|
||||
|
||||
mLayerManager = std::move(lm);
|
||||
return mLayerManager;
|
||||
mWindowRenderer = std::move(renderer);
|
||||
return !!mWindowRenderer;
|
||||
}
|
||||
|
||||
void RemoteLayerTreeOwner::OwnerContentChanged() {
|
||||
Unused << AttachLayerManager();
|
||||
Unused << AttachWindowRenderer();
|
||||
}
|
||||
|
||||
void RemoteLayerTreeOwner::GetTextureFactoryIdentifier(
|
||||
TextureFactoryIdentifier* aTextureFactoryIdentifier) const {
|
||||
RefPtr<LayerManager> lm =
|
||||
mBrowserParent ? GetLayerManager(mBrowserParent) : nullptr;
|
||||
RefPtr<WindowRenderer> renderer =
|
||||
mBrowserParent ? GetWindowRenderer(mBrowserParent) : nullptr;
|
||||
// Perhaps the document containing this frame currently has no presentation?
|
||||
if (lm) {
|
||||
*aTextureFactoryIdentifier = lm->GetTextureFactoryIdentifier();
|
||||
if (renderer && renderer->AsLayerManager()) {
|
||||
*aTextureFactoryIdentifier =
|
||||
renderer->AsLayerManager()->GetTextureFactoryIdentifier();
|
||||
} else {
|
||||
*aTextureFactoryIdentifier = TextureFactoryIdentifier();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ class RemoteLayerTreeOwner final {
|
|||
void Destroy();
|
||||
|
||||
void EnsureLayersConnected(CompositorOptions* aCompositorOptions);
|
||||
LayerManager* AttachLayerManager();
|
||||
bool AttachWindowRenderer();
|
||||
void OwnerContentChanged();
|
||||
|
||||
LayersId GetLayersId() const { return mLayersId; }
|
||||
|
|
@ -73,7 +73,7 @@ class RemoteLayerTreeOwner final {
|
|||
CompositorOptions mCompositorOptions;
|
||||
|
||||
dom::BrowserParent* mBrowserParent;
|
||||
RefPtr<LayerManager> mLayerManager;
|
||||
RefPtr<WindowRenderer> mWindowRenderer;
|
||||
|
||||
bool mInitialized;
|
||||
// A flag that indicates whether or not the compositor knows about the
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@
|
|||
#include "mozilla/layers/ScrollableLayerGuid.h" // for ScrollableLayerGuid, ScrollableLayerGuid::ViewID
|
||||
#include "nsRefPtrHashtable.h" // for nsRefPtrHashtable
|
||||
|
||||
class gfxContext;
|
||||
namespace mozilla {
|
||||
|
||||
namespace layers {
|
||||
class LayerManager;
|
||||
class WebRenderLayerManager;
|
||||
|
|
@ -81,7 +81,21 @@ class FrameRecorder {
|
|||
FramesTimingRecording mRecording;
|
||||
};
|
||||
|
||||
/**
|
||||
* WindowRenderer is the retained rendering object owned by an nsIWidget for
|
||||
* drawing the contents of that window, the role previously handled by
|
||||
* LayerManager.
|
||||
*
|
||||
* It can be WebRender, (deprecated) Layers, or an immediate-mode
|
||||
* FallbackRenderer.
|
||||
*
|
||||
* The intention is for LayerManager to be removed entirely in the near future,
|
||||
* with WebRender inheriting directly from this class. It is likely that more
|
||||
* cleanup can be done once that happens.
|
||||
*/
|
||||
class WindowRenderer : public FrameRecorder {
|
||||
NS_INLINE_DECL_REFCOUNTING(WindowRenderer)
|
||||
|
||||
public:
|
||||
// Cast to implementation types.
|
||||
virtual layers::LayerManager* AsLayerManager() { return nullptr; }
|
||||
|
|
@ -117,6 +131,8 @@ class WindowRenderer : public FrameRecorder {
|
|||
virtual bool EndEmptyTransaction(
|
||||
EndTransactionFlags aFlags = END_DEFAULT) = 0;
|
||||
|
||||
virtual void Destroy() {}
|
||||
|
||||
/**
|
||||
* Type of layer manager this is. This is to be used sparsely in order to
|
||||
* avoid a lot of Layers backend specific code. It should be used only when
|
||||
|
|
@ -154,6 +170,8 @@ class WindowRenderer : public FrameRecorder {
|
|||
*/
|
||||
virtual void WaitOnTransactionProcessed() {}
|
||||
|
||||
virtual bool IsCompositingCheap() { return true; }
|
||||
|
||||
/**
|
||||
* Return the name of the layer manager's backend.
|
||||
*/
|
||||
|
|
@ -196,13 +214,21 @@ class WindowRenderer : public FrameRecorder {
|
|||
void UpdatePartialPrerenderedAnimations(
|
||||
const nsTArray<uint64_t>& aJankedAnimations);
|
||||
|
||||
const TimeStamp& GetAnimationReadyTime() const { return mAnimationReadyTime; }
|
||||
|
||||
protected:
|
||||
virtual ~WindowRenderer() = default;
|
||||
|
||||
// Transform animations which are not fully pre-rendered because it's on a
|
||||
// large frame. We need to update the pre-rendered area once after we tried
|
||||
// to composite area which is outside of the pre-rendered area on the
|
||||
// compositor.
|
||||
nsRefPtrHashtable<nsUint64HashKey, dom::Animation>
|
||||
mPartialPrerenderedAnimations;
|
||||
|
||||
// The time when painting most recently finished. This is recorded so that
|
||||
// we can time any play-pending animations from this point.
|
||||
TimeStamp mAnimationReadyTime;
|
||||
};
|
||||
|
||||
} // namespace mozilla
|
||||
|
|
|
|||
|
|
@ -2331,7 +2331,7 @@ static void TriggerPendingAnimations(Document& aDoc,
|
|||
aDoc.EnumerateSubDocuments(recurse);
|
||||
}
|
||||
|
||||
LayerManager* nsDisplayListBuilder::GetWidgetLayerManager(nsView** aView) {
|
||||
WindowRenderer* nsDisplayListBuilder::GetWidgetWindowRenderer(nsView** aView) {
|
||||
if (aView) {
|
||||
*aView = RootReferenceFrame()->GetView();
|
||||
}
|
||||
|
|
@ -2341,10 +2341,15 @@ LayerManager* nsDisplayListBuilder::GetWidgetLayerManager(nsView** aView) {
|
|||
}
|
||||
nsIWidget* window = RootReferenceFrame()->GetNearestWidget();
|
||||
if (window) {
|
||||
WindowRenderer* renderer = window->GetWindowRenderer();
|
||||
if (renderer) {
|
||||
return renderer->AsLayerManager();
|
||||
}
|
||||
return window->GetWindowRenderer();
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
LayerManager* nsDisplayListBuilder::GetWidgetLayerManager(nsView** aView) {
|
||||
WindowRenderer* renderer = GetWidgetWindowRenderer();
|
||||
if (renderer) {
|
||||
return renderer->AsLayerManager();
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -2512,13 +2517,17 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
|
|||
AUTO_PROFILER_LABEL("nsDisplayList::PaintRoot", GRAPHICS);
|
||||
|
||||
RefPtr<LayerManager> layerManager;
|
||||
WindowRenderer* renderer = nullptr;
|
||||
bool widgetTransaction = false;
|
||||
bool doBeginTransaction = true;
|
||||
nsView* view = nullptr;
|
||||
if (aFlags & PAINT_USE_WIDGET_LAYERS) {
|
||||
layerManager = aBuilder->GetWidgetLayerManager(&view);
|
||||
if (layerManager) {
|
||||
layerManager->SetContainsSVG(false);
|
||||
renderer = aBuilder->GetWidgetWindowRenderer(&view);
|
||||
if (renderer) {
|
||||
layerManager = renderer->AsLayerManager();
|
||||
if (layerManager) {
|
||||
layerManager->SetContainsSVG(false);
|
||||
}
|
||||
|
||||
doBeginTransaction = !(aFlags & PAINT_EXISTING_TRANSACTION);
|
||||
widgetTransaction = true;
|
||||
|
|
@ -2530,7 +2539,7 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
|
|||
PresShell* presShell = presContext->PresShell();
|
||||
Document* document = presShell->GetDocument();
|
||||
|
||||
if (!layerManager) {
|
||||
if (!renderer) {
|
||||
if (!aCtx) {
|
||||
NS_WARNING("Nowhere to paint into");
|
||||
return nullptr;
|
||||
|
|
@ -2546,7 +2555,8 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
if (layerManager->GetBackendType() == LayersBackend::LAYERS_WR) {
|
||||
if (renderer->GetBackendType() == LayersBackend::LAYERS_WR) {
|
||||
MOZ_ASSERT(layerManager);
|
||||
if (doBeginTransaction) {
|
||||
if (aCtx) {
|
||||
if (!layerManager->BeginTransactionWithTarget(aCtx)) {
|
||||
|
|
@ -2618,39 +2628,40 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
|
|||
UniquePtr<LayerProperties> props;
|
||||
|
||||
bool computeInvalidRect =
|
||||
(computeInvalidFunc || (!layerManager->IsCompositingCheap() &&
|
||||
layerManager->NeedsWidgetInvalidation())) &&
|
||||
(computeInvalidFunc || (!renderer->IsCompositingCheap() &&
|
||||
renderer->NeedsWidgetInvalidation())) &&
|
||||
widgetTransaction;
|
||||
|
||||
if (computeInvalidRect) {
|
||||
if (computeInvalidRect && layerManager) {
|
||||
props = LayerProperties::CloneFrom(layerManager->GetRoot());
|
||||
}
|
||||
|
||||
if (doBeginTransaction) {
|
||||
if (aCtx) {
|
||||
MOZ_ASSERT(layerManager);
|
||||
if (!layerManager->BeginTransactionWithTarget(aCtx)) {
|
||||
return nullptr;
|
||||
}
|
||||
} else {
|
||||
if (!layerManager->BeginTransaction()) {
|
||||
if (!renderer->BeginTransaction()) {
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool temp =
|
||||
aBuilder->SetIsCompositingCheap(layerManager->IsCompositingCheap());
|
||||
bool temp = aBuilder->SetIsCompositingCheap(renderer->IsCompositingCheap());
|
||||
LayerManager::EndTransactionFlags flags = LayerManager::END_DEFAULT;
|
||||
if (layerManager->NeedsWidgetInvalidation() &&
|
||||
(aFlags & PAINT_NO_COMPOSITE)) {
|
||||
if (renderer->NeedsWidgetInvalidation() && (aFlags & PAINT_NO_COMPOSITE)) {
|
||||
flags = LayerManager::END_NO_COMPOSITE;
|
||||
}
|
||||
|
||||
MaybeSetupTransactionIdAllocator(layerManager, presContext);
|
||||
if (layerManager) {
|
||||
MaybeSetupTransactionIdAllocator(layerManager, presContext);
|
||||
}
|
||||
|
||||
bool sent = false;
|
||||
if (aFlags & PAINT_IDENTICAL_DISPLAY_LIST) {
|
||||
sent = layerManager->EndEmptyTransaction(flags);
|
||||
sent = renderer->EndEmptyTransaction(flags);
|
||||
}
|
||||
|
||||
if (!sent) {
|
||||
|
|
@ -2681,7 +2692,7 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
|
|||
|
||||
aBuilder->SetIsCompositingCheap(temp);
|
||||
|
||||
if (document && widgetTransaction) {
|
||||
if (document && widgetTransaction && layerManager) {
|
||||
TriggerPendingAnimations(*document, layerManager->GetAnimationReadyTime());
|
||||
}
|
||||
|
||||
|
|
@ -2691,11 +2702,11 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
|
|||
computeInvalidFunc)) {
|
||||
invalid = nsIntRect::MaxIntRect();
|
||||
}
|
||||
} else if (widgetTransaction) {
|
||||
} else if (widgetTransaction && layerManager) {
|
||||
LayerProperties::ClearInvalidations(layerManager->GetRoot());
|
||||
}
|
||||
|
||||
bool shouldInvalidate = layerManager->NeedsWidgetInvalidation();
|
||||
bool shouldInvalidate = renderer->NeedsWidgetInvalidation();
|
||||
|
||||
if (view) {
|
||||
if (props) {
|
||||
|
|
@ -2724,7 +2735,9 @@ already_AddRefed<LayerManager> nsDisplayList::PaintRoot(
|
|||
}
|
||||
}
|
||||
|
||||
layerManager->SetUserData(&gLayerManagerLayerBuilder, nullptr);
|
||||
if (layerManager) {
|
||||
layerManager->SetUserData(&gLayerManagerLayerBuilder, nullptr);
|
||||
}
|
||||
return layerManager.forget();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -422,6 +422,7 @@ class nsDisplayListBuilder {
|
|||
mTemporaryItems.AppendElement(aItem);
|
||||
}
|
||||
|
||||
WindowRenderer* GetWidgetWindowRenderer(nsView** aView = nullptr);
|
||||
layers::LayerManager* GetWidgetLayerManager(nsView** aView = nullptr);
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -336,6 +336,9 @@ void nsViewManager::Refresh(nsView* aView,
|
|||
// Try to just Composite the current WindowRenderer contents. If
|
||||
// that fails then we need tor repaint, and request that it gets
|
||||
// composited as well.
|
||||
// Once BasicLayerManager is removed, Composite will never succeed, so
|
||||
// we can remove it and only have the call to Paint for
|
||||
// FallbackRenderer.
|
||||
if (!presShell->Composite(aView)) {
|
||||
presShell->Paint(aView, damageRegion, PaintFlags::PaintComposite);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@
|
|||
#include "mozilla/PresShell.h"
|
||||
#include "mozilla/SchedulerGroup.h"
|
||||
#include "mozilla/StaticPrefs_browser.h"
|
||||
#include "mozilla/StaticPrefs_gfx.h"
|
||||
#include "mozilla/TextComposition.h"
|
||||
#include "mozilla/TextEventDispatcher.h"
|
||||
#include "mozilla/TextEvents.h"
|
||||
|
|
@ -117,7 +118,7 @@ void PuppetWidget::InfallibleCreate(nsIWidget* aParent,
|
|||
PuppetWidget* parent = static_cast<PuppetWidget*>(aParent);
|
||||
if (parent) {
|
||||
parent->SetChild(this);
|
||||
mLayerManager = parent->GetWindowRenderer()->AsLayerManager();
|
||||
mWindowRenderer = parent->GetWindowRenderer();
|
||||
} else {
|
||||
Resize(mBounds.X(), mBounds.Y(), mBounds.Width(), mBounds.Height(), false);
|
||||
}
|
||||
|
|
@ -165,10 +166,10 @@ void PuppetWidget::Destroy() {
|
|||
mMemoryPressureObserver = nullptr;
|
||||
}
|
||||
mChild = nullptr;
|
||||
if (mLayerManager) {
|
||||
mLayerManager->Destroy();
|
||||
if (mWindowRenderer) {
|
||||
mWindowRenderer->Destroy();
|
||||
}
|
||||
mLayerManager = nullptr;
|
||||
mWindowRenderer = nullptr;
|
||||
mBrowserChild = nullptr;
|
||||
}
|
||||
|
||||
|
|
@ -586,13 +587,13 @@ bool PuppetWidget::GetEditCommands(NativeKeyBindingsType aType,
|
|||
}
|
||||
|
||||
WindowRenderer* PuppetWidget::GetWindowRenderer() {
|
||||
if (!mLayerManager) {
|
||||
if (!mWindowRenderer) {
|
||||
if (XRE_IsParentProcess()) {
|
||||
// On the parent process there is no CompositorBridgeChild which confuses
|
||||
// some layers code, so we use basic layers instead. Note that we create
|
||||
// a non-retaining layer manager since we don't care about performance.
|
||||
mLayerManager = new BasicLayerManager(BasicLayerManager::BLM_OFFSCREEN);
|
||||
return mLayerManager;
|
||||
mWindowRenderer = new BasicLayerManager(BasicLayerManager::BLM_OFFSCREEN);
|
||||
return mWindowRenderer;
|
||||
}
|
||||
|
||||
// If we know for sure that the parent side of this BrowserChild is not
|
||||
|
|
@ -601,10 +602,10 @@ WindowRenderer* PuppetWidget::GetWindowRenderer() {
|
|||
// can do drawing in this process.
|
||||
MOZ_ASSERT(!mBrowserChild ||
|
||||
mBrowserChild->IsLayersConnected() != Some(true));
|
||||
mLayerManager = new BasicLayerManager(this);
|
||||
mWindowRenderer = CreateBasicLayerManager();
|
||||
}
|
||||
|
||||
return mLayerManager;
|
||||
return mWindowRenderer;
|
||||
}
|
||||
|
||||
bool PuppetWidget::CreateRemoteLayerManager(
|
||||
|
|
@ -626,7 +627,7 @@ bool PuppetWidget::CreateRemoteLayerManager(
|
|||
// it if we successfully create its successor because a partially initialized
|
||||
// layer manager is worse than a fully initialized but shutdown layer manager.
|
||||
DestroyLayerManager();
|
||||
mLayerManager = std::move(lm);
|
||||
mWindowRenderer = std::move(lm);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -1006,8 +1007,9 @@ void PuppetWidget::PaintNowIfNeeded() {
|
|||
|
||||
void PuppetWidget::OnMemoryPressure(layers::MemoryPressureReason aWhy) {
|
||||
if (aWhy != MemoryPressureReason::LOW_MEMORY_ONGOING && !mVisible &&
|
||||
mLayerManager && XRE_IsContentProcess()) {
|
||||
mLayerManager->ClearCachedResources();
|
||||
mWindowRenderer && mWindowRenderer->AsLayerManager() &&
|
||||
XRE_IsContentProcess()) {
|
||||
mWindowRenderer->AsLayerManager()->ClearCachedResources();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -181,7 +181,7 @@ class PuppetWidget : public nsBaseWidget,
|
|||
bool CreateRemoteLayerManager(
|
||||
const std::function<bool(LayerManager*)>& aInitializeFunc);
|
||||
|
||||
bool HasLayerManager() { return !!mLayerManager; }
|
||||
bool HasLayerManager() { return !!mWindowRenderer; }
|
||||
|
||||
virtual void SetInputContext(const InputContext& aContext,
|
||||
const InputContextAction& aAction) override;
|
||||
|
|
|
|||
|
|
@ -2186,21 +2186,21 @@ nsresult nsWindow::MakeFullScreen(bool aFullScreen, nsIScreen*) {
|
|||
}
|
||||
|
||||
mozilla::WindowRenderer* nsWindow::GetWindowRenderer() {
|
||||
if (mLayerManager) {
|
||||
return mLayerManager;
|
||||
if (mWindowRenderer) {
|
||||
return mWindowRenderer;
|
||||
}
|
||||
|
||||
if (mIsDisablingWebRender) {
|
||||
CreateLayerManager();
|
||||
mIsDisablingWebRender = false;
|
||||
return mLayerManager;
|
||||
return mWindowRenderer;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void nsWindow::CreateLayerManager() {
|
||||
if (mLayerManager) {
|
||||
if (mWindowRenderer) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -2216,7 +2216,7 @@ void nsWindow::CreateLayerManager() {
|
|||
if (ShouldUseOffMainThreadCompositing()) {
|
||||
LayoutDeviceIntRect rect = GetBounds();
|
||||
CreateCompositor(rect.Width(), rect.Height());
|
||||
if (mLayerManager) {
|
||||
if (mWindowRenderer) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -2226,7 +2226,7 @@ void nsWindow::CreateLayerManager() {
|
|||
|
||||
if (!ComputeShouldAccelerate() || sFailedToCreateGLContext) {
|
||||
printf_stderr(" -- creating basic, not accelerated\n");
|
||||
mLayerManager = CreateBasicLayerManager();
|
||||
mWindowRenderer = CreateBasicLayerManager();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -705,10 +705,10 @@ void nsWindow::Destroy() {
|
|||
mCreated = false;
|
||||
|
||||
/** Need to clean our LayerManager up while still alive */
|
||||
if (mLayerManager) {
|
||||
mLayerManager->Destroy();
|
||||
if (mWindowRenderer) {
|
||||
mWindowRenderer->Destroy();
|
||||
}
|
||||
mLayerManager = nullptr;
|
||||
mWindowRenderer = nullptr;
|
||||
|
||||
#ifdef MOZ_WAYLAND
|
||||
// Shut down our local vsync source
|
||||
|
|
@ -3529,7 +3529,8 @@ gboolean nsWindow::OnExposeEvent(cairo_t* cr) {
|
|||
|
||||
bool painted = false;
|
||||
{
|
||||
if (renderer->GetBackendType() == LayersBackend::LAYERS_BASIC) {
|
||||
if (renderer->GetBackendType() == LayersBackend::LAYERS_NONE ||
|
||||
renderer->GetBackendType() == LayersBackend::LAYERS_BASIC) {
|
||||
if (GetTransparencyMode() == eTransparencyTransparent &&
|
||||
layerBuffering == BufferMode::BUFFER_NONE && mHasAlphaVisual) {
|
||||
// If our draw target is unbuffered and we use an alpha channel,
|
||||
|
|
@ -6117,9 +6118,9 @@ LayoutDeviceIntSize nsWindow::GetSafeWindowSize(LayoutDeviceIntSize aSize) {
|
|||
// we also must ensure that the window can fit in a Cairo surface.
|
||||
LayoutDeviceIntSize result = aSize;
|
||||
int32_t maxSize = 32767;
|
||||
if (mLayerManager && mLayerManager->AsKnowsCompositor()) {
|
||||
maxSize = std::min(maxSize,
|
||||
mLayerManager->AsKnowsCompositor()->GetMaxTextureSize());
|
||||
if (mWindowRenderer && mWindowRenderer->AsKnowsCompositor()) {
|
||||
maxSize = std::min(
|
||||
maxSize, mWindowRenderer->AsKnowsCompositor()->GetMaxTextureSize());
|
||||
}
|
||||
if (result.width > maxSize) {
|
||||
result.width = maxSize;
|
||||
|
|
@ -6135,9 +6136,9 @@ void nsWindow::EnsureGrabs(void) {
|
|||
}
|
||||
|
||||
void nsWindow::CleanLayerManagerRecursive(void) {
|
||||
if (mLayerManager) {
|
||||
mLayerManager->Destroy();
|
||||
mLayerManager = nullptr;
|
||||
if (mWindowRenderer) {
|
||||
mWindowRenderer->Destroy();
|
||||
mWindowRenderer = nullptr;
|
||||
}
|
||||
|
||||
DestroyCompositor();
|
||||
|
|
@ -8284,7 +8285,7 @@ nsIWidget::WindowRenderer* nsWindow::GetWindowRenderer() {
|
|||
// Prevent external code from triggering the re-creation of the
|
||||
// LayerManager/Compositor during shutdown. Just return what we currently
|
||||
// have, which is most likely null.
|
||||
return mLayerManager;
|
||||
return mWindowRenderer;
|
||||
}
|
||||
|
||||
return nsBaseWidget::GetWindowRenderer();
|
||||
|
|
@ -8305,9 +8306,9 @@ void nsWindow::SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) {
|
|||
}
|
||||
|
||||
void nsWindow::ClearCachedResources() {
|
||||
if (mLayerManager && mLayerManager->GetBackendType() ==
|
||||
mozilla::layers::LayersBackend::LAYERS_BASIC) {
|
||||
mLayerManager->ClearCachedResources();
|
||||
if (mWindowRenderer && mWindowRenderer->GetBackendType() ==
|
||||
mozilla::layers::LayersBackend::LAYERS_BASIC) {
|
||||
mWindowRenderer->AsLayerManager()->ClearCachedResources();
|
||||
}
|
||||
|
||||
GList* children = gdk_window_peek_children(mGdkWindow);
|
||||
|
|
|
|||
|
|
@ -154,7 +154,6 @@ nsBaseWidget::nsBaseWidget()
|
|||
: mWidgetListener(nullptr),
|
||||
mAttachedWidgetListener(nullptr),
|
||||
mPreviouslyAttachedWidgetListener(nullptr),
|
||||
mLayerManager(nullptr),
|
||||
mCompositorVsyncDispatcher(nullptr),
|
||||
mBorderStyle(eBorderStyle_none),
|
||||
mBounds(0, 0, 0, 0),
|
||||
|
|
@ -390,10 +389,10 @@ void nsBaseWidget::DestroyCompositor() {
|
|||
// This prevents the layer manager from starting a new transaction during
|
||||
// shutdown.
|
||||
void nsBaseWidget::RevokeTransactionIdAllocator() {
|
||||
if (!mLayerManager) {
|
||||
if (!mWindowRenderer || !mWindowRenderer->AsLayerManager()) {
|
||||
return;
|
||||
}
|
||||
mLayerManager->SetTransactionIdAllocator(nullptr);
|
||||
mWindowRenderer->AsLayerManager()->SetTransactionIdAllocator(nullptr);
|
||||
}
|
||||
|
||||
void nsBaseWidget::ReleaseContentController() {
|
||||
|
|
@ -404,9 +403,9 @@ void nsBaseWidget::ReleaseContentController() {
|
|||
}
|
||||
|
||||
void nsBaseWidget::DestroyLayerManager() {
|
||||
if (mLayerManager) {
|
||||
mLayerManager->Destroy();
|
||||
mLayerManager = nullptr;
|
||||
if (mWindowRenderer) {
|
||||
mWindowRenderer->Destroy();
|
||||
mWindowRenderer = nullptr;
|
||||
}
|
||||
DestroyCompositor();
|
||||
}
|
||||
|
|
@ -436,8 +435,9 @@ void nsBaseWidget::FreeLocalesChangedObserver() {
|
|||
nsBaseWidget::~nsBaseWidget() {
|
||||
IMEStateManager::WidgetDestroyed(this);
|
||||
|
||||
if (mLayerManager) {
|
||||
if (BasicLayerManager* mgr = mLayerManager->AsBasicLayerManager()) {
|
||||
if (mWindowRenderer && mWindowRenderer->AsLayerManager()) {
|
||||
if (BasicLayerManager* mgr =
|
||||
mWindowRenderer->AsLayerManager()->AsBasicLayerManager()) {
|
||||
mgr->ClearRetainerWidget();
|
||||
}
|
||||
}
|
||||
|
|
@ -881,12 +881,10 @@ nsresult nsBaseWidget::MakeFullScreen(bool aFullScreen, nsIScreen* aScreen) {
|
|||
}
|
||||
|
||||
nsBaseWidget::AutoLayerManagerSetup::AutoLayerManagerSetup(
|
||||
nsBaseWidget* aWidget, gfxContext* aTarget, BufferMode aDoubleBuffering,
|
||||
ScreenRotation aRotation)
|
||||
nsBaseWidget* aWidget, gfxContext* aTarget, BufferMode aDoubleBuffering)
|
||||
: mWidget(aWidget) {
|
||||
LayerManager* lm = mWidget->GetWindowRenderer()
|
||||
? mWidget->GetWindowRenderer()->AsLayerManager()
|
||||
: nullptr;
|
||||
WindowRenderer* renderer = mWidget->GetWindowRenderer();
|
||||
LayerManager* lm = renderer ? renderer->AsLayerManager() : nullptr;
|
||||
NS_ASSERTION(
|
||||
!lm || lm->GetBackendType() == LayersBackend::LAYERS_BASIC,
|
||||
"AutoLayerManagerSetup instantiated for non-basic layer backend!");
|
||||
|
|
@ -894,7 +892,8 @@ nsBaseWidget::AutoLayerManagerSetup::AutoLayerManagerSetup(
|
|||
mLayerManager = lm->AsBasicLayerManager();
|
||||
if (mLayerManager) {
|
||||
mLayerManager->SetDefaultTarget(aTarget);
|
||||
mLayerManager->SetDefaultTargetConfiguration(aDoubleBuffering, aRotation);
|
||||
mLayerManager->SetDefaultTargetConfiguration(aDoubleBuffering,
|
||||
ROTATION_0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1482,7 +1481,7 @@ void nsBaseWidget::CreateCompositor(int aWidth, int aHeight) {
|
|||
|
||||
WindowUsesOMTC();
|
||||
|
||||
mLayerManager = std::move(lm);
|
||||
mWindowRenderer = std::move(lm);
|
||||
|
||||
// Only track compositors for top-level windows, since other window types
|
||||
// may use the basic compositor. Except on the OS X - see bug 1306383
|
||||
|
|
@ -1494,7 +1493,7 @@ void nsBaseWidget::CreateCompositor(int aWidth, int aHeight) {
|
|||
|
||||
if (getCompositorFromThisWindow) {
|
||||
gfxPlatform::GetPlatform()->NotifyCompositorCreated(
|
||||
mLayerManager->GetCompositorBackendType());
|
||||
mWindowRenderer->GetCompositorBackendType());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1508,7 +1507,7 @@ bool nsBaseWidget::ShouldUseOffMainThreadCompositing() {
|
|||
}
|
||||
|
||||
WindowRenderer* nsBaseWidget::GetWindowRenderer() {
|
||||
if (!mLayerManager) {
|
||||
if (!mWindowRenderer) {
|
||||
if (!mShutdownObserver) {
|
||||
// We are shutting down, do not try to re-create a LayerManager
|
||||
return nullptr;
|
||||
|
|
@ -1518,14 +1517,14 @@ WindowRenderer* nsBaseWidget::GetWindowRenderer() {
|
|||
CreateCompositor();
|
||||
}
|
||||
|
||||
if (!mLayerManager) {
|
||||
mLayerManager = CreateBasicLayerManager();
|
||||
if (!mWindowRenderer) {
|
||||
mWindowRenderer = CreateBasicLayerManager();
|
||||
}
|
||||
}
|
||||
return mLayerManager;
|
||||
return mWindowRenderer;
|
||||
}
|
||||
|
||||
LayerManager* nsBaseWidget::CreateBasicLayerManager() {
|
||||
WindowRenderer* nsBaseWidget::CreateBasicLayerManager() {
|
||||
return new BasicLayerManager(this);
|
||||
}
|
||||
|
||||
|
|
@ -1534,10 +1533,10 @@ CompositorBridgeChild* nsBaseWidget::GetRemoteRenderer() {
|
|||
}
|
||||
|
||||
void nsBaseWidget::ClearCachedWebrenderResources() {
|
||||
if (!mLayerManager || !mLayerManager->AsWebRenderLayerManager()) {
|
||||
if (!mWindowRenderer || !mWindowRenderer->AsWebRender()) {
|
||||
return;
|
||||
}
|
||||
mLayerManager->ClearCachedResources();
|
||||
mWindowRenderer->AsWebRender()->ClearCachedResources();
|
||||
}
|
||||
|
||||
already_AddRefed<gfx::DrawTarget> nsBaseWidget::StartRemoteDrawing() {
|
||||
|
|
|
|||
|
|
@ -43,6 +43,7 @@ class gfxContext;
|
|||
namespace mozilla {
|
||||
class CompositorVsyncDispatcher;
|
||||
class LiveResizeListener;
|
||||
class FallbackRenderer;
|
||||
|
||||
#ifdef ACCESSIBILITY
|
||||
namespace a11y {
|
||||
|
|
@ -398,8 +399,7 @@ class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference {
|
|||
class AutoLayerManagerSetup {
|
||||
public:
|
||||
AutoLayerManagerSetup(nsBaseWidget* aWidget, gfxContext* aTarget,
|
||||
BufferMode aDoubleBuffering,
|
||||
ScreenRotation aRotation = mozilla::ROTATION_0);
|
||||
BufferMode aDoubleBuffering);
|
||||
~AutoLayerManagerSetup();
|
||||
|
||||
private:
|
||||
|
|
@ -576,7 +576,7 @@ class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference {
|
|||
return nsIWidget::CreateChildWindow();
|
||||
}
|
||||
|
||||
LayerManager* CreateBasicLayerManager();
|
||||
WindowRenderer* CreateBasicLayerManager();
|
||||
|
||||
nsPopupType PopupType() const { return mPopupType; }
|
||||
|
||||
|
|
@ -702,7 +702,7 @@ class nsBaseWidget : public nsIWidget, public nsSupportsWeakReference {
|
|||
nsIWidgetListener* mWidgetListener;
|
||||
nsIWidgetListener* mAttachedWidgetListener;
|
||||
nsIWidgetListener* mPreviouslyAttachedWidgetListener;
|
||||
RefPtr<LayerManager> mLayerManager;
|
||||
RefPtr<WindowRenderer> mWindowRenderer;
|
||||
RefPtr<CompositorSession> mCompositorSession;
|
||||
RefPtr<CompositorBridgeChild> mCompositorBridgeChild;
|
||||
|
||||
|
|
|
|||
|
|
@ -2075,7 +2075,7 @@ void nsWindow::Move(double aX, double aY) {
|
|||
// Workaround SetWindowPos bug with D3D9. If our window has a clip
|
||||
// region, some drivers or OSes may incorrectly copy into the clipped-out
|
||||
// area.
|
||||
if (IsPlugin() && !mLayerManager && mClipRects &&
|
||||
if (IsPlugin() && !mWindowRenderer && mClipRects &&
|
||||
(mClipRectCount != 1 ||
|
||||
!mClipRects[0].IsEqualInterior(
|
||||
LayoutDeviceIntRect(0, 0, mBounds.Width(), mBounds.Height())))) {
|
||||
|
|
@ -4081,8 +4081,8 @@ bool nsWindow::HasPendingInputEvent() {
|
|||
**************************************************************/
|
||||
|
||||
WindowRenderer* nsWindow::GetWindowRenderer() {
|
||||
if (mLayerManager) {
|
||||
return mLayerManager;
|
||||
if (mWindowRenderer) {
|
||||
return mWindowRenderer;
|
||||
}
|
||||
|
||||
if (!mLocalesChangedObserver) {
|
||||
|
|
@ -4093,12 +4093,12 @@ WindowRenderer* nsWindow::GetWindowRenderer() {
|
|||
::GetClientRect(mWnd, &windowRect);
|
||||
|
||||
// Try OMTC first.
|
||||
if (!mLayerManager && ShouldUseOffMainThreadCompositing()) {
|
||||
if (!mWindowRenderer && ShouldUseOffMainThreadCompositing()) {
|
||||
gfxWindowsPlatform::GetPlatform()->UpdateRenderMode();
|
||||
CreateCompositor();
|
||||
}
|
||||
|
||||
if (!mLayerManager) {
|
||||
if (!mWindowRenderer) {
|
||||
MOZ_ASSERT(!mCompositorSession && !mCompositorBridgeChild);
|
||||
MOZ_ASSERT(!mCompositorWidgetDelegate);
|
||||
|
||||
|
|
@ -4113,15 +4113,15 @@ WindowRenderer* nsWindow::GetWindowRenderer() {
|
|||
mBasicLayersSurface =
|
||||
new InProcessWinCompositorWidget(initData, options, this);
|
||||
mCompositorWidgetDelegate = mBasicLayersSurface;
|
||||
mLayerManager = CreateBasicLayerManager();
|
||||
mWindowRenderer = CreateBasicLayerManager();
|
||||
}
|
||||
|
||||
NS_ASSERTION(mLayerManager, "Couldn't provide a valid layer manager.");
|
||||
NS_ASSERTION(mWindowRenderer, "Couldn't provide a valid window renderer.");
|
||||
|
||||
if (mLayerManager) {
|
||||
if (mWindowRenderer) {
|
||||
// Update the size constraints now that the layer manager has been
|
||||
// created.
|
||||
KnowsCompositor* knowsCompositor = mLayerManager->AsKnowsCompositor();
|
||||
KnowsCompositor* knowsCompositor = mWindowRenderer->AsKnowsCompositor();
|
||||
if (knowsCompositor) {
|
||||
SizeConstraints c = mSizeConstraints;
|
||||
mMaxTextureSize = knowsCompositor->GetMaxTextureSize();
|
||||
|
|
@ -4131,7 +4131,7 @@ WindowRenderer* nsWindow::GetWindowRenderer() {
|
|||
}
|
||||
}
|
||||
|
||||
return mLayerManager;
|
||||
return mWindowRenderer;
|
||||
}
|
||||
|
||||
/**************************************************************
|
||||
|
|
@ -8034,9 +8034,9 @@ BOOL CALLBACK nsWindow::ClearResourcesCallback(HWND aWnd, LPARAM aMsg) {
|
|||
}
|
||||
|
||||
void nsWindow::ClearCachedResources() {
|
||||
if (mLayerManager &&
|
||||
mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC) {
|
||||
mLayerManager->ClearCachedResources();
|
||||
if (mWindowRenderer &&
|
||||
mWindowRenderer->GetBackendType() == LayersBackend::LAYERS_BASIC) {
|
||||
mWindowRenderer->AsLayerManager()->ClearCachedResources();
|
||||
}
|
||||
::EnumChildWindows(mWnd, nsWindow::ClearResourcesCallback, 0);
|
||||
}
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче