deleted file mode 100644
--- a/gfx/doc/README.displayitem
+++ /dev/null
@@ -1,28 +0,0 @@
-How to add a new WebRender display item from a Gecko Display item, the general flow is to:
-
-(1) Force layout to create a new active layer for the gecko display item.
-(2) Plumb the data needed for the display item from content through WebRenderBridgeParent on the parent side.
-(3) From WebRenderBridgeParent, call out into bindings.rs and implement the appropriate WR calls.
-
-More detailed steps are:
-
-1) Force layout to create an active layer for the gecko display item.
-See http://searchfox.org/mozilla-central/source/layout/painting/nsDisplayList.h#1850
-
-For most items, we should just be creating a DisplayItemLayer. The DisplayItemLayer has a pointer to the nsDisplayItem. To layerize, just return an active layer for the current item.
-
-See https://hg.mozilla.org/projects/graphics/file/c8873c351679e4a394170cd899e8b5a5fb2a00e7/layout/painting/nsDisplayList.cpp#l4403
-
-Thus for most display items, it's just implementing:
-GetLayerState,
-BuildLayer (which should just call BuildDisplayItemLayer)
-CreateWebRenderCommands.
-
-2) When implementing CreateWebRenderCommands, take a look at the nsDisplayItem::Paint method and reproduce the logic in webrender display items.
-
-If you need to implement a new WebRender display item (generally shouldn't be needed):
-1) If you need to pipe in a new WR display item type, do it in WebRenderMessages.ipdl.
-2) If you need to add a custom IPC serialization mechanism, do it in WebRenderMessageUtils.h
-3) Add a new function in WebRender.h that will call out into webrender for a new WR display item.
-4) In WebRenderBridgeParent::ProcessWebRenderCommands, call out to the new function in (3).
-5) Fill out the function in (3) in bindings.rs to make webrender do the right thing.
--- a/gfx/layers/Layers.cpp
+++ b/gfx/layers/Layers.cpp
@@ -2069,44 +2069,16 @@ ContainerLayer::DumpPacket(layerscope::L
Layer::DumpPacket(aPacket, aParent);
// Get this layer data
using namespace layerscope;
LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
layer->set_type(LayersPacket::Layer::ContainerLayer);
}
void
-DisplayItemLayer::EndTransaction() {
- mItem = nullptr;
- mBuilder = nullptr;
-}
-
-void
-DisplayItemLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
-{
- Layer::PrintInfo(aStream, aPrefix);
- const char* type = "TYPE_UNKNOWN";
- if (mItem) {
- type = mItem->Name();
- }
-
- aStream << " [itype type=" << type << "]";
-}
-
-void
-DisplayItemLayer::DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent)
-{
- Layer::DumpPacket(aPacket, aParent);
- // Get this layer data
- using namespace layerscope;
- LayersPacket::Layer* layer = aPacket->mutable_layer(aPacket->layer_size()-1);
- layer->set_type(LayersPacket::Layer::DisplayItemLayer);
-}
-
-void
ColorLayer::PrintInfo(std::stringstream& aStream, const char* aPrefix)
{
Layer::PrintInfo(aStream, aPrefix);
AppendToString(aStream, mColor, " [color=", "]");
AppendToString(aStream, mBounds, " [bounds=", "]");
}
void
@@ -2367,32 +2339,16 @@ LayerManager::DumpPacket(layerscope::Lay
// Add a new layer data (LayerManager)
LayersPacket::Layer* layer = aPacket->add_layer();
layer->set_type(LayersPacket::Layer::LayerManager);
layer->set_ptr(reinterpret_cast<uint64_t>(this));
// Layer Tree Root
layer->set_parentptr(0);
}
-void
-LayerManager::TrackDisplayItemLayer(RefPtr<DisplayItemLayer> aLayer)
-{
- mDisplayItemLayers.AppendElement(aLayer);
-}
-
-void
-LayerManager::ClearDisplayItemLayers()
-{
- for (uint32_t i = 0; i < mDisplayItemLayers.Length(); i++) {
- mDisplayItemLayers[i]->EndTransaction();
- }
-
- mDisplayItemLayers.Clear();
-}
-
/*static*/ bool
LayerManager::IsLogEnabled()
{
return MOZ_LOG_TEST(GetLog(), LogLevel::Debug);
}
bool
LayerManager::SetPendingScrollUpdateForNextTransaction(FrameMetrics::ViewID aScrollId,
--- a/gfx/layers/Layers.h
+++ b/gfx/layers/Layers.h
@@ -83,17 +83,16 @@ class AsyncPanZoomController;
class BasicLayerManager;
class ClientLayerManager;
class HostLayerManager;
class Layer;
class LayerMetricsWrapper;
class PaintedLayer;
class ContainerLayer;
class ImageLayer;
-class DisplayItemLayer;
class ColorLayer;
class CompositorAnimations;
class CompositorBridgeChild;
class CanvasLayer;
class BorderLayer;
class ReadbackLayer;
class ReadbackProcessor;
class RefLayer;
@@ -441,41 +440,27 @@ public:
*/
virtual already_AddRefed<ReadbackLayer> CreateReadbackLayer() { return nullptr; }
/**
* CONSTRUCTION PHASE ONLY
* Create a RefLayer for this manager's layer tree.
*/
virtual already_AddRefed<RefLayer> CreateRefLayer() { return nullptr; }
/**
- * CONSTRUCTION PHASE ONLY
- * Create a DisplayItemLayer for this manager's layer tree.
- */
- virtual already_AddRefed<DisplayItemLayer> CreateDisplayItemLayer() { return nullptr; }
- /**
* Can be called anytime, from any thread.
*
* Creates an Image container which forwards its images to the compositor within
* layer transactions on the main thread or asynchronously using the ImageBridge IPDL protocol.
* In the case of asynchronous, If the protocol is not available, the returned ImageContainer
* will forward images within layer transactions.
*/
static already_AddRefed<ImageContainer> CreateImageContainer(ImageContainer::Mode flag
= ImageContainer::SYNCHRONOUS);
/**
- * Since the lifetimes of display items and display item layers are different,
- * calling this tells the layer manager that the display item layer is valid for
- * only one transaction. Users should call ClearDisplayItemLayers() to remove
- * references to the dead display item at the end of a transaction.
- */
- virtual void TrackDisplayItemLayer(RefPtr<DisplayItemLayer> aLayer);
- virtual void ClearDisplayItemLayers();
-
- /**
* Type of layer manager his is. This is to be used sparsely in order to
* avoid a lot of Layers backend specific code. It should be used only when
* Layers backend specific functionality is necessary.
*/
virtual LayersBackend GetBackendType() = 0;
/**
* Type of layers backend that will be used to composite this layer tree.
@@ -784,24 +769,16 @@ public:
* scroll position updates to the APZ code.
*/
virtual bool SetPendingScrollUpdateForNextTransaction(FrameMetrics::ViewID aScrollId,
const ScrollUpdateInfo& aUpdateInfo);
Maybe<ScrollUpdateInfo> GetPendingScrollInfoUpdate(FrameMetrics::ViewID aScrollId);
void ClearPendingScrollInfoUpdate();
private:
std::map<FrameMetrics::ViewID,ScrollUpdateInfo> mPendingScrollUpdates;
-
- // Display items are only valid during this transaction.
- // At the end of the transaction, we have to go and clear out
- // DisplayItemLayer's and null their display item. See comment
- // above DisplayItemLayer declaration.
- // Since layers are ref counted, we also have to stop holding
- // a reference to the display item layer as well.
- nsTArray<RefPtr<DisplayItemLayer>> mDisplayItemLayers;
};
/**
* A Layer represents anything that can be rendered onto a destination
* surface.
*/
class Layer {
NS_INLINE_DECL_REFCOUNTING(Layer)
@@ -1573,22 +1550,16 @@ public:
virtual HostLayer* AsHostLayer() { return nullptr; }
/**
* Dynamic cast to a ShadowableLayer. Return null if this is not a
* ShadowableLayer. Can be used anytime.
*/
virtual ShadowableLayer* AsShadowableLayer() { return nullptr; }
- /**
- * Dynamic cast as a DisplayItemLayer. Return null if not a
- * DisplayItemLayer. Can be used anytime.
- */
- virtual DisplayItemLayer* AsDisplayItemLayer() { return nullptr; }
-
// These getters can be used anytime. They return the effective
// values that should be used when drawing this layer to screen,
// accounting for this layer possibly being a shadow.
const Maybe<ParentLayerIntRect>& GetLocalClipRect();
const LayerIntRegion& GetLocalVisibleRegion();
bool Extend3DContext() {
return GetContentFlags() & CONTENT_EXTEND_3D_CONTEXT;
@@ -2389,71 +2360,16 @@ protected:
bool mSupportsComponentAlphaChildren;
bool mMayHaveReadbackChild;
// This is updated by ComputeDifferences. This will be true if we need to invalidate
// the intermediate surface.
bool mChildrenChanged;
};
/**
- * A generic layer that references back to its display item.
- *
- * In order to not throw away information early in the pipeline from layout -> webrender,
- * we'd like a generic layer type that can represent all the nsDisplayItems instead of
- * creating a new layer type for each nsDisplayItem for Webrender. Another option
- * is to break down nsDisplayItems into smaller nsDisplayItems early in the pipeline.
- * The problem with this is that the whole pipeline would have to deal with more
- * display items, which is slower.
- *
- * An alternative is to create a DisplayItemLayer, but the wrinkle with this is that
- * it has a pointer to its nsDisplayItem. Managing the lifetime is key as display items
- * only live as long as their display list builder, which goes away at the end of a paint.
- * Layers however, are retained between paints.
- * It's ok to recycle a DisplayItemLayer for a different display item since its just a pointer.
- * Instead, when a layer transaction is completed, it is up to the layer manager to tell
- * DisplayItemLayers that the display item pointer is no longer valid.
- */
-class DisplayItemLayer : public Layer {
- public:
- virtual DisplayItemLayer* AsDisplayItemLayer() override { return this; }
- void EndTransaction();
-
- MOZ_LAYER_DECL_NAME("DisplayItemLayer", TYPE_DISPLAYITEM)
-
- void SetDisplayItem(nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder) {
- mItem = aItem;
- mBuilder = aBuilder;
- }
-
- nsDisplayItem* GetDisplayItem() { return mItem; }
- nsDisplayListBuilder* GetDisplayListBuilder() { return mBuilder; }
-
- virtual void ComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface) override
- {
- gfx::Matrix4x4 idealTransform = GetLocalTransform() * aTransformToSurface;
- mEffectiveTransform = SnapTransformTranslation(idealTransform, nullptr);
- ComputeEffectiveTransformForMaskLayers(aTransformToSurface);
- }
-
- protected:
- DisplayItemLayer(LayerManager* aManager, void* aImplData)
- : Layer(aManager, aImplData)
- , mItem(nullptr)
- {}
-
- virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
-
- virtual void DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent) override;
-
- // READ COMMENT ABOVE TO ENSURE WE DON'T HAVE A DANGLING POINTER
- nsDisplayItem* mItem;
- nsDisplayListBuilder* mBuilder;
-};
-
-/**
* A Layer which just renders a solid color in its visible region. It actually
* can fill any area that contains the visible region, so if you need to
* restrict the area filled, set a clip region on this layer.
*/
class ColorLayer : public Layer {
public:
virtual ColorLayer* AsColorLayer() override { return this; }
deleted file mode 100644
--- a/gfx/layers/basic/BasicDisplayItemLayer.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/* -*- 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/. */
-
-#include "BasicLayersImpl.h" // for FillRectWithMask, etc
-#include "Layers.h" // for Layer, etc
-#include "BasicImplData.h" // for BasicImplData
-#include "BasicLayers.h" // for BasicLayerManager
-#include "gfxContext.h" // for gfxContext, etc
-#include "gfxRect.h" // for gfxRect
-#include "gfx2DGlue.h"
-#include "mozilla/mozalloc.h" // for operator new
-#include "nsCOMPtr.h" // for already_AddRefed
-#include "nsDebug.h" // for NS_ASSERTION
-#include "nsISupportsImpl.h" // for Layer::AddRef, etc
-#include "nsRect.h" // for mozilla::gfx::IntRect
-#include "nsRegion.h" // for nsIntRegion
-#include "mozilla/gfx/PathHelpers.h"
-#include "mozilla/gfx/Helpers.h"
-#include "nsDisplayList.h" // for nsDisplayItem
-#include "nsCaret.h"
-
-using namespace mozilla::gfx;
-
-namespace mozilla {
-namespace layers {
-
-class BasicDisplayItemLayer : public DisplayItemLayer, public BasicImplData {
-public:
- explicit BasicDisplayItemLayer(BasicLayerManager* aLayerManager) :
- DisplayItemLayer(aLayerManager, static_cast<BasicImplData*>(this))
- {
- MOZ_COUNT_CTOR(BasicDisplayItemLayer);
- }
-
-protected:
- virtual ~BasicDisplayItemLayer()
- {
- MOZ_COUNT_DTOR(BasicDisplayItemLayer);
- }
-
-public:
- virtual void SetVisibleRegion(const LayerIntRegion& aRegion) override
- {
- NS_ASSERTION(BasicManager()->InConstruction(),
- "Can only set properties in construction phase");
- DisplayItemLayer::SetVisibleRegion(aRegion);
- }
-
- virtual void Paint(DrawTarget* aDT,
- const gfx::Point& aDeviceOffset,
- Layer* aMaskLayer) override
- {
- if (IsHidden() || !mItem || !mBuilder) {
- return;
- }
-
- AutoRestoreTransform autoRestoreTransform(aDT);
- Matrix transform = aDT->GetTransform();
- RefPtr<gfxContext> context = gfxContext::CreateOrNull(aDT, aDeviceOffset);
- context->SetMatrix(transform);
-
- mItem->Paint(mBuilder, context);
- }
-
-protected:
- BasicLayerManager* BasicManager()
- {
- return static_cast<BasicLayerManager*>(mManager);
- }
-};
-
-already_AddRefed<DisplayItemLayer>
-BasicLayerManager::CreateDisplayItemLayer()
-{
- NS_ASSERTION(InConstruction(), "Only allowed in construction phase");
- RefPtr<DisplayItemLayer> layer = new BasicDisplayItemLayer(this);
- return layer.forget();
-}
-
-} // namespace layers
-} // namespace mozilla
--- a/gfx/layers/basic/BasicLayerManager.cpp
+++ b/gfx/layers/basic/BasicLayerManager.cpp
@@ -648,18 +648,16 @@ BasicLayerManager::EndTransactionInterna
if (!mTransactionIncomplete) {
// This is still valid if the transaction was incomplete.
mUsingDefaultTarget = false;
}
NS_ASSERTION(!aCallback || !mTransactionIncomplete,
"If callback is not null, transaction must be complete");
- ClearDisplayItemLayers();
-
// XXX - We should probably assert here that for an incomplete transaction
// out target is the default target.
return !mTransactionIncomplete;
}
void
BasicLayerManager::FlashWidgetUpdateArea(gfxContext *aContext)
--- a/gfx/layers/basic/BasicLayers.h
+++ b/gfx/layers/basic/BasicLayers.h
@@ -21,17 +21,16 @@
#include "nsRegion.h" // for nsIntRegion
#include "nscore.h" // for nsAString, etc
class nsIWidget;
namespace mozilla {
namespace layers {
-class DisplayItemLayer;
class ImageFactory;
class ImageLayer;
class PaintLayerContext;
class ReadbackLayer;
/**
* This is a cairo/Thebes-only, main-thread-only implementation of layers.
*
@@ -112,17 +111,16 @@ public:
virtual already_AddRefed<PaintedLayer> CreatePaintedLayer() override;
virtual already_AddRefed<ContainerLayer> CreateContainerLayer() override;
virtual already_AddRefed<ImageLayer> CreateImageLayer() override;
virtual already_AddRefed<CanvasLayer> CreateCanvasLayer() override;
virtual already_AddRefed<ColorLayer> CreateColorLayer() override;
virtual already_AddRefed<BorderLayer> CreateBorderLayer() override;
virtual already_AddRefed<ReadbackLayer> CreateReadbackLayer() override;
- virtual already_AddRefed<DisplayItemLayer> CreateDisplayItemLayer() override;
virtual ImageFactory *GetImageFactory();
virtual LayersBackend GetBackendType() override { return LayersBackend::LAYERS_BASIC; }
virtual void GetBackendName(nsAString& name) override { name.AssignLiteral("Basic"); }
bool InConstruction() { return mPhase == PHASE_CONSTRUCTION; }
#ifdef DEBUG
bool InDrawing() { return mPhase == PHASE_DRAWING; }
--- a/gfx/layers/moz.build
+++ b/gfx/layers/moz.build
@@ -334,17 +334,16 @@ UNIFIED_SOURCES += [
'AsyncCanvasRenderer.cpp',
'AxisPhysicsModel.cpp',
'AxisPhysicsMSDModel.cpp',
'basic/BasicBorderLayer.cpp',
'basic/BasicCanvasLayer.cpp',
'basic/BasicColorLayer.cpp',
'basic/BasicCompositor.cpp',
'basic/BasicContainerLayer.cpp',
- 'basic/BasicDisplayItemLayer.cpp',
'basic/BasicImages.cpp',
'basic/BasicLayerManager.cpp',
'basic/BasicLayersImpl.cpp',
'basic/BasicPaintedLayer.cpp',
'basic/TextureHostBasic.cpp',
'BSPTree.cpp',
'BufferTexture.cpp',
'BufferUnrotate.cpp',
--- a/gfx/layers/wr/WebRenderLayerManager.cpp
+++ b/gfx/layers/wr/WebRenderLayerManager.cpp
@@ -321,18 +321,16 @@ WebRenderLayerManager::EndTransactionWit
{
AUTO_PROFILER_TRACING("Paint", "ForwardDPTransaction");
WrBridge()->EndTransaction(contentSize, dl, resourceUpdates, size.ToUnknownSize(),
mLatestTransactionId, mScrollData, transactionStart);
}
MakeSnapshotIfRequired(size);
mNeedsComposite = false;
-
- ClearDisplayItemLayers();
}
void
WebRenderLayerManager::SetFocusTarget(const FocusTarget& aFocusTarget)
{
mFocusTarget = aFocusTarget;
}
--- a/gfx/thebes/gfxPrefs.h
+++ b/gfx/thebes/gfxPrefs.h
@@ -544,28 +544,18 @@ private:
DECL_GFX_PREF(Once, "image.multithreaded_decoding.limit", ImageMTDecodingLimit, int32_t, -1);
DECL_GFX_PREF(Once, "image.multithreaded_decoding.idle_timeout", ImageMTDecodingIdleTimeout, int32_t, -1);
DECL_GFX_PREF(Once, "layers.acceleration.disabled", LayersAccelerationDisabledDoNotUseDirectly, bool, false);
DECL_GFX_PREF(Live, "layers.acceleration.draw-fps", LayersDrawFPS, bool, false);
DECL_GFX_PREF(Live, "layers.acceleration.draw-fps.print-histogram", FPSPrintHistogram, bool, false);
DECL_GFX_PREF(Live, "layers.acceleration.draw-fps.write-to-file", WriteFPSToFile, bool, false);
DECL_GFX_PREF(Once, "layers.acceleration.force-enabled", LayersAccelerationForceEnabledDoNotUseDirectly, bool, false);
- DECL_GFX_PREF(Live, "layers.advanced.background-color", LayersAllowBackgroundColorLayers, bool, false);
- DECL_OVERRIDE_PREF(Live, "layers.advanced.background-image", LayersAllowBackgroundImage, gfxPrefs::OverrideBase_WebRender());
+ DECL_GFX_PREF(Live, "layers.advanced.border-layers", LayersAllowBorderLayers, bool, false);
DECL_GFX_PREF(Live, "layers.advanced.basic-layer.enabled", LayersAdvancedBasicLayerEnabled, bool, false);
- DECL_OVERRIDE_PREF(Live, "layers.advanced.border-layers", LayersAllowBorderLayers, gfxPrefs::OverrideBase_WebRender());
- DECL_OVERRIDE_PREF(Live, "layers.advanced.bullet-layers", LayersAllowBulletLayers, gfxPrefs::OverrideBase_WebRender());
- DECL_OVERRIDE_PREF(Live, "layers.advanced.canvas-background-color", LayersAllowCanvasBackgroundColorLayers, gfxPrefs::OverrideBase_WebRender());
- DECL_GFX_PREF(Live, "layers.advanced.caret-layers", LayersAllowCaretLayers, bool, false);
- DECL_OVERRIDE_PREF(Live, "layers.advanced.columnRule-layers", LayersAllowColumnRuleLayers, gfxPrefs::OverrideBase_WebRender());
- DECL_OVERRIDE_PREF(Live, "layers.advanced.image-layers", LayersAllowImageLayers, gfxPrefs::OverrideBase_WebRender());
- DECL_OVERRIDE_PREF(Live, "layers.advanced.outline-layers", LayersAllowOutlineLayers, gfxPrefs::OverrideBase_WebRender());
- DECL_GFX_PREF(Live, "layers.advanced.solid-color", LayersAllowSolidColorLayers, bool, false);
- DECL_GFX_PREF(Live, "layers.advanced.table", LayersAllowTable, bool, false);
DECL_GFX_PREF(Once, "layers.amd-switchable-gfx.enabled", LayersAMDSwitchableGfxEnabled, bool, false);
DECL_GFX_PREF(Once, "layers.async-pan-zoom.enabled", AsyncPanZoomEnabledDoNotUseDirectly, bool, true);
DECL_GFX_PREF(Once, "layers.async-pan-zoom.separate-event-thread", AsyncPanZoomSeparateEventThread, bool, false);
DECL_GFX_PREF(Live, "layers.bench.enabled", LayersBenchEnabled, bool, false);
DECL_GFX_PREF(Once, "layers.bufferrotation.enabled", BufferRotationEnabled, bool, true);
DECL_GFX_PREF(Live, "layers.child-process-shutdown", ChildProcessShutdown, bool, true);
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
// If MOZ_GFX_OPTIMIZE_MOBILE is defined, we force component alpha off
--- a/layout/forms/nsButtonFrameRenderer.cpp
+++ b/layout/forms/nsButtonFrameRenderer.cpp
@@ -92,21 +92,16 @@ public:
virtual bool CreateWebRenderCommands(
mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
- virtual already_AddRefed<Layer> BuildLayer(
- nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
-
bool CanBuildWebRenderDisplayItems();
virtual void Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) const override;
NS_DISPLAY_DECL_NAME("ButtonBoxShadowOuter", TYPE_BUTTON_BOX_SHADOW_OUTER)
};
@@ -144,25 +139,16 @@ nsDisplayButtonBoxShadowOuter::CanBuildW
// input buttons.
if (nativeTheme) {
return false;
}
return true;
}
-already_AddRefed<Layer>
-nsDisplayButtonBoxShadowOuter::BuildLayer(
- nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
bool
nsDisplayButtonBoxShadowOuter::CreateWebRenderCommands(
mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
@@ -255,43 +241,32 @@ public:
virtual void Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) const override;
virtual nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion *aInvalidRegion) const override;
- virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
NS_DISPLAY_DECL_NAME("ButtonBorderBackground", TYPE_BUTTON_BORDER_BACKGROUND)
private:
nsButtonFrameRenderer* mBFR;
};
nsDisplayItemGeometry*
nsDisplayButtonBorder::AllocateGeometry(nsDisplayListBuilder* aBuilder)
{
return new nsDisplayItemGenericImageGeometry(this, aBuilder);
}
-already_AddRefed<Layer>
-nsDisplayButtonBorder::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
bool
nsDisplayButtonBorder::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
// This is really a combination of paint box shadow inner +
@@ -379,19 +354,16 @@ public:
#endif
nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion *aInvalidRegion) const override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) override;
- virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
NS_DISPLAY_DECL_NAME("ButtonForeground", TYPE_BUTTON_FOREGROUND)
private:
nsButtonFrameRenderer* mBFR;
@@ -432,24 +404,16 @@ void nsDisplayButtonForeground::Paint(ns
// Draw the -moz-focus-inner border
ImgDrawResult result =
mBFR->PaintInnerFocusBorder(aBuilder, presContext, *aCtx, mVisibleRect, r);
nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, result);
}
}
-already_AddRefed<mozilla::layers::Layer>
-nsDisplayButtonForeground::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
bool
nsDisplayButtonForeground::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
Maybe<nsCSSBorderRenderer> br;
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -626,24 +626,16 @@ public:
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) const override
{
*aSnap = false;
return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame();
}
- virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters) override;
-
- virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters) override;
-
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue&,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
virtual void HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
HitTestState* aState,
@@ -687,66 +679,16 @@ public:
return nsDisplayItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);
}
protected:
Maybe<BulletRenderer> mBulletRenderer;
};
-LayerState
-nsDisplayBullet::GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters)
-{
- if (!ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowBulletLayers)) {
- return LAYER_NONE;
- }
- RefPtr<gfxContext> screenRefCtx = gfxContext::CreateOrNull(
- gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget().get());
-
- Maybe<BulletRenderer> br = static_cast<nsBulletFrame*>(mFrame)->
- CreateBulletRenderer(*screenRefCtx, ToReferenceFrame());
-
- if (!br) {
- return LAYER_NONE;
- }
-
- if (br->IsImageType()) {
- uint32_t flags = aBuilder->ShouldSyncDecodeImages()
- ? imgIContainer::FLAG_SYNC_DECODE
- : imgIContainer::FLAG_NONE;
-
- if (!br->IsImageContainerAvailable(aManager, flags)) {
- return LAYER_NONE;
- }
- }
-
- if (br->IsTextType()) {
- if (!br->BuildGlyphForText(this, mDisableSubpixelAA)) {
- return LAYER_NONE;
- }
- }
-
- mBulletRenderer = br;
- return LAYER_ACTIVE;
-}
-
-already_AddRefed<layers::Layer>
-nsDisplayBullet::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- if (!mBulletRenderer) {
- return nullptr;
- }
-
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
bool
nsDisplayBullet::CreateWebRenderCommands(wr::DisplayListBuilder& aBuilder,
wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
// FIXME: avoid needing to make this target if we're drawing text
--- a/layout/generic/nsCanvasFrame.cpp
+++ b/layout/generic/nsCanvasFrame.cpp
@@ -282,20 +282,16 @@ already_AddRefed<Layer>
nsDisplayCanvasBackgroundColor::BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters)
{
if (NS_GET_A(mColor) == 0) {
return nullptr;
}
- if (aManager->GetBackendType() == layers::LayersBackend::LAYERS_WR) {
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
- }
-
RefPtr<ColorLayer> layer = static_cast<ColorLayer*>
(aManager->GetLayerBuilder()->GetLeafLayerFor(aBuilder, this));
if (!layer) {
layer = aManager->CreateColorLayer();
if (!layer) {
return nullptr;
}
}
@@ -317,19 +313,16 @@ nsDisplayCanvasBackgroundColor::BuildLay
bool
nsDisplayCanvasBackgroundColor::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
ContainerLayerParameters parameter;
- if (GetLayerState(aDisplayListBuilder, aManager, parameter) != LAYER_ACTIVE) {
- return false;
- }
nsCanvasFrame *frame = static_cast<nsCanvasFrame *>(mFrame);
nsPoint offset = ToReferenceFrame();
nsRect bgClipRect = frame->CanvasArea() + offset;
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
LayoutDeviceRect rect = LayoutDeviceRect::FromAppUnits(
bgClipRect, appUnitsPerDevPixel);
--- a/layout/generic/nsCanvasFrame.h
+++ b/layout/generic/nsCanvasFrame.h
@@ -163,18 +163,17 @@ public:
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters) override
{
- if (ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowCanvasBackgroundColorLayers) ||
- ForceActiveLayers()) {
+ if (ForceActiveLayers()) {
return mozilla::LAYER_ACTIVE;
}
return mozilla::LAYER_NONE;
}
virtual void Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) override;
void SetExtraBackgroundColor(nscolor aColor)
--- a/layout/generic/nsColumnSetFrame.cpp
+++ b/layout/generic/nsColumnSetFrame.cpp
@@ -35,22 +35,16 @@ public:
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) const override
{
*aSnap = false;
return static_cast<nsColumnSetFrame*>(mFrame)->
CalculateColumnRuleBounds(ToReferenceFrame());
}
- virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters) override;
- virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
virtual void Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) override;
@@ -66,44 +60,16 @@ nsDisplayColumnRule::Paint(nsDisplayList
{
static_cast<nsColumnSetFrame*>(mFrame)->
CreateBorderRenderers(mBorderRenderers, aCtx, mVisibleRect, ToReferenceFrame());
for (auto iter = mBorderRenderers.begin(); iter != mBorderRenderers.end(); iter++) {
iter->DrawBorders();
}
}
-LayerState
-nsDisplayColumnRule::GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters)
-{
- if (!gfxPrefs::LayersAllowColumnRuleLayers()) {
- return LAYER_NONE;
- }
- RefPtr<gfxContext> screenRefCtx = gfxContext::CreateOrNull(
- gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget().get());
-
- static_cast<nsColumnSetFrame*>(mFrame)->
- CreateBorderRenderers(mBorderRenderers, screenRefCtx, mVisibleRect, ToReferenceFrame());
-
- if (mBorderRenderers.IsEmpty()) {
- return LAYER_NONE;
- }
-
- return LAYER_ACTIVE;
-}
-
-already_AddRefed<nsDisplayItem::Layer>
-nsDisplayColumnRule::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
bool
nsDisplayColumnRule::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
--- a/layout/generic/nsImageFrame.cpp
+++ b/layout/generic/nsImageFrame.cpp
@@ -1601,18 +1601,17 @@ nsDisplayImage::GetDestRect() const
return imageFrame->PredictedDestRect(frameContentBox);
}
LayerState
nsDisplayImage::GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters)
{
- if (!nsDisplayItem::ForceActiveLayers() &&
- !ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowImageLayers)) {
+ if (!nsDisplayItem::ForceActiveLayers()) {
bool animated = false;
if (!nsLayoutUtils::AnimatedImageLayersEnabled() ||
mImage->GetType() != imgIContainer::TYPE_RASTER ||
NS_FAILED(mImage->GetAnimated(&animated)) ||
!animated) {
if (!aManager->IsCompositingCheap() ||
!nsLayoutUtils::GPUImageScalingEnabled()) {
return LAYER_NONE;
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -3251,22 +3251,19 @@ bool
nsDisplayItem::ShouldUseAdvancedLayer(LayerManager* aManager, PrefFunc aFunc) const
{
return CanUseAdvancedLayer(aManager) ? aFunc() : false;
}
bool
nsDisplayItem::CanUseAdvancedLayer(LayerManager* aManager) const
{
- if (!gfxPrefs::LayersAdvancedBasicLayerEnabled() &&
- aManager && aManager->GetBackendType() != layers::LayersBackend::LAYERS_WR) {
- return false;
- }
-
- return true;
+ return gfxPrefs::LayersAdvancedBasicLayerEnabled() ||
+ !aManager ||
+ aManager->GetBackendType() == layers::LayersBackend::LAYERS_WR;
}
static const DisplayItemClipChain*
FindCommonAncestorClipForIntersection(const DisplayItemClipChain* aOne,
const DisplayItemClipChain* aTwo)
{
for (const ActiveScrolledRoot* asr =
ActiveScrolledRoot::PickDescendant(aOne->mASR, aTwo->mASR);
@@ -3315,53 +3312,30 @@ nsDisplayItem::IntersectClip(nsDisplayLi
nsRect
nsDisplayItem::GetClippedBounds(nsDisplayListBuilder* aBuilder) const
{
bool snap;
nsRect r = GetBounds(aBuilder, &snap);
return GetClip().ApplyNonRoundedIntersection(r);
}
-already_AddRefed<Layer>
-nsDisplayItem::BuildDisplayItemLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- RefPtr<Layer> oldLayer = aManager->GetLayerBuilder()->GetLeafLayerFor(aBuilder, this);
- RefPtr<DisplayItemLayer> layer = oldLayer ? oldLayer->AsDisplayItemLayer() : nullptr;
-
- if (!layer) {
- layer = aManager->CreateDisplayItemLayer();
-
- if (!layer) {
- return nullptr;
- }
- }
-
- aManager->TrackDisplayItemLayer(layer);
- layer->SetDisplayItem(this, aBuilder);
- layer->SetBaseTransform(gfx::Matrix4x4::Translation(aContainerParameters.mOffset.x,
- aContainerParameters.mOffset.y, 0));
- return layer.forget();
-}
-
nsRect
nsDisplaySolidColor::GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) const
{
*aSnap = true;
return mBounds;
}
LayerState
nsDisplaySolidColor::GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters)
{
- if (ForceActiveLayers() || ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowSolidColorLayers)) {
+ if (ForceActiveLayers()) {
return LAYER_ACTIVE;
}
return LAYER_NONE;
}
already_AddRefed<Layer>
nsDisplaySolidColor::BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
@@ -4059,21 +4033,16 @@ static void CheckForBorderItem(nsDisplay
LayerState
nsDisplayBackgroundImage::GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters)
{
mImageFlags = aBuilder->GetBackgroundPaintFlags();
CheckForBorderItem(this, mImageFlags);
- if (ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowBackgroundImage) &&
- CanBuildWebRenderDisplayItems(aManager)) {
- return LAYER_ACTIVE;
- }
-
ImageLayerization shouldLayerize = ShouldCreateOwnLayer(aBuilder, aManager);
if (shouldLayerize == NO_LAYER_NEEDED) {
// We can skip the call to CanOptimizeToImageLayer if we don't want a
// layer anyway.
return LAYER_NONE;
}
if (CanOptimizeToImageLayer(aManager, aBuilder)) {
@@ -4111,20 +4080,16 @@ nsDisplayBackgroundImage::GetLayerState(
return LAYER_NONE;
}
already_AddRefed<Layer>
nsDisplayBackgroundImage::BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters)
{
- if (ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowBackgroundImage)) {
- return BuildDisplayItemLayer(aBuilder, aManager, aParameters);
- }
-
RefPtr<ImageLayer> layer = static_cast<ImageLayer*>
(aManager->GetLayerBuilder()->GetLeafLayerFor(aBuilder, this));
if (!layer) {
layer = aManager->CreateImageLayer();
if (!layer)
return nullptr;
}
RefPtr<ImageContainer> imageContainer = GetContainer(aManager, aBuilder);
@@ -4147,17 +4112,17 @@ nsDisplayBackgroundImage::CanBuildWebRen
bool
nsDisplayBackgroundImage::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
ContainerLayerParameters parameter;
- if (GetLayerState(aDisplayListBuilder, aManager, parameter) != LAYER_ACTIVE) {
+ if (!CanBuildWebRenderDisplayItems(aManager)) {
return false;
}
if (aDisplayListBuilder) {
mImageFlags = aDisplayListBuilder->GetBackgroundPaintFlags();
}
CheckForBorderItem(this, mImageFlags);
nsCSSRendering::PaintBGParams params =
@@ -4747,18 +4712,17 @@ nsDisplayBackgroundColor::CanApplyOpacit
}
LayerState
nsDisplayBackgroundColor::GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters)
{
StyleGeometryBox clip = mBackgroundStyle->mImage.mLayers[0].mClip;
- if ((ForceActiveLayers() || ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowBackgroundColorLayers)) &&
- clip != StyleGeometryBox::Text) {
+ if (ForceActiveLayers() && clip != StyleGeometryBox::Text) {
return LAYER_ACTIVE;
}
return LAYER_NONE;
}
already_AddRefed<Layer>
nsDisplayBackgroundColor::BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
@@ -4972,72 +4936,48 @@ nsDisplayOutline::Paint(nsDisplayListBui
nsPoint offset = ToReferenceFrame();
nsCSSRendering::PaintOutline(mFrame->PresContext(), *aCtx, mFrame,
mVisibleRect,
nsRect(offset, mFrame->GetSize()),
mFrame->StyleContext());
}
-LayerState
-nsDisplayOutline::GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters)
-{
- if (!ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowOutlineLayers)) {
- return LAYER_NONE;
- }
-
- uint8_t outlineStyle = mFrame->StyleContext()->StyleOutline()->mOutlineStyle;
- if (outlineStyle == NS_STYLE_BORDER_STYLE_AUTO && nsLayoutUtils::IsOutlineStyleAutoEnabled()) {
- nsITheme* theme = mFrame->PresContext()->GetTheme();
- if (theme && theme->ThemeSupportsWidget(mFrame->PresContext(), mFrame,
- NS_THEME_FOCUS_OUTLINE)) {
- return LAYER_NONE;
- }
- }
-
- nsPoint offset = ToReferenceFrame();
- Maybe<nsCSSBorderRenderer> br =
- nsCSSRendering::CreateBorderRendererForOutline(mFrame->PresContext(),
- nullptr, mFrame,
- mVisibleRect,
- nsRect(offset, mFrame->GetSize()),
- mFrame->StyleContext());
-
- if (!br) {
- return LAYER_NONE;
- }
-
- mBorderRenderer = br;
-
- return LAYER_ACTIVE;
-}
-
-already_AddRefed<Layer>
-nsDisplayOutline::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
bool
nsDisplayOutline::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
ContainerLayerParameters parameter;
- if (GetLayerState(aDisplayListBuilder, aManager, parameter) != LAYER_ACTIVE) {
+
+ uint8_t outlineStyle = mFrame->StyleContext()->StyleOutline()->mOutlineStyle;
+ if (outlineStyle == NS_STYLE_BORDER_STYLE_AUTO && nsLayoutUtils::IsOutlineStyleAutoEnabled()) {
+ nsITheme* theme = mFrame->PresContext()->GetTheme();
+ if (theme && theme->ThemeSupportsWidget(mFrame->PresContext(), mFrame,
+ NS_THEME_FOCUS_OUTLINE)) {
+ return false;
+ }
+ }
+
+ nsPoint offset = ToReferenceFrame();
+
+ mozilla::Maybe<nsCSSBorderRenderer> borderRenderer =
+ nsCSSRendering::CreateBorderRendererForOutline(mFrame->PresContext(),
+ nullptr, mFrame,
+ mVisibleRect,
+ nsRect(offset, mFrame->GetSize()),
+ mFrame->StyleContext());
+
+ if (!borderRenderer) {
return false;
}
- mBorderRenderer->CreateWebRenderCommands(this, aBuilder, aResources, aSc);
+ borderRenderer->CreateWebRenderCommands(this, aBuilder, aResources, aSc);
return true;
}
bool
nsDisplayOutline::IsInvisibleInRect(const nsRect& aRect) const
{
const nsStyleOutline* outline = mFrame->StyleOutline();
nsRect borderBox(ToReferenceFrame(), mFrame->GetSize());
@@ -5444,36 +5384,16 @@ nsDisplayCaret::CreateWebRenderCommands(
aBuilder.PushRect(hook,
hook,
!BackfaceIsHidden(),
wr::ToColorF(color));
}
return true;
}
-LayerState
-nsDisplayCaret::GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters)
-{
- if (ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowCaretLayers)) {
- return LAYER_ACTIVE;
- }
-
- return LAYER_NONE;
-}
-
-already_AddRefed<Layer>
-nsDisplayCaret::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
nsDisplayBorder::nsDisplayBorder(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
: nsDisplayItem(aBuilder, aFrame)
, mBorderIsEmpty(false)
{
MOZ_COUNT_CTOR(nsDisplayBorder);
mBounds = CalculateBounds<nsRect>(*mFrame->StyleBorder());
}
@@ -5594,35 +5514,31 @@ already_AddRefed<Layer>
nsDisplayBorder::BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters)
{
if (mBorderIsEmpty) {
return nullptr;
}
- if (ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowBorderLayers)) {
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
- } else {
- RefPtr<BorderLayer> layer = static_cast<BorderLayer*>
- (aManager->GetLayerBuilder()->GetLeafLayerFor(aBuilder, this));
- if (!layer) {
- layer = aManager->CreateBorderLayer();
- if (!layer)
- return nullptr;
- }
- layer->SetRect(mRect);
- layer->SetCornerRadii(mCorners);
- layer->SetColors(mColors);
- layer->SetWidths(mWidths);
- layer->SetStyles(mBorderStyles);
- layer->SetBaseTransform(gfx::Matrix4x4::Translation(aContainerParameters.mOffset.x,
- aContainerParameters.mOffset.y, 0));
- return layer.forget();
- }
+ RefPtr<BorderLayer> layer = static_cast<BorderLayer*>
+ (aManager->GetLayerBuilder()->GetLeafLayerFor(aBuilder, this));
+ if (!layer) {
+ layer = aManager->CreateBorderLayer();
+ if (!layer)
+ return nullptr;
+ }
+ layer->SetRect(mRect);
+ layer->SetCornerRadii(mCorners);
+ layer->SetColors(mColors);
+ layer->SetWidths(mWidths);
+ layer->SetStyles(mBorderStyles);
+ layer->SetBaseTransform(gfx::Matrix4x4::Translation(aContainerParameters.mOffset.x,
+ aContainerParameters.mOffset.y, 0));
+ return layer.forget();
}
bool
nsDisplayBorder::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
@@ -5875,24 +5791,16 @@ nsDisplayBoxShadowOuter::ComputeVisibili
if (!nsDisplayItem::ComputeVisibility(aBuilder, aVisibleRegion)) {
return false;
}
mVisibleRegion.And(*aVisibleRegion, mVisibleRect);
return true;
}
-already_AddRefed<Layer>
-nsDisplayBoxShadowOuter::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
bool
nsDisplayBoxShadowOuter::CanBuildWebRenderDisplayItems()
{
nsCSSShadowArray* shadows = mFrame->StyleEffects()->mBoxShadow;
if (!shadows) {
return false;
}
@@ -6076,24 +5984,16 @@ nsDisplayBoxShadowInner::CanCreateWebRen
// input buttons.
if (nativeTheme) {
return false;
}
return true;
}
-already_AddRefed<Layer>
-nsDisplayBoxShadowInner::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
/* static */ void
nsDisplayBoxShadowInner::CreateInsetBoxShadowWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsRegion& aVisibleRegion,
nsIFrame* aFrame,
const nsRect aBorderRect)
{
if (!nsCSSRendering::ShouldPaintBoxShadowInner(aFrame)) {
--- a/layout/painting/nsDisplayList.h
+++ b/layout/painting/nsDisplayList.h
@@ -2545,24 +2545,16 @@ public:
* This function assumes that aData and aLayerData will either both be null,
* or will both be non-null. The caller is responsible for enforcing this.
*/
virtual bool UpdateScrollData(mozilla::layers::WebRenderScrollData* aData,
mozilla::layers::WebRenderLayerScrollData* aLayerData)
{ return false; }
/**
- * Builds a DisplayItemLayer and sets the display item to this.
- */
- already_AddRefed<Layer>
- BuildDisplayItemLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters);
-
- /**
* On entry, aVisibleRegion contains the region (relative to ReferenceFrame())
* which may be visible. If the display item opaquely covers an area, it
* can remove that area from aVisibleRegion before returning.
* nsDisplayList::ComputeVisibility automatically subtracts the region
* returned by GetOpaqueRegion, and automatically removes items whose bounds
* do not intersect the visible area, so implementations of
* nsDisplayItem::ComputeVisibility do not need to do these things.
* nsDisplayList::ComputeVisibility will already have set mVisibleRect on
@@ -3531,22 +3523,16 @@ public:
virtual ~nsDisplayCaret();
#endif
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,
bool* aSnap) const override;
virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("Caret", TYPE_CARET)
- virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters) override;
- virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
protected:
RefPtr<nsCaret> mCaret;
@@ -4424,20 +4410,16 @@ public:
mOpacity = 1.0f;
}
virtual nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override
{
return new nsDisplayBoxShadowOuterGeometry(this, aBuilder, mOpacity);
}
- virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
-
bool CanBuildWebRenderDisplayItems();
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
nsRect GetBoundsInternal();
@@ -4494,19 +4476,16 @@ public:
static bool CanCreateWebRenderCommands(nsDisplayListBuilder* aBuilder,
nsIFrame* aFrame,
nsPoint aReferencePoint);
static void CreateInsetBoxShadowWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsRegion& aVisibleRegion,
nsIFrame* aFrame,
const nsRect aBorderRect);
- virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
private:
nsRegion mVisibleRegion;
@@ -4522,33 +4501,25 @@ public:
MOZ_COUNT_CTOR(nsDisplayOutline);
}
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayOutline() {
MOZ_COUNT_DTOR(nsDisplayOutline);
}
#endif
- virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters) override;
- virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
virtual bool IsInvisibleInRect(const nsRect& aRect) const override;
virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) const override;
virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
NS_DISPLAY_DECL_NAME("Outline", TYPE_OUTLINE)
-
- mozilla::Maybe<nsCSSBorderRenderer> mBorderRenderer;
};
/**
* A class that lets you receive events within the frame bounds but never paints.
*/
class nsDisplayEventReceiver : public nsDisplayItem {
public:
nsDisplayEventReceiver(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -1260,27 +1260,21 @@ public:
#ifdef NS_BUILD_REFCNT_LOGGING
virtual ~nsDisplayTableBorderCollapse() {
MOZ_COUNT_DTOR(nsDisplayTableBorderCollapse);
}
#endif
virtual void Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) override;
- virtual already_AddRefed<layers::Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
- virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters) override;
NS_DISPLAY_DECL_NAME("TableBorderCollapse", TYPE_TABLE_BORDER_COLLAPSE)
};
void
nsDisplayTableBorderCollapse::Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx)
{
nsPoint pt = ToReferenceFrame();
@@ -1293,49 +1287,29 @@ nsDisplayTableBorderCollapse::Paint(nsDi
// But that would mean modifying PaintBCBorders, ugh
AutoRestoreTransform autoRestoreTransform(drawTarget);
drawTarget->SetTransform(
drawTarget->GetTransform().PreTranslate(ToPoint(devPixelOffset)));
static_cast<nsTableFrame*>(mFrame)->PaintBCBorders(*drawTarget, mVisibleRect - pt);
}
-already_AddRefed<layers::Layer>
-nsDisplayTableBorderCollapse::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
bool
nsDisplayTableBorderCollapse::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
static_cast<nsTableFrame *>(mFrame)->CreateWebRenderCommandsForBCBorders(aBuilder,
aSc,
ToReferenceFrame());
return true;
}
-LayerState
-nsDisplayTableBorderCollapse::GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters)
-{
- if (gfxPrefs::LayersAllowTable()) {
- return LAYER_ACTIVE;
- }
-
- return LAYER_NONE;
-}
-
/* static */ void
nsTableFrame::GenericTraversal(nsDisplayListBuilder* aBuilder, nsFrame* aFrame,
const nsDisplayListSet& aLists)
{
// This is similar to what nsContainerFrame::BuildDisplayListForNonBlockChildren
// does, except that we allow the children's background and borders to go
// in our BorderBackground list. This doesn't really affect background
// painting --- the children won't actually draw their own backgrounds
--- a/layout/xul/nsImageBoxFrame.cpp
+++ b/layout/xul/nsImageBoxFrame.cpp
@@ -535,36 +535,16 @@ void nsDisplayXULImage::Paint(nsDisplayL
flags |= imgIContainer::FLAG_HIGH_QUALITY_SCALING;
ImgDrawResult result = static_cast<nsImageBoxFrame*>(mFrame)->
PaintImage(*aCtx, mVisibleRect, ToReferenceFrame(), flags);
nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, result);
}
-LayerState
-nsDisplayXULImage::GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters)
-{
- if (ShouldUseAdvancedLayer(aManager, gfxPrefs::LayersAllowImageLayers) &&
- CanOptimizeToImageLayer(aManager, aBuilder)) {
- return LAYER_ACTIVE;
- }
- return LAYER_NONE;
-}
-
-already_AddRefed<Layer>
-nsDisplayXULImage::BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters)
-{
- return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
-}
-
bool
nsDisplayXULImage::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder)
{
nsImageBoxFrame* imageFrame = static_cast<nsImageBoxFrame*>(mFrame);
--- a/layout/xul/nsImageBoxFrame.h
+++ b/layout/xul/nsImageBoxFrame.h
@@ -169,24 +169,16 @@ public:
virtual void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion* aInvalidRegion) const override;
// Doesn't handle HitTest because nsLeafBoxFrame already creates an
// event receiver for us
virtual void Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) override;
- virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aParameters) override;
-
- virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
- LayerManager* aManager,
- const ContainerLayerParameters& aContainerParameters) override;
-
virtual bool CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
mozilla::wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
mozilla::layers::WebRenderLayerManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
NS_DISPLAY_DECL_NAME("XULImage", TYPE_XUL_IMAGE)
};
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -5991,34 +5991,16 @@ pref("asanreporter.clientid", "unknown")
#if defined(XP_WIN)
pref("layers.mlgpu.enabled", true);
// Both this and the master "enabled" pref must be on to use Advanced Layers
// on Windows 7.
pref("layers.mlgpu.enable-on-windows7", true);
#endif
-// Set advanced layers preferences here to have them show up in about:config or
-// to be overridable in reftest.list files. They should pretty much all be set
-// to a value of 2, and the conditional-pref code in gfxPrefs.h will convert
-// it to a boolean as appropriate. In particular, do NOT add ifdefs here to
-// turn these on and off, instead use the conditional-pref code in gfxPrefs.h
-// to do that.
-pref("layers.advanced.background-color", false);
-pref("layers.advanced.background-image", 2);
-pref("layers.advanced.border-layers", 2);
-pref("layers.advanced.bullet-layers", 2);
-pref("layers.advanced.canvas-background-color", 2);
-pref("layers.advanced.caret-layers", false);
-pref("layers.advanced.columnRule-layers", 2);
-pref("layers.advanced.image-layers", 2);
-pref("layers.advanced.outline-layers", 2);
-pref("layers.advanced.solid-color", false);
-pref("layers.advanced.table", false);
-
// Enable lowercased response header name
pref("dom.xhr.lowercase_header.enabled", false);
// Control whether clients.openWindow() opens windows in the same process
// that called the API vs following our normal multi-process selection
// algorithm. Restricting openWindow to same process improves service worker
// web compat in the short term. Once the SW multi-e10s refactor is complete
// this can be removed.