--- a/gfx/layers/wr/WebRenderDisplayItemLayer.cpp
+++ b/gfx/layers/wr/WebRenderDisplayItemLayer.cpp
@@ -110,16 +110,17 @@ WebRenderDisplayItemLayer::SendImageCont
mImageContainer = aContainer;
}
return mKey;
}
bool
WebRenderDisplayItemLayer::PushItemAsImage(wr::DisplayListBuilder& aBuilder,
+ const StackingContextHelper& aSc,
nsTArray<layers::WebRenderParentCommand>& aParentCommands)
{
if (!mImageContainer) {
mImageContainer = LayerManager::CreateImageContainer();
}
if (!mImageClient) {
mImageClient = ImageClient::CreateImageClient(CompositableType::IMAGE,
--- a/gfx/layers/wr/WebRenderDisplayItemLayer.h
+++ b/gfx/layers/wr/WebRenderDisplayItemLayer.h
@@ -24,16 +24,17 @@ public:
: DisplayItemLayer(aLayerManager, static_cast<WebRenderLayer*>(this))
{
MOZ_COUNT_CTOR(WebRenderDisplayItemLayer);
}
Maybe<wr::ImageKey> SendImageContainer(ImageContainer* aContainer,
nsTArray<layers::WebRenderParentCommand>& aParentCommands);
bool PushItemAsImage(wr::DisplayListBuilder& aBuilder,
+ const StackingContextHelper& aSc,
nsTArray<layers::WebRenderParentCommand>& aParentCommands);
protected:
virtual ~WebRenderDisplayItemLayer();
public:
Layer* GetLayer() override { return this; }
void RenderLayer(wr::DisplayListBuilder& aBuilder,
--- a/layout/forms/nsButtonFrameRenderer.cpp
+++ b/layout/forms/nsButtonFrameRenderer.cpp
@@ -211,20 +211,21 @@ nsDisplayButtonBorder::CreateWebRenderCo
nsTArray<WebRenderParentCommand>& aCommands,
WebRenderDisplayItemLayer* aLayer)
{
MOZ_ASSERT(mBorderRenderer);
// This is really a combination of paint box shadow inner +
// paint border.
nsRect buttonRect = nsRect(ToReferenceFrame(), mFrame->GetSize());
nsDisplayBoxShadowInner::CreateInsetBoxShadowWebRenderCommands(aBuilder,
+ aSc,
aLayer,
mFrame,
buttonRect);
- mBorderRenderer->CreateWebRenderCommands(aBuilder, aLayer);
+ mBorderRenderer->CreateWebRenderCommands(aBuilder, aSc, aLayer);
}
void
nsDisplayButtonBorder::ComputeInvalidationRegion(
nsDisplayListBuilder* aBuilder,
const nsDisplayItemGeometry* aGeometry,
nsRegion *aInvalidRegion)
{
@@ -374,17 +375,17 @@ nsDisplayButtonForeground::BuildLayer(ns
void
nsDisplayButtonForeground::CreateWebRenderCommands(wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer)
{
MOZ_ASSERT(mBorderRenderer.isSome());
- mBorderRenderer->CreateWebRenderCommands(aBuilder, aLayer);
+ mBorderRenderer->CreateWebRenderCommands(aBuilder, aSc, aLayer);
}
nsresult
nsButtonFrameRenderer::DisplayButton(nsDisplayListBuilder* aBuilder,
nsDisplayList* aBackground,
nsDisplayList* aForeground)
{
if (mFrame->StyleEffects()->mBoxShadow) {
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -487,17 +487,17 @@ BulletRenderer::CreateWebRenderCommandsF
wr::DisplayListBuilder& aBuilder,
const layers::StackingContextHelper& aSc,
nsTArray<layers::WebRenderParentCommand>& aParentCommands,
layers::WebRenderDisplayItemLayer* aLayer)
{
MOZ_ASSERT(IsPathType());
MOZ_ASSERT(aLayer->GetDisplayItem() == aItem);
- if (!aLayer->PushItemAsImage(aBuilder, aParentCommands)) {
+ if (!aLayer->PushItemAsImage(aBuilder, aSc, aParentCommands)) {
NS_WARNING("Fail to create WebRender commands for Bullet path.");
}
}
void
BulletRenderer::CreateWebRenderCommandsForText(nsDisplayItem* aItem,
wr::DisplayListBuilder& aBuilder,
const layers::StackingContextHelper& aSc,
--- a/layout/generic/nsColumnSetFrame.cpp
+++ b/layout/generic/nsColumnSetFrame.cpp
@@ -103,17 +103,17 @@ nsDisplayColumnRule::BuildLayer(nsDispla
void
nsDisplayColumnRule::CreateWebRenderCommands(wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
WebRenderDisplayItemLayer* aLayer)
{
MOZ_ASSERT(!mBorderRenderers.IsEmpty());
for (auto iter = mBorderRenderers.begin(); iter != mBorderRenderers.end(); iter++) {
- iter->CreateWebRenderCommands(aBuilder, aLayer);
+ iter->CreateWebRenderCommands(aBuilder, aSc, aLayer);
}
}
/**
* Tracking issues:
*
* XXX cursor movement around the top and bottom of colums seems to make the editor
* lose the caret.
--- a/layout/painting/nsCSSRendering.cpp
+++ b/layout/painting/nsCSSRendering.cpp
@@ -1970,16 +1970,17 @@ nsCSSRendering::CanBuildWebRenderDisplay
// We only support painting gradients and image for a single style image layer
return aBackgroundStyle->mImage.mLayers[aLayer].mImage.GetType() == eStyleImageType_Gradient ||
aBackgroundStyle->mImage.mLayers[aLayer].mImage.GetType() == eStyleImageType_Image;
}
DrawResult
nsCSSRendering::BuildWebRenderDisplayItemsForStyleImageLayer(const PaintBGParams& aParams,
mozilla::wr::DisplayListBuilder& aBuilder,
+ const mozilla::layers::StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer)
{
NS_PRECONDITION(aParams.frame,
"Frame is expected to be provided to BuildWebRenderDisplayItemsForStyleImageLayer");
nsStyleContext *sc;
if (!FindBackground(aParams.frame, &sc)) {
@@ -1995,17 +1996,17 @@ nsCSSRendering::BuildWebRenderDisplayIte
nsIContent* content = aParams.frame->GetContent();
if (!content || content->GetParent()) {
return DrawResult::NOT_READY;
}
sc = aParams.frame->StyleContext();
}
- return BuildWebRenderDisplayItemsForStyleImageLayerWithSC(aParams, aBuilder, aParentCommands, aLayer,
+ return BuildWebRenderDisplayItemsForStyleImageLayerWithSC(aParams, aBuilder, aSc, aParentCommands, aLayer,
sc, *aParams.frame->StyleBorder());
}
static bool
IsOpaqueBorderEdge(const nsStyleBorder& aBorder, mozilla::Side aSide)
{
if (aBorder.GetComputedBorder().Side(aSide) == 0)
return true;
@@ -2711,16 +2712,17 @@ nsCSSRendering::PaintStyleImageLayerWith
}
return result;
}
DrawResult
nsCSSRendering::BuildWebRenderDisplayItemsForStyleImageLayerWithSC(const PaintBGParams& aParams,
mozilla::wr::DisplayListBuilder& aBuilder,
+ const mozilla::layers::StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer,
nsStyleContext *aBackgroundSC,
const nsStyleBorder& aBorder)
{
MOZ_ASSERT(CanBuildWebRenderDisplayItemsForStyleImageLayer(aParams.presCtx,
aParams.frame,
aBackgroundSC->StyleBackground(),
@@ -2756,17 +2758,17 @@ nsCSSRendering::BuildWebRenderDisplayIte
nsBackgroundLayerState state =
PrepareImageLayer(&aParams.presCtx, aParams.frame,
aParams.paintFlags, paintBorderArea,
clipState.mBGClipArea, layer, nullptr);
if (!state.mFillArea.IsEmpty()) {
return state.mImageRenderer.BuildWebRenderDisplayItemsForLayer(&aParams.presCtx,
- aBuilder, aParentCommands, aLayer,
+ aBuilder, aSc, aParentCommands, aLayer,
state.mDestArea, state.mFillArea,
state.mAnchor + paintBorderArea.TopLeft(),
clipState.mDirtyRectInAppUnits,
state.mRepeatSize, aParams.opacity);
}
return DrawResult::SUCCESS;
}
--- a/layout/painting/nsCSSRendering.h
+++ b/layout/painting/nsCSSRendering.h
@@ -28,16 +28,17 @@ namespace mozilla {
namespace gfx {
struct Color;
class DrawTarget;
} // namespace gfx
namespace layers {
class ImageContainer;
+class StackingContextHelper;
class WebRenderDisplayItemLayer;
class WebRenderParentCommand;
} // namespace layers
namespace wr {
class DisplayListBuilder;
} // namespace wr
@@ -492,21 +493,23 @@ struct nsCSSRendering {
const nsStyleBorder& aBorder);
static bool CanBuildWebRenderDisplayItemsForStyleImageLayer(nsPresContext& aPresCtx,
nsIFrame *aFrame,
const nsStyleBackground* aBackgroundStyle,
int32_t aLayer);
static DrawResult BuildWebRenderDisplayItemsForStyleImageLayer(const PaintBGParams& aParams,
mozilla::wr::DisplayListBuilder& aBuilder,
+ const mozilla::layers::StackingContextHelper& aSc,
nsTArray<mozilla::layers::WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer);
static DrawResult BuildWebRenderDisplayItemsForStyleImageLayerWithSC(const PaintBGParams& aParams,
mozilla::wr::DisplayListBuilder& aBuilder,
+ const mozilla::layers::StackingContextHelper& aSc,
nsTArray<mozilla::layers::WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer,
nsStyleContext *mBackgroundSC,
const nsStyleBorder& aBorder);
/**
* Returns the rectangle covered by the given background layer image, taking
* into account background positioning, sizing, and repetition, but not
--- a/layout/painting/nsCSSRenderingBorders.cpp
+++ b/layout/painting/nsCSSRenderingBorders.cpp
@@ -3546,16 +3546,17 @@ nsCSSBorderRenderer::CanCreateWebRenderC
}
}
return true;
}
void
nsCSSBorderRenderer::CreateWebRenderCommands(wr::DisplayListBuilder& aBuilder,
+ const layers::StackingContextHelper& aSc,
layers::WebRenderDisplayItemLayer* aLayer,
gfx::Rect aClipRect)
{
LayoutDeviceRect outerRect = LayoutDeviceRect::FromUnknownRect(mOuterRect);
LayerRect transformedRect = aLayer->RelativeToParent(outerRect);
WrBorderSide side[4];
NS_FOR_CSS_SIDES(i) {
side[i] = wr::ToWrBorderSide(ToDeviceColor(mBorderColors[i]), mBorderStyles[i]);
--- a/layout/painting/nsCSSRenderingBorders.h
+++ b/layout/painting/nsCSSRenderingBorders.h
@@ -25,16 +25,17 @@
struct nsBorderColors;
class nsDisplayBorder;
namespace mozilla {
namespace gfx {
class GradientStops;
} // namespace gfx
namespace layers {
+class StackingContextHelper;
class WebRenderDisplayItemLayer;
} // namespace layers
} // namespace mozilla
// define this to enable a bunch of debug dump info
#undef DEBUG_NEW_BORDERS
/*
@@ -102,16 +103,17 @@ public:
nsBorderColors* const* aCompositeColors,
nscolor aBackgroundColor);
// draw the entire border
void DrawBorders();
bool CanCreateWebRenderCommands();
void CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
+ const mozilla::layers::StackingContextHelper& aSc,
mozilla::layers::WebRenderDisplayItemLayer* aLayer,
Rect aClipRect = Rect(0, 0, 0, 0));
// utility function used for background painting as well as borders
static void ComputeInnerRadii(const RectCornerRadii& aRadii,
const Float* aBorderSizes,
RectCornerRadii* aInnerRadiiRet);
--- a/layout/painting/nsCSSRenderingGradients.cpp
+++ b/layout/painting/nsCSSRenderingGradients.cpp
@@ -1022,16 +1022,17 @@ nsCSSGradientRenderer::BuildWebRenderPar
aLineStart = LayoutDevicePoint(mLineStart.x, mLineStart.y);
aLineEnd = LayoutDevicePoint(mLineEnd.x, mLineEnd.y);
aGradientRadius = LayoutDeviceSize(mRadiusX, mRadiusY);
}
void
nsCSSGradientRenderer::BuildWebRenderDisplayItems(wr::DisplayListBuilder& aBuilder,
+ const layers::StackingContextHelper& aSc,
layers::WebRenderDisplayItemLayer* aLayer,
const nsRect& aDest,
const nsRect& aFillArea,
const nsSize& aRepeatSize,
const CSSIntRect& aSrc,
float aOpacity)
{
if (aDest.IsEmpty() || aFillArea.IsEmpty()) {
--- a/layout/painting/nsCSSRenderingGradients.h
+++ b/layout/painting/nsCSSRenderingGradients.h
@@ -10,16 +10,17 @@
#include "nsStyleStruct.h"
#include "Units.h"
#include "mozilla/Maybe.h"
#include "mozilla/gfx/2D.h"
namespace mozilla {
namespace layers {
+class StackingContextHelper;
class WebRenderDisplayItemLayer;
} // namespace layers
namespace wr {
class DisplayListBuilder;
} // namespace wr
// A resolved color stop, with a specific position along the gradient line and
@@ -75,16 +76,17 @@ public:
* aLayer - the layer to make this display item relative to
* aDest - where the first tile of gradient is
* aFill - the area to be filled with tiles of aDest
* aRepeatSize - the distance from the origin of a tile
* to the next origin of a tile
* aSrc - the area of the gradient that will fill aDest
*/
void BuildWebRenderDisplayItems(wr::DisplayListBuilder& aBuilder,
+ const layers::StackingContextHelper& aSc,
layers::WebRenderDisplayItemLayer* aLayer,
const nsRect& aDest,
const nsRect& aFill,
const nsSize& aRepeatSize,
const mozilla::CSSIntRect& aSrc,
float aOpacity = 1.0);
private:
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -3437,17 +3437,17 @@ nsDisplayBackgroundImage::CreateWebRende
nsCSSRendering::PaintBGParams params =
nsCSSRendering::PaintBGParams::ForSingleLayer(*mFrame->PresContext(),
mVisibleRect, mBackgroundRect,
mFrame, 0, mLayer,
CompositionOp::OP_OVER);
params.bgClipRect = &mBounds;
image::DrawResult result =
- nsCSSRendering::BuildWebRenderDisplayItemsForStyleImageLayer(params, aBuilder, aParentCommands, aLayer);
+ nsCSSRendering::BuildWebRenderDisplayItemsForStyleImageLayer(params, aBuilder, aSc, aParentCommands, aLayer);
nsDisplayBackgroundGeometry::UpdateDrawResult(this, result);
}
void
nsDisplayBackgroundImage::HitTest(nsDisplayListBuilder* aBuilder,
const nsRect& aRect,
HitTestState* aState,
@@ -4234,17 +4234,17 @@ nsDisplayOutline::CreateWebRenderCommand
MOZ_ASSERT(mBorderRenderer.isSome());
gfx::Rect clip(0, 0, 0, 0);
if (GetClip().HasClip()) {
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
clip = LayoutDeviceRect::FromAppUnits(
GetClip().GetClipRect(), appUnitsPerDevPixel).ToUnknownRect();
}
- mBorderRenderer->CreateWebRenderCommands(aBuilder, aLayer, clip);
+ mBorderRenderer->CreateWebRenderCommands(aBuilder, aSc, aLayer, clip);
}
bool
nsDisplayOutline::IsInvisibleInRect(const nsRect& aRect)
{
const nsStyleOutline* outline = mFrame->StyleOutline();
nsRect borderBox(ToReferenceFrame(), mFrame->GetSize());
if (borderBox.Contains(aRect) &&
@@ -4753,16 +4753,17 @@ nsDisplayBorder::BuildLayer(nsDisplayLis
layer->SetBaseTransform(gfx::Matrix4x4::Translation(aContainerParameters.mOffset.x,
aContainerParameters.mOffset.y, 0));
return layer.forget();
}
}
void
nsDisplayBorder::CreateBorderImageWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
+ const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
WebRenderDisplayItemLayer* aLayer)
{
MOZ_ASSERT(mBorderImageRenderer);
if (!mBorderImageRenderer->mImageRenderer.IsReady()) {
return;
}
@@ -4870,26 +4871,26 @@ void
nsDisplayBorder::CreateWebRenderCommands(wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
WebRenderDisplayItemLayer* aLayer)
{
MOZ_ASSERT(mBorderImageRenderer || mBorderRenderer);
if (mBorderImageRenderer) {
- CreateBorderImageWebRenderCommands(aBuilder, aParentCommands, aLayer);
+ CreateBorderImageWebRenderCommands(aBuilder, aSc, aParentCommands, aLayer);
} else if (mBorderRenderer) {
gfx::Rect clip(0, 0, 0, 0);
if (GetClip().HasClip()) {
int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
clip = LayoutDeviceRect::FromAppUnits(
GetClip().GetClipRect(), appUnitsPerDevPixel).ToUnknownRect();
}
- mBorderRenderer->CreateWebRenderCommands(aBuilder, aLayer, clip);
+ mBorderRenderer->CreateWebRenderCommands(aBuilder, aSc, aLayer, clip);
}
}
void
nsDisplayBorder::Paint(nsDisplayListBuilder* aBuilder,
nsRenderingContext* aCtx) {
nsPoint offset = ToReferenceFrame();
@@ -5334,16 +5335,17 @@ nsDisplayBoxShadowInner::BuildLayer(nsDi
LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters)
{
return BuildDisplayItemLayer(aBuilder, aManager, aContainerParameters);
}
/* static */ void
nsDisplayBoxShadowInner::CreateInsetBoxShadowWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
+ const StackingContextHelper& aSc,
WebRenderDisplayItemLayer* aLayer,
nsIFrame* aFrame,
const nsRect aBorderRect)
{
if (!nsCSSRendering::ShouldPaintBoxShadowInner(aFrame)) {
return;
}
@@ -5404,17 +5406,17 @@ void
nsDisplayBoxShadowInner::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aCommands,
WebRenderDisplayItemLayer* aLayer)
{
nsPoint offset = ToReferenceFrame();
nsRect borderRect = nsRect(offset, mFrame->GetSize());
- nsDisplayBoxShadowInner::CreateInsetBoxShadowWebRenderCommands(aBuilder, aLayer, mFrame, borderRect);
+ nsDisplayBoxShadowInner::CreateInsetBoxShadowWebRenderCommands(aBuilder, aSc, aLayer, mFrame, borderRect);
}
bool
nsDisplayBoxShadowInner::ComputeVisibility(nsDisplayListBuilder* aBuilder,
nsRegion* aVisibleRegion) {
if (!nsDisplayItem::ComputeVisibility(aBuilder, aVisibleRegion)) {
return false;
}
--- a/layout/painting/nsDisplayList.h
+++ b/layout/painting/nsDisplayList.h
@@ -2861,16 +2861,17 @@ public:
virtual nsRegion GetTightBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override
{
*aSnap = true;
return CalculateBounds(*mFrame->StyleBorder());
}
protected:
void CreateBorderImageWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
+ const StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
WebRenderDisplayItemLayer* aLayer);
nsRegion CalculateBounds(const nsStyleBorder& aStyleBorder);
mozilla::Array<mozilla::gfx::Color, 4> mColors;
mozilla::Array<mozilla::LayerCoord, 4> mWidths;
mozilla::Array<mozilla::LayerSize, 4> mCorners;
mozilla::Array<uint8_t, 4> mBorderStyles;
@@ -3452,16 +3453,17 @@ public:
aInvalidRegion->Or(geometry->mBounds, GetBounds(aBuilder, &snap));
}
}
static bool CanCreateWebRenderCommands(nsDisplayListBuilder* aBuilder,
nsIFrame* aFrame,
nsPoint aReferencePoint);
static void CreateInsetBoxShadowWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,
+ const StackingContextHelper& aSc,
WebRenderDisplayItemLayer* aLayer,
nsIFrame* aFrame,
const nsRect aBorderRect);
virtual LayerState GetLayerState(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
const ContainerLayerParameters& aParameters) override;
virtual already_AddRefed<Layer> BuildLayer(nsDisplayListBuilder* aBuilder,
LayerManager* aManager,
--- a/layout/painting/nsImageRenderer.cpp
+++ b/layout/painting/nsImageRenderer.cpp
@@ -574,16 +574,17 @@ nsImageRenderer::Draw(nsPresContext*
}
return result;
}
DrawResult
nsImageRenderer::BuildWebRenderDisplayItems(nsPresContext* aPresContext,
mozilla::wr::DisplayListBuilder& aBuilder,
+ const mozilla::layers::StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer,
const nsRect& aDirtyRect,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsSize& aRepeatSize,
const CSSIntRect& aSrc,
@@ -599,17 +600,17 @@ nsImageRenderer::BuildWebRenderDisplayIt
}
switch (mType) {
case eStyleImageType_Gradient:
{
nsCSSGradientRenderer renderer =
nsCSSGradientRenderer::Create(aPresContext, mGradientData, mSize);
- renderer.BuildWebRenderDisplayItems(aBuilder, aLayer, aDest, aFill, aRepeatSize, aSrc, aOpacity);
+ renderer.BuildWebRenderDisplayItems(aBuilder, aSc, aLayer, aDest, aFill, aRepeatSize, aSrc, aOpacity);
break;
}
case eStyleImageType_Image:
{
RefPtr<layers::ImageContainer> container = mImageContainer->GetImageContainer(aLayer->WrManager(),
ConvertImageRendererToDrawFlags(mFlags));
if (!container) {
NS_WARNING("Failed to get image container");
@@ -708,16 +709,17 @@ nsImageRenderer::DrawLayer(nsPresContext
nsPresContext::AppUnitsToIntCSSPixels(mSize.width),
nsPresContext::AppUnitsToIntCSSPixels(mSize.height)),
aOpacity);
}
DrawResult
nsImageRenderer::BuildWebRenderDisplayItemsForLayer(nsPresContext* aPresContext,
mozilla::wr::DisplayListBuilder& aBuilder,
+ const mozilla::layers::StackingContextHelper& aSc,
nsTArray<WebRenderParentCommand>& aParentCommands,
WebRenderDisplayItemLayer* aLayer,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsRect& aDirty,
const nsSize& aRepeatSize,
float aOpacity)
@@ -726,17 +728,17 @@ nsImageRenderer::BuildWebRenderDisplayIt
NS_NOTREACHED("Ensure PrepareImage() has returned true before calling me");
return mPrepareResult;
}
if (aDest.IsEmpty() || aFill.IsEmpty() ||
mSize.width <= 0 || mSize.height <= 0) {
return DrawResult::SUCCESS;
}
- return BuildWebRenderDisplayItems(aPresContext, aBuilder, aParentCommands, aLayer,
+ return BuildWebRenderDisplayItems(aPresContext, aBuilder, aSc, aParentCommands, aLayer,
aDirty, aDest, aFill, aAnchor, aRepeatSize,
CSSIntRect(0, 0,
nsPresContext::AppUnitsToIntCSSPixels(mSize.width),
nsPresContext::AppUnitsToIntCSSPixels(mSize.height)),
aOpacity);
}
/**
--- a/layout/painting/nsImageRenderer.h
+++ b/layout/painting/nsImageRenderer.h
@@ -9,16 +9,17 @@
#include "nsLayoutUtils.h"
#include "nsStyleStruct.h"
#include "Units.h"
class gfxDrawable;
namespace mozilla {
namespace layers {
+class StackingContextHelper;
class WebRenderParentCommand;
class WebRenderDisplayItemLayer;
} // namespace layers
namespace wr {
class DisplayListBuilder;
} // namespace wr
@@ -203,16 +204,17 @@ public:
/**
* Builds WebRender DisplayItems for an image using
* {background|mask}-specific arguments.
* @see nsLayoutUtils::DrawImage() for parameters.
*/
DrawResult BuildWebRenderDisplayItemsForLayer(nsPresContext* aPresContext,
mozilla::wr::DisplayListBuilder& aBuilder,
+ const mozilla::layers::StackingContextHelper& aSc,
nsTArray<layers::WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsRect& aDirty,
const nsSize& aRepeatSize,
float aOpacity);
@@ -287,16 +289,17 @@ private:
* Builds WebRender DisplayItems for the image.
* aSrc is a rect on the source image which will be mapped to aDest; it's
* currently only used for gradients.
*
* @see nsLayoutUtils::DrawImage() for other parameters.
*/
DrawResult BuildWebRenderDisplayItems(nsPresContext* aPresContext,
mozilla::wr::DisplayListBuilder& aBuilder,
+ const mozilla::layers::StackingContextHelper& aSc,
nsTArray<layers::WebRenderParentCommand>& aParentCommands,
mozilla::layers::WebRenderDisplayItemLayer* aLayer,
const nsRect& aDirtyRect,
const nsRect& aDest,
const nsRect& aFill,
const nsPoint& aAnchor,
const nsSize& aRepeatSize,
const mozilla::CSSIntRect& aSrc,