diff options
Diffstat (limited to 'layout/painting/nsCSSRendering.cpp')
| -rw-r--r-- | layout/painting/nsCSSRendering.cpp | 4982 |
1 files changed, 4982 insertions, 0 deletions
diff --git a/layout/painting/nsCSSRendering.cpp b/layout/painting/nsCSSRendering.cpp new file mode 100644 index 0000000000..0662b54b30 --- /dev/null +++ b/layout/painting/nsCSSRendering.cpp @@ -0,0 +1,4982 @@ +/* -*- 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/. */ + +/* utility functions for drawing borders and backgrounds */ + +#include "nsCSSRendering.h" + +#include <ctime> + +#include "gfx2DGlue.h" +#include "gfxContext.h" +#include "mozilla/ArrayUtils.h" +#include "mozilla/ComputedStyle.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/StaticPrefs_layout.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/Helpers.h" +#include "mozilla/gfx/Logging.h" +#include "mozilla/gfx/PathHelpers.h" +#include "mozilla/HashFunctions.h" +#include "mozilla/MathAlgorithms.h" +#include "mozilla/PresShell.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/SVGImageContext.h" +#include "gfxFont.h" +#include "ScaledFontBase.h" +#include "skia/include/core/SkTextBlob.h" + +#include "BorderConsts.h" +#include "nsCanvasFrame.h" +#include "nsStyleConsts.h" +#include "nsPresContext.h" +#include "nsIFrame.h" +#include "nsIFrameInlines.h" +#include "nsPageSequenceFrame.h" +#include "nsPoint.h" +#include "nsRect.h" +#include "nsFrameManager.h" +#include "nsGkAtoms.h" +#include "nsCSSAnonBoxes.h" +#include "nsIContent.h" +#include "mozilla/dom/DocumentInlines.h" +#include "nsIScrollableFrame.h" +#include "imgIContainer.h" +#include "ImageOps.h" +#include "nsCSSColorUtils.h" +#include "nsITheme.h" +#include "nsLayoutUtils.h" +#include "nsBlockFrame.h" +#include "nsStyleStructInlines.h" +#include "nsCSSFrameConstructor.h" +#include "nsCSSProps.h" +#include "nsContentUtils.h" +#include "gfxDrawable.h" +#include "nsCSSRenderingBorders.h" +#include "mozilla/css/ImageLoader.h" +#include "ImageContainer.h" +#include "mozilla/ProfilerLabels.h" +#include "mozilla/StaticPrefs_layout.h" +#include "mozilla/Telemetry.h" +#include "gfxUtils.h" +#include "gfxGradientCache.h" +#include "nsInlineFrame.h" +#include "nsRubyTextContainerFrame.h" +#include <algorithm> +#include "TextDrawTarget.h" + +using namespace mozilla; +using namespace mozilla::css; +using namespace mozilla::gfx; +using namespace mozilla::image; +using mozilla::CSSSizeOrRatio; +using mozilla::dom::Document; + +static int gFrameTreeLockCount = 0; + +// To avoid storing this data on nsInlineFrame (bloat) and to avoid +// recalculating this for each frame in a continuation (perf), hold +// a cache of various coordinate information that we need in order +// to paint inline backgrounds. +struct InlineBackgroundData { + InlineBackgroundData() + : mFrame(nullptr), + mLineContainer(nullptr), + mContinuationPoint(0), + mUnbrokenMeasure(0), + mLineContinuationPoint(0), + mPIStartBorderData{}, + mBidiEnabled(false), + mVertical(false) {} + + ~InlineBackgroundData() = default; + + void Reset() { + mBoundingBox.SetRect(0, 0, 0, 0); + mContinuationPoint = mLineContinuationPoint = mUnbrokenMeasure = 0; + mFrame = mLineContainer = nullptr; + mPIStartBorderData.Reset(); + } + + /** + * Return a continuous rect for (an inline) aFrame relative to the + * continuation that draws the left-most part of the background. + * This is used when painting backgrounds. + */ + nsRect GetContinuousRect(nsIFrame* aFrame) { + MOZ_ASSERT(static_cast<nsInlineFrame*>(do_QueryFrame(aFrame))); + + SetFrame(aFrame); + + nscoord pos; // an x coordinate if writing-mode is horizontal; + // y coordinate if vertical + if (mBidiEnabled) { + pos = mLineContinuationPoint; + + // Scan continuations on the same line as aFrame and accumulate the widths + // of frames that are to the left (if this is an LTR block) or right + // (if it's RTL) of the current one. + bool isRtlBlock = (mLineContainer->StyleVisibility()->mDirection == + StyleDirection::Rtl); + nscoord curOffset = mVertical ? aFrame->GetOffsetTo(mLineContainer).y + : aFrame->GetOffsetTo(mLineContainer).x; + + // If the continuation is fluid we know inlineFrame is not on the same + // line. If it's not fluid, we need to test further to be sure. + nsIFrame* inlineFrame = aFrame->GetPrevContinuation(); + while (inlineFrame && !inlineFrame->GetNextInFlow() && + AreOnSameLine(aFrame, inlineFrame)) { + nscoord frameOffset = mVertical + ? inlineFrame->GetOffsetTo(mLineContainer).y + : inlineFrame->GetOffsetTo(mLineContainer).x; + if (isRtlBlock == (frameOffset >= curOffset)) { + pos += mVertical ? inlineFrame->GetSize().height + : inlineFrame->GetSize().width; + } + inlineFrame = inlineFrame->GetPrevContinuation(); + } + + inlineFrame = aFrame->GetNextContinuation(); + while (inlineFrame && !inlineFrame->GetPrevInFlow() && + AreOnSameLine(aFrame, inlineFrame)) { + nscoord frameOffset = mVertical + ? inlineFrame->GetOffsetTo(mLineContainer).y + : inlineFrame->GetOffsetTo(mLineContainer).x; + if (isRtlBlock == (frameOffset >= curOffset)) { + pos += mVertical ? inlineFrame->GetSize().height + : inlineFrame->GetSize().width; + } + inlineFrame = inlineFrame->GetNextContinuation(); + } + if (isRtlBlock) { + // aFrame itself is also to the right of its left edge, so add its + // width. + pos += mVertical ? aFrame->GetSize().height : aFrame->GetSize().width; + // pos is now the distance from the left [top] edge of aFrame to the + // right [bottom] edge of the unbroken content. Change it to indicate + // the distance from the left [top] edge of the unbroken content to the + // left [top] edge of aFrame. + pos = mUnbrokenMeasure - pos; + } + } else { + pos = mContinuationPoint; + } + + // Assume background-origin: border and return a rect with offsets + // relative to (0,0). If we have a different background-origin, + // then our rect should be deflated appropriately by our caller. + return mVertical + ? nsRect(0, -pos, mFrame->GetSize().width, mUnbrokenMeasure) + : nsRect(-pos, 0, mUnbrokenMeasure, mFrame->GetSize().height); + } + + /** + * Return a continuous rect for (an inline) aFrame relative to the + * continuation that should draw the left[top]-border. This is used when + * painting borders and clipping backgrounds. This may NOT be the same + * continuous rect as for drawing backgrounds; the continuation with the + * left[top]-border might be somewhere in the middle of that rect (e.g. BIDI), + * in those cases we need the reverse background order starting at the + * left[top]-border continuation. + */ + nsRect GetBorderContinuousRect(nsIFrame* aFrame, nsRect aBorderArea) { + // Calling GetContinuousRect(aFrame) here may lead to Reset/Init which + // resets our mPIStartBorderData so we save it ... + PhysicalInlineStartBorderData saved(mPIStartBorderData); + nsRect joinedBorderArea = GetContinuousRect(aFrame); + if (!saved.mIsValid || saved.mFrame != mPIStartBorderData.mFrame) { + if (aFrame == mPIStartBorderData.mFrame) { + if (mVertical) { + mPIStartBorderData.SetCoord(joinedBorderArea.y); + } else { + mPIStartBorderData.SetCoord(joinedBorderArea.x); + } + } else if (mPIStartBorderData.mFrame) { + // Copy data to a temporary object so that computing the + // continous rect here doesn't clobber our normal state. + InlineBackgroundData temp = *this; + if (mVertical) { + mPIStartBorderData.SetCoord( + temp.GetContinuousRect(mPIStartBorderData.mFrame).y); + } else { + mPIStartBorderData.SetCoord( + temp.GetContinuousRect(mPIStartBorderData.mFrame).x); + } + } + } else { + // ... and restore it when possible. + mPIStartBorderData.SetCoord(saved.mCoord); + } + if (mVertical) { + if (joinedBorderArea.y > mPIStartBorderData.mCoord) { + joinedBorderArea.y = + -(mUnbrokenMeasure + joinedBorderArea.y - aBorderArea.height); + } else { + joinedBorderArea.y -= mPIStartBorderData.mCoord; + } + } else { + if (joinedBorderArea.x > mPIStartBorderData.mCoord) { + joinedBorderArea.x = + -(mUnbrokenMeasure + joinedBorderArea.x - aBorderArea.width); + } else { + joinedBorderArea.x -= mPIStartBorderData.mCoord; + } + } + return joinedBorderArea; + } + + nsRect GetBoundingRect(nsIFrame* aFrame) { + SetFrame(aFrame); + + // Move the offsets relative to (0,0) which puts the bounding box into + // our coordinate system rather than our parent's. We do this by + // moving it the back distance from us to the bounding box. + // This also assumes background-origin: border, so our caller will + // need to deflate us if needed. + nsRect boundingBox(mBoundingBox); + nsPoint point = mFrame->GetPosition(); + boundingBox.MoveBy(-point.x, -point.y); + + return boundingBox; + } + + protected: + // This is a coordinate on the inline axis, but is not a true logical inline- + // coord because it is always measured from left to right (if horizontal) or + // from top to bottom (if vertical), ignoring any bidi RTL directionality. + // We'll call this "physical inline start", or PIStart for short. + struct PhysicalInlineStartBorderData { + nsIFrame* mFrame; // the continuation that may have a left-border + nscoord mCoord; // cached GetContinuousRect(mFrame).x or .y + bool mIsValid; // true if mCoord is valid + void Reset() { + mFrame = nullptr; + mIsValid = false; + } + void SetCoord(nscoord aCoord) { + mCoord = aCoord; + mIsValid = true; + } + }; + + nsIFrame* mFrame; + nsIFrame* mLineContainer; + nsRect mBoundingBox; + nscoord mContinuationPoint; + nscoord mUnbrokenMeasure; + nscoord mLineContinuationPoint; + PhysicalInlineStartBorderData mPIStartBorderData; + bool mBidiEnabled; + bool mVertical; + + void SetFrame(nsIFrame* aFrame) { + MOZ_ASSERT(aFrame, "Need a frame"); + NS_ASSERTION(gFrameTreeLockCount > 0, + "Can't call this when frame tree is not locked"); + + if (aFrame == mFrame) { + return; + } + + nsIFrame* prevContinuation = GetPrevContinuation(aFrame); + + if (!prevContinuation || mFrame != prevContinuation) { + // Ok, we've got the wrong frame. We have to start from scratch. + Reset(); + Init(aFrame); + return; + } + + // Get our last frame's size and add its width to our continuation + // point before we cache the new frame. + mContinuationPoint += + mVertical ? mFrame->GetSize().height : mFrame->GetSize().width; + + // If this a new line, update mLineContinuationPoint. + if (mBidiEnabled && + (aFrame->GetPrevInFlow() || !AreOnSameLine(mFrame, aFrame))) { + mLineContinuationPoint = mContinuationPoint; + } + + mFrame = aFrame; + } + + nsIFrame* GetPrevContinuation(nsIFrame* aFrame) { + nsIFrame* prevCont = aFrame->GetPrevContinuation(); + if (!prevCont && aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) { + nsIFrame* block = aFrame->GetProperty(nsIFrame::IBSplitPrevSibling()); + if (block) { + // The {ib} properties are only stored on first continuations + NS_ASSERTION(!block->GetPrevContinuation(), + "Incorrect value for IBSplitPrevSibling"); + prevCont = block->GetProperty(nsIFrame::IBSplitPrevSibling()); + NS_ASSERTION(prevCont, "How did that happen?"); + } + } + return prevCont; + } + + nsIFrame* GetNextContinuation(nsIFrame* aFrame) { + nsIFrame* nextCont = aFrame->GetNextContinuation(); + if (!nextCont && aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) { + // The {ib} properties are only stored on first continuations + aFrame = aFrame->FirstContinuation(); + nsIFrame* block = aFrame->GetProperty(nsIFrame::IBSplitSibling()); + if (block) { + nextCont = block->GetProperty(nsIFrame::IBSplitSibling()); + NS_ASSERTION(nextCont, "How did that happen?"); + } + } + return nextCont; + } + + void Init(nsIFrame* aFrame) { + mPIStartBorderData.Reset(); + mBidiEnabled = aFrame->PresContext()->BidiEnabled(); + if (mBidiEnabled) { + // Find the line container frame + mLineContainer = aFrame; + while (mLineContainer && mLineContainer->IsLineParticipant()) { + mLineContainer = mLineContainer->GetParent(); + } + + MOZ_ASSERT(mLineContainer, "Cannot find line containing frame."); + MOZ_ASSERT(mLineContainer != aFrame, + "line container frame " + "should be an ancestor of the target frame."); + } + + mVertical = aFrame->GetWritingMode().IsVertical(); + + // Start with the previous flow frame as our continuation point + // is the total of the widths of the previous frames. + nsIFrame* inlineFrame = GetPrevContinuation(aFrame); + bool changedLines = false; + while (inlineFrame) { + if (!mPIStartBorderData.mFrame && + !(mVertical ? inlineFrame->GetSkipSides().Top() + : inlineFrame->GetSkipSides().Left())) { + mPIStartBorderData.mFrame = inlineFrame; + } + nsRect rect = inlineFrame->GetRect(); + mContinuationPoint += mVertical ? rect.height : rect.width; + if (mBidiEnabled && + (changedLines || !AreOnSameLine(aFrame, inlineFrame))) { + mLineContinuationPoint += mVertical ? rect.height : rect.width; + changedLines = true; + } + mUnbrokenMeasure += mVertical ? rect.height : rect.width; + mBoundingBox.UnionRect(mBoundingBox, rect); + inlineFrame = GetPrevContinuation(inlineFrame); + } + + // Next add this frame and subsequent frames to the bounding box and + // unbroken width. + inlineFrame = aFrame; + while (inlineFrame) { + if (!mPIStartBorderData.mFrame && + !(mVertical ? inlineFrame->GetSkipSides().Top() + : inlineFrame->GetSkipSides().Left())) { + mPIStartBorderData.mFrame = inlineFrame; + } + nsRect rect = inlineFrame->GetRect(); + mUnbrokenMeasure += mVertical ? rect.height : rect.width; + mBoundingBox.UnionRect(mBoundingBox, rect); + inlineFrame = GetNextContinuation(inlineFrame); + } + + mFrame = aFrame; + } + + bool AreOnSameLine(nsIFrame* aFrame1, nsIFrame* aFrame2) { + if (nsBlockFrame* blockFrame = do_QueryFrame(mLineContainer)) { + bool isValid1, isValid2; + nsBlockInFlowLineIterator it1(blockFrame, aFrame1, &isValid1); + nsBlockInFlowLineIterator it2(blockFrame, aFrame2, &isValid2); + return isValid1 && isValid2 && + // Make sure aFrame1 and aFrame2 are in the same continuation of + // blockFrame. + it1.GetContainer() == it2.GetContainer() && + // And on the same line in it + it1.GetLine().get() == it2.GetLine().get(); + } + if (nsRubyTextContainerFrame* rtcFrame = do_QueryFrame(mLineContainer)) { + nsBlockFrame* block = nsLayoutUtils::FindNearestBlockAncestor(rtcFrame); + // Ruby text container can only hold one line of text, so if they + // are in the same continuation, they are in the same line. Since + // ruby text containers are bidi isolate, they are never split for + // bidi reordering, which means being in different continuation + // indicates being in different lines. + for (nsIFrame* frame = rtcFrame->FirstContinuation(); frame; + frame = frame->GetNextContinuation()) { + bool isDescendant1 = + nsLayoutUtils::IsProperAncestorFrame(frame, aFrame1, block); + bool isDescendant2 = + nsLayoutUtils::IsProperAncestorFrame(frame, aFrame2, block); + if (isDescendant1 && isDescendant2) { + return true; + } + if (isDescendant1 || isDescendant2) { + return false; + } + } + MOZ_ASSERT_UNREACHABLE("None of the frames is a descendant of this rtc?"); + } + MOZ_ASSERT_UNREACHABLE("Do we have any other type of line container?"); + return false; + } +}; + +static StaticAutoPtr<InlineBackgroundData> gInlineBGData; + +// Initialize any static variables used by nsCSSRendering. +void nsCSSRendering::Init() { + NS_ASSERTION(!gInlineBGData, "Init called twice"); + gInlineBGData = new InlineBackgroundData(); +} + +// Clean up any global variables used by nsCSSRendering. +void nsCSSRendering::Shutdown() { gInlineBGData = nullptr; } + +/** + * Make a bevel color + */ +static nscolor MakeBevelColor(mozilla::Side whichSide, StyleBorderStyle style, + nscolor aBorderColor) { + nscolor colors[2]; + nscolor theColor; + + // Given a background color and a border color + // calculate the color used for the shading + NS_GetSpecial3DColors(colors, aBorderColor); + + if ((style == StyleBorderStyle::Outset) || + (style == StyleBorderStyle::Ridge)) { + // Flip colors for these two border styles + switch (whichSide) { + case eSideBottom: + whichSide = eSideTop; + break; + case eSideRight: + whichSide = eSideLeft; + break; + case eSideTop: + whichSide = eSideBottom; + break; + case eSideLeft: + whichSide = eSideRight; + break; + } + } + + switch (whichSide) { + case eSideBottom: + theColor = colors[1]; + break; + case eSideRight: + theColor = colors[1]; + break; + case eSideTop: + theColor = colors[0]; + break; + case eSideLeft: + default: + theColor = colors[0]; + break; + } + return theColor; +} + +static bool GetRadii(nsIFrame* aForFrame, const nsStyleBorder& aBorder, + const nsRect& aOrigBorderArea, const nsRect& aBorderArea, + nscoord aRadii[8]) { + bool haveRoundedCorners; + nsSize sz = aBorderArea.Size(); + nsSize frameSize = aForFrame->GetSize(); + if (&aBorder == aForFrame->StyleBorder() && + frameSize == aOrigBorderArea.Size()) { + haveRoundedCorners = aForFrame->GetBorderRadii(sz, sz, Sides(), aRadii); + } else { + haveRoundedCorners = nsIFrame::ComputeBorderRadii( + aBorder.mBorderRadius, frameSize, sz, Sides(), aRadii); + } + + return haveRoundedCorners; +} + +static bool GetRadii(nsIFrame* aForFrame, const nsStyleBorder& aBorder, + const nsRect& aOrigBorderArea, const nsRect& aBorderArea, + RectCornerRadii* aBgRadii) { + nscoord radii[8]; + bool haveRoundedCorners = + GetRadii(aForFrame, aBorder, aOrigBorderArea, aBorderArea, radii); + + if (haveRoundedCorners) { + auto d2a = aForFrame->PresContext()->AppUnitsPerDevPixel(); + nsCSSRendering::ComputePixelRadii(radii, d2a, aBgRadii); + } + return haveRoundedCorners; +} + +static nsRect JoinBoxesForBlockAxisSlice(nsIFrame* aFrame, + const nsRect& aBorderArea) { + // Inflate the block-axis size as if our continuations were laid out + // adjacent in that axis. Note that we don't touch the inline size. + const auto wm = aFrame->GetWritingMode(); + const nsSize dummyContainerSize; + LogicalRect borderArea(wm, aBorderArea, dummyContainerSize); + nscoord bSize = 0; + nsIFrame* f = aFrame->GetNextContinuation(); + for (; f; f = f->GetNextContinuation()) { + bSize += f->BSize(wm); + } + borderArea.BSize(wm) += bSize; + bSize = 0; + f = aFrame->GetPrevContinuation(); + for (; f; f = f->GetPrevContinuation()) { + bSize += f->BSize(wm); + } + borderArea.BStart(wm) -= bSize; + borderArea.BSize(wm) += bSize; + return borderArea.GetPhysicalRect(wm, dummyContainerSize); +} + +/** + * Inflate aBorderArea which is relative to aFrame's origin to calculate + * a hypothetical non-split frame area for all the continuations. + * See "Joining Boxes for 'slice'" in + * http://dev.w3.org/csswg/css-break/#break-decoration + */ +enum InlineBoxOrder { eForBorder, eForBackground }; +static nsRect JoinBoxesForSlice(nsIFrame* aFrame, const nsRect& aBorderArea, + InlineBoxOrder aOrder) { + if (static_cast<nsInlineFrame*>(do_QueryFrame(aFrame))) { + return (aOrder == eForBorder + ? gInlineBGData->GetBorderContinuousRect(aFrame, aBorderArea) + : gInlineBGData->GetContinuousRect(aFrame)) + + aBorderArea.TopLeft(); + } + return JoinBoxesForBlockAxisSlice(aFrame, aBorderArea); +} + +/* static */ +bool nsCSSRendering::IsBoxDecorationSlice(const nsStyleBorder& aStyleBorder) { + return aStyleBorder.mBoxDecorationBreak == StyleBoxDecorationBreak::Slice; +} + +/* static */ +nsRect nsCSSRendering::BoxDecorationRectForBorder( + nsIFrame* aFrame, const nsRect& aBorderArea, Sides aSkipSides, + const nsStyleBorder* aStyleBorder) { + if (!aStyleBorder) { + aStyleBorder = aFrame->StyleBorder(); + } + // If aSkipSides.IsEmpty() then there are no continuations, or it's + // a ::first-letter that wants all border sides on the first continuation. + return IsBoxDecorationSlice(*aStyleBorder) && !aSkipSides.IsEmpty() + ? ::JoinBoxesForSlice(aFrame, aBorderArea, eForBorder) + : aBorderArea; +} + +/* static */ +nsRect nsCSSRendering::BoxDecorationRectForBackground( + nsIFrame* aFrame, const nsRect& aBorderArea, Sides aSkipSides, + const nsStyleBorder* aStyleBorder) { + if (!aStyleBorder) { + aStyleBorder = aFrame->StyleBorder(); + } + // If aSkipSides.IsEmpty() then there are no continuations, or it's + // a ::first-letter that wants all border sides on the first continuation. + return IsBoxDecorationSlice(*aStyleBorder) && !aSkipSides.IsEmpty() + ? ::JoinBoxesForSlice(aFrame, aBorderArea, eForBackground) + : aBorderArea; +} + +//---------------------------------------------------------------------- +// Thebes Border Rendering Code Start + +/* + * Compute the float-pixel radii that should be used for drawing + * this border/outline, given the various input bits. + */ +/* static */ +void nsCSSRendering::ComputePixelRadii(const nscoord* aAppUnitsRadii, + nscoord aAppUnitsPerPixel, + RectCornerRadii* oBorderRadii) { + Float radii[8]; + for (const auto corner : mozilla::AllPhysicalHalfCorners()) { + radii[corner] = Float(aAppUnitsRadii[corner]) / aAppUnitsPerPixel; + } + + (*oBorderRadii)[C_TL] = Size(radii[eCornerTopLeftX], radii[eCornerTopLeftY]); + (*oBorderRadii)[C_TR] = + Size(radii[eCornerTopRightX], radii[eCornerTopRightY]); + (*oBorderRadii)[C_BR] = + Size(radii[eCornerBottomRightX], radii[eCornerBottomRightY]); + (*oBorderRadii)[C_BL] = + Size(radii[eCornerBottomLeftX], radii[eCornerBottomLeftY]); +} + +static Maybe<nsStyleBorder> GetBorderIfVisited(const ComputedStyle& aStyle) { + Maybe<nsStyleBorder> result; + // Don't check RelevantLinkVisited here, since we want to take the + // same amount of time whether or not it's true. + const ComputedStyle* styleIfVisited = aStyle.GetStyleIfVisited(); + if (MOZ_LIKELY(!styleIfVisited)) { + return result; + } + + result.emplace(*aStyle.StyleBorder()); + auto& newBorder = result.ref(); + for (const auto side : mozilla::AllPhysicalSides()) { + nscolor color = aStyle.GetVisitedDependentColor( + nsStyleBorder::BorderColorFieldFor(side)); + newBorder.BorderColorFor(side) = StyleColor::FromColor(color); + } + + return result; +} + +ImgDrawResult nsCSSRendering::PaintBorder( + nsPresContext* aPresContext, gfxContext& aRenderingContext, + nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, + ComputedStyle* aStyle, PaintBorderFlags aFlags, Sides aSkipSides) { + AUTO_PROFILER_LABEL("nsCSSRendering::PaintBorder", GRAPHICS); + + Maybe<nsStyleBorder> visitedBorder = GetBorderIfVisited(*aStyle); + return PaintBorderWithStyleBorder( + aPresContext, aRenderingContext, aForFrame, aDirtyRect, aBorderArea, + visitedBorder.refOr(*aStyle->StyleBorder()), aStyle, aFlags, aSkipSides); +} + +Maybe<nsCSSBorderRenderer> nsCSSRendering::CreateBorderRenderer( + nsPresContext* aPresContext, DrawTarget* aDrawTarget, nsIFrame* aForFrame, + const nsRect& aDirtyRect, const nsRect& aBorderArea, ComputedStyle* aStyle, + bool* aOutBorderIsEmpty, Sides aSkipSides) { + Maybe<nsStyleBorder> visitedBorder = GetBorderIfVisited(*aStyle); + return CreateBorderRendererWithStyleBorder( + aPresContext, aDrawTarget, aForFrame, aDirtyRect, aBorderArea, + visitedBorder.refOr(*aStyle->StyleBorder()), aStyle, aOutBorderIsEmpty, + aSkipSides); +} + +ImgDrawResult nsCSSRendering::CreateWebRenderCommandsForBorder( + nsDisplayItem* aItem, nsIFrame* aForFrame, const nsRect& aBorderArea, + mozilla::wr::DisplayListBuilder& aBuilder, + mozilla::wr::IpcResourceUpdateQueue& aResources, + const mozilla::layers::StackingContextHelper& aSc, + mozilla::layers::RenderRootStateManager* aManager, + nsDisplayListBuilder* aDisplayListBuilder) { + const auto* style = aForFrame->Style(); + Maybe<nsStyleBorder> visitedBorder = GetBorderIfVisited(*style); + return nsCSSRendering::CreateWebRenderCommandsForBorderWithStyleBorder( + aItem, aForFrame, aBorderArea, aBuilder, aResources, aSc, aManager, + aDisplayListBuilder, visitedBorder.refOr(*style->StyleBorder())); +} + +void nsCSSRendering::CreateWebRenderCommandsForNullBorder( + nsDisplayItem* aItem, nsIFrame* aForFrame, const nsRect& aBorderArea, + mozilla::wr::DisplayListBuilder& aBuilder, + mozilla::wr::IpcResourceUpdateQueue& aResources, + const mozilla::layers::StackingContextHelper& aSc, + const nsStyleBorder& aStyleBorder) { + bool borderIsEmpty = false; + Maybe<nsCSSBorderRenderer> br = + nsCSSRendering::CreateNullBorderRendererWithStyleBorder( + aForFrame->PresContext(), nullptr, aForFrame, nsRect(), aBorderArea, + aStyleBorder, aForFrame->Style(), &borderIsEmpty, + aForFrame->GetSkipSides()); + if (!borderIsEmpty && br) { + br->CreateWebRenderCommands(aItem, aBuilder, aResources, aSc); + } +} + +ImgDrawResult nsCSSRendering::CreateWebRenderCommandsForBorderWithStyleBorder( + nsDisplayItem* aItem, nsIFrame* aForFrame, const nsRect& aBorderArea, + mozilla::wr::DisplayListBuilder& aBuilder, + mozilla::wr::IpcResourceUpdateQueue& aResources, + const mozilla::layers::StackingContextHelper& aSc, + mozilla::layers::RenderRootStateManager* aManager, + nsDisplayListBuilder* aDisplayListBuilder, + const nsStyleBorder& aStyleBorder) { + auto& borderImage = aStyleBorder.mBorderImageSource; + // First try to create commands for simple borders. + if (borderImage.IsNone()) { + CreateWebRenderCommandsForNullBorder( + aItem, aForFrame, aBorderArea, aBuilder, aResources, aSc, aStyleBorder); + return ImgDrawResult::SUCCESS; + } + + // Next we try image and gradient borders. Gradients are not supported at + // this very moment. + if (!borderImage.IsImageRequestType()) { + return ImgDrawResult::NOT_SUPPORTED; + } + + if (aStyleBorder.mBorderImageRepeatH == StyleBorderImageRepeat::Space || + aStyleBorder.mBorderImageRepeatV == StyleBorderImageRepeat::Space) { + return ImgDrawResult::NOT_SUPPORTED; + } + + uint32_t flags = 0; + if (aDisplayListBuilder->IsPaintingToWindow()) { + flags |= nsImageRenderer::FLAG_PAINTING_TO_WINDOW; + } + if (aDisplayListBuilder->ShouldSyncDecodeImages()) { + flags |= nsImageRenderer::FLAG_SYNC_DECODE_IMAGES; + } + + bool dummy; + image::ImgDrawResult result; + Maybe<nsCSSBorderImageRenderer> bir = + nsCSSBorderImageRenderer::CreateBorderImageRenderer( + aForFrame->PresContext(), aForFrame, aBorderArea, aStyleBorder, + aItem->GetBounds(aDisplayListBuilder, &dummy), + aForFrame->GetSkipSides(), flags, &result); + + if (!bir) { + // We aren't ready. Try to fallback to the null border image if present but + // return the draw result for the border image renderer. + CreateWebRenderCommandsForNullBorder( + aItem, aForFrame, aBorderArea, aBuilder, aResources, aSc, aStyleBorder); + return result; + } + + return bir->CreateWebRenderCommands(aItem, aForFrame, aBuilder, aResources, + aSc, aManager, aDisplayListBuilder); +} + +static nsCSSBorderRenderer ConstructBorderRenderer( + nsPresContext* aPresContext, ComputedStyle* aStyle, DrawTarget* aDrawTarget, + nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, + const nsStyleBorder& aStyleBorder, Sides aSkipSides, bool* aNeedsClip) { + nsMargin border = aStyleBorder.GetComputedBorder(); + + // Compute the outermost boundary of the area that might be painted. + // Same coordinate space as aBorderArea & aBGClipRect. + nsRect joinedBorderArea = nsCSSRendering::BoxDecorationRectForBorder( + aForFrame, aBorderArea, aSkipSides, &aStyleBorder); + RectCornerRadii bgRadii; + ::GetRadii(aForFrame, aStyleBorder, aBorderArea, joinedBorderArea, &bgRadii); + + PrintAsFormatString(" joinedBorderArea: %d %d %d %d\n", joinedBorderArea.x, + joinedBorderArea.y, joinedBorderArea.width, + joinedBorderArea.height); + + // start drawing + if (nsCSSRendering::IsBoxDecorationSlice(aStyleBorder)) { + if (joinedBorderArea.IsEqualEdges(aBorderArea)) { + // No need for a clip, just skip the sides we don't want. + border.ApplySkipSides(aSkipSides); + } else { + // We're drawing borders around the joined continuation boxes so we need + // to clip that to the slice that we want for this frame. + *aNeedsClip = true; + } + } else { + MOZ_ASSERT(joinedBorderArea.IsEqualEdges(aBorderArea), + "Should use aBorderArea for box-decoration-break:clone"); + MOZ_ASSERT( + aForFrame->GetSkipSides().IsEmpty() || + aForFrame->IsTrueOverflowContainer() || + aForFrame->IsColumnSetFrame(), // a little broader than column-rule + "Should not skip sides for box-decoration-break:clone except " + "::first-letter/line continuations or other frame types that " + "don't have borders but those shouldn't reach this point. " + "Overflow containers do reach this point though, as does " + "column-rule drawing (which always involves a columnset)."); + border.ApplySkipSides(aSkipSides); + } + + // Convert to dev pixels. + nscoord oneDevPixel = aPresContext->DevPixelsToAppUnits(1); + Rect joinedBorderAreaPx = NSRectToRect(joinedBorderArea, oneDevPixel); + Float borderWidths[4] = { + Float(border.top) / oneDevPixel, Float(border.right) / oneDevPixel, + Float(border.bottom) / oneDevPixel, Float(border.left) / oneDevPixel}; + Rect dirtyRect = NSRectToRect(aDirtyRect, oneDevPixel); + + StyleBorderStyle borderStyles[4]; + nscolor borderColors[4]; + + // pull out styles, colors + for (const auto i : mozilla::AllPhysicalSides()) { + borderStyles[i] = aStyleBorder.GetBorderStyle(i); + borderColors[i] = aStyleBorder.BorderColorFor(i).CalcColor(*aStyle); + } + + PrintAsFormatString( + " borderStyles: %d %d %d %d\n", static_cast<int>(borderStyles[0]), + static_cast<int>(borderStyles[1]), static_cast<int>(borderStyles[2]), + static_cast<int>(borderStyles[3])); + + return nsCSSBorderRenderer( + aPresContext, aDrawTarget, dirtyRect, joinedBorderAreaPx, borderStyles, + borderWidths, bgRadii, borderColors, !aForFrame->BackfaceIsHidden(), + *aNeedsClip ? Some(NSRectToRect(aBorderArea, oneDevPixel)) : Nothing()); +} + +ImgDrawResult nsCSSRendering::PaintBorderWithStyleBorder( + nsPresContext* aPresContext, gfxContext& aRenderingContext, + nsIFrame* aForFrame, const nsRect& aDirtyRect, const nsRect& aBorderArea, + const nsStyleBorder& aStyleBorder, ComputedStyle* aStyle, + PaintBorderFlags aFlags, Sides aSkipSides) { + DrawTarget& aDrawTarget = *aRenderingContext.GetDrawTarget(); + + PrintAsStringNewline("++ PaintBorder"); + + // Check to see if we have an appearance defined. If so, we let the theme + // renderer draw the border. DO not get the data from aForFrame, since the + // passed in ComputedStyle may be different! Always use |aStyle|! + StyleAppearance appearance = aStyle->StyleDisplay()->EffectiveAppearance(); + if (appearance != StyleAppearance::None) { + nsITheme* theme = aPresContext->Theme(); + if (theme->ThemeSupportsWidget(aPresContext, aForFrame, appearance)) { + return ImgDrawResult::SUCCESS; // Let the theme handle it. + } + } + + if (!aStyleBorder.mBorderImageSource.IsNone()) { + ImgDrawResult result = ImgDrawResult::SUCCESS; + + uint32_t irFlags = 0; + if (aFlags & PaintBorderFlags::SyncDecodeImages) { + irFlags |= nsImageRenderer::FLAG_SYNC_DECODE_IMAGES; + } + + // Creating the border image renderer will request a decode, and we rely on + // that happening. + Maybe<nsCSSBorderImageRenderer> renderer = + nsCSSBorderImageRenderer::CreateBorderImageRenderer( + aPresContext, aForFrame, aBorderArea, aStyleBorder, aDirtyRect, + aSkipSides, irFlags, &result); + // renderer was created successfully, which means border image is ready to + // be used. + if (renderer) { + MOZ_ASSERT(result == ImgDrawResult::SUCCESS); + return renderer->DrawBorderImage(aPresContext, aRenderingContext, + aForFrame, aDirtyRect); + } + } + + ImgDrawResult result = ImgDrawResult::SUCCESS; + + // If we had a border-image, but it wasn't loaded, then we should return + // ImgDrawResult::NOT_READY; we'll want to try again if we do a paint with + // sync decoding enabled. + if (!aStyleBorder.mBorderImageSource.IsNone()) { + result = ImgDrawResult::NOT_READY; + } + + nsMargin border = aStyleBorder.GetComputedBorder(); + if (0 == border.left && 0 == border.right && 0 == border.top && + 0 == border.bottom) { + // Empty border area + return result; + } + + bool needsClip = false; + nsCSSBorderRenderer br = ConstructBorderRenderer( + aPresContext, aStyle, &aDrawTarget, aForFrame, aDirtyRect, aBorderArea, + aStyleBorder, aSkipSides, &needsClip); + if (needsClip) { + aDrawTarget.PushClipRect(NSRectToSnappedRect( + aBorderArea, aForFrame->PresContext()->AppUnitsPerDevPixel(), + aDrawTarget)); + } + + br.DrawBorders(); + + if (needsClip) { + aDrawTarget.PopClip(); + } + + PrintAsStringNewline(); + + return result; +} + +Maybe<nsCSSBorderRenderer> nsCSSRendering::CreateBorderRendererWithStyleBorder( + nsPresContext* aPresContext, DrawTarget* aDrawTarget, nsIFrame* aForFrame, + const nsRect& aDirtyRect, const nsRect& aBorderArea, + const nsStyleBorder& aStyleBorder, ComputedStyle* aStyle, + bool* aOutBorderIsEmpty, Sides aSkipSides) { + if (!aStyleBorder.mBorderImageSource.IsNone()) { + return Nothing(); + } + return CreateNullBorderRendererWithStyleBorder( + aPresContext, aDrawTarget, aForFrame, aDirtyRect, aBorderArea, + aStyleBorder, aStyle, aOutBorderIsEmpty, aSkipSides); +} + +Maybe<nsCSSBorderRenderer> +nsCSSRendering::CreateNullBorderRendererWithStyleBorder( + nsPresContext* aPresContext, DrawTarget* aDrawTarget, nsIFrame* aForFrame, + const nsRect& aDirtyRect, const nsRect& aBorderArea, + const nsStyleBorder& aStyleBorder, ComputedStyle* aStyle, + bool* aOutBorderIsEmpty, Sides aSkipSides) { + StyleAppearance appearance = aStyle->StyleDisplay()->EffectiveAppearance(); + if (appearance != StyleAppearance::None) { + nsITheme* theme = aPresContext->Theme(); + if (theme->ThemeSupportsWidget(aPresContext, aForFrame, appearance)) { + // The border will be draw as part of the themed background item created + // for this same frame. If no themed background item was created then not + // drawing also matches that we do without webrender and what + // nsDisplayBorder does for themed borders. + if (aOutBorderIsEmpty) { + *aOutBorderIsEmpty = true; + } + return Nothing(); + } + } + + nsMargin border = aStyleBorder.GetComputedBorder(); + if (0 == border.left && 0 == border.right && 0 == border.top && + 0 == border.bottom) { + // Empty border area + if (aOutBorderIsEmpty) { + *aOutBorderIsEmpty = true; + } + return Nothing(); + } + + bool needsClip = false; + nsCSSBorderRenderer br = ConstructBorderRenderer( + aPresContext, aStyle, aDrawTarget, aForFrame, aDirtyRect, aBorderArea, + aStyleBorder, aSkipSides, &needsClip); + return Some(br); +} + +Maybe<nsCSSBorderRenderer> +nsCSSRendering::CreateBorderRendererForNonThemedOutline( + nsPresContext* aPresContext, DrawTarget* aDrawTarget, nsIFrame* aForFrame, + const nsRect& aDirtyRect, const nsRect& aInnerRect, ComputedStyle* aStyle) { + // Get our ComputedStyle's color struct. + const nsStyleOutline* ourOutline = aStyle->StyleOutline(); + if (!ourOutline->ShouldPaintOutline()) { + // Empty outline + return Nothing(); + } + + nsRect innerRect = aInnerRect; + + const nsSize effectiveOffset = ourOutline->EffectiveOffsetFor(innerRect); + innerRect.Inflate(effectiveOffset); + + // If the dirty rect is completely inside the border area (e.g., only the + // content is being painted), then we can skip out now + // XXX this isn't exactly true for rounded borders, where the inside curves + // may encroach into the content area. A safer calculation would be to + // shorten insideRect by the radius one each side before performing this test. + if (innerRect.Contains(aDirtyRect)) { + return Nothing(); + } + + const nscoord width = ourOutline->GetOutlineWidth(); + + StyleBorderStyle outlineStyle; + // Themed outlines are handled by our callers, if supported. + if (ourOutline->mOutlineStyle.IsAuto()) { + if (width == 0) { + return Nothing(); // empty outline + } + // http://dev.w3.org/csswg/css-ui/#outline + // "User agents may treat 'auto' as 'solid'." + outlineStyle = StyleBorderStyle::Solid; + } else { + outlineStyle = ourOutline->mOutlineStyle.AsBorderStyle(); + } + + RectCornerRadii outlineRadii; + nsRect outerRect = innerRect; + outerRect.Inflate(width); + + const nscoord oneDevPixel = aPresContext->AppUnitsPerDevPixel(); + Rect oRect(NSRectToRect(outerRect, oneDevPixel)); + + const Float outlineWidths[4] = { + Float(width) / oneDevPixel, Float(width) / oneDevPixel, + Float(width) / oneDevPixel, Float(width) / oneDevPixel}; + + // convert the radii + nscoord twipsRadii[8]; + + // get the radius for our outline + if (aForFrame->GetBorderRadii(twipsRadii)) { + RectCornerRadii innerRadii; + ComputePixelRadii(twipsRadii, oneDevPixel, &innerRadii); + + const auto devPxOffset = LayoutDeviceSize::FromAppUnits( + effectiveOffset, aPresContext->AppUnitsPerDevPixel()); + + const Float widths[4] = {outlineWidths[0] + devPxOffset.Height(), + outlineWidths[1] + devPxOffset.Width(), + outlineWidths[2] + devPxOffset.Height(), + outlineWidths[3] + devPxOffset.Width()}; + nsCSSBorderRenderer::ComputeOuterRadii(innerRadii, widths, &outlineRadii); + } + + StyleBorderStyle outlineStyles[4] = {outlineStyle, outlineStyle, outlineStyle, + outlineStyle}; + + // This handles treating the initial color as 'currentColor'; if we + // ever want 'invert' back we'll need to do a bit of work here too. + nscolor outlineColor = + aStyle->GetVisitedDependentColor(&nsStyleOutline::mOutlineColor); + nscolor outlineColors[4] = {outlineColor, outlineColor, outlineColor, + outlineColor}; + + Rect dirtyRect = NSRectToRect(aDirtyRect, oneDevPixel); + + return Some(nsCSSBorderRenderer( + aPresContext, aDrawTarget, dirtyRect, oRect, outlineStyles, outlineWidths, + outlineRadii, outlineColors, !aForFrame->BackfaceIsHidden(), Nothing())); +} + +void nsCSSRendering::PaintNonThemedOutline(nsPresContext* aPresContext, + gfxContext& aRenderingContext, + nsIFrame* aForFrame, + const nsRect& aDirtyRect, + const nsRect& aInnerRect, + ComputedStyle* aStyle) { + Maybe<nsCSSBorderRenderer> br = CreateBorderRendererForNonThemedOutline( + aPresContext, aRenderingContext.GetDrawTarget(), aForFrame, aDirtyRect, + aInnerRect, aStyle); + if (!br) { + return; + } + + // start drawing + br->DrawBorders(); + + PrintAsStringNewline(); +} + +void nsCSSRendering::PaintFocus(nsPresContext* aPresContext, + DrawTarget* aDrawTarget, + const nsRect& aFocusRect, nscolor aColor) { + nscoord oneCSSPixel = nsPresContext::CSSPixelsToAppUnits(1); + nscoord oneDevPixel = aPresContext->DevPixelsToAppUnits(1); + + Rect focusRect(NSRectToRect(aFocusRect, oneDevPixel)); + + RectCornerRadii focusRadii; + { + nscoord twipsRadii[8] = {0, 0, 0, 0, 0, 0, 0, 0}; + ComputePixelRadii(twipsRadii, oneDevPixel, &focusRadii); + } + Float focusWidths[4] = { + Float(oneCSSPixel) / oneDevPixel, Float(oneCSSPixel) / oneDevPixel, + Float(oneCSSPixel) / oneDevPixel, Float(oneCSSPixel) / oneDevPixel}; + + StyleBorderStyle focusStyles[4] = { + StyleBorderStyle::Dotted, StyleBorderStyle::Dotted, + StyleBorderStyle::Dotted, StyleBorderStyle::Dotted}; + nscolor focusColors[4] = {aColor, aColor, aColor, aColor}; + + // Because this renders a dotted border, the background color + // should not be used. Therefore, we provide a value that will + // be blatantly wrong if it ever does get used. (If this becomes + // something that CSS can style, this function will then have access + // to a ComputedStyle and can use the same logic that PaintBorder + // and PaintOutline do.) + // + // WebRender layers-free mode don't use PaintFocus function. Just assign + // the backface-visibility to true for this case. + nsCSSBorderRenderer br(aPresContext, aDrawTarget, focusRect, focusRect, + focusStyles, focusWidths, focusRadii, focusColors, + true, Nothing()); + br.DrawBorders(); + + PrintAsStringNewline(); +} + +// Thebes Border Rendering Code End +//---------------------------------------------------------------------- + +//---------------------------------------------------------------------- + +/** + * Helper for ComputeObjectAnchorPoint; parameters are the same as for + * that function, except they're for a single coordinate / a single size + * dimension. (so, x/width vs. y/height) + */ +static void ComputeObjectAnchorCoord(const LengthPercentage& aCoord, + const nscoord aOriginBounds, + const nscoord aImageSize, + nscoord* aTopLeftCoord, + nscoord* aAnchorPointCoord) { + nscoord extraSpace = aOriginBounds - aImageSize; + + // The anchor-point doesn't care about our image's size; just the size + // of the region we're rendering into. + *aAnchorPointCoord = aCoord.Resolve( + aOriginBounds, static_cast<nscoord (*)(float)>(NSToCoordRoundWithClamp)); + // Adjust aTopLeftCoord by the specified % of the extra space. + *aTopLeftCoord = aCoord.Resolve( + extraSpace, static_cast<nscoord (*)(float)>(NSToCoordRoundWithClamp)); +} + +void nsImageRenderer::ComputeObjectAnchorPoint(const Position& aPos, + const nsSize& aOriginBounds, + const nsSize& aImageSize, + nsPoint* aTopLeft, + nsPoint* aAnchorPoint) { + ComputeObjectAnchorCoord(aPos.horizontal, aOriginBounds.width, + aImageSize.width, &aTopLeft->x, &aAnchorPoint->x); + + ComputeObjectAnchorCoord(aPos.vertical, aOriginBounds.height, + aImageSize.height, &aTopLeft->y, &aAnchorPoint->y); +} + +// In print / print preview we have multiple canvas frames (one for each page, +// and one for the document as a whole). For the topmost one, we really want the +// page sequence page background, not the root or body's background. +static nsIFrame* GetPageSequenceForCanvas(const nsIFrame* aCanvasFrame) { + MOZ_ASSERT(aCanvasFrame->IsCanvasFrame(), "not a canvas frame"); + nsPresContext* pc = aCanvasFrame->PresContext(); + if (!pc->IsRootPaginatedDocument()) { + return nullptr; + } + auto* ps = pc->PresShell()->GetPageSequenceFrame(); + if (NS_WARN_IF(!ps)) { + return nullptr; + } + if (ps->GetParent() != aCanvasFrame) { + return nullptr; + } + return ps; +} + +auto nsCSSRendering::FindEffectiveBackgroundColor(nsIFrame* aFrame, + bool aStopAtThemed, + bool aPreferBodyToCanvas) + -> EffectiveBackgroundColor { + MOZ_ASSERT(aFrame); + nsPresContext* pc = aFrame->PresContext(); + auto BgColorIfNotTransparent = [&](nsIFrame* aFrame) -> Maybe<nscolor> { + nscolor c = + aFrame->GetVisitedDependentColor(&nsStyleBackground::mBackgroundColor); + if (NS_GET_A(c) == 255) { + return Some(c); + } + if (NS_GET_A(c)) { + // TODO(emilio): We should maybe just blend with ancestor bg colors and + // such, but this is probably good enough for now, matches pre-existing + // behavior. + const nscolor defaultBg = pc->DefaultBackgroundColor(); + MOZ_ASSERT(NS_GET_A(defaultBg) == 255, "PreferenceSheet guarantees this"); + return Some(NS_ComposeColors(defaultBg, c)); + } + return Nothing(); + }; + + for (nsIFrame* frame = aFrame; frame; + frame = nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(frame)) { + if (auto bg = BgColorIfNotTransparent(frame)) { + return {*bg}; + } + + if (aStopAtThemed && frame->IsThemed()) { + return {NS_TRANSPARENT, true}; + } + + if (frame->IsCanvasFrame()) { + if (aPreferBodyToCanvas && !GetPageSequenceForCanvas(frame)) { + if (auto* body = pc->Document()->GetBodyElement()) { + if (nsIFrame* f = body->GetPrimaryFrame()) { + if (auto bg = BgColorIfNotTransparent(f)) { + return {*bg}; + } + } + } + } + if (nsIFrame* bgFrame = FindBackgroundFrame(frame)) { + if (auto bg = BgColorIfNotTransparent(bgFrame)) { + return {*bg}; + } + } + } + } + + return {pc->DefaultBackgroundColor()}; +} + +nsIFrame* nsCSSRendering::FindBackgroundStyleFrame(nsIFrame* aForFrame) { + const nsStyleBackground* result = aForFrame->StyleBackground(); + + // Check if we need to do propagation from BODY rather than HTML. + if (!result->IsTransparent(aForFrame)) { + return aForFrame; + } + + nsIContent* content = aForFrame->GetContent(); + // The root element content can't be null. We wouldn't know what + // frame to create for aFrame. + // Use |OwnerDoc| so it works during destruction. + if (!content) { + return aForFrame; + } + + Document* document = content->OwnerDoc(); + + dom::Element* bodyContent = document->GetBodyElement(); + // We need to null check the body node (bug 118829) since + // there are cases, thanks to the fix for bug 5569, where we + // will reflow a document with no body. In particular, if a + // SCRIPT element in the head blocks the parser and then has a + // SCRIPT that does "document.location.href = 'foo'", then + // nsParser::Terminate will call |DidBuildModel| methods + // through to the content sink, which will call |StartLayout| + // and thus |Initialize| on the pres shell. See bug 119351 + // for the ugly details. + if (!bodyContent || aForFrame->StyleDisplay()->IsContainAny()) { + return aForFrame; + } + + nsIFrame* bodyFrame = bodyContent->GetPrimaryFrame(); + if (!bodyFrame || bodyFrame->StyleDisplay()->IsContainAny()) { + return aForFrame; + } + + return nsLayoutUtils::GetStyleFrame(bodyFrame); +} + +/** + * |FindBackground| finds the correct style data to use to paint the + * background. It is responsible for handling the following two + * statements in section 14.2 of CSS2: + * + * The background of the box generated by the root element covers the + * entire canvas. + * + * For HTML documents, however, we recommend that authors specify the + * background for the BODY element rather than the HTML element. User + * agents should observe the following precedence rules to fill in the + * background: if the value of the 'background' property for the HTML + * element is different from 'transparent' then use it, else use the + * value of the 'background' property for the BODY element. If the + * resulting value is 'transparent', the rendering is undefined. + * + * Thus, in our implementation, it is responsible for ensuring that: + * + we paint the correct background on the |nsCanvasFrame| or |nsPageFrame|, + * + we don't paint the background on the root element, and + * + we don't paint the background on the BODY element in *some* cases, + * and for SGML-based HTML documents only. + * + * |FindBackground| checks whether a background should be painted. If yes, it + * returns the resulting ComputedStyle to use for the background information; + * Otherwise, it returns nullptr. + */ +ComputedStyle* nsCSSRendering::FindRootFrameBackground(nsIFrame* aForFrame) { + return FindBackgroundStyleFrame(aForFrame)->Style(); +} + +static nsIFrame* FindCanvasBackgroundFrame(const nsIFrame* aForFrame, + nsIFrame* aRootElementFrame) { + MOZ_ASSERT(aForFrame->IsCanvasFrame(), "not a canvas frame"); + if (auto* ps = GetPageSequenceForCanvas(aForFrame)) { + return ps; + } + if (aRootElementFrame) { + return nsCSSRendering::FindBackgroundStyleFrame(aRootElementFrame); + } + // This should always give transparent, so we'll fill it in with the default + // color if needed. This seems to happen a bit while a page is being loaded. + return const_cast<nsIFrame*>(aForFrame); +} + +// Helper for FindBackgroundFrame. Returns true if aForFrame has a meaningful +// background that it should draw (i.e. that it hasn't propagated to another +// frame). See documentation for FindBackground. +inline bool FrameHasMeaningfulBackground(const nsIFrame* aForFrame, + nsIFrame* aRootElementFrame) { + MOZ_ASSERT(!aForFrame->IsCanvasFrame(), + "FindBackgroundFrame handles canvas frames before calling us, " + "so we don't need to consider them here"); + + if (aForFrame == aRootElementFrame) { + // We must have propagated our background to the viewport or canvas. Abort. + return false; + } + + // Return true unless the frame is for a BODY element whose background + // was propagated to the viewport. + + nsIContent* content = aForFrame->GetContent(); + if (!content || content->NodeInfo()->NameAtom() != nsGkAtoms::body) { + return true; // not frame for a "body" element + } + // It could be a non-HTML "body" element but that's OK, we'd fail the + // bodyContent check below + + if (aForFrame->Style()->GetPseudoType() != PseudoStyleType::NotPseudo || + aForFrame->StyleDisplay()->IsContainAny()) { + return true; // A pseudo-element frame, or contained. + } + + // We should only look at the <html> background if we're in an HTML document + Document* document = content->OwnerDoc(); + + dom::Element* bodyContent = document->GetBodyElement(); + if (bodyContent != content) { + return true; // this wasn't the background that was propagated + } + + // This can be called even when there's no root element yet, during frame + // construction, via nsLayoutUtils::FrameHasTransparency and + // nsContainerFrame::SyncFrameViewProperties. + if (!aRootElementFrame || aRootElementFrame->StyleDisplay()->IsContainAny()) { + return true; + } + + const nsStyleBackground* htmlBG = aRootElementFrame->StyleBackground(); + return !htmlBG->IsTransparent(aRootElementFrame); +} + +nsIFrame* nsCSSRendering::FindBackgroundFrame(const nsIFrame* aForFrame) { + nsIFrame* rootElementFrame = + aForFrame->PresShell()->FrameConstructor()->GetRootElementStyleFrame(); + if (aForFrame->IsCanvasFrame()) { + return FindCanvasBackgroundFrame(aForFrame, rootElementFrame); + } + + if (FrameHasMeaningfulBackground(aForFrame, rootElementFrame)) { + return const_cast<nsIFrame*>(aForFrame); + } + + return nullptr; +} + +ComputedStyle* nsCSSRendering::FindBackground(const nsIFrame* aForFrame) { + if (auto* backgroundFrame = FindBackgroundFrame(aForFrame)) { + return backgroundFrame->Style(); + } + return nullptr; +} + +void nsCSSRendering::BeginFrameTreesLocked() { ++gFrameTreeLockCount; } + +void nsCSSRendering::EndFrameTreesLocked() { + NS_ASSERTION(gFrameTreeLockCount > 0, "Unbalanced EndFrameTreeLocked"); + --gFrameTreeLockCount; + if (gFrameTreeLockCount == 0) { + gInlineBGData->Reset(); + } +} + +bool nsCSSRendering::HasBoxShadowNativeTheme(nsIFrame* aFrame, + bool& aMaybeHasBorderRadius) { + const nsStyleDisplay* styleDisplay = aFrame->StyleDisplay(); + nsITheme::Transparency transparency; + if (aFrame->IsThemed(styleDisplay, &transparency)) { + aMaybeHasBorderRadius = false; + // For opaque (rectangular) theme widgets we can take the generic + // border-box path with border-radius disabled. + return transparency != nsITheme::eOpaque; + } + + aMaybeHasBorderRadius = true; + return false; +} + +gfx::sRGBColor nsCSSRendering::GetShadowColor(const StyleSimpleShadow& aShadow, + nsIFrame* aFrame, + float aOpacity) { + // Get the shadow color; if not specified, use the foreground color + nscolor shadowColor = aShadow.color.CalcColor(aFrame); + sRGBColor color = sRGBColor::FromABGR(shadowColor); + color.a *= aOpacity; + return color; +} + +nsRect nsCSSRendering::GetShadowRect(const nsRect& aFrameArea, + bool aNativeTheme, nsIFrame* aForFrame) { + nsRect frameRect = aNativeTheme ? aForFrame->InkOverflowRectRelativeToSelf() + + aFrameArea.TopLeft() + : aFrameArea; + Sides skipSides = aForFrame->GetSkipSides(); + frameRect = BoxDecorationRectForBorder(aForFrame, frameRect, skipSides); + + // Explicitly do not need to account for the spread radius here + // Webrender does it for us or PaintBoxShadow will for non-WR + return frameRect; +} + +bool nsCSSRendering::GetBorderRadii(const nsRect& aFrameRect, + const nsRect& aBorderRect, nsIFrame* aFrame, + RectCornerRadii& aOutRadii) { + const nscoord oneDevPixel = aFrame->PresContext()->DevPixelsToAppUnits(1); + nscoord twipsRadii[8]; + NS_ASSERTION( + aBorderRect.Size() == aFrame->VisualBorderRectRelativeToSelf().Size(), + "unexpected size"); + nsSize sz = aFrameRect.Size(); + bool hasBorderRadius = aFrame->GetBorderRadii(sz, sz, Sides(), twipsRadii); + if (hasBorderRadius) { + ComputePixelRadii(twipsRadii, oneDevPixel, &aOutRadii); + } + + return hasBorderRadius; +} + +void nsCSSRendering::PaintBoxShadowOuter(nsPresContext* aPresContext, + gfxContext& aRenderingContext, + nsIFrame* aForFrame, + const nsRect& aFrameArea, + const nsRect& aDirtyRect, + float aOpacity) { + DrawTarget& aDrawTarget = *aRenderingContext.GetDrawTarget(); + auto shadows = aForFrame->StyleEffects()->mBoxShadow.AsSpan(); + if (shadows.IsEmpty()) { + return; + } + + bool hasBorderRadius; + // mutually exclusive with hasBorderRadius + bool nativeTheme = HasBoxShadowNativeTheme(aForFrame, hasBorderRadius); + const nsStyleDisplay* styleDisplay = aForFrame->StyleDisplay(); + + nsRect frameRect = GetShadowRect(aFrameArea, nativeTheme, aForFrame); + + // Get any border radius, since box-shadow must also have rounded corners if + // the frame does. + RectCornerRadii borderRadii; + const nscoord oneDevPixel = aPresContext->DevPixelsToAppUnits(1); + if (hasBorderRadius) { + nscoord twipsRadii[8]; + NS_ASSERTION( + aFrameArea.Size() == aForFrame->VisualBorderRectRelativeToSelf().Size(), + "unexpected size"); + nsSize sz = frameRect.Size(); + hasBorderRadius = aForFrame->GetBorderRadii(sz, sz, Sides(), twipsRadii); + if (hasBorderRadius) { + ComputePixelRadii(twipsRadii, oneDevPixel, &borderRadii); + } + } + + // We don't show anything that intersects with the frame we're blurring on. So + // tell the blurrer not to do unnecessary work there. + gfxRect skipGfxRect = ThebesRect(NSRectToRect(frameRect, oneDevPixel)); + skipGfxRect.Round(); + bool useSkipGfxRect = true; + if (nativeTheme) { + // Optimize non-leaf native-themed frames by skipping computing pixels + // in the padding-box. We assume the padding-box is going to be painted + // opaquely for non-leaf frames. + // XXX this may not be a safe assumption; we should make this go away + // by optimizing box-shadow drawing more for the cases where we don't have a + // skip-rect. + useSkipGfxRect = !aForFrame->IsLeaf(); + nsRect paddingRect = + aForFrame->GetPaddingRectRelativeToSelf() + aFrameArea.TopLeft(); + skipGfxRect = nsLayoutUtils::RectToGfxRect(paddingRect, oneDevPixel); + } else if (hasBorderRadius) { + skipGfxRect.Deflate(gfxMargin( + std::max(borderRadii[C_TL].height, borderRadii[C_TR].height), 0, + std::max(borderRadii[C_BL].height, borderRadii[C_BR].height), 0)); + } + + for (const StyleBoxShadow& shadow : Reversed(shadows)) { + if (shadow.inset) { + continue; + } + + nsRect shadowRect = frameRect; + nsPoint shadowOffset(shadow.base.horizontal.ToAppUnits(), + shadow.base.vertical.ToAppUnits()); + shadowRect.MoveBy(shadowOffset); + nscoord shadowSpread = shadow.spread.ToAppUnits(); + if (!nativeTheme) { + shadowRect.Inflate(shadowSpread); + } + + // shadowRect won't include the blur, so make an extra rect here that + // includes the blur for use in the even-odd rule below. + nsRect shadowRectPlusBlur = shadowRect; + nscoord blurRadius = shadow.base.blur.ToAppUnits(); + shadowRectPlusBlur.Inflate( + nsContextBoxBlur::GetBlurRadiusMargin(blurRadius, oneDevPixel)); + + Rect shadowGfxRectPlusBlur = NSRectToRect(shadowRectPlusBlur, oneDevPixel); + shadowGfxRectPlusBlur.RoundOut(); + MaybeSnapToDevicePixels(shadowGfxRectPlusBlur, aDrawTarget, true); + + sRGBColor gfxShadowColor = GetShadowColor(shadow.base, aForFrame, aOpacity); + + if (nativeTheme) { + nsContextBoxBlur blurringArea; + + // When getting the widget shape from the native theme, we're going + // to draw the widget into the shadow surface to create a mask. + // We need to ensure that there actually *is* a shadow surface + // and that we're not going to draw directly into aRenderingContext. + gfxContext* shadowContext = blurringArea.Init( + shadowRect, shadowSpread, blurRadius, oneDevPixel, &aRenderingContext, + aDirtyRect, useSkipGfxRect ? &skipGfxRect : nullptr, + nsContextBoxBlur::FORCE_MASK); + if (!shadowContext) continue; + + MOZ_ASSERT(shadowContext == blurringArea.GetContext()); + + aRenderingContext.Save(); + aRenderingContext.SetColor(gfxShadowColor); + + // Draw the shape of the frame so it can be blurred. Recall how + // nsContextBoxBlur doesn't make any temporary surfaces if blur is 0 and + // it just returns the original surface? If we have no blur, we're + // painting this fill on the actual content surface (aRenderingContext == + // shadowContext) which is why we set up the color and clip before doing + // this. + + // We don't clip the border-box from the shadow, nor any other box. + // We assume that the native theme is going to paint over the shadow. + + // Draw the widget shape + gfxContextMatrixAutoSaveRestore save(shadowContext); + gfxPoint devPixelOffset = nsLayoutUtils::PointToGfxPoint( + shadowOffset, aPresContext->AppUnitsPerDevPixel()); + shadowContext->SetMatrixDouble( + shadowContext->CurrentMatrixDouble().PreTranslate(devPixelOffset)); + + nsRect nativeRect = aDirtyRect; + nativeRect.MoveBy(-shadowOffset); + nativeRect.IntersectRect(frameRect, nativeRect); + aPresContext->Theme()->DrawWidgetBackground( + shadowContext, aForFrame, styleDisplay->EffectiveAppearance(), + aFrameArea, nativeRect, nsITheme::DrawOverflow::No); + + blurringArea.DoPaint(); + aRenderingContext.Restore(); + } else { + aRenderingContext.Save(); + + { + Rect innerClipRect = NSRectToRect(frameRect, oneDevPixel); + if (!MaybeSnapToDevicePixels(innerClipRect, aDrawTarget, true)) { + innerClipRect.Round(); + } + + // Clip out the interior of the frame's border edge so that the shadow + // is only painted outside that area. + RefPtr<PathBuilder> builder = + aDrawTarget.CreatePathBuilder(FillRule::FILL_EVEN_ODD); + AppendRectToPath(builder, shadowGfxRectPlusBlur); + if (hasBorderRadius) { + AppendRoundedRectToPath(builder, innerClipRect, borderRadii); + } else { + AppendRectToPath(builder, innerClipRect); + } + RefPtr<Path> path = builder->Finish(); + aRenderingContext.Clip(path); + } + + // Clip the shadow so that we only get the part that applies to aForFrame. + nsRect fragmentClip = shadowRectPlusBlur; + Sides skipSides = aForFrame->GetSkipSides(); + if (!skipSides.IsEmpty()) { + if (skipSides.Left()) { + nscoord xmost = fragmentClip.XMost(); + fragmentClip.x = aFrameArea.x; + fragmentClip.width = xmost - fragmentClip.x; + } + if (skipSides.Right()) { + nscoord xmost = fragmentClip.XMost(); + nscoord overflow = xmost - aFrameArea.XMost(); + if (overflow > 0) { + fragmentClip.width -= overflow; + } + } + if (skipSides.Top()) { + nscoord ymost = fragmentClip.YMost(); + fragmentClip.y = aFrameArea.y; + fragmentClip.height = ymost - fragmentClip.y; + } + if (skipSides.Bottom()) { + nscoord ymost = fragmentClip.YMost(); + nscoord overflow = ymost - aFrameArea.YMost(); + if (overflow > 0) { + fragmentClip.height -= overflow; + } + } + } + fragmentClip = fragmentClip.Intersect(aDirtyRect); + aRenderingContext.Clip(NSRectToSnappedRect( + fragmentClip, aForFrame->PresContext()->AppUnitsPerDevPixel(), + aDrawTarget)); + + RectCornerRadii clipRectRadii; + if (hasBorderRadius) { + Float spreadDistance = Float(shadowSpread / oneDevPixel); + + Float borderSizes[4]; + + borderSizes[eSideLeft] = spreadDistance; + borderSizes[eSideTop] = spreadDistance; + borderSizes[eSideRight] = spreadDistance; + borderSizes[eSideBottom] = spreadDistance; + + nsCSSBorderRenderer::ComputeOuterRadii(borderRadii, borderSizes, + &clipRectRadii); + } + nsContextBoxBlur::BlurRectangle( + &aRenderingContext, shadowRect, oneDevPixel, + hasBorderRadius ? &clipRectRadii : nullptr, blurRadius, + gfxShadowColor, aDirtyRect, skipGfxRect); + aRenderingContext.Restore(); + } + } +} + +nsRect nsCSSRendering::GetBoxShadowInnerPaddingRect(nsIFrame* aFrame, + const nsRect& aFrameArea) { + Sides skipSides = aFrame->GetSkipSides(); + nsRect frameRect = BoxDecorationRectForBorder(aFrame, aFrameArea, skipSides); + + nsRect paddingRect = frameRect; + nsMargin border = aFrame->GetUsedBorder(); + paddingRect.Deflate(border); + return paddingRect; +} + +bool nsCSSRendering::ShouldPaintBoxShadowInner(nsIFrame* aFrame) { + const Span<const StyleBoxShadow> shadows = + aFrame->StyleEffects()->mBoxShadow.AsSpan(); + if (shadows.IsEmpty()) { + return false; + } + + if (aFrame->IsThemed() && aFrame->GetContent() && + !nsContentUtils::IsChromeDoc(aFrame->GetContent()->GetComposedDoc())) { + // There's no way of getting hold of a shape corresponding to a + // "padding-box" for native-themed widgets, so just don't draw + // inner box-shadows for them. But we allow chrome to paint inner + // box shadows since chrome can be aware of the platform theme. + return false; + } + + return true; +} + +bool nsCSSRendering::GetShadowInnerRadii(nsIFrame* aFrame, + const nsRect& aFrameArea, + RectCornerRadii& aOutInnerRadii) { + // Get any border radius, since box-shadow must also have rounded corners + // if the frame does. + nscoord twipsRadii[8]; + nsRect frameRect = + BoxDecorationRectForBorder(aFrame, aFrameArea, aFrame->GetSkipSides()); + nsSize sz = frameRect.Size(); + nsMargin border = aFrame->GetUsedBorder(); + aFrame->GetBorderRadii(sz, sz, Sides(), twipsRadii); + const nscoord oneDevPixel = aFrame->PresContext()->DevPixelsToAppUnits(1); + + RectCornerRadii borderRadii; + + const bool hasBorderRadius = + GetBorderRadii(frameRect, aFrameArea, aFrame, borderRadii); + + if (hasBorderRadius) { + ComputePixelRadii(twipsRadii, oneDevPixel, &borderRadii); + + Float borderSizes[4] = { + Float(border.top) / oneDevPixel, Float(border.right) / oneDevPixel, + Float(border.bottom) / oneDevPixel, Float(border.left) / oneDevPixel}; + nsCSSBorderRenderer::ComputeInnerRadii(borderRadii, borderSizes, + &aOutInnerRadii); + } + + return hasBorderRadius; +} + +void nsCSSRendering::PaintBoxShadowInner(nsPresContext* aPresContext, + gfxContext& aRenderingContext, + nsIFrame* aForFrame, + const nsRect& aFrameArea) { + if (!ShouldPaintBoxShadowInner(aForFrame)) { + return; + } + + const Span<const StyleBoxShadow> shadows = + aForFrame->StyleEffects()->mBoxShadow.AsSpan(); + NS_ASSERTION( + aForFrame->IsFieldSetFrame() || aFrameArea.Size() == aForFrame->GetSize(), + "unexpected size"); + + nsRect paddingRect = GetBoxShadowInnerPaddingRect(aForFrame, aFrameArea); + + RectCornerRadii innerRadii; + bool hasBorderRadius = GetShadowInnerRadii(aForFrame, aFrameArea, innerRadii); + + const nscoord oneDevPixel = aPresContext->DevPixelsToAppUnits(1); + + for (const StyleBoxShadow& shadow : Reversed(shadows)) { + if (!shadow.inset) { + continue; + } + + // shadowPaintRect: the area to paint on the temp surface + // shadowClipRect: the area on the temporary surface within shadowPaintRect + // that we will NOT paint in + nscoord blurRadius = shadow.base.blur.ToAppUnits(); + nsMargin blurMargin = + nsContextBoxBlur::GetBlurRadiusMargin(blurRadius, oneDevPixel); + nsRect shadowPaintRect = paddingRect; + shadowPaintRect.Inflate(blurMargin); + + // Round the spread radius to device pixels (by truncation). + // This mostly matches what we do for borders, except that we don't round + // up values between zero and one device pixels to one device pixel. + // This way of rounding is symmetric around zero, which makes sense for + // the spread radius. + int32_t spreadDistance = shadow.spread.ToAppUnits() / oneDevPixel; + nscoord spreadDistanceAppUnits = + aPresContext->DevPixelsToAppUnits(spreadDistance); + + nsRect shadowClipRect = paddingRect; + shadowClipRect.MoveBy(shadow.base.horizontal.ToAppUnits(), + shadow.base.vertical.ToAppUnits()); + shadowClipRect.Deflate(spreadDistanceAppUnits, spreadDistanceAppUnits); + + Rect shadowClipGfxRect = NSRectToRect(shadowClipRect, oneDevPixel); + shadowClipGfxRect.Round(); + + RectCornerRadii clipRectRadii; + if (hasBorderRadius) { + // Calculate the radii the inner clipping rect will have + Float borderSizes[4] = {0, 0, 0, 0}; + + // See PaintBoxShadowOuter and bug 514670 + if (innerRadii[C_TL].width > 0 || innerRadii[C_BL].width > 0) { + borderSizes[eSideLeft] = spreadDistance; + } + + if (innerRadii[C_TL].height > 0 || innerRadii[C_TR].height > 0) { + borderSizes[eSideTop] = spreadDistance; + } + + if (innerRadii[C_TR].width > 0 || innerRadii[C_BR].width > 0) { + borderSizes[eSideRight] = spreadDistance; + } + + if (innerRadii[C_BL].height > 0 || innerRadii[C_BR].height > 0) { + borderSizes[eSideBottom] = spreadDistance; + } + + nsCSSBorderRenderer::ComputeInnerRadii(innerRadii, borderSizes, + &clipRectRadii); + } + + // Set the "skip rect" to the area within the frame that we don't paint in, + // including after blurring. + nsRect skipRect = shadowClipRect; + skipRect.Deflate(blurMargin); + gfxRect skipGfxRect = nsLayoutUtils::RectToGfxRect(skipRect, oneDevPixel); + if (hasBorderRadius) { + skipGfxRect.Deflate(gfxMargin( + std::max(clipRectRadii[C_TL].height, clipRectRadii[C_TR].height), 0, + std::max(clipRectRadii[C_BL].height, clipRectRadii[C_BR].height), 0)); + } + + // When there's a blur radius, gfxAlphaBoxBlur leaves the skiprect area + // unchanged. And by construction the gfxSkipRect is not touched by the + // rendered shadow (even after blurring), so those pixels must be completely + // transparent in the shadow, so drawing them changes nothing. + DrawTarget* drawTarget = aRenderingContext.GetDrawTarget(); + + // Clip the context to the area of the frame's padding rect, so no part of + // the shadow is painted outside. Also cut out anything beyond where the + // inset shadow will be. + Rect shadowGfxRect = NSRectToRect(paddingRect, oneDevPixel); + shadowGfxRect.Round(); + + sRGBColor shadowColor = GetShadowColor(shadow.base, aForFrame, 1.0); + aRenderingContext.Save(); + + // This clips the outside border radius. + // clipRectRadii is the border radius inside the inset shadow. + if (hasBorderRadius) { + RefPtr<Path> roundedRect = + MakePathForRoundedRect(*drawTarget, shadowGfxRect, innerRadii); + aRenderingContext.Clip(roundedRect); + } else { + aRenderingContext.Clip(shadowGfxRect); + } + + nsContextBoxBlur insetBoxBlur; + gfxRect destRect = + nsLayoutUtils::RectToGfxRect(shadowPaintRect, oneDevPixel); + Point shadowOffset(shadow.base.horizontal.ToAppUnits() / oneDevPixel, + shadow.base.vertical.ToAppUnits() / oneDevPixel); + + insetBoxBlur.InsetBoxBlur( + &aRenderingContext, ToRect(destRect), shadowClipGfxRect, shadowColor, + blurRadius, spreadDistanceAppUnits, oneDevPixel, hasBorderRadius, + clipRectRadii, ToRect(skipGfxRect), shadowOffset); + aRenderingContext.Restore(); + } +} + +/* static */ +nsCSSRendering::PaintBGParams nsCSSRendering::PaintBGParams::ForAllLayers( + nsPresContext& aPresCtx, const nsRect& aDirtyRect, + const nsRect& aBorderArea, nsIFrame* aFrame, uint32_t aPaintFlags, + float aOpacity) { + MOZ_ASSERT(aFrame); + + PaintBGParams result(aPresCtx, aDirtyRect, aBorderArea, aFrame, aPaintFlags, + -1, CompositionOp::OP_OVER, aOpacity); + + return result; +} + +/* static */ +nsCSSRendering::PaintBGParams nsCSSRendering::PaintBGParams::ForSingleLayer( + nsPresContext& aPresCtx, const nsRect& aDirtyRect, + const nsRect& aBorderArea, nsIFrame* aFrame, uint32_t aPaintFlags, + int32_t aLayer, CompositionOp aCompositionOp, float aOpacity) { + MOZ_ASSERT(aFrame && (aLayer != -1)); + + PaintBGParams result(aPresCtx, aDirtyRect, aBorderArea, aFrame, aPaintFlags, + aLayer, aCompositionOp, aOpacity); + + return result; +} + +ImgDrawResult nsCSSRendering::PaintStyleImageLayer(const PaintBGParams& aParams, + gfxContext& aRenderingCtx) { + AUTO_PROFILER_LABEL("nsCSSRendering::PaintStyleImageLayer", GRAPHICS); + + MOZ_ASSERT(aParams.frame, + "Frame is expected to be provided to PaintStyleImageLayer"); + + const ComputedStyle* sc = FindBackground(aParams.frame); + if (!sc) { + // We don't want to bail out if moz-appearance is set on a root + // node. If it has a parent content node, bail because it's not + // a root, otherwise keep going in order to let the theme stuff + // draw the background. The canvas really should be drawing the + // bg, but there's no way to hook that up via css. + if (!aParams.frame->StyleDisplay()->HasAppearance()) { + return ImgDrawResult::SUCCESS; + } + + nsIContent* content = aParams.frame->GetContent(); + if (!content || content->GetParent()) { + return ImgDrawResult::SUCCESS; + } + + sc = aParams.frame->Style(); + } + + return PaintStyleImageLayerWithSC(aParams, aRenderingCtx, sc, + *aParams.frame->StyleBorder()); +} + +bool nsCSSRendering::CanBuildWebRenderDisplayItemsForStyleImageLayer( + WebRenderLayerManager* aManager, nsPresContext& aPresCtx, nsIFrame* aFrame, + const nsStyleBackground* aBackgroundStyle, int32_t aLayer, + uint32_t aPaintFlags) { + if (!aBackgroundStyle) { + return false; + } + + MOZ_ASSERT(aFrame && aLayer >= 0 && + (uint32_t)aLayer < aBackgroundStyle->mImage.mLayers.Length()); + + // We cannot draw native themed backgrounds + StyleAppearance appearance = aFrame->StyleDisplay()->EffectiveAppearance(); + if (appearance != StyleAppearance::None) { + nsITheme* theme = aPresCtx.Theme(); + if (theme->ThemeSupportsWidget(&aPresCtx, aFrame, appearance)) { + return false; + } + } + + // We only support painting gradients and image for a single style image + // layer, and we don't support crop-rects. + const auto& styleImage = + aBackgroundStyle->mImage.mLayers[aLayer].mImage.FinalImage(); + if (styleImage.IsImageRequestType()) { + imgRequestProxy* requestProxy = styleImage.GetImageRequest(); + if (!requestProxy) { + return false; + } + + uint32_t imageFlags = imgIContainer::FLAG_NONE; + if (aPaintFlags & nsCSSRendering::PAINTBG_SYNC_DECODE_IMAGES) { + imageFlags |= imgIContainer::FLAG_SYNC_DECODE; + } + + nsCOMPtr<imgIContainer> srcImage; + requestProxy->GetImage(getter_AddRefs(srcImage)); + if (!srcImage || + !srcImage->IsImageContainerAvailable(aManager, imageFlags)) { + return false; + } + + return true; + } + + if (styleImage.IsGradient()) { + return true; + } + + return false; +} + +ImgDrawResult nsCSSRendering::BuildWebRenderDisplayItemsForStyleImageLayer( + const PaintBGParams& aParams, mozilla::wr::DisplayListBuilder& aBuilder, + mozilla::wr::IpcResourceUpdateQueue& aResources, + const mozilla::layers::StackingContextHelper& aSc, + mozilla::layers::RenderRootStateManager* aManager, nsDisplayItem* aItem) { + MOZ_ASSERT(aParams.frame, + "Frame is expected to be provided to " + "BuildWebRenderDisplayItemsForStyleImageLayer"); + + ComputedStyle* sc = FindBackground(aParams.frame); + if (!sc) { + // We don't want to bail out if moz-appearance is set on a root + // node. If it has a parent content node, bail because it's not + // a root, otherwise keep going in order to let the theme stuff + // draw the background. The canvas really should be drawing the + // bg, but there's no way to hook that up via css. + if (!aParams.frame->StyleDisplay()->HasAppearance()) { + return ImgDrawResult::SUCCESS; + } + + nsIContent* content = aParams.frame->GetContent(); + if (!content || content->GetParent()) { + return ImgDrawResult::SUCCESS; + } + + sc = aParams.frame->Style(); + } + return BuildWebRenderDisplayItemsForStyleImageLayerWithSC( + aParams, aBuilder, aResources, aSc, aManager, aItem, sc, + *aParams.frame->StyleBorder()); +} + +static bool IsOpaqueBorderEdge(const nsStyleBorder& aBorder, + mozilla::Side aSide) { + if (aBorder.GetComputedBorder().Side(aSide) == 0) return true; + switch (aBorder.GetBorderStyle(aSide)) { + case StyleBorderStyle::Solid: + case StyleBorderStyle::Groove: + case StyleBorderStyle::Ridge: + case StyleBorderStyle::Inset: + case StyleBorderStyle::Outset: + break; + default: + return false; + } + + // If we're using a border image, assume it's not fully opaque, + // because we may not even have the image loaded at this point, and + // even if we did, checking whether the relevant tile is fully + // opaque would be too much work. + if (!aBorder.mBorderImageSource.IsNone()) { + return false; + } + + StyleColor color = aBorder.BorderColorFor(aSide); + // We don't know the foreground color here, so if it's being used + // we must assume it might be transparent. + return !color.MaybeTransparent(); +} + +/** + * Returns true if all border edges are either missing or opaque. + */ +static bool IsOpaqueBorder(const nsStyleBorder& aBorder) { + for (const auto i : mozilla::AllPhysicalSides()) { + if (!IsOpaqueBorderEdge(aBorder, i)) { + return false; + } + } + return true; +} + +static inline void SetupDirtyRects(const nsRect& aBGClipArea, + const nsRect& aCallerDirtyRect, + nscoord aAppUnitsPerPixel, + /* OUT: */ + nsRect* aDirtyRect, gfxRect* aDirtyRectGfx) { + aDirtyRect->IntersectRect(aBGClipArea, aCallerDirtyRect); + + // Compute the Thebes equivalent of the dirtyRect. + *aDirtyRectGfx = nsLayoutUtils::RectToGfxRect(*aDirtyRect, aAppUnitsPerPixel); + NS_WARNING_ASSERTION(aDirtyRect->IsEmpty() || !aDirtyRectGfx->IsEmpty(), + "converted dirty rect should not be empty"); + MOZ_ASSERT(!aDirtyRect->IsEmpty() || aDirtyRectGfx->IsEmpty(), + "second should be empty if first is"); +} + +static bool IsSVGStyleGeometryBox(StyleGeometryBox aBox) { + return (aBox == StyleGeometryBox::FillBox || + aBox == StyleGeometryBox::StrokeBox || + aBox == StyleGeometryBox::ViewBox); +} + +static bool IsHTMLStyleGeometryBox(StyleGeometryBox aBox) { + return (aBox == StyleGeometryBox::ContentBox || + aBox == StyleGeometryBox::PaddingBox || + aBox == StyleGeometryBox::BorderBox || + aBox == StyleGeometryBox::MarginBox); +} + +static StyleGeometryBox ComputeBoxValueForOrigin(nsIFrame* aForFrame, + StyleGeometryBox aBox) { + // The mapping for mask-origin is from + // https://drafts.fxtf.org/css-masking/#the-mask-origin + if (!aForFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) { + // For elements with associated CSS layout box, the values fill-box, + // stroke-box and view-box compute to the initial value of mask-origin. + if (IsSVGStyleGeometryBox(aBox)) { + return StyleGeometryBox::BorderBox; + } + } else { + // For SVG elements without associated CSS layout box, the values + // content-box, padding-box, border-box compute to fill-box. + if (IsHTMLStyleGeometryBox(aBox)) { + return StyleGeometryBox::FillBox; + } + } + + return aBox; +} + +static StyleGeometryBox ComputeBoxValueForClip(const nsIFrame* aForFrame, + StyleGeometryBox aBox) { + // The mapping for mask-clip is from + // https://drafts.fxtf.org/css-masking/#the-mask-clip + if (aForFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)) { + // For SVG elements without associated CSS layout box, the used values for + // content-box and padding-box compute to fill-box and for border-box and + // margin-box compute to stroke-box. + switch (aBox) { + case StyleGeometryBox::ContentBox: + case StyleGeometryBox::PaddingBox: + return StyleGeometryBox::FillBox; + case StyleGeometryBox::BorderBox: + case StyleGeometryBox::MarginBox: + return StyleGeometryBox::StrokeBox; + default: + return aBox; + } + } + + // For elements with associated CSS layout box, the used values for fill-box + // compute to content-box and for stroke-box and view-box compute to + // border-box. + switch (aBox) { + case StyleGeometryBox::FillBox: + return StyleGeometryBox::ContentBox; + case StyleGeometryBox::StrokeBox: + case StyleGeometryBox::ViewBox: + return StyleGeometryBox::BorderBox; + default: + return aBox; + } +} + +bool nsCSSRendering::ImageLayerClipState::IsValid() const { + // mDirtyRectInDevPx comes from mDirtyRectInAppUnits. mDirtyRectInAppUnits + // can not be empty if mDirtyRectInDevPx is not. + if (!mDirtyRectInDevPx.IsEmpty() && mDirtyRectInAppUnits.IsEmpty()) { + return false; + } + + if (mHasRoundedCorners == mClippedRadii.IsEmpty()) { + return false; + } + + return true; +} + +/* static */ +void nsCSSRendering::GetImageLayerClip( + const nsStyleImageLayers::Layer& aLayer, nsIFrame* aForFrame, + const nsStyleBorder& aBorder, const nsRect& aBorderArea, + const nsRect& aCallerDirtyRect, bool aWillPaintBorder, + nscoord aAppUnitsPerPixel, + /* out */ ImageLayerClipState* aClipState) { + StyleGeometryBox layerClip = ComputeBoxValueForClip(aForFrame, aLayer.mClip); + if (IsSVGStyleGeometryBox(layerClip)) { + MOZ_ASSERT(aForFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)); + + // The coordinate space of clipArea is svg user space. + nsRect clipArea = + nsLayoutUtils::ComputeSVGReferenceRect(aForFrame, layerClip); + + nsRect strokeBox = (layerClip == StyleGeometryBox::StrokeBox) + ? clipArea + : nsLayoutUtils::ComputeSVGReferenceRect( + aForFrame, StyleGeometryBox::StrokeBox); + nsRect clipAreaRelativeToStrokeBox = clipArea - strokeBox.TopLeft(); + + // aBorderArea is the stroke-box area in a coordinate space defined by + // the caller. This coordinate space can be svg user space of aForFrame, + // the space of aForFrame's reference-frame, or anything else. + // + // Which coordinate space chosen for aBorderArea is not matter. What + // matter is to ensure returning aClipState->mBGClipArea in the consistent + // coordiante space with aBorderArea. So we evaluate the position of clip + // area base on the position of aBorderArea here. + aClipState->mBGClipArea = + clipAreaRelativeToStrokeBox + aBorderArea.TopLeft(); + + SetupDirtyRects(aClipState->mBGClipArea, aCallerDirtyRect, + aAppUnitsPerPixel, &aClipState->mDirtyRectInAppUnits, + &aClipState->mDirtyRectInDevPx); + MOZ_ASSERT(aClipState->IsValid()); + return; + } + + if (layerClip == StyleGeometryBox::NoClip) { + aClipState->mBGClipArea = aCallerDirtyRect; + + SetupDirtyRects(aClipState->mBGClipArea, aCallerDirtyRect, + aAppUnitsPerPixel, &aClipState->mDirtyRectInAppUnits, + &aClipState->mDirtyRectInDevPx); + MOZ_ASSERT(aClipState->IsValid()); + return; + } + + MOZ_ASSERT(!aForFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)); + + // Compute the outermost boundary of the area that might be painted. + // Same coordinate space as aBorderArea. + Sides skipSides = aForFrame->GetSkipSides(); + nsRect clipBorderArea = + BoxDecorationRectForBorder(aForFrame, aBorderArea, skipSides, &aBorder); + + bool haveRoundedCorners = false; + LayoutFrameType fType = aForFrame->Type(); + if (fType != LayoutFrameType::TableColGroup && + fType != LayoutFrameType::TableCol && + fType != LayoutFrameType::TableRow && + fType != LayoutFrameType::TableRowGroup) { + haveRoundedCorners = GetRadii(aForFrame, aBorder, aBorderArea, + clipBorderArea, aClipState->mRadii); + } + bool isSolidBorder = aWillPaintBorder && IsOpaqueBorder(aBorder); + if (isSolidBorder && layerClip == StyleGeometryBox::BorderBox) { + // If we have rounded corners, we need to inflate the background + // drawing area a bit to avoid seams between the border and + // background. + layerClip = haveRoundedCorners ? StyleGeometryBox::MozAlmostPadding + : StyleGeometryBox::PaddingBox; + } + + aClipState->mBGClipArea = clipBorderArea; + + if (aForFrame->IsScrollFrame() && + StyleImageLayerAttachment::Local == aLayer.mAttachment) { + // As of this writing, this is still in discussion in the CSS Working Group + // http://lists.w3.org/Archives/Public/www-style/2013Jul/0250.html + + // The rectangle for 'background-clip' scrolls with the content, + // but the background is also clipped at a non-scrolling 'padding-box' + // like the content. (See below.) + // Therefore, only 'content-box' makes a difference here. + if (layerClip == StyleGeometryBox::ContentBox) { + nsIScrollableFrame* scrollableFrame = do_QueryFrame(aForFrame); + // Clip at a rectangle attached to the scrolled content. + aClipState->mHasAdditionalBGClipArea = true; + aClipState->mAdditionalBGClipArea = + nsRect(aClipState->mBGClipArea.TopLeft() + + scrollableFrame->GetScrolledFrame()->GetPosition() + // For the dir=rtl case: + + scrollableFrame->GetScrollRange().TopLeft(), + scrollableFrame->GetScrolledRect().Size()); + nsMargin padding = aForFrame->GetUsedPadding(); + // padding-bottom is ignored on scrollable frames: + // https://bugzilla.mozilla.org/show_bug.cgi?id=748518 + padding.bottom = 0; + padding.ApplySkipSides(skipSides); + aClipState->mAdditionalBGClipArea.Deflate(padding); + } + + // Also clip at a non-scrolling, rounded-corner 'padding-box', + // same as the scrolled content because of the 'overflow' property. + layerClip = StyleGeometryBox::PaddingBox; + } + + // See the comment of StyleGeometryBox::Margin. + // Hitting this assertion means we decide to turn on margin-box support for + // positioned mask from CSS parser and style system. In this case, you + // should *inflate* mBGClipArea by the margin returning from + // aForFrame->GetUsedMargin() in the code chunk bellow. + MOZ_ASSERT(layerClip != StyleGeometryBox::MarginBox, + "StyleGeometryBox::MarginBox rendering is not supported yet.\n"); + + if (layerClip != StyleGeometryBox::BorderBox && + layerClip != StyleGeometryBox::Text) { + nsMargin border = aForFrame->GetUsedBorder(); + if (layerClip == StyleGeometryBox::MozAlmostPadding) { + // Reduce |border| by 1px (device pixels) on all sides, if + // possible, so that we don't get antialiasing seams between the + // {background|mask} and border. + border.top = std::max(0, border.top - aAppUnitsPerPixel); + border.right = std::max(0, border.right - aAppUnitsPerPixel); + border.bottom = std::max(0, border.bottom - aAppUnitsPerPixel); + border.left = std::max(0, border.left - aAppUnitsPerPixel); + } else if (layerClip != StyleGeometryBox::PaddingBox) { + NS_ASSERTION(layerClip == StyleGeometryBox::ContentBox, + "unexpected background-clip"); + border += aForFrame->GetUsedPadding(); + } + border.ApplySkipSides(skipSides); + aClipState->mBGClipArea.Deflate(border); + + if (haveRoundedCorners) { + nsIFrame::AdjustBorderRadii(aClipState->mRadii, -border); + } + } + + if (haveRoundedCorners) { + auto d2a = aForFrame->PresContext()->AppUnitsPerDevPixel(); + nsCSSRendering::ComputePixelRadii(aClipState->mRadii, d2a, + &aClipState->mClippedRadii); + aClipState->mHasRoundedCorners = !aClipState->mClippedRadii.IsEmpty(); + } + + if (!haveRoundedCorners && aClipState->mHasAdditionalBGClipArea) { + // Do the intersection here to account for the fast path(?) below. + aClipState->mBGClipArea = + aClipState->mBGClipArea.Intersect(aClipState->mAdditionalBGClipArea); + aClipState->mHasAdditionalBGClipArea = false; + } + + SetupDirtyRects(aClipState->mBGClipArea, aCallerDirtyRect, aAppUnitsPerPixel, + &aClipState->mDirtyRectInAppUnits, + &aClipState->mDirtyRectInDevPx); + + MOZ_ASSERT(aClipState->IsValid()); +} + +static void SetupImageLayerClip(nsCSSRendering::ImageLayerClipState& aClipState, + gfxContext* aCtx, nscoord aAppUnitsPerPixel, + gfxContextAutoSaveRestore* aAutoSR) { + if (aClipState.mDirtyRectInDevPx.IsEmpty()) { + // Our caller won't draw anything under this condition, so no need + // to set more up. + return; + } + + if (aClipState.mCustomClip) { + // We don't support custom clips and rounded corners, arguably a bug, but + // table painting seems to depend on it. + return; + } + + // If we have rounded corners, clip all subsequent drawing to the + // rounded rectangle defined by bgArea and bgRadii (we don't know + // whether the rounded corners intrude on the dirtyRect or not). + // Do not do this if we have a caller-provided clip rect -- + // as above with bgArea, arguably a bug, but table painting seems + // to depend on it. + + if (aClipState.mHasAdditionalBGClipArea) { + gfxRect bgAreaGfx = nsLayoutUtils::RectToGfxRect( + aClipState.mAdditionalBGClipArea, aAppUnitsPerPixel); + bgAreaGfx.Round(); + gfxUtils::ConditionRect(bgAreaGfx); + + aAutoSR->EnsureSaved(aCtx); + aCtx->SnappedClip(bgAreaGfx); + } + + if (aClipState.mHasRoundedCorners) { + Rect bgAreaGfx = NSRectToRect(aClipState.mBGClipArea, aAppUnitsPerPixel); + bgAreaGfx.Round(); + + if (bgAreaGfx.IsEmpty()) { + // I think it's become possible to hit this since + // https://hg.mozilla.org/mozilla-central/rev/50e934e4979b landed. + NS_WARNING("converted background area should not be empty"); + // Make our caller not do anything. + aClipState.mDirtyRectInDevPx.SizeTo(gfxSize(0.0, 0.0)); + return; + } + + aAutoSR->EnsureSaved(aCtx); + + RefPtr<Path> roundedRect = MakePathForRoundedRect( + *aCtx->GetDrawTarget(), bgAreaGfx, aClipState.mClippedRadii); + aCtx->Clip(roundedRect); + } +} + +static void DrawBackgroundColor(nsCSSRendering::ImageLayerClipState& aClipState, + gfxContext* aCtx, nscoord aAppUnitsPerPixel) { + if (aClipState.mDirtyRectInDevPx.IsEmpty()) { + // Our caller won't draw anything under this condition, so no need + // to set more up. + return; + } + + DrawTarget* drawTarget = aCtx->GetDrawTarget(); + + // We don't support custom clips and rounded corners, arguably a bug, but + // table painting seems to depend on it. + if (!aClipState.mHasRoundedCorners || aClipState.mCustomClip) { + aCtx->NewPath(); + aCtx->SnappedRectangle(aClipState.mDirtyRectInDevPx); + aCtx->Fill(); + return; + } + + Rect bgAreaGfx = NSRectToRect(aClipState.mBGClipArea, aAppUnitsPerPixel); + bgAreaGfx.Round(); + + if (bgAreaGfx.IsEmpty()) { + // I think it's become possible to hit this since + // https://hg.mozilla.org/mozilla-central/rev/50e934e4979b landed. + NS_WARNING("converted background area should not be empty"); + // Make our caller not do anything. + aClipState.mDirtyRectInDevPx.SizeTo(gfxSize(0.0, 0.0)); + return; + } + + aCtx->Save(); + gfxRect dirty = ThebesRect(bgAreaGfx).Intersect(aClipState.mDirtyRectInDevPx); + + aCtx->SnappedClip(dirty); + + if (aClipState.mHasAdditionalBGClipArea) { + gfxRect bgAdditionalAreaGfx = nsLayoutUtils::RectToGfxRect( + aClipState.mAdditionalBGClipArea, aAppUnitsPerPixel); + bgAdditionalAreaGfx.Round(); + gfxUtils::ConditionRect(bgAdditionalAreaGfx); + aCtx->SnappedClip(bgAdditionalAreaGfx); + } + + RefPtr<Path> roundedRect = + MakePathForRoundedRect(*drawTarget, bgAreaGfx, aClipState.mClippedRadii); + aCtx->SetPath(roundedRect); + aCtx->Fill(); + aCtx->Restore(); +} + +enum class ScrollbarColorKind { + Thumb, + Track, +}; + +static Maybe<nscolor> CalcScrollbarColor(nsIFrame* aFrame, + ScrollbarColorKind aKind) { + ComputedStyle* scrollbarStyle = nsLayoutUtils::StyleForScrollbar(aFrame); + const auto& colors = scrollbarStyle->StyleUI()->mScrollbarColor; + if (colors.IsAuto()) { + return Nothing(); + } + const auto& color = aKind == ScrollbarColorKind::Thumb + ? colors.AsColors().thumb + : colors.AsColors().track; + return Some(color.CalcColor(*scrollbarStyle)); +} + +static nscolor GetBackgroundColor(nsIFrame* aFrame, + const ComputedStyle* aStyle) { + switch (aStyle->StyleDisplay()->EffectiveAppearance()) { + case StyleAppearance::ScrollbarthumbVertical: + case StyleAppearance::ScrollbarthumbHorizontal: { + if (Maybe<nscolor> overrideColor = + CalcScrollbarColor(aFrame, ScrollbarColorKind::Thumb)) { + return *overrideColor; + } + break; + } + case StyleAppearance::ScrollbarVertical: + case StyleAppearance::ScrollbarHorizontal: + case StyleAppearance::Scrollcorner: { + if (Maybe<nscolor> overrideColor = + CalcScrollbarColor(aFrame, ScrollbarColorKind::Track)) { + return *overrideColor; + } + break; + } + default: + break; + } + return aStyle->GetVisitedDependentColor(&nsStyleBackground::mBackgroundColor); +} + +nscolor nsCSSRendering::DetermineBackgroundColor(nsPresContext* aPresContext, + const ComputedStyle* aStyle, + nsIFrame* aFrame, + bool& aDrawBackgroundImage, + bool& aDrawBackgroundColor) { + auto shouldPaint = aFrame->ComputeShouldPaintBackground(); + aDrawBackgroundImage = shouldPaint.mImage; + aDrawBackgroundColor = shouldPaint.mColor; + + const nsStyleBackground* bg = aStyle->StyleBackground(); + nscolor bgColor; + if (aDrawBackgroundColor) { + bgColor = GetBackgroundColor(aFrame, aStyle); + if (NS_GET_A(bgColor) == 0) { + aDrawBackgroundColor = false; + } + } else { + // If GetBackgroundColorDraw() is false, we are still expected to + // draw color in the background of any frame that's not completely + // transparent, but we are expected to use white instead of whatever + // color was specified. + bgColor = NS_RGB(255, 255, 255); + if (aDrawBackgroundImage || !bg->IsTransparent(aStyle)) { + aDrawBackgroundColor = true; + } else { + bgColor = NS_RGBA(0, 0, 0, 0); + } + } + + // We can skip painting the background color if a background image is opaque. + nsStyleImageLayers::Repeat repeat = bg->BottomLayer().mRepeat; + bool xFullRepeat = repeat.mXRepeat == StyleImageLayerRepeat::Repeat || + repeat.mXRepeat == StyleImageLayerRepeat::Round; + bool yFullRepeat = repeat.mYRepeat == StyleImageLayerRepeat::Repeat || + repeat.mYRepeat == StyleImageLayerRepeat::Round; + if (aDrawBackgroundColor && xFullRepeat && yFullRepeat && + bg->BottomLayer().mImage.IsOpaque() && + bg->BottomLayer().mBlendMode == StyleBlend::Normal) { + aDrawBackgroundColor = false; + } + + return bgColor; +} + +static CompositionOp DetermineCompositionOp( + const nsCSSRendering::PaintBGParams& aParams, + const nsStyleImageLayers& aLayers, uint32_t aLayerIndex) { + if (aParams.layer >= 0) { + // When drawing a single layer, use the specified composition op. + return aParams.compositionOp; + } + + const nsStyleImageLayers::Layer& layer = aLayers.mLayers[aLayerIndex]; + // When drawing all layers, get the compositon op from each image layer. + if (aParams.paintFlags & nsCSSRendering::PAINTBG_MASK_IMAGE) { + // Always using OP_OVER mode while drawing the bottom mask layer. + if (aLayerIndex == (aLayers.mImageCount - 1)) { + return CompositionOp::OP_OVER; + } + + return nsCSSRendering::GetGFXCompositeMode(layer.mComposite); + } + + return nsCSSRendering::GetGFXBlendMode(layer.mBlendMode); +} + +ImgDrawResult nsCSSRendering::PaintStyleImageLayerWithSC( + const PaintBGParams& aParams, gfxContext& aRenderingCtx, + const ComputedStyle* aBackgroundSC, const nsStyleBorder& aBorder) { + MOZ_ASSERT(aParams.frame, + "Frame is expected to be provided to PaintStyleImageLayerWithSC"); + + // If we're drawing all layers, aCompositonOp is ignored, so make sure that + // it was left at its default value. + MOZ_ASSERT(aParams.layer != -1 || + aParams.compositionOp == CompositionOp::OP_OVER); + + // Check to see if we have an appearance defined. If so, we let the theme + // renderer draw the background and bail out. + // XXXzw this ignores aParams.bgClipRect. + StyleAppearance appearance = + aParams.frame->StyleDisplay()->EffectiveAppearance(); + if (appearance != StyleAppearance::None) { + nsITheme* theme = aParams.presCtx.Theme(); + if (theme->ThemeSupportsWidget(&aParams.presCtx, aParams.frame, + appearance)) { + nsRect drawing(aParams.borderArea); + theme->GetWidgetOverflow(aParams.presCtx.DeviceContext(), aParams.frame, + appearance, &drawing); + drawing.IntersectRect(drawing, aParams.dirtyRect); + theme->DrawWidgetBackground(&aRenderingCtx, aParams.frame, appearance, + aParams.borderArea, drawing); + return ImgDrawResult::SUCCESS; + } + } + + // For canvas frames (in the CSS sense) we draw the background color using + // a solid color item that gets added in nsLayoutUtils::PaintFrame, + // or nsSubDocumentFrame::BuildDisplayList (bug 488242). (The solid + // color may be moved into nsDisplayCanvasBackground by + // PresShell::AddCanvasBackgroundColorItem(), and painted by + // nsDisplayCanvasBackground directly.) Either way we don't need to + // paint the background color here. + bool isCanvasFrame = aParams.frame->IsCanvasFrame(); + const bool paintMask = aParams.paintFlags & PAINTBG_MASK_IMAGE; + + // Determine whether we are drawing background images and/or + // background colors. + bool drawBackgroundImage = true; + bool drawBackgroundColor = !paintMask; + nscolor bgColor = NS_RGBA(0, 0, 0, 0); + if (!paintMask) { + bgColor = + DetermineBackgroundColor(&aParams.presCtx, aBackgroundSC, aParams.frame, + drawBackgroundImage, drawBackgroundColor); + } + + // Masks shouldn't be suppressed for print. + MOZ_ASSERT_IF(paintMask, drawBackgroundImage); + + const nsStyleImageLayers& layers = + paintMask ? aBackgroundSC->StyleSVGReset()->mMask + : aBackgroundSC->StyleBackground()->mImage; + // If we're drawing a specific layer, we don't want to draw the + // background color. + if (drawBackgroundColor && aParams.layer >= 0) { + drawBackgroundColor = false; + } + + // At this point, drawBackgroundImage and drawBackgroundColor are + // true if and only if we are actually supposed to paint an image or + // color into aDirtyRect, respectively. + if (!drawBackgroundImage && !drawBackgroundColor) { + return ImgDrawResult::SUCCESS; + } + + // The 'bgClipArea' (used only by the image tiling logic, far below) + // is the caller-provided aParams.bgClipRect if any, or else the area + // determined by the value of 'background-clip' in + // SetupCurrentBackgroundClip. (Arguably it should be the + // intersection, but that breaks the table painter -- in particular, + // taking the intersection breaks reftests/bugs/403249-1[ab].) + nscoord appUnitsPerPixel = aParams.presCtx.AppUnitsPerDevPixel(); + ImageLayerClipState clipState; + if (aParams.bgClipRect) { + clipState.mBGClipArea = *aParams.bgClipRect; + clipState.mCustomClip = true; + clipState.mHasRoundedCorners = false; + SetupDirtyRects(clipState.mBGClipArea, aParams.dirtyRect, appUnitsPerPixel, + &clipState.mDirtyRectInAppUnits, + &clipState.mDirtyRectInDevPx); + } else { + GetImageLayerClip(layers.BottomLayer(), aParams.frame, aBorder, + aParams.borderArea, aParams.dirtyRect, + (aParams.paintFlags & PAINTBG_WILL_PAINT_BORDER), + appUnitsPerPixel, &clipState); + } + + // If we might be using a background color, go ahead and set it now. + if (drawBackgroundColor && !isCanvasFrame) { + aRenderingCtx.SetColor(sRGBColor::FromABGR(bgColor)); + } + + // If there is no background image, draw a color. (If there is + // neither a background image nor a color, we wouldn't have gotten + // this far.) + if (!drawBackgroundImage) { + if (!isCanvasFrame) { + DrawBackgroundColor(clipState, &aRenderingCtx, appUnitsPerPixel); + } + return ImgDrawResult::SUCCESS; + } + + if (layers.mImageCount < 1) { + // Return if there are no background layers, all work from this point + // onwards happens iteratively on these. + return ImgDrawResult::SUCCESS; + } + + MOZ_ASSERT((aParams.layer < 0) || + (layers.mImageCount > uint32_t(aParams.layer))); + + // The background color is rendered over the entire dirty area, + // even if the image isn't. + if (drawBackgroundColor && !isCanvasFrame) { + DrawBackgroundColor(clipState, &aRenderingCtx, appUnitsPerPixel); + } + + // Compute the outermost boundary of the area that might be painted. + // Same coordinate space as aParams.borderArea & aParams.bgClipRect. + Sides skipSides = aParams.frame->GetSkipSides(); + nsRect paintBorderArea = BoxDecorationRectForBackground( + aParams.frame, aParams.borderArea, skipSides, &aBorder); + nsRect clipBorderArea = BoxDecorationRectForBorder( + aParams.frame, aParams.borderArea, skipSides, &aBorder); + + ImgDrawResult result = ImgDrawResult::SUCCESS; + StyleGeometryBox currentBackgroundClip = StyleGeometryBox::BorderBox; + const bool drawAllLayers = (aParams.layer < 0); + uint32_t count = drawAllLayers + ? layers.mImageCount // iterate all image layers. + : layers.mImageCount - + aParams.layer; // iterate from the bottom layer to + // the 'aParams.layer-th' layer. + NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT_WITH_RANGE( + i, layers, layers.mImageCount - 1, count) { + // NOTE: no Save() yet, we do that later by calling autoSR.EnsureSaved(ctx) + // in the cases we need it. + gfxContextAutoSaveRestore autoSR; + const nsStyleImageLayers::Layer& layer = layers.mLayers[i]; + + ImageLayerClipState currentLayerClipState = clipState; + if (!aParams.bgClipRect) { + bool isBottomLayer = (i == layers.mImageCount - 1); + if (currentBackgroundClip != layer.mClip || isBottomLayer) { + currentBackgroundClip = layer.mClip; + if (!isBottomLayer) { + currentLayerClipState = {}; + // For the bottom layer, we already called GetImageLayerClip above + // and it stored its results in clipState. + GetImageLayerClip(layer, aParams.frame, aBorder, aParams.borderArea, + aParams.dirtyRect, + (aParams.paintFlags & PAINTBG_WILL_PAINT_BORDER), + appUnitsPerPixel, ¤tLayerClipState); + } + SetupImageLayerClip(currentLayerClipState, &aRenderingCtx, + appUnitsPerPixel, &autoSR); + if (!clipBorderArea.IsEqualEdges(aParams.borderArea)) { + // We're drawing the background for the joined continuation boxes + // so we need to clip that to the slice that we want for this + // frame. + gfxRect clip = nsLayoutUtils::RectToGfxRect(aParams.borderArea, + appUnitsPerPixel); + autoSR.EnsureSaved(&aRenderingCtx); + aRenderingCtx.SnappedClip(clip); + } + } + } + + // Skip the following layer preparing and painting code if the current + // layer is not selected for drawing. + if (aParams.layer >= 0 && i != (uint32_t)aParams.layer) { + continue; + } + nsBackgroundLayerState state = PrepareImageLayer( + &aParams.presCtx, aParams.frame, aParams.paintFlags, paintBorderArea, + currentLayerClipState.mBGClipArea, layer, nullptr); + result &= state.mImageRenderer.PrepareResult(); + + // Skip the layer painting code if we found the dirty region is empty. + if (currentLayerClipState.mDirtyRectInDevPx.IsEmpty()) { + continue; + } + + if (!state.mFillArea.IsEmpty()) { + CompositionOp co = DetermineCompositionOp(aParams, layers, i); + if (co != CompositionOp::OP_OVER) { + NS_ASSERTION(aRenderingCtx.CurrentOp() == CompositionOp::OP_OVER, + "It is assumed the initial op is OP_OVER, when it is " + "restored later"); + aRenderingCtx.SetOp(co); + } + + result &= state.mImageRenderer.DrawLayer( + &aParams.presCtx, aRenderingCtx, state.mDestArea, state.mFillArea, + state.mAnchor + paintBorderArea.TopLeft(), + currentLayerClipState.mDirtyRectInAppUnits, state.mRepeatSize, + aParams.opacity); + + if (co != CompositionOp::OP_OVER) { + aRenderingCtx.SetOp(CompositionOp::OP_OVER); + } + } + } + + return result; +} + +ImgDrawResult +nsCSSRendering::BuildWebRenderDisplayItemsForStyleImageLayerWithSC( + const PaintBGParams& aParams, mozilla::wr::DisplayListBuilder& aBuilder, + mozilla::wr::IpcResourceUpdateQueue& aResources, + const mozilla::layers::StackingContextHelper& aSc, + mozilla::layers::RenderRootStateManager* aManager, nsDisplayItem* aItem, + ComputedStyle* aBackgroundSC, const nsStyleBorder& aBorder) { + MOZ_ASSERT(!(aParams.paintFlags & PAINTBG_MASK_IMAGE)); + + nscoord appUnitsPerPixel = aParams.presCtx.AppUnitsPerDevPixel(); + ImageLayerClipState clipState; + + clipState.mBGClipArea = *aParams.bgClipRect; + clipState.mCustomClip = true; + clipState.mHasRoundedCorners = false; + SetupDirtyRects(clipState.mBGClipArea, aParams.dirtyRect, appUnitsPerPixel, + &clipState.mDirtyRectInAppUnits, + &clipState.mDirtyRectInDevPx); + + // Compute the outermost boundary of the area that might be painted. + // Same coordinate space as aParams.borderArea & aParams.bgClipRect. + Sides skipSides = aParams.frame->GetSkipSides(); + nsRect paintBorderArea = BoxDecorationRectForBackground( + aParams.frame, aParams.borderArea, skipSides, &aBorder); + + const nsStyleImageLayers& layers = aBackgroundSC->StyleBackground()->mImage; + const nsStyleImageLayers::Layer& layer = layers.mLayers[aParams.layer]; + + // Skip the following layer painting code if we found the dirty region is + // empty or the current layer is not selected for drawing. + if (clipState.mDirtyRectInDevPx.IsEmpty()) { + return ImgDrawResult::SUCCESS; + } + + ImgDrawResult result = ImgDrawResult::SUCCESS; + nsBackgroundLayerState state = + PrepareImageLayer(&aParams.presCtx, aParams.frame, aParams.paintFlags, + paintBorderArea, clipState.mBGClipArea, layer, nullptr); + result &= state.mImageRenderer.PrepareResult(); + + if (!state.mFillArea.IsEmpty()) { + result &= state.mImageRenderer.BuildWebRenderDisplayItemsForLayer( + &aParams.presCtx, aBuilder, aResources, aSc, aManager, aItem, + state.mDestArea, state.mFillArea, + state.mAnchor + paintBorderArea.TopLeft(), + clipState.mDirtyRectInAppUnits, state.mRepeatSize, aParams.opacity); + } + + return result; +} + +nsRect nsCSSRendering::ComputeImageLayerPositioningArea( + nsPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aBorderArea, + const nsStyleImageLayers::Layer& aLayer, nsIFrame** aAttachedToFrame, + bool* aOutIsTransformedFixed) { + // Compute {background|mask} origin area relative to aBorderArea now as we + // may need it to compute the effective image size for a CSS gradient. + nsRect positionArea; + + StyleGeometryBox layerOrigin = + ComputeBoxValueForOrigin(aForFrame, aLayer.mOrigin); + + if (IsSVGStyleGeometryBox(layerOrigin)) { + MOZ_ASSERT(aForFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)); + *aAttachedToFrame = aForFrame; + + positionArea = + nsLayoutUtils::ComputeSVGReferenceRect(aForFrame, layerOrigin); + + nsPoint toStrokeBoxOffset = nsPoint(0, 0); + if (layerOrigin != StyleGeometryBox::StrokeBox) { + nsRect strokeBox = nsLayoutUtils::ComputeSVGReferenceRect( + aForFrame, StyleGeometryBox::StrokeBox); + toStrokeBoxOffset = positionArea.TopLeft() - strokeBox.TopLeft(); + } + + // For SVG frames, the return value is relative to the stroke box + return nsRect(toStrokeBoxOffset, positionArea.Size()); + } + + MOZ_ASSERT(!aForFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)); + + LayoutFrameType frameType = aForFrame->Type(); + nsIFrame* geometryFrame = aForFrame; + if (MOZ_UNLIKELY(frameType == LayoutFrameType::Scroll && + StyleImageLayerAttachment::Local == aLayer.mAttachment)) { + nsIScrollableFrame* scrollableFrame = do_QueryFrame(aForFrame); + positionArea = nsRect(scrollableFrame->GetScrolledFrame()->GetPosition() + // For the dir=rtl case: + + scrollableFrame->GetScrollRange().TopLeft(), + scrollableFrame->GetScrolledRect().Size()); + // The ScrolledRect’s size does not include the borders or scrollbars, + // reverse the handling of background-origin + // compared to the common case below. + if (layerOrigin == StyleGeometryBox::BorderBox) { + nsMargin border = geometryFrame->GetUsedBorder(); + border.ApplySkipSides(geometryFrame->GetSkipSides()); + positionArea.Inflate(border); + positionArea.Inflate(scrollableFrame->GetActualScrollbarSizes()); + } else if (layerOrigin != StyleGeometryBox::PaddingBox) { + nsMargin padding = geometryFrame->GetUsedPadding(); + padding.ApplySkipSides(geometryFrame->GetSkipSides()); + positionArea.Deflate(padding); + NS_ASSERTION(layerOrigin == StyleGeometryBox::ContentBox, + "unknown background-origin value"); + } + *aAttachedToFrame = aForFrame; + return positionArea; + } + + if (MOZ_UNLIKELY(frameType == LayoutFrameType::Canvas)) { + geometryFrame = aForFrame->PrincipalChildList().FirstChild(); + // geometryFrame might be null if this canvas is a page created + // as an overflow container (e.g. the in-flow content has already + // finished and this page only displays the continuations of + // absolutely positioned content). + if (geometryFrame) { + positionArea = + nsPlaceholderFrame::GetRealFrameFor(geometryFrame)->GetRect(); + } + } else { + positionArea = nsRect(nsPoint(0, 0), aBorderArea.Size()); + } + + // See the comment of StyleGeometryBox::MarginBox. + // Hitting this assertion means we decide to turn on margin-box support for + // positioned mask from CSS parser and style system. In this case, you + // should *inflate* positionArea by the margin returning from + // geometryFrame->GetUsedMargin() in the code chunk bellow. + MOZ_ASSERT(aLayer.mOrigin != StyleGeometryBox::MarginBox, + "StyleGeometryBox::MarginBox rendering is not supported yet.\n"); + + // {background|mask} images are tiled over the '{background|mask}-clip' area + // but the origin of the tiling is based on the '{background|mask}-origin' + // area. + if (layerOrigin != StyleGeometryBox::BorderBox && geometryFrame) { + nsMargin border = geometryFrame->GetUsedBorder(); + if (layerOrigin != StyleGeometryBox::PaddingBox) { + border += geometryFrame->GetUsedPadding(); + NS_ASSERTION(layerOrigin == StyleGeometryBox::ContentBox, + "unknown background-origin value"); + } + positionArea.Deflate(border); + } + + nsIFrame* attachedToFrame = aForFrame; + if (StyleImageLayerAttachment::Fixed == aLayer.mAttachment) { + // If it's a fixed background attachment, then the image is placed + // relative to the viewport, which is the area of the root frame + // in a screen context or the page content frame in a print context. + attachedToFrame = aPresContext->PresShell()->GetRootFrame(); + NS_ASSERTION(attachedToFrame, "no root frame"); + nsIFrame* pageContentFrame = nullptr; + if (aPresContext->IsPaginated()) { + pageContentFrame = nsLayoutUtils::GetClosestFrameOfType( + aForFrame, LayoutFrameType::PageContent); + if (pageContentFrame) { + attachedToFrame = pageContentFrame; + } + // else this is an embedded shell and its root frame is what we want + } + + // If the background is affected by a transform, treat is as if it + // wasn't fixed. + if (nsLayoutUtils::IsTransformed(aForFrame, attachedToFrame)) { + attachedToFrame = aForFrame; + *aOutIsTransformedFixed = true; + } else { + // Set the background positioning area to the viewport's area + // (relative to aForFrame) + positionArea = nsRect(-aForFrame->GetOffsetTo(attachedToFrame), + attachedToFrame->GetSize()); + + if (!pageContentFrame) { + // Subtract the size of scrollbars. + nsIScrollableFrame* scrollableFrame = + aPresContext->PresShell()->GetRootScrollFrameAsScrollable(); + if (scrollableFrame) { + nsMargin scrollbars = scrollableFrame->GetActualScrollbarSizes(); + positionArea.Deflate(scrollbars); + } + } + + // If we have the dynamic toolbar, we need to expand the image area to + // include the region under the dynamic toolbar, otherwise we will see a + // blank space under the toolbar. + if (aPresContext->IsRootContentDocumentCrossProcess() && + aPresContext->HasDynamicToolbar()) { + positionArea.SizeTo(nsLayoutUtils::ExpandHeightForDynamicToolbar( + aPresContext, positionArea.Size())); + } + } + } + *aAttachedToFrame = attachedToFrame; + + return positionArea; +} + +/* static */ +nscoord nsCSSRendering::ComputeRoundedSize(nscoord aCurrentSize, + nscoord aPositioningSize) { + float repeatCount = NS_roundf(float(aPositioningSize) / float(aCurrentSize)); + if (repeatCount < 1.0f) { + return aPositioningSize; + } + return nscoord(NS_lround(float(aPositioningSize) / repeatCount)); +} + +// Apply the CSS image sizing algorithm as it applies to background images. +// See http://www.w3.org/TR/css3-background/#the-background-size . +// aIntrinsicSize is the size that the background image 'would like to be'. +// It can be found by calling nsImageRenderer::ComputeIntrinsicSize. +static nsSize ComputeDrawnSizeForBackground( + const CSSSizeOrRatio& aIntrinsicSize, const nsSize& aBgPositioningArea, + const StyleBackgroundSize& aLayerSize, StyleImageLayerRepeat aXRepeat, + StyleImageLayerRepeat aYRepeat) { + nsSize imageSize; + + // Size is dictated by cover or contain rules. + if (aLayerSize.IsContain() || aLayerSize.IsCover()) { + nsImageRenderer::FitType fitType = aLayerSize.IsCover() + ? nsImageRenderer::COVER + : nsImageRenderer::CONTAIN; + imageSize = nsImageRenderer::ComputeConstrainedSize( + aBgPositioningArea, aIntrinsicSize.mRatio, fitType); + } else { + MOZ_ASSERT(aLayerSize.IsExplicitSize()); + const auto& width = aLayerSize.explicit_size.width; + const auto& height = aLayerSize.explicit_size.height; + // No cover/contain constraint, use default algorithm. + CSSSizeOrRatio specifiedSize; + if (width.IsLengthPercentage()) { + specifiedSize.SetWidth( + width.AsLengthPercentage().Resolve(aBgPositioningArea.width)); + } + if (height.IsLengthPercentage()) { + specifiedSize.SetHeight( + height.AsLengthPercentage().Resolve(aBgPositioningArea.height)); + } + + imageSize = nsImageRenderer::ComputeConcreteSize( + specifiedSize, aIntrinsicSize, aBgPositioningArea); + } + + // See https://www.w3.org/TR/css3-background/#background-size . + // "If 'background-repeat' is 'round' for one (or both) dimensions, there is a + // second + // step. The UA must scale the image in that dimension (or both dimensions) + // so that it fits a whole number of times in the background positioning + // area." + // "If 'background-repeat' is 'round' for one dimension only and if + // 'background-size' + // is 'auto' for the other dimension, then there is a third step: that other + // dimension is scaled so that the original aspect ratio is restored." + bool isRepeatRoundInBothDimensions = + aXRepeat == StyleImageLayerRepeat::Round && + aYRepeat == StyleImageLayerRepeat::Round; + + // Calculate the rounded size only if the background-size computation + // returned a correct size for the image. + if (imageSize.width && aXRepeat == StyleImageLayerRepeat::Round) { + imageSize.width = nsCSSRendering::ComputeRoundedSize( + imageSize.width, aBgPositioningArea.width); + if (!isRepeatRoundInBothDimensions && aLayerSize.IsExplicitSize() && + aLayerSize.explicit_size.height.IsAuto()) { + // Restore intrinsic ratio + if (aIntrinsicSize.mRatio) { + imageSize.height = + aIntrinsicSize.mRatio.Inverted().ApplyTo(imageSize.width); + } + } + } + + // Calculate the rounded size only if the background-size computation + // returned a correct size for the image. + if (imageSize.height && aYRepeat == StyleImageLayerRepeat::Round) { + imageSize.height = nsCSSRendering::ComputeRoundedSize( + imageSize.height, aBgPositioningArea.height); + if (!isRepeatRoundInBothDimensions && aLayerSize.IsExplicitSize() && + aLayerSize.explicit_size.width.IsAuto()) { + // Restore intrinsic ratio + if (aIntrinsicSize.mRatio) { + imageSize.width = aIntrinsicSize.mRatio.ApplyTo(imageSize.height); + } + } + } + + return imageSize; +} + +/* ComputeSpacedRepeatSize + * aImageDimension: the image width/height + * aAvailableSpace: the background positioning area width/height + * aRepeat: determine whether the image is repeated + * Returns the image size plus gap size of app units for use as spacing + */ +static nscoord ComputeSpacedRepeatSize(nscoord aImageDimension, + nscoord aAvailableSpace, bool& aRepeat) { + float ratio = static_cast<float>(aAvailableSpace) / aImageDimension; + + if (ratio < 2.0f) { // If you can't repeat at least twice, then don't repeat. + aRepeat = false; + return aImageDimension; + } + + aRepeat = true; + return (aAvailableSpace - aImageDimension) / (NSToIntFloor(ratio) - 1); +} + +/* static */ +nscoord nsCSSRendering::ComputeBorderSpacedRepeatSize(nscoord aImageDimension, + nscoord aAvailableSpace, + nscoord& aSpace) { + int32_t count = aImageDimension ? (aAvailableSpace / aImageDimension) : 0; + aSpace = (aAvailableSpace - aImageDimension * count) / (count + 1); + return aSpace + aImageDimension; +} + +nsBackgroundLayerState nsCSSRendering::PrepareImageLayer( + nsPresContext* aPresContext, nsIFrame* aForFrame, uint32_t aFlags, + const nsRect& aBorderArea, const nsRect& aBGClipRect, + const nsStyleImageLayers::Layer& aLayer, bool* aOutIsTransformedFixed) { + /* + * The properties we need to keep in mind when drawing style image + * layers are: + * + * background-image/ mask-image + * background-repeat/ mask-repeat + * background-attachment + * background-position/ mask-position + * background-clip/ mask-clip + * background-origin/ mask-origin + * background-size/ mask-size + * background-blend-mode + * box-decoration-break + * mask-mode + * mask-composite + * + * (background-color applies to the entire element and not to individual + * layers, so it is irrelevant to this method.) + * + * These properties have the following dependencies upon each other when + * determining rendering: + * + * background-image/ mask-image + * no dependencies + * background-repeat/ mask-repeat + * no dependencies + * background-attachment + * no dependencies + * background-position/ mask-position + * depends upon background-size/mask-size (for the image's scaled size) + * and background-break (for the background positioning area) + * background-clip/ mask-clip + * no dependencies + * background-origin/ mask-origin + * depends upon background-attachment (only in the case where that value + * is 'fixed') + * background-size/ mask-size + * depends upon box-decoration-break (for the background positioning area + * for resolving percentages), background-image (for the image's intrinsic + * size), background-repeat (if that value is 'round'), and + * background-origin (for the background painting area, when + * background-repeat is 'round') + * background-blend-mode + * no dependencies + * mask-mode + * no dependencies + * mask-composite + * no dependencies + * box-decoration-break + * no dependencies + * + * As a result of only-if dependencies we don't strictly do a topological + * sort of the above properties when processing, but it's pretty close to one: + * + * background-clip/mask-clip (by caller) + * background-image/ mask-image + * box-decoration-break, background-origin/ mask origin + * background-attachment (postfix for background-origin if 'fixed') + * background-size/ mask-size + * background-position/ mask-position + * background-repeat/ mask-repeat + */ + + uint32_t irFlags = 0; + if (aFlags & nsCSSRendering::PAINTBG_SYNC_DECODE_IMAGES) { + irFlags |= nsImageRenderer::FLAG_SYNC_DECODE_IMAGES; + } + if (aFlags & nsCSSRendering::PAINTBG_TO_WINDOW) { + irFlags |= nsImageRenderer::FLAG_PAINTING_TO_WINDOW; + } + if (aFlags & nsCSSRendering::PAINTBG_HIGH_QUALITY_SCALING) { + irFlags |= nsImageRenderer::FLAG_HIGH_QUALITY_SCALING; + } + // Only do partial bg image drawing in content documents: non-content + // documents are viewed as UI of the browser and a partial draw of a bg image + // might look weird in that context. + if (StaticPrefs::layout_display_partial_background_images() && + XRE_IsContentProcess() && !aPresContext->IsChrome()) { + irFlags |= nsImageRenderer::FLAG_DRAW_PARTIAL_FRAMES; + } + + nsBackgroundLayerState state(aForFrame, &aLayer.mImage, irFlags); + if (!state.mImageRenderer.PrepareImage()) { + // There's no image or it's not ready to be painted. + if (aOutIsTransformedFixed && + StyleImageLayerAttachment::Fixed == aLayer.mAttachment) { + nsIFrame* attachedToFrame = aPresContext->PresShell()->GetRootFrame(); + NS_ASSERTION(attachedToFrame, "no root frame"); + nsIFrame* pageContentFrame = nullptr; + if (aPresContext->IsPaginated()) { + pageContentFrame = nsLayoutUtils::GetClosestFrameOfType( + aForFrame, LayoutFrameType::PageContent); + if (pageContentFrame) { + attachedToFrame = pageContentFrame; + } + // else this is an embedded shell and its root frame is what we want + } + + *aOutIsTransformedFixed = + nsLayoutUtils::IsTransformed(aForFrame, attachedToFrame); + } + return state; + } + + // The frame to which the background is attached + nsIFrame* attachedToFrame = aForFrame; + // Is the background marked 'fixed', but affected by a transform? + bool transformedFixed = false; + // Compute background origin area relative to aBorderArea now as we may need + // it to compute the effective image size for a CSS gradient. + nsRect positionArea = ComputeImageLayerPositioningArea( + aPresContext, aForFrame, aBorderArea, aLayer, &attachedToFrame, + &transformedFixed); + if (aOutIsTransformedFixed) { + *aOutIsTransformedFixed = transformedFixed; + } + + // For background-attachment:fixed backgrounds, we'll override the area + // where the background can be drawn to the viewport. + nsRect bgClipRect = aBGClipRect; + + if (StyleImageLayerAttachment::Fixed == aLayer.mAttachment && + !transformedFixed && (aFlags & nsCSSRendering::PAINTBG_TO_WINDOW)) { + bgClipRect = positionArea + aBorderArea.TopLeft(); + } + + StyleImageLayerRepeat repeatX = aLayer.mRepeat.mXRepeat; + StyleImageLayerRepeat repeatY = aLayer.mRepeat.mYRepeat; + + // Scale the image as specified for background-size and background-repeat. + // Also as required for proper background positioning when background-position + // is defined with percentages. + CSSSizeOrRatio intrinsicSize = state.mImageRenderer.ComputeIntrinsicSize(); + nsSize bgPositionSize = positionArea.Size(); + nsSize imageSize = ComputeDrawnSizeForBackground( + intrinsicSize, bgPositionSize, aLayer.mSize, repeatX, repeatY); + + if (imageSize.width <= 0 || imageSize.height <= 0) return state; + + state.mImageRenderer.SetPreferredSize(intrinsicSize, imageSize); + + // Compute the anchor point. + // + // relative to aBorderArea.TopLeft() (which is where the top-left + // of aForFrame's border-box will be rendered) + nsPoint imageTopLeft; + + // Compute the position of the background now that the background's size is + // determined. + nsImageRenderer::ComputeObjectAnchorPoint(aLayer.mPosition, bgPositionSize, + imageSize, &imageTopLeft, + &state.mAnchor); + state.mRepeatSize = imageSize; + if (repeatX == StyleImageLayerRepeat::Space) { + bool isRepeat; + state.mRepeatSize.width = ComputeSpacedRepeatSize( + imageSize.width, bgPositionSize.width, isRepeat); + if (isRepeat) { + imageTopLeft.x = 0; + state.mAnchor.x = 0; + } else { + repeatX = StyleImageLayerRepeat::NoRepeat; + } + } + + if (repeatY == StyleImageLayerRepeat::Space) { + bool isRepeat; + state.mRepeatSize.height = ComputeSpacedRepeatSize( + imageSize.height, bgPositionSize.height, isRepeat); + if (isRepeat) { + imageTopLeft.y = 0; + state.mAnchor.y = 0; + } else { + repeatY = StyleImageLayerRepeat::NoRepeat; + } + } + + imageTopLeft += positionArea.TopLeft(); + state.mAnchor += positionArea.TopLeft(); + state.mDestArea = nsRect(imageTopLeft + aBorderArea.TopLeft(), imageSize); + state.mFillArea = state.mDestArea; + + ExtendMode repeatMode = ExtendMode::CLAMP; + if (repeatX == StyleImageLayerRepeat::Repeat || + repeatX == StyleImageLayerRepeat::Round || + repeatX == StyleImageLayerRepeat::Space) { + state.mFillArea.x = bgClipRect.x; + state.mFillArea.width = bgClipRect.width; + repeatMode = ExtendMode::REPEAT_X; + } + if (repeatY == StyleImageLayerRepeat::Repeat || + repeatY == StyleImageLayerRepeat::Round || + repeatY == StyleImageLayerRepeat::Space) { + state.mFillArea.y = bgClipRect.y; + state.mFillArea.height = bgClipRect.height; + + /*** + * We're repeating on the X axis already, + * so if we have to repeat in the Y axis, + * we really need to repeat in both directions. + */ + if (repeatMode == ExtendMode::REPEAT_X) { + repeatMode = ExtendMode::REPEAT; + } else { + repeatMode = ExtendMode::REPEAT_Y; + } + } + state.mImageRenderer.SetExtendMode(repeatMode); + state.mImageRenderer.SetMaskOp(aLayer.mMaskMode); + + state.mFillArea.IntersectRect(state.mFillArea, bgClipRect); + + return state; +} + +nsRect nsCSSRendering::GetBackgroundLayerRect( + nsPresContext* aPresContext, nsIFrame* aForFrame, const nsRect& aBorderArea, + const nsRect& aClipRect, const nsStyleImageLayers::Layer& aLayer, + uint32_t aFlags) { + Sides skipSides = aForFrame->GetSkipSides(); + nsRect borderArea = + BoxDecorationRectForBackground(aForFrame, aBorderArea, skipSides); + nsBackgroundLayerState state = PrepareImageLayer( + aPresContext, aForFrame, aFlags, borderArea, aClipRect, aLayer); + return state.mFillArea; +} + +// Begin table border-collapsing section +// These functions were written to not disrupt the normal ones and yet satisfy +// some additional requirements At some point, all functions should be unified +// to include the additional functionality that these provide + +static nscoord RoundIntToPixel(nscoord aValue, nscoord aOneDevPixel, + bool aRoundDown = false) { + if (aOneDevPixel <= 0) { + // We must be rendering to a device that has a resolution greater than + // one device pixel! + // In that case, aValue is as accurate as it's going to get. + return aValue; + } + + nscoord halfPixel = NSToCoordRound(aOneDevPixel / 2.0f); + nscoord extra = aValue % aOneDevPixel; + nscoord finalValue = (!aRoundDown && (extra >= halfPixel)) + ? aValue + (aOneDevPixel - extra) + : aValue - extra; + return finalValue; +} + +static nscoord RoundFloatToPixel(float aValue, nscoord aOneDevPixel, + bool aRoundDown = false) { + return RoundIntToPixel(NSToCoordRound(aValue), aOneDevPixel, aRoundDown); +} + +static void SetPoly(const Rect& aRect, Point* poly) { + poly[0].x = aRect.x; + poly[0].y = aRect.y; + poly[1].x = aRect.x + aRect.width; + poly[1].y = aRect.y; + poly[2].x = aRect.x + aRect.width; + poly[2].y = aRect.y + aRect.height; + poly[3].x = aRect.x; + poly[3].y = aRect.y + aRect.height; +} + +static void DrawDashedSegment(DrawTarget& aDrawTarget, nsRect aRect, + nscoord aDashLength, nscolor aColor, + int32_t aAppUnitsPerDevPixel, bool aHorizontal) { + ColorPattern color(ToDeviceColor(aColor)); + DrawOptions drawOptions(1.f, CompositionOp::OP_OVER, AntialiasMode::NONE); + StrokeOptions strokeOptions; + + Float dash[2]; + dash[0] = Float(aDashLength) / aAppUnitsPerDevPixel; + dash[1] = dash[0]; + + strokeOptions.mDashPattern = dash; + strokeOptions.mDashLength = MOZ_ARRAY_LENGTH(dash); + + if (aHorizontal) { + nsPoint left = (aRect.TopLeft() + aRect.BottomLeft()) / 2; + nsPoint right = (aRect.TopRight() + aRect.BottomRight()) / 2; + strokeOptions.mLineWidth = Float(aRect.height) / aAppUnitsPerDevPixel; + StrokeLineWithSnapping(left, right, aAppUnitsPerDevPixel, aDrawTarget, + color, strokeOptions, drawOptions); + } else { + nsPoint top = (aRect.TopLeft() + aRect.TopRight()) / 2; + nsPoint bottom = (aRect.BottomLeft() + aRect.BottomRight()) / 2; + strokeOptions.mLineWidth = Float(aRect.width) / aAppUnitsPerDevPixel; + StrokeLineWithSnapping(top, bottom, aAppUnitsPerDevPixel, aDrawTarget, + color, strokeOptions, drawOptions); + } +} + +static void DrawSolidBorderSegment( + DrawTarget& aDrawTarget, nsRect aRect, nscolor aColor, + int32_t aAppUnitsPerDevPixel, + mozilla::Side aStartBevelSide = mozilla::eSideTop, + nscoord aStartBevelOffset = 0, + mozilla::Side aEndBevelSide = mozilla::eSideTop, + nscoord aEndBevelOffset = 0) { + ColorPattern color(ToDeviceColor(aColor)); + DrawOptions drawOptions(1.f, CompositionOp::OP_OVER, AntialiasMode::NONE); + + nscoord oneDevPixel = NSIntPixelsToAppUnits(1, aAppUnitsPerDevPixel); + // We don't need to bevel single pixel borders + if ((aRect.width == oneDevPixel) || (aRect.height == oneDevPixel) || + ((0 == aStartBevelOffset) && (0 == aEndBevelOffset))) { + // simple rectangle + aDrawTarget.FillRect( + NSRectToSnappedRect(aRect, aAppUnitsPerDevPixel, aDrawTarget), color, + drawOptions); + } else { + // polygon with beveling + Point poly[4]; + SetPoly(NSRectToSnappedRect(aRect, aAppUnitsPerDevPixel, aDrawTarget), + poly); + + Float startBevelOffset = + NSAppUnitsToFloatPixels(aStartBevelOffset, aAppUnitsPerDevPixel); + switch (aStartBevelSide) { + case eSideTop: + poly[0].x += startBevelOffset; + break; + case eSideBottom: + poly[3].x += startBevelOffset; + break; + case eSideRight: + poly[1].y += startBevelOffset; + break; + case eSideLeft: + poly[0].y += startBevelOffset; + } + + Float endBevelOffset = + NSAppUnitsToFloatPixels(aEndBevelOffset, aAppUnitsPerDevPixel); + switch (aEndBevelSide) { + case eSideTop: + poly[1].x -= endBevelOffset; + break; + case eSideBottom: + poly[2].x -= endBevelOffset; + break; + case eSideRight: + poly[2].y -= endBevelOffset; + break; + case eSideLeft: + poly[3].y -= endBevelOffset; + } + + RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder(); + builder->MoveTo(poly[0]); + builder->LineTo(poly[1]); + builder->LineTo(poly[2]); + builder->LineTo(poly[3]); + builder->Close(); + RefPtr<Path> path = builder->Finish(); + aDrawTarget.Fill(path, color, drawOptions); + } +} + +static void GetDashInfo(nscoord aBorderLength, nscoord aDashLength, + nscoord aOneDevPixel, int32_t& aNumDashSpaces, + nscoord& aStartDashLength, nscoord& aEndDashLength) { + aNumDashSpaces = 0; + if (aStartDashLength + aDashLength + aEndDashLength >= aBorderLength) { + aStartDashLength = aBorderLength; + aEndDashLength = 0; + } else { + aNumDashSpaces = + (aBorderLength - aDashLength) / (2 * aDashLength); // round down + nscoord extra = aBorderLength - aStartDashLength - aEndDashLength - + (((2 * aNumDashSpaces) - 1) * aDashLength); + if (extra > 0) { + nscoord half = RoundIntToPixel(extra / 2, aOneDevPixel); + aStartDashLength += half; + aEndDashLength += (extra - half); + } + } +} + +void nsCSSRendering::DrawTableBorderSegment( + DrawTarget& aDrawTarget, StyleBorderStyle aBorderStyle, + nscolor aBorderColor, const nsRect& aBorder, int32_t aAppUnitsPerDevPixel, + mozilla::Side aStartBevelSide, nscoord aStartBevelOffset, + mozilla::Side aEndBevelSide, nscoord aEndBevelOffset) { + bool horizontal = + ((eSideTop == aStartBevelSide) || (eSideBottom == aStartBevelSide)); + nscoord oneDevPixel = NSIntPixelsToAppUnits(1, aAppUnitsPerDevPixel); + + if ((oneDevPixel >= aBorder.width) || (oneDevPixel >= aBorder.height) || + (StyleBorderStyle::Dashed == aBorderStyle) || + (StyleBorderStyle::Dotted == aBorderStyle)) { + // no beveling for 1 pixel border, dash or dot + aStartBevelOffset = 0; + aEndBevelOffset = 0; + } + + switch (aBorderStyle) { + case StyleBorderStyle::None: + case StyleBorderStyle::Hidden: + // NS_ASSERTION(false, "style of none or hidden"); + break; + case StyleBorderStyle::Dotted: + case StyleBorderStyle::Dashed: { + nscoord dashLength = + (StyleBorderStyle::Dashed == aBorderStyle) ? DASH_LENGTH : DOT_LENGTH; + // make the dash length proportional to the border thickness + dashLength *= (horizontal) ? aBorder.height : aBorder.width; + // make the min dash length for the ends 1/2 the dash length + nscoord minDashLength = + (StyleBorderStyle::Dashed == aBorderStyle) + ? RoundFloatToPixel(((float)dashLength) / 2.0f, + aAppUnitsPerDevPixel) + : dashLength; + minDashLength = std::max(minDashLength, oneDevPixel); + nscoord numDashSpaces = 0; + nscoord startDashLength = minDashLength; + nscoord endDashLength = minDashLength; + if (horizontal) { + GetDashInfo(aBorder.width, dashLength, aAppUnitsPerDevPixel, + numDashSpaces, startDashLength, endDashLength); + nsRect rect(aBorder.x, aBorder.y, startDashLength, aBorder.height); + DrawSolidBorderSegment(aDrawTarget, rect, aBorderColor, + aAppUnitsPerDevPixel); + + rect.x += startDashLength + dashLength; + rect.width = + aBorder.width - (startDashLength + endDashLength + dashLength); + DrawDashedSegment(aDrawTarget, rect, dashLength, aBorderColor, + aAppUnitsPerDevPixel, horizontal); + + rect.x += rect.width; + rect.width = endDashLength; + DrawSolidBorderSegment(aDrawTarget, rect, aBorderColor, + aAppUnitsPerDevPixel); + } else { + GetDashInfo(aBorder.height, dashLength, aAppUnitsPerDevPixel, + numDashSpaces, startDashLength, endDashLength); + nsRect rect(aBorder.x, aBorder.y, aBorder.width, startDashLength); + DrawSolidBorderSegment(aDrawTarget, rect, aBorderColor, + aAppUnitsPerDevPixel); + + rect.y += rect.height + dashLength; + rect.height = + aBorder.height - (startDashLength + endDashLength + dashLength); + DrawDashedSegment(aDrawTarget, rect, dashLength, aBorderColor, + aAppUnitsPerDevPixel, horizontal); + + rect.y += rect.height; + rect.height = endDashLength; + DrawSolidBorderSegment(aDrawTarget, rect, aBorderColor, + aAppUnitsPerDevPixel); + } + } break; + default: + AutoTArray<SolidBeveledBorderSegment, 3> segments; + GetTableBorderSolidSegments( + segments, aBorderStyle, aBorderColor, aBorder, aAppUnitsPerDevPixel, + aStartBevelSide, aStartBevelOffset, aEndBevelSide, aEndBevelOffset); + for (const auto& segment : segments) { + DrawSolidBorderSegment( + aDrawTarget, segment.mRect, segment.mColor, aAppUnitsPerDevPixel, + segment.mStartBevel.mSide, segment.mStartBevel.mOffset, + segment.mEndBevel.mSide, segment.mEndBevel.mOffset); + } + break; + } +} + +void nsCSSRendering::GetTableBorderSolidSegments( + nsTArray<SolidBeveledBorderSegment>& aSegments, + StyleBorderStyle aBorderStyle, nscolor aBorderColor, const nsRect& aBorder, + int32_t aAppUnitsPerDevPixel, mozilla::Side aStartBevelSide, + nscoord aStartBevelOffset, mozilla::Side aEndBevelSide, + nscoord aEndBevelOffset) { + const bool horizontal = + eSideTop == aStartBevelSide || eSideBottom == aStartBevelSide; + const nscoord oneDevPixel = NSIntPixelsToAppUnits(1, aAppUnitsPerDevPixel); + + switch (aBorderStyle) { + case StyleBorderStyle::None: + case StyleBorderStyle::Hidden: + return; + case StyleBorderStyle::Dotted: + case StyleBorderStyle::Dashed: + MOZ_ASSERT_UNREACHABLE("Caller should have checked"); + return; + case StyleBorderStyle::Groove: + case StyleBorderStyle::Ridge: + if ((horizontal && (oneDevPixel >= aBorder.height)) || + (!horizontal && (oneDevPixel >= aBorder.width))) { + aSegments.AppendElement( + SolidBeveledBorderSegment{aBorder, + aBorderColor, + {aStartBevelSide, aStartBevelOffset}, + {aEndBevelSide, aEndBevelOffset}}); + } else { + nscoord startBevel = + (aStartBevelOffset > 0) + ? RoundFloatToPixel(0.5f * (float)aStartBevelOffset, + aAppUnitsPerDevPixel, true) + : 0; + nscoord endBevel = + (aEndBevelOffset > 0) + ? RoundFloatToPixel(0.5f * (float)aEndBevelOffset, + aAppUnitsPerDevPixel, true) + : 0; + mozilla::Side ridgeGrooveSide = (horizontal) ? eSideTop : eSideLeft; + // FIXME: In theory, this should use the visited-dependent + // background color, but I don't care. + nscolor bevelColor = + MakeBevelColor(ridgeGrooveSide, aBorderStyle, aBorderColor); + nsRect rect(aBorder); + nscoord half; + if (horizontal) { // top, bottom + half = RoundFloatToPixel(0.5f * (float)aBorder.height, + aAppUnitsPerDevPixel); + rect.height = half; + if (eSideTop == aStartBevelSide) { + rect.x += startBevel; + rect.width -= startBevel; + } + if (eSideTop == aEndBevelSide) { + rect.width -= endBevel; + } + aSegments.AppendElement( + SolidBeveledBorderSegment{rect, + bevelColor, + {aStartBevelSide, startBevel}, + {aEndBevelSide, endBevel}}); + } else { // left, right + half = RoundFloatToPixel(0.5f * (float)aBorder.width, + aAppUnitsPerDevPixel); + rect.width = half; + if (eSideLeft == aStartBevelSide) { + rect.y += startBevel; + rect.height -= startBevel; + } + if (eSideLeft == aEndBevelSide) { + rect.height -= endBevel; + } + aSegments.AppendElement( + SolidBeveledBorderSegment{rect, + bevelColor, + {aStartBevelSide, startBevel}, + {aEndBevelSide, endBevel}}); + } + + rect = aBorder; + ridgeGrooveSide = + (eSideTop == ridgeGrooveSide) ? eSideBottom : eSideRight; + // FIXME: In theory, this should use the visited-dependent + // background color, but I don't care. + bevelColor = + MakeBevelColor(ridgeGrooveSide, aBorderStyle, aBorderColor); + if (horizontal) { + rect.y = rect.y + half; + rect.height = aBorder.height - half; + if (eSideBottom == aStartBevelSide) { + rect.x += startBevel; + rect.width -= startBevel; + } + if (eSideBottom == aEndBevelSide) { + rect.width -= endBevel; + } + aSegments.AppendElement( + SolidBeveledBorderSegment{rect, + bevelColor, + {aStartBevelSide, startBevel}, + {aEndBevelSide, endBevel}}); + } else { + rect.x = rect.x + half; + rect.width = aBorder.width - half; + if (eSideRight == aStartBevelSide) { + rect.y += aStartBevelOffset - startBevel; + rect.height -= startBevel; + } + if (eSideRight == aEndBevelSide) { + rect.height -= endBevel; + } + aSegments.AppendElement( + SolidBeveledBorderSegment{rect, + bevelColor, + {aStartBevelSide, startBevel}, + {aEndBevelSide, endBevel}}); + } + } + break; + case StyleBorderStyle::Double: + // We can only do "double" borders if the thickness of the border + // is more than 2px. Otherwise, we fall through to painting a + // solid border. + if ((aBorder.width > 2 * oneDevPixel || horizontal) && + (aBorder.height > 2 * oneDevPixel || !horizontal)) { + nscoord startBevel = + (aStartBevelOffset > 0) + ? RoundFloatToPixel(0.333333f * (float)aStartBevelOffset, + aAppUnitsPerDevPixel) + : 0; + nscoord endBevel = + (aEndBevelOffset > 0) + ? RoundFloatToPixel(0.333333f * (float)aEndBevelOffset, + aAppUnitsPerDevPixel) + : 0; + if (horizontal) { // top, bottom + nscoord thirdHeight = RoundFloatToPixel( + 0.333333f * (float)aBorder.height, aAppUnitsPerDevPixel); + + // draw the top line or rect + nsRect topRect(aBorder.x, aBorder.y, aBorder.width, thirdHeight); + if (eSideTop == aStartBevelSide) { + topRect.x += aStartBevelOffset - startBevel; + topRect.width -= aStartBevelOffset - startBevel; + } + if (eSideTop == aEndBevelSide) { + topRect.width -= aEndBevelOffset - endBevel; + } + + aSegments.AppendElement( + SolidBeveledBorderSegment{topRect, + aBorderColor, + {aStartBevelSide, startBevel}, + {aEndBevelSide, endBevel}}); + + // draw the botom line or rect + nscoord heightOffset = aBorder.height - thirdHeight; + nsRect bottomRect(aBorder.x, aBorder.y + heightOffset, aBorder.width, + aBorder.height - heightOffset); + if (eSideBottom == aStartBevelSide) { + bottomRect.x += aStartBevelOffset - startBevel; + bottomRect.width -= aStartBevelOffset - startBevel; + } + if (eSideBottom == aEndBevelSide) { + bottomRect.width -= aEndBevelOffset - endBevel; + } + aSegments.AppendElement( + SolidBeveledBorderSegment{bottomRect, + aBorderColor, + {aStartBevelSide, startBevel}, + {aEndBevelSide, endBevel}}); + } else { // left, right + nscoord thirdWidth = RoundFloatToPixel( + 0.333333f * (float)aBorder.width, aAppUnitsPerDevPixel); + + nsRect leftRect(aBorder.x, aBorder.y, thirdWidth, aBorder.height); + if (eSideLeft == aStartBevelSide) { + leftRect.y += aStartBevelOffset - startBevel; + leftRect.height -= aStartBevelOffset - startBevel; + } + if (eSideLeft == aEndBevelSide) { + leftRect.height -= aEndBevelOffset - endBevel; + } + + aSegments.AppendElement( + SolidBeveledBorderSegment{leftRect, + aBorderColor, + {aStartBevelSide, startBevel}, + {aEndBevelSide, endBevel}}); + + nscoord widthOffset = aBorder.width - thirdWidth; + nsRect rightRect(aBorder.x + widthOffset, aBorder.y, + aBorder.width - widthOffset, aBorder.height); + if (eSideRight == aStartBevelSide) { + rightRect.y += aStartBevelOffset - startBevel; + rightRect.height -= aStartBevelOffset - startBevel; + } + if (eSideRight == aEndBevelSide) { + rightRect.height -= aEndBevelOffset - endBevel; + } + aSegments.AppendElement( + SolidBeveledBorderSegment{rightRect, + aBorderColor, + {aStartBevelSide, startBevel}, + {aEndBevelSide, endBevel}}); + } + break; + } + // else fall through to solid + [[fallthrough]]; + case StyleBorderStyle::Solid: + aSegments.AppendElement( + SolidBeveledBorderSegment{aBorder, + aBorderColor, + {aStartBevelSide, aStartBevelOffset}, + {aEndBevelSide, aEndBevelOffset}}); + break; + case StyleBorderStyle::Outset: + case StyleBorderStyle::Inset: + MOZ_ASSERT_UNREACHABLE( + "inset, outset should have been converted to groove, ridge"); + break; + } +} + +// End table border-collapsing section + +Rect nsCSSRendering::ExpandPaintingRectForDecorationLine( + nsIFrame* aFrame, const StyleTextDecorationStyle aStyle, + const Rect& aClippedRect, const Float aICoordInFrame, + const Float aCycleLength, bool aVertical) { + switch (aStyle) { + case StyleTextDecorationStyle::Dotted: + case StyleTextDecorationStyle::Dashed: + case StyleTextDecorationStyle::Wavy: + break; + default: + NS_ERROR("Invalid style was specified"); + return aClippedRect; + } + + nsBlockFrame* block = nullptr; + // Note that when we paint the decoration lines in relative positioned + // box, we should paint them like all of the boxes are positioned as static. + nscoord framePosInBlockAppUnits = 0; + for (nsIFrame* f = aFrame; f; f = f->GetParent()) { + block = do_QueryFrame(f); + if (block) { + break; + } + framePosInBlockAppUnits += + aVertical ? f->GetNormalPosition().y : f->GetNormalPosition().x; + } + + NS_ENSURE_TRUE(block, aClippedRect); + + nsPresContext* pc = aFrame->PresContext(); + Float framePosInBlock = + Float(pc->AppUnitsToGfxUnits(framePosInBlockAppUnits)); + int32_t rectPosInBlock = int32_t(NS_round(framePosInBlock + aICoordInFrame)); + int32_t extraStartEdge = + rectPosInBlock - (rectPosInBlock / int32_t(aCycleLength) * aCycleLength); + Rect rect(aClippedRect); + if (aVertical) { + rect.y -= extraStartEdge; + rect.height += extraStartEdge; + } else { + rect.x -= extraStartEdge; + rect.width += extraStartEdge; + } + return rect; +} + +// Converts a GfxFont to an SkFont +// Either returns true if it was successful, or false if something went wrong +static bool GetSkFontFromGfxFont(DrawTarget& aDrawTarget, gfxFont* aFont, + SkFont& aSkFont) { + RefPtr<ScaledFont> scaledFont = aFont->GetScaledFont(&aDrawTarget); + if (!scaledFont) { + return false; + } + + ScaledFontBase* fontBase = static_cast<ScaledFontBase*>(scaledFont.get()); + + SkTypeface* typeface = fontBase->GetSkTypeface(); + if (!typeface) { + return false; + } + + aSkFont = SkFont(sk_ref_sp(typeface), SkFloatToScalar(fontBase->GetSize())); + return true; +} + +// Computes data used to position the decoration line within a +// SkTextBlob, data is returned through aBounds +static void GetPositioning( + const nsCSSRendering::PaintDecorationLineParams& aParams, const Rect& aRect, + Float aOneCSSPixel, Float aCenterBaselineOffset, SkScalar aBounds[]) { + /** + * How Positioning in Skia Works + * Take the letter "n" for example + * We set textPos as 0, 0 + * This is represented in Skia like so (not to scale) + * ^ + * -10px | _ __ + * | | '_ \ + * -5px | | | | | + * y-axis | |_| |_| + * (0,0) -----------------------> + * | 5px 10px + * 5px | + * | + * 10px | + * v + * 0 on the x axis is a line that touches the bottom of the n + * (0,0) is the bottom left-hand corner of the n character + * Moving "up" from the n is going in a negative y direction + * Moving "down" from the n is going in a positive y direction + * + * The intercepts that are returned in this arrangement will be + * offset by the original point it starts at. (This happens in + * the SkipInk function below). + * + * In Skia, text MUST be laid out such that the next character + * in the RunBuffer is further along the x-axis than the previous + * character, otherwise there is undefined/strange behavior. + */ + + Float rectThickness = aParams.vertical ? aRect.Width() : aRect.Height(); + + // the upper and lower lines/edges of the under or over line + SkScalar upperLine, lowerLine; + if (aParams.decoration == mozilla::StyleTextDecorationLine::OVERLINE) { + lowerLine = + -aParams.offset + aParams.defaultLineThickness - aCenterBaselineOffset; + upperLine = lowerLine - rectThickness; + } else { + // underlines in vertical text are offset from the center of + // the text, and not the baseline + // Skia sets the text at it's baseline so we have to offset it + // for text in vertical-* writing modes + upperLine = -aParams.offset - aCenterBaselineOffset; + lowerLine = upperLine + rectThickness; + } + + // set up the bounds, add in a little padding to the thickness of the line + // (unless the line is <= 1 CSS pixel thick) + Float lineThicknessPadding = aParams.lineSize.height > aOneCSSPixel + ? 0.25f * aParams.lineSize.height + : 0; + // don't allow padding greater than 0.75 CSS pixel + lineThicknessPadding = std::min(lineThicknessPadding, 0.75f * aOneCSSPixel); + aBounds[0] = upperLine - lineThicknessPadding; + aBounds[1] = lowerLine + lineThicknessPadding; +} + +// positions an individual glyph according to the given offset +static SkPoint GlyphPosition(const gfxTextRun::DetailedGlyph& aGlyph, + const SkPoint& aTextPos, + int32_t aAppUnitsPerDevPixel) { + SkPoint point = {aGlyph.mOffset.x, aGlyph.mOffset.y}; + + // convert to device pixels + point.fX /= (float)aAppUnitsPerDevPixel; + point.fY /= (float)aAppUnitsPerDevPixel; + + // add offsets + point.fX += aTextPos.fX; + point.fY += aTextPos.fY; + return point; +} + +// returns a count of all the glyphs that will be rendered +// excludes ligature continuations, includes the number of individual +// glyph records. This includes the number of DetailedGlyphs that a single +// CompressedGlyph record points to. This function is necessary because Skia +// needs the total length of glyphs to add to it's run buffer before it creates +// the RunBuffer object, and this cannot be resized later. +static uint32_t CountAllGlyphs( + const gfxTextRun* aTextRun, + const gfxTextRun::CompressedGlyph* aCompressedGlyph, uint32_t aStringStart, + uint32_t aStringEnd) { + uint32_t totalGlyphCount = 0; + + for (const gfxTextRun::CompressedGlyph* cg = aCompressedGlyph + aStringStart; + cg < aCompressedGlyph + aStringEnd; ++cg) { + totalGlyphCount += cg->IsSimpleGlyph() ? 1 : cg->GetGlyphCount(); + } + + return totalGlyphCount; +} + +static void AddDetailedGlyph(const SkTextBlobBuilder::RunBuffer& aRunBuffer, + const gfxTextRun::DetailedGlyph& aGlyph, + int aIndex, float aAppUnitsPerDevPixel, + SkPoint& aTextPos) { + // add glyph ID to the run buffer at i + aRunBuffer.glyphs[aIndex] = aGlyph.mGlyphID; + + // position the glyph correctly using the detailed offsets + SkPoint position = GlyphPosition(aGlyph, aTextPos, aAppUnitsPerDevPixel); + aRunBuffer.pos[2 * aIndex] = position.fX; + aRunBuffer.pos[(2 * aIndex) + 1] = position.fY; + + // increase aTextPos.fx by the advance + aTextPos.fX += ((float)aGlyph.mAdvance / aAppUnitsPerDevPixel); +} + +static void AddSimpleGlyph(const SkTextBlobBuilder::RunBuffer& aRunBuffer, + const gfxTextRun::CompressedGlyph& aGlyph, + int aIndex, float aAppUnitsPerDevPixel, + SkPoint& aTextPos) { + aRunBuffer.glyphs[aIndex] = aGlyph.GetSimpleGlyph(); + + // simple glyphs are offset from 0, so we'll just use textPos + aRunBuffer.pos[2 * aIndex] = aTextPos.fX; + aRunBuffer.pos[(2 * aIndex) + 1] = aTextPos.fY; + + // increase aTextPos.fX by the advance + aTextPos.fX += ((float)aGlyph.GetSimpleAdvance() / aAppUnitsPerDevPixel); +} + +// Sets up a Skia TextBlob of the specified font, text position, and made up of +// the glyphs between aStringStart and aStringEnd. Handles RTL and LTR text +// and positions each glyph within the text blob +static sk_sp<const SkTextBlob> CreateTextBlob( + const gfxTextRun* aTextRun, + const gfxTextRun::CompressedGlyph* aCompressedGlyph, const SkFont& aFont, + const gfxTextRun::PropertyProvider::Spacing* aSpacing, + uint32_t aStringStart, uint32_t aStringEnd, float aAppUnitsPerDevPixel, + SkPoint& aTextPos, int32_t& aSpacingOffset) { + // allocate space for the run buffer, then fill it with the glyphs + uint32_t len = + CountAllGlyphs(aTextRun, aCompressedGlyph, aStringStart, aStringEnd); + if (len <= 0) { + return nullptr; + } + + SkTextBlobBuilder builder; + const SkTextBlobBuilder::RunBuffer& run = builder.allocRunPos(aFont, len); + + // RTL text should be read in by glyph starting at aStringEnd - 1 down until + // aStringStart. + bool isRTL = aTextRun->IsRightToLeft(); + uint32_t currIndex = isRTL ? aStringEnd - 1 : aStringStart; // textRun index + // currIndex will be advanced by |step| until it reaches |limit|, which is the + // final index to be handled (NOT one beyond the final index) + int step = isRTL ? -1 : 1; + uint32_t limit = isRTL ? aStringStart : aStringEnd - 1; + + uint32_t i = 0; // index into the SkTextBlob we're building + while (true) { + // Loop exit test is below, just before we update currIndex. + aTextPos.fX += + isRTL ? aSpacing[aSpacingOffset].mAfter / aAppUnitsPerDevPixel + : aSpacing[aSpacingOffset].mBefore / aAppUnitsPerDevPixel; + + if (aCompressedGlyph[currIndex].IsSimpleGlyph()) { + MOZ_ASSERT(i < len, "glyph count error!"); + AddSimpleGlyph(run, aCompressedGlyph[currIndex], i, aAppUnitsPerDevPixel, + aTextPos); + i++; + } else { + // if it's detailed, potentially add multiple into run.glyphs + uint32_t count = aCompressedGlyph[currIndex].GetGlyphCount(); + if (count > 0) { + gfxTextRun::DetailedGlyph* detailGlyph = + aTextRun->GetDetailedGlyphs(currIndex); + for (uint32_t d = isRTL ? count - 1 : 0; count; count--, d += step) { + MOZ_ASSERT(i < len, "glyph count error!"); + AddDetailedGlyph(run, detailGlyph[d], i, aAppUnitsPerDevPixel, + aTextPos); + i++; + } + } + } + aTextPos.fX += isRTL + ? aSpacing[aSpacingOffset].mBefore / aAppUnitsPerDevPixel + : aSpacing[aSpacingOffset].mAfter / aAppUnitsPerDevPixel; + aSpacingOffset += step; + + if (currIndex == limit) { + break; + } + currIndex += step; + } + + MOZ_ASSERT(i == len, "glyph count error!"); + + return builder.make(); +} + +// Given a TextBlob, the bounding lines, and the set of current intercepts this +// function adds the intercepts for the current TextBlob into the given set of +// previoulsy calculated intercepts. This set is either of length 0, or a +// multiple of 2 (since every intersection with a piece of text results in two +// intercepts: entering/exiting) +static void GetTextIntercepts(const sk_sp<const SkTextBlob>& aBlob, + const SkScalar aBounds[], + nsTArray<SkScalar>& aIntercepts) { + // It's possible that we'll encounter a Windows exception deep inside + // Skia's DirectWrite code while trying to get the intercepts. To avoid + // crashing in this case, catch any such exception here and discard the + // newly-added (and incompletely filled in) elements. + int count = 0; + MOZ_SEH_TRY { + // https://skia.org/user/api/SkTextBlob_Reference#Text_Blob_Text_Intercepts + count = aBlob->getIntercepts(aBounds, nullptr); + if (count < 2) { + return; + } + aBlob->getIntercepts(aBounds, aIntercepts.AppendElements(count)); + } + MOZ_SEH_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { + gfxCriticalNote << "Exception occurred getting text intercepts"; + aIntercepts.TruncateLength(aIntercepts.Length() - count); + } +} + +// This function, given a set of intercepts that represent each intersection +// between an under/overline and text, makes a series of calls to +// PaintDecorationLineInternal that paints a series of clip rects which +// implement the text-decoration-skip-ink property +// Logic for where to place each clipped rect, and the length of each rect is +// included here +static void SkipInk(nsIFrame* aFrame, DrawTarget& aDrawTarget, + const nsCSSRendering::PaintDecorationLineParams& aParams, + const nsTArray<SkScalar>& aIntercepts, Float aPadding, + Rect& aRect) { + nsCSSRendering::PaintDecorationLineParams clipParams = aParams; + int length = aIntercepts.Length(); + + SkScalar startIntercept = 0; + SkScalar endIntercept = 0; + + // keep track of the direction we are drawing the clipped rects in + // for sideways text, our intercepts from the first glyph are actually + // decreasing (towards the top edge of the page), so we use a negative + // direction + Float dir = 1.0f; + Float lineStart = aParams.vertical ? aParams.pt.y : aParams.pt.x; + Float lineEnd = lineStart + aParams.lineSize.width; + if (aParams.sidewaysLeft) { + dir = -1.0f; + std::swap(lineStart, lineEnd); + } + + for (int i = 0; i <= length; i += 2) { + // handle start/end edge cases and set up general case + startIntercept = (i > 0) ? (dir * aIntercepts[i - 1]) + lineStart + : lineStart - (dir * aPadding); + endIntercept = (i < length) ? (dir * aIntercepts[i]) + lineStart + : lineEnd + (dir * aPadding); + + // remove padding at both ends for width + // the start of the line is calculated so the padding removes just + // enough so that the line starts at its normal position + clipParams.lineSize.width = + (dir * (endIntercept - startIntercept)) - (2.0 * aPadding); + + // Don't draw decoration lines that have a smaller width than 1, or half + // the line-end padding dimension. + if (clipParams.lineSize.width < std::max(aPadding * 0.5, 1.0)) { + continue; + } + + // Start the line right after the intercept's location plus room for + // padding; snap the rect edges to device pixels for consistent rendering + // of dots across separate fragments of a dotted line. + if (aParams.vertical) { + clipParams.pt.y = aParams.sidewaysLeft ? endIntercept + aPadding + : startIntercept + aPadding; + aRect.y = std::floor(clipParams.pt.y + 0.5); + aRect.SetBottomEdge( + std::floor(clipParams.pt.y + clipParams.lineSize.width + 0.5)); + } else { + clipParams.pt.x = startIntercept + aPadding; + aRect.x = std::floor(clipParams.pt.x + 0.5); + aRect.SetRightEdge( + std::floor(clipParams.pt.x + clipParams.lineSize.width + 0.5)); + } + + nsCSSRendering::PaintDecorationLineInternal(aFrame, aDrawTarget, clipParams, + aRect); + } +} + +void nsCSSRendering::PaintDecorationLine( + nsIFrame* aFrame, DrawTarget& aDrawTarget, + const PaintDecorationLineParams& aParams) { + NS_ASSERTION(aParams.style != StyleTextDecorationStyle::None, + "aStyle is none"); + + Rect rect = ToRect(GetTextDecorationRectInternal(aParams.pt, aParams)); + if (rect.IsEmpty() || !rect.Intersects(aParams.dirtyRect)) { + return; + } + + if (aParams.decoration != StyleTextDecorationLine::UNDERLINE && + aParams.decoration != StyleTextDecorationLine::OVERLINE && + aParams.decoration != StyleTextDecorationLine::LINE_THROUGH) { + MOZ_ASSERT_UNREACHABLE("Invalid text decoration value"); + return; + } + + // Check if decoration line will skip past ascenders/descenders + // text-decoration-skip-ink only applies to overlines/underlines + mozilla::StyleTextDecorationSkipInk skipInk = + aFrame->StyleText()->mTextDecorationSkipInk; + bool skipInkEnabled = + skipInk != mozilla::StyleTextDecorationSkipInk::None && + aParams.decoration != StyleTextDecorationLine::LINE_THROUGH; + + if (!skipInkEnabled || aParams.glyphRange.Length() == 0) { + PaintDecorationLineInternal(aFrame, aDrawTarget, aParams, rect); + return; + } + + // check if the frame is a text frame or not + nsTextFrame* textFrame = nullptr; + if (aFrame->IsTextFrame()) { + textFrame = static_cast<nsTextFrame*>(aFrame); + } else { + PaintDecorationLineInternal(aFrame, aDrawTarget, aParams, rect); + return; + } + + // get text run and current text offset (for line wrapping) + gfxTextRun* textRun = + textFrame->GetTextRun(nsTextFrame::TextRunType::eInflated); + + // used for conversions from app units to device pixels + int32_t appUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel(); + + // pointer to the array of glyphs for this TextRun + gfxTextRun::CompressedGlyph* characterGlyphs = textRun->GetCharacterGlyphs(); + + // get positioning info + SkPoint textPos = {0, aParams.baselineOffset}; + SkScalar bounds[] = {0, 0}; + Float oneCSSPixel = aFrame->PresContext()->CSSPixelsToDevPixels(1.0f); + if (!textRun->UseCenterBaseline()) { + GetPositioning(aParams, rect, oneCSSPixel, 0, bounds); + } + + // array for the text intercepts + AutoTArray<SkScalar, 256> intercepts; + + // array for spacing data + AutoTArray<gfxTextRun::PropertyProvider::Spacing, 64> spacing; + spacing.SetLength(aParams.glyphRange.Length()); + if (aParams.provider != nullptr) { + aParams.provider->GetSpacing(aParams.glyphRange, spacing.Elements()); + } + + // loop through each glyph run + // in most cases there will only be one + bool isRTL = textRun->IsRightToLeft(); + int32_t spacingOffset = isRTL ? aParams.glyphRange.Length() - 1 : 0; + gfxTextRun::GlyphRunIterator iter(textRun, aParams.glyphRange, isRTL); + + // For any glyph run where we don't actually do skipping, we'll need to + // advance the current position by its width. + // (For runs we do process, CreateTextBlob will update the position.) + auto currentGlyphRunAdvance = [&]() { + return textRun->GetAdvanceWidth( + gfxTextRun::Range(iter.StringStart(), iter.StringEnd()), + aParams.provider) / + appUnitsPerDevPixel; + }; + + for (; !iter.AtEnd(); iter.NextRun()) { + if (iter.GlyphRun()->mOrientation == + mozilla::gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT || + (iter.GlyphRun()->mIsCJK && + skipInk == mozilla::StyleTextDecorationSkipInk::Auto)) { + // We don't support upright text in vertical modes currently + // (see https://bugzilla.mozilla.org/show_bug.cgi?id=1572294), + // but we do need to update textPos so that following runs will be + // correctly positioned. + // We also don't apply skip-ink to CJK text runs because many fonts + // have an underline that looks really bad if this is done + // (see https://bugzilla.mozilla.org/show_bug.cgi?id=1573249), + // when skip-ink is set to 'auto'. + textPos.fX += currentGlyphRunAdvance(); + continue; + } + + gfxFont* font = iter.GlyphRun()->mFont; + // Don't try to apply skip-ink to 'sbix' fonts like Apple Color Emoji, + // because old macOS (10.9) may crash trying to retrieve glyph paths + // that don't exist. + if (font->GetFontEntry()->HasFontTable(TRUETYPE_TAG('s', 'b', 'i', 'x'))) { + textPos.fX += currentGlyphRunAdvance(); + continue; + } + + // get a Skia version of the glyph run's font + SkFont skiafont; + if (!GetSkFontFromGfxFont(aDrawTarget, font, skiafont)) { + PaintDecorationLineInternal(aFrame, aDrawTarget, aParams, rect); + return; + } + + // Create a text blob with correctly positioned glyphs. This also updates + // textPos.fX with the advance of the glyphs. + sk_sp<const SkTextBlob> textBlob = + CreateTextBlob(textRun, characterGlyphs, skiafont, spacing.Elements(), + iter.StringStart(), iter.StringEnd(), + (float)appUnitsPerDevPixel, textPos, spacingOffset); + + if (!textBlob) { + textPos.fX += currentGlyphRunAdvance(); + continue; + } + + if (textRun->UseCenterBaseline()) { + // writing modes that use a center baseline need to be adjusted on a + // font-by-font basis since Skia lines up the text on a alphabetic + // baseline, but for some vertical-* writing modes the offset is from the + // center. + gfxFont::Metrics metrics = font->GetMetrics(nsFontMetrics::eHorizontal); + Float centerToBaseline = (metrics.emAscent - metrics.emDescent) / 2.0f; + GetPositioning(aParams, rect, oneCSSPixel, centerToBaseline, bounds); + } + + // compute the text intercepts that need to be skipped + GetTextIntercepts(textBlob, bounds, intercepts); + } + bool needsSkipInk = intercepts.Length() > 0; + + if (needsSkipInk) { + // Padding between glyph intercepts and the decoration line: we use the + // decoration line thickness, clamped to a minimum of 1px and a maximum + // of 0.2em. + Float padding = + std::min(std::max(aParams.lineSize.height, oneCSSPixel), + Float(textRun->GetFontGroup()->GetStyle()->size / 5.0)); + SkipInk(aFrame, aDrawTarget, aParams, intercepts, padding, rect); + } else { + PaintDecorationLineInternal(aFrame, aDrawTarget, aParams, rect); + } +} + +void nsCSSRendering::PaintDecorationLineInternal( + nsIFrame* aFrame, DrawTarget& aDrawTarget, + const PaintDecorationLineParams& aParams, Rect aRect) { + Float lineThickness = std::max(NS_round(aParams.lineSize.height), 1.0); + + DeviceColor color = ToDeviceColor(aParams.color); + ColorPattern colorPat(color); + StrokeOptions strokeOptions(lineThickness); + DrawOptions drawOptions; + + Float dash[2]; + + AutoPopClips autoPopClips(&aDrawTarget); + + mozilla::layout::TextDrawTarget* textDrawer = nullptr; + if (aDrawTarget.GetBackendType() == BackendType::WEBRENDER_TEXT) { + textDrawer = static_cast<mozilla::layout::TextDrawTarget*>(&aDrawTarget); + } + + switch (aParams.style) { + case StyleTextDecorationStyle::Solid: + case StyleTextDecorationStyle::Double: + break; + case StyleTextDecorationStyle::Dashed: { + autoPopClips.PushClipRect(aRect); + Float dashWidth = lineThickness * DOT_LENGTH * DASH_LENGTH; + dash[0] = dashWidth; + dash[1] = dashWidth; + strokeOptions.mDashPattern = dash; + strokeOptions.mDashLength = MOZ_ARRAY_LENGTH(dash); + strokeOptions.mLineCap = CapStyle::BUTT; + aRect = ExpandPaintingRectForDecorationLine( + aFrame, aParams.style, aRect, aParams.icoordInFrame, dashWidth * 2, + aParams.vertical); + // We should continue to draw the last dash even if it is not in the rect. + aRect.width += dashWidth; + break; + } + case StyleTextDecorationStyle::Dotted: { + autoPopClips.PushClipRect(aRect); + Float dashWidth = lineThickness * DOT_LENGTH; + if (lineThickness > 2.0) { + dash[0] = 0.f; + dash[1] = dashWidth * 2.f; + strokeOptions.mLineCap = CapStyle::ROUND; + } else { + dash[0] = dashWidth; + dash[1] = dashWidth; + } + strokeOptions.mDashPattern = dash; + strokeOptions.mDashLength = MOZ_ARRAY_LENGTH(dash); + aRect = ExpandPaintingRectForDecorationLine( + aFrame, aParams.style, aRect, aParams.icoordInFrame, dashWidth * 2, + aParams.vertical); + // We should continue to draw the last dot even if it is not in the rect. + aRect.width += dashWidth; + break; + } + case StyleTextDecorationStyle::Wavy: + autoPopClips.PushClipRect(aRect); + if (lineThickness > 2.0) { + drawOptions.mAntialiasMode = AntialiasMode::SUBPIXEL; + } else { + // Don't use anti-aliasing here. Because looks like lighter color wavy + // line at this case. And probably, users don't think the + // non-anti-aliased wavy line is not pretty. + drawOptions.mAntialiasMode = AntialiasMode::NONE; + } + break; + default: + NS_ERROR("Invalid style value!"); + return; + } + + // The block-direction position should be set to the middle of the line. + if (aParams.vertical) { + aRect.x += lineThickness / 2; + } else { + aRect.y += lineThickness / 2; + } + + switch (aParams.style) { + case StyleTextDecorationStyle::Solid: + case StyleTextDecorationStyle::Dotted: + case StyleTextDecorationStyle::Dashed: { + Point p1 = aRect.TopLeft(); + Point p2 = aParams.vertical ? aRect.BottomLeft() : aRect.TopRight(); + if (textDrawer) { + textDrawer->AppendDecoration(p1, p2, lineThickness, aParams.vertical, + color, aParams.style); + } else { + aDrawTarget.StrokeLine(p1, p2, colorPat, strokeOptions, drawOptions); + } + return; + } + case StyleTextDecorationStyle::Double: { + /** + * We are drawing double line as: + * + * +-------------------------------------------+ + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| ^ + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| | lineThickness + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| v + * | | + * | | + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| ^ + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| | lineThickness + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| v + * +-------------------------------------------+ + */ + Point p1a = aRect.TopLeft(); + Point p2a = aParams.vertical ? aRect.BottomLeft() : aRect.TopRight(); + + if (aParams.vertical) { + aRect.width -= lineThickness; + } else { + aRect.height -= lineThickness; + } + + Point p1b = aParams.vertical ? aRect.TopRight() : aRect.BottomLeft(); + Point p2b = aRect.BottomRight(); + + if (textDrawer) { + textDrawer->AppendDecoration(p1a, p2a, lineThickness, aParams.vertical, + color, StyleTextDecorationStyle::Solid); + textDrawer->AppendDecoration(p1b, p2b, lineThickness, aParams.vertical, + color, StyleTextDecorationStyle::Solid); + } else { + aDrawTarget.StrokeLine(p1a, p2a, colorPat, strokeOptions, drawOptions); + aDrawTarget.StrokeLine(p1b, p2b, colorPat, strokeOptions, drawOptions); + } + return; + } + case StyleTextDecorationStyle::Wavy: { + /** + * We are drawing wavy line as: + * + * P: Path, X: Painted pixel + * + * +---------------------------------------+ + * XX|X XXXXXX XXXXXX | + * PP|PX XPPPPPPX XPPPPPPX | ^ + * XX|XPX XPXXXXXXPX XPXXXXXXPX| | + * | XPX XPX XPX XPX XP|X |adv + * | XPXXXXXXPX XPXXXXXXPX X|PX | + * | XPPPPPPX XPPPPPPX |XPX v + * | XXXXXX XXXXXX | XX + * +---------------------------------------+ + * <---><---> ^ + * adv flatLengthAtVertex rightMost + * + * 1. Always starts from top-left of the drawing area, however, we need + * to draw the line from outside of the rect. Because the start + * point of the line is not good style if we draw from inside it. + * 2. First, draw horizontal line from outside the rect to top-left of + * the rect; + * 3. Goes down to bottom of the area at 45 degrees. + * 4. Slides to right horizontaly, see |flatLengthAtVertex|. + * 5. Goes up to top of the area at 45 degrees. + * 6. Slides to right horizontaly. + * 7. Repeat from 2 until reached to right-most edge of the area. + * + * In the vertical case, swap horizontal and vertical coordinates and + * directions in the above description. + */ + + Float& rectICoord = aParams.vertical ? aRect.y : aRect.x; + Float& rectISize = aParams.vertical ? aRect.height : aRect.width; + const Float rectBSize = aParams.vertical ? aRect.width : aRect.height; + + const Float adv = rectBSize - lineThickness; + const Float flatLengthAtVertex = + std::max((lineThickness - 1.0) * 2.0, 1.0); + + // Align the start of wavy lines to the nearest ancestor block. + const Float cycleLength = 2 * (adv + flatLengthAtVertex); + aRect = ExpandPaintingRectForDecorationLine( + aFrame, aParams.style, aRect, aParams.icoordInFrame, cycleLength, + aParams.vertical); + + if (textDrawer) { + // Undo attempted centering + Float& rectBCoord = aParams.vertical ? aRect.x : aRect.y; + rectBCoord -= lineThickness / 2; + + textDrawer->AppendWavyDecoration(aRect, lineThickness, aParams.vertical, + color); + return; + } + + // figure out if we can trim whole cycles from the left and right edges + // of the line, to try and avoid creating an unnecessarily long and + // complex path (but don't do this for webrender, ) + const Float dirtyRectICoord = + aParams.vertical ? aParams.dirtyRect.y : aParams.dirtyRect.x; + int32_t skipCycles = floor((dirtyRectICoord - rectICoord) / cycleLength); + if (skipCycles > 0) { + rectICoord += skipCycles * cycleLength; + rectISize -= skipCycles * cycleLength; + } + + rectICoord += lineThickness / 2.0; + + Point pt(aRect.TopLeft()); + Float& ptICoord = aParams.vertical ? pt.y.value : pt.x.value; + Float& ptBCoord = aParams.vertical ? pt.x.value : pt.y.value; + if (aParams.vertical) { + ptBCoord += adv; + } + Float iCoordLimit = ptICoord + rectISize + lineThickness; + + const Float dirtyRectIMost = aParams.vertical ? aParams.dirtyRect.YMost() + : aParams.dirtyRect.XMost(); + skipCycles = floor((iCoordLimit - dirtyRectIMost) / cycleLength); + if (skipCycles > 0) { + iCoordLimit -= skipCycles * cycleLength; + } + + RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder(); + RefPtr<Path> path; + + ptICoord -= lineThickness; + builder->MoveTo(pt); // 1 + + ptICoord = rectICoord; + builder->LineTo(pt); // 2 + + // In vertical mode, to go "down" relative to the text we need to + // decrease the block coordinate, whereas in horizontal we increase + // it. So the sense of this flag is effectively inverted. + bool goDown = !aParams.vertical; + uint32_t iter = 0; + while (ptICoord < iCoordLimit) { + if (++iter > 1000) { + // stroke the current path and start again, to avoid pathological + // behavior in cairo with huge numbers of path segments + path = builder->Finish(); + aDrawTarget.Stroke(path, colorPat, strokeOptions, drawOptions); + builder = aDrawTarget.CreatePathBuilder(); + builder->MoveTo(pt); + iter = 0; + } + ptICoord += adv; + ptBCoord += goDown ? adv : -adv; + + builder->LineTo(pt); // 3 and 5 + + ptICoord += flatLengthAtVertex; + builder->LineTo(pt); // 4 and 6 + + goDown = !goDown; + } + path = builder->Finish(); + aDrawTarget.Stroke(path, colorPat, strokeOptions, drawOptions); + return; + } + default: + NS_ERROR("Invalid style value!"); + } +} + +Rect nsCSSRendering::DecorationLineToPath( + const PaintDecorationLineParams& aParams) { + NS_ASSERTION(aParams.style != StyleTextDecorationStyle::None, + "aStyle is none"); + + Rect path; // To benefit from RVO, we return this from all return points + + Rect rect = ToRect(GetTextDecorationRectInternal(aParams.pt, aParams)); + if (rect.IsEmpty() || !rect.Intersects(aParams.dirtyRect)) { + return path; + } + + if (aParams.decoration != StyleTextDecorationLine::UNDERLINE && + aParams.decoration != StyleTextDecorationLine::OVERLINE && + aParams.decoration != StyleTextDecorationLine::LINE_THROUGH) { + MOZ_ASSERT_UNREACHABLE("Invalid text decoration value"); + return path; + } + + if (aParams.style != StyleTextDecorationStyle::Solid) { + // For the moment, we support only solid text decorations. + return path; + } + + Float lineThickness = std::max(NS_round(aParams.lineSize.height), 1.0); + + // The block-direction position should be set to the middle of the line. + if (aParams.vertical) { + rect.x += lineThickness / 2; + path = Rect(rect.TopLeft() - Point(lineThickness / 2, 0.0), + Size(lineThickness, rect.Height())); + } else { + rect.y += lineThickness / 2; + path = Rect(rect.TopLeft() - Point(0.0, lineThickness / 2), + Size(rect.Width(), lineThickness)); + } + + return path; +} + +nsRect nsCSSRendering::GetTextDecorationRect( + nsPresContext* aPresContext, const DecorationRectParams& aParams) { + NS_ASSERTION(aPresContext, "aPresContext is null"); + NS_ASSERTION(aParams.style != StyleTextDecorationStyle::None, + "aStyle is none"); + + gfxRect rect = GetTextDecorationRectInternal(Point(0, 0), aParams); + // The rect values are already rounded to nearest device pixels. + nsRect r; + r.x = aPresContext->GfxUnitsToAppUnits(rect.X()); + r.y = aPresContext->GfxUnitsToAppUnits(rect.Y()); + r.width = aPresContext->GfxUnitsToAppUnits(rect.Width()); + r.height = aPresContext->GfxUnitsToAppUnits(rect.Height()); + return r; +} + +gfxRect nsCSSRendering::GetTextDecorationRectInternal( + const Point& aPt, const DecorationRectParams& aParams) { + NS_ASSERTION(aParams.style <= StyleTextDecorationStyle::Wavy, + "Invalid aStyle value"); + + if (aParams.style == StyleTextDecorationStyle::None) { + return gfxRect(0, 0, 0, 0); + } + + bool canLiftUnderline = aParams.descentLimit >= 0.0; + + gfxFloat iCoord = aParams.vertical ? aPt.y : aPt.x; + gfxFloat bCoord = aParams.vertical ? aPt.x : aPt.y; + + // 'left' and 'right' are relative to the line, so for vertical writing modes + // they will actually become top and bottom of the rendered line. + // Similarly, aLineSize.width and .height are actually length and thickness + // of the line, which runs horizontally or vertically according to aVertical. + const gfxFloat left = floor(iCoord + 0.5), + right = floor(iCoord + aParams.lineSize.width + 0.5); + + // We compute |r| as if for a horizontal text run, and then swap vertical + // and horizontal coordinates at the end if vertical was requested. + gfxRect r(left, 0, right - left, 0); + + gfxFloat lineThickness = NS_round(aParams.lineSize.height); + lineThickness = std::max(lineThickness, 1.0); + gfxFloat defaultLineThickness = NS_round(aParams.defaultLineThickness); + defaultLineThickness = std::max(defaultLineThickness, 1.0); + + gfxFloat ascent = NS_round(aParams.ascent); + gfxFloat descentLimit = floor(aParams.descentLimit); + + gfxFloat suggestedMaxRectHeight = + std::max(std::min(ascent, descentLimit), 1.0); + r.height = lineThickness; + if (aParams.style == StyleTextDecorationStyle::Double) { + /** + * We will draw double line as: + * + * +-------------------------------------------+ + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| ^ + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| | lineThickness + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| v + * | | ^ + * | | | gap + * | | v + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| ^ + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| | lineThickness + * |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| v + * +-------------------------------------------+ + */ + gfxFloat gap = NS_round(lineThickness / 2.0); + gap = std::max(gap, 1.0); + r.height = lineThickness * 2.0 + gap; + if (canLiftUnderline) { + if (r.Height() > suggestedMaxRectHeight) { + // Don't shrink the line height, because the thickness has some meaning. + // We can just shrink the gap at this time. + r.height = std::max(suggestedMaxRectHeight, lineThickness * 2.0 + 1.0); + } + } + } else if (aParams.style == StyleTextDecorationStyle::Wavy) { + /** + * We will draw wavy line as: + * + * +-------------------------------------------+ + * |XXXXX XXXXXX XXXXXX | ^ + * |XXXXXX XXXXXXXX XXXXXXXX | | lineThickness + * |XXXXXXX XXXXXXXXXX XXXXXXXXXX| v + * | XXX XXX XXX XXX XX| + * | XXXXXXXXXX XXXXXXXXXX X| + * | XXXXXXXX XXXXXXXX | + * | XXXXXX XXXXXX | + * +-------------------------------------------+ + */ + r.height = lineThickness > 2.0 ? lineThickness * 4.0 : lineThickness * 3.0; + if (canLiftUnderline) { + if (r.Height() > suggestedMaxRectHeight) { + // Don't shrink the line height even if there is not enough space, + // because the thickness has some meaning. E.g., the 1px wavy line and + // 2px wavy line can be used for different meaning in IME selections + // at same time. + r.height = std::max(suggestedMaxRectHeight, lineThickness * 2.0); + } + } + } + + gfxFloat baseline = floor(bCoord + aParams.ascent + 0.5); + + // Calculate adjusted offset based on writing-mode/orientation and thickness + // of decoration line. The input value aParams.offset is the nominal position + // (offset from baseline) where we would draw a single, infinitely-thin line; + // but for a wavy or double line, we'll need to move the bounding rect of the + // decoration outwards from the baseline so that an underline remains below + // the glyphs, and an overline above them, despite the increased block-dir + // extent of the decoration. + // + // So adjustments by r.Height() are used to make the wider line styles (wavy + // and double) "grow" in the appropriate direction compared to the basic + // single line. + // + // Note that at this point, the decoration rect is being calculated in line- + // relative coordinates, where 'x' is line-rightwards, and 'y' is line- + // upwards. We'll swap them to be physical coords at the end. + gfxFloat offset = 0.0; + + if (aParams.decoration == StyleTextDecorationLine::UNDERLINE) { + offset = aParams.offset; + if (canLiftUnderline) { + if (descentLimit < -offset + r.Height()) { + // If we can ignore the offset and the decoration line is overflowing, + // we should align the bottom edge of the decoration line rect if it's + // possible. Otherwise, we should lift up the top edge of the rect as + // far as possible. + gfxFloat offsetBottomAligned = -descentLimit + r.Height(); + gfxFloat offsetTopAligned = 0.0; + offset = std::min(offsetBottomAligned, offsetTopAligned); + } + } + } else if (aParams.decoration == StyleTextDecorationLine::OVERLINE) { + // For overline, we adjust the offset by defaultlineThickness (the default + // thickness of a single decoration line) because empirically it looks + // better to draw the overline just inside rather than outside the font's + // ascent, which is what nsTextFrame passes as aParams.offset (as fonts + // don't provide an explicit overline-offset). + offset = aParams.offset - defaultLineThickness + r.Height(); + } else if (aParams.decoration == StyleTextDecorationLine::LINE_THROUGH) { + // To maintain a consistent mid-point for line-through decorations, + // we adjust the offset by half of the decoration rect's height. + gfxFloat extra = floor(r.Height() / 2.0 + 0.5); + extra = std::max(extra, lineThickness); + // computes offset for when user specifies a decoration width since + // aParams.offset is derived from the font metric's line height + gfxFloat decorationThicknessOffset = + (lineThickness - defaultLineThickness) / 2.0; + offset = aParams.offset - lineThickness + extra + decorationThicknessOffset; + } else { + MOZ_ASSERT_UNREACHABLE("Invalid text decoration value"); + } + + // Convert line-relative coordinate system (x = line-right, y = line-up) + // to physical coords, and move the decoration rect to the calculated + // offset from baseline. + if (aParams.vertical) { + std::swap(r.x, r.y); + std::swap(r.width, r.height); + // line-upwards in vertical mode = physical-right, so we /add/ offset + // to baseline. Except in sideways-lr mode, where line-upwards will be + // physical leftwards. + if (aParams.sidewaysLeft) { + r.x = baseline - floor(offset + 0.5); + } else { + r.x = baseline + floor(offset - r.Width() + 0.5); + } + } else { + // line-upwards in horizontal mode = physical-up, but our physical coord + // system works downwards, so we /subtract/ offset from baseline. + r.y = baseline - floor(offset + 0.5); + } + + return r; +} + +#define MAX_BLUR_RADIUS 300 +#define MAX_SPREAD_RADIUS 50 + +static inline gfxPoint ComputeBlurStdDev(nscoord aBlurRadius, + int32_t aAppUnitsPerDevPixel, + gfxFloat aScaleX, gfxFloat aScaleY) { + // http://dev.w3.org/csswg/css3-background/#box-shadow says that the + // standard deviation of the blur should be half the given blur value. + gfxFloat blurStdDev = gfxFloat(aBlurRadius) / gfxFloat(aAppUnitsPerDevPixel); + + return gfxPoint( + std::min((blurStdDev * aScaleX), gfxFloat(MAX_BLUR_RADIUS)) / 2.0, + std::min((blurStdDev * aScaleY), gfxFloat(MAX_BLUR_RADIUS)) / 2.0); +} + +static inline IntSize ComputeBlurRadius(nscoord aBlurRadius, + int32_t aAppUnitsPerDevPixel, + gfxFloat aScaleX = 1.0, + gfxFloat aScaleY = 1.0) { + gfxPoint scaledBlurStdDev = + ComputeBlurStdDev(aBlurRadius, aAppUnitsPerDevPixel, aScaleX, aScaleY); + return gfxAlphaBoxBlur::CalculateBlurRadius(scaledBlurStdDev); +} + +// ----- +// nsContextBoxBlur +// ----- +gfxContext* nsContextBoxBlur::Init(const nsRect& aRect, nscoord aSpreadRadius, + nscoord aBlurRadius, + int32_t aAppUnitsPerDevPixel, + gfxContext* aDestinationCtx, + const nsRect& aDirtyRect, + const gfxRect* aSkipRect, uint32_t aFlags) { + if (aRect.IsEmpty()) { + mContext = nullptr; + return nullptr; + } + + IntSize blurRadius; + IntSize spreadRadius; + GetBlurAndSpreadRadius(aDestinationCtx->GetDrawTarget(), aAppUnitsPerDevPixel, + aBlurRadius, aSpreadRadius, blurRadius, spreadRadius); + + mDestinationCtx = aDestinationCtx; + + // If not blurring, draw directly onto the destination device + if (blurRadius.width <= 0 && blurRadius.height <= 0 && + spreadRadius.width <= 0 && spreadRadius.height <= 0 && + !(aFlags & FORCE_MASK)) { + mContext = aDestinationCtx; + return mContext; + } + + // Convert from app units to device pixels + gfxRect rect = nsLayoutUtils::RectToGfxRect(aRect, aAppUnitsPerDevPixel); + + gfxRect dirtyRect = + nsLayoutUtils::RectToGfxRect(aDirtyRect, aAppUnitsPerDevPixel); + dirtyRect.RoundOut(); + + gfxMatrix transform = aDestinationCtx->CurrentMatrixDouble(); + rect = transform.TransformBounds(rect); + + mPreTransformed = !transform.IsIdentity(); + + // Create the temporary surface for blurring + dirtyRect = transform.TransformBounds(dirtyRect); + bool useHardwareAccel = !(aFlags & DISABLE_HARDWARE_ACCELERATION_BLUR); + if (aSkipRect) { + gfxRect skipRect = transform.TransformBounds(*aSkipRect); + mOwnedContext = + mAlphaBoxBlur.Init(aDestinationCtx, rect, spreadRadius, blurRadius, + &dirtyRect, &skipRect, useHardwareAccel); + } else { + mOwnedContext = + mAlphaBoxBlur.Init(aDestinationCtx, rect, spreadRadius, blurRadius, + &dirtyRect, nullptr, useHardwareAccel); + } + mContext = mOwnedContext.get(); + + if (mContext) { + // we don't need to blur if skipRect is equal to rect + // and mContext will be nullptr + mContext->Multiply(transform); + } + return mContext; +} + +void nsContextBoxBlur::DoPaint() { + if (mContext == mDestinationCtx) { + return; + } + + gfxContextMatrixAutoSaveRestore saveMatrix(mDestinationCtx); + + if (mPreTransformed) { + mDestinationCtx->SetMatrix(Matrix()); + } + + mAlphaBoxBlur.Paint(mDestinationCtx); +} + +gfxContext* nsContextBoxBlur::GetContext() { return mContext; } + +/* static */ +nsMargin nsContextBoxBlur::GetBlurRadiusMargin(nscoord aBlurRadius, + int32_t aAppUnitsPerDevPixel) { + IntSize blurRadius = ComputeBlurRadius(aBlurRadius, aAppUnitsPerDevPixel); + + nsMargin result; + result.top = result.bottom = blurRadius.height * aAppUnitsPerDevPixel; + result.left = result.right = blurRadius.width * aAppUnitsPerDevPixel; + return result; +} + +/* static */ +void nsContextBoxBlur::BlurRectangle( + gfxContext* aDestinationCtx, const nsRect& aRect, + int32_t aAppUnitsPerDevPixel, RectCornerRadii* aCornerRadii, + nscoord aBlurRadius, const sRGBColor& aShadowColor, + const nsRect& aDirtyRect, const gfxRect& aSkipRect) { + DrawTarget& aDestDrawTarget = *aDestinationCtx->GetDrawTarget(); + + if (aRect.IsEmpty()) { + return; + } + + Rect shadowGfxRect = NSRectToRect(aRect, aAppUnitsPerDevPixel); + + if (aBlurRadius <= 0) { + ColorPattern color(ToDeviceColor(aShadowColor)); + if (aCornerRadii) { + RefPtr<Path> roundedRect = + MakePathForRoundedRect(aDestDrawTarget, shadowGfxRect, *aCornerRadii); + aDestDrawTarget.Fill(roundedRect, color); + } else { + aDestDrawTarget.FillRect(shadowGfxRect, color); + } + return; + } + + gfxFloat scaleX = 1; + gfxFloat scaleY = 1; + + // Do blurs in device space when possible. + // Chrome/Skia always does the blurs in device space + // and will sometimes get incorrect results (e.g. rotated blurs) + gfxMatrix transform = aDestinationCtx->CurrentMatrixDouble(); + // XXX: we could probably handle negative scales but for now it's easier just + // to fallback + if (!transform.HasNonAxisAlignedTransform() && transform._11 > 0.0 && + transform._22 > 0.0) { + scaleX = transform._11; + scaleY = transform._22; + aDestinationCtx->SetMatrix(Matrix()); + } else { + transform = gfxMatrix(); + } + + gfxPoint blurStdDev = + ComputeBlurStdDev(aBlurRadius, aAppUnitsPerDevPixel, scaleX, scaleY); + + gfxRect dirtyRect = + nsLayoutUtils::RectToGfxRect(aDirtyRect, aAppUnitsPerDevPixel); + dirtyRect.RoundOut(); + + gfxRect shadowThebesRect = + transform.TransformBounds(ThebesRect(shadowGfxRect)); + dirtyRect = transform.TransformBounds(dirtyRect); + gfxRect skipRect = transform.TransformBounds(aSkipRect); + + if (aCornerRadii) { + aCornerRadii->Scale(scaleX, scaleY); + } + + gfxAlphaBoxBlur::BlurRectangle(aDestinationCtx, shadowThebesRect, + aCornerRadii, blurStdDev, aShadowColor, + dirtyRect, skipRect); +} + +/* static */ +void nsContextBoxBlur::GetBlurAndSpreadRadius( + DrawTarget* aDestDrawTarget, int32_t aAppUnitsPerDevPixel, + nscoord aBlurRadius, nscoord aSpreadRadius, IntSize& aOutBlurRadius, + IntSize& aOutSpreadRadius, bool aConstrainSpreadRadius) { + // Do blurs in device space when possible. + // Chrome/Skia always does the blurs in device space + // and will sometimes get incorrect results (e.g. rotated blurs) + Matrix transform = aDestDrawTarget->GetTransform(); + // XXX: we could probably handle negative scales but for now it's easier just + // to fallback + gfxFloat scaleX, scaleY; + if (transform.HasNonAxisAlignedTransform() || transform._11 <= 0.0 || + transform._22 <= 0.0) { + scaleX = 1; + scaleY = 1; + } else { + scaleX = transform._11; + scaleY = transform._22; + } + + // compute a large or smaller blur radius + aOutBlurRadius = + ComputeBlurRadius(aBlurRadius, aAppUnitsPerDevPixel, scaleX, scaleY); + aOutSpreadRadius = + IntSize(int32_t(aSpreadRadius * scaleX / aAppUnitsPerDevPixel), + int32_t(aSpreadRadius * scaleY / aAppUnitsPerDevPixel)); + + if (aConstrainSpreadRadius) { + aOutSpreadRadius.width = + std::min(aOutSpreadRadius.width, int32_t(MAX_SPREAD_RADIUS)); + aOutSpreadRadius.height = + std::min(aOutSpreadRadius.height, int32_t(MAX_SPREAD_RADIUS)); + } +} + +/* static */ +bool nsContextBoxBlur::InsetBoxBlur( + gfxContext* aDestinationCtx, Rect aDestinationRect, Rect aShadowClipRect, + sRGBColor& aShadowColor, nscoord aBlurRadiusAppUnits, + nscoord aSpreadDistanceAppUnits, int32_t aAppUnitsPerDevPixel, + bool aHasBorderRadius, RectCornerRadii& aInnerClipRectRadii, Rect aSkipRect, + Point aShadowOffset) { + if (aDestinationRect.IsEmpty()) { + mContext = nullptr; + return false; + } + + gfxContextAutoSaveRestore autoRestore(aDestinationCtx); + + IntSize blurRadius; + IntSize spreadRadius; + // Convert the blur and spread radius to device pixels + bool constrainSpreadRadius = false; + GetBlurAndSpreadRadius(aDestinationCtx->GetDrawTarget(), aAppUnitsPerDevPixel, + aBlurRadiusAppUnits, aSpreadDistanceAppUnits, + blurRadius, spreadRadius, constrainSpreadRadius); + + // The blur and spread radius are scaled already, so scale all + // input data to the blur. This way, we don't have to scale the min + // inset blur to the invert of the dest context, then rescale it back + // when we draw to the destination surface. + auto scale = aDestinationCtx->CurrentMatrix().ScaleFactors(); + Matrix transform = aDestinationCtx->CurrentMatrix(); + + // XXX: we could probably handle negative scales but for now it's easier just + // to fallback + if (!transform.HasNonAxisAlignedTransform() && transform._11 > 0.0 && + transform._22 > 0.0) { + // If we don't have a rotation, we're pre-transforming all the rects. + aDestinationCtx->SetMatrix(Matrix()); + } else { + // Don't touch anything, we have a rotation. + transform = Matrix(); + } + + Rect transformedDestRect = transform.TransformBounds(aDestinationRect); + Rect transformedShadowClipRect = transform.TransformBounds(aShadowClipRect); + Rect transformedSkipRect = transform.TransformBounds(aSkipRect); + + transformedDestRect.Round(); + transformedShadowClipRect.Round(); + transformedSkipRect.RoundIn(); + + for (size_t i = 0; i < 4; i++) { + aInnerClipRectRadii[i].width = + std::floor(scale.xScale * aInnerClipRectRadii[i].width); + aInnerClipRectRadii[i].height = + std::floor(scale.yScale * aInnerClipRectRadii[i].height); + } + + mAlphaBoxBlur.BlurInsetBox(aDestinationCtx, transformedDestRect, + transformedShadowClipRect, blurRadius, + aShadowColor, + aHasBorderRadius ? &aInnerClipRectRadii : nullptr, + transformedSkipRect, aShadowOffset); + return true; +} |