summaryrefslogtreecommitdiffstats
path: root/layout/base/nsLayoutUtils.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/base/nsLayoutUtils.cpp')
-rw-r--r--layout/base/nsLayoutUtils.cpp9186
1 files changed, 9186 insertions, 0 deletions
diff --git a/layout/base/nsLayoutUtils.cpp b/layout/base/nsLayoutUtils.cpp
new file mode 100644
index 000000000..ed34f39ce
--- /dev/null
+++ b/layout/base/nsLayoutUtils.cpp
@@ -0,0 +1,9186 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sw=2 et tw=78: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsLayoutUtils.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/BasicEvents.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/EffectCompositor.h"
+#include "mozilla/EffectSet.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/PathHelpers.h"
+#include "mozilla/layers/PAPZ.h"
+#include "mozilla/Likely.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/Unused.h"
+#include "nsCharTraits.h"
+#include "nsFontMetrics.h"
+#include "nsPresContext.h"
+#include "nsIContent.h"
+#include "nsIDOMHTMLDocument.h"
+#include "nsIDOMHTMLElement.h"
+#include "nsFrameList.h"
+#include "nsGkAtoms.h"
+#include "nsHtml5Atoms.h"
+#include "nsIAtom.h"
+#include "nsCaret.h"
+#include "nsCSSPseudoElements.h"
+#include "nsCSSAnonBoxes.h"
+#include "nsCSSColorUtils.h"
+#include "nsView.h"
+#include "nsViewManager.h"
+#include "nsPlaceholderFrame.h"
+#include "nsIScrollableFrame.h"
+#include "nsIDOMEvent.h"
+#include "nsDisplayList.h"
+#include "nsRegion.h"
+#include "nsFrameManager.h"
+#include "nsBlockFrame.h"
+#include "nsBidiPresUtils.h"
+#include "imgIContainer.h"
+#include "ImageOps.h"
+#include "ImageRegion.h"
+#include "gfxRect.h"
+#include "gfxContext.h"
+#include "nsRenderingContext.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsCSSRendering.h"
+#include "nsTextFragment.h"
+#include "nsThemeConstants.h"
+#include "nsPIDOMWindow.h"
+#include "nsIDocShell.h"
+#include "nsIWidget.h"
+#include "gfxMatrix.h"
+#include "gfxPrefs.h"
+#include "gfxTypes.h"
+#include "nsTArray.h"
+#include "mozilla/dom/HTMLCanvasElement.h"
+#include "nsICanvasRenderingContextInternal.h"
+#include "gfxPlatform.h"
+#include <algorithm>
+#include <limits>
+#include "mozilla/dom/HTMLVideoElement.h"
+#include "mozilla/dom/HTMLImageElement.h"
+#include "mozilla/dom/DOMRect.h"
+#include "mozilla/dom/DOMStringList.h"
+#include "mozilla/dom/KeyframeEffectReadOnly.h"
+#include "mozilla/layers/APZCCallbackHelper.h"
+#include "imgIRequest.h"
+#include "nsIImageLoadingContent.h"
+#include "nsCOMPtr.h"
+#include "nsCSSProps.h"
+#include "nsListControlFrame.h"
+#include "mozilla/dom/Element.h"
+#include "nsCanvasFrame.h"
+#include "gfxDrawable.h"
+#include "gfxEnv.h"
+#include "gfxUtils.h"
+#include "nsDataHashtable.h"
+#include "nsTableWrapperFrame.h"
+#include "nsTextFrame.h"
+#include "nsFontFaceList.h"
+#include "nsFontInflationData.h"
+#include "nsSVGUtils.h"
+#include "SVGImageContext.h"
+#include "SVGTextFrame.h"
+#include "nsStyleStructInlines.h"
+#include "nsStyleTransformMatrix.h"
+#include "nsIFrameInlines.h"
+#include "ImageContainer.h"
+#include "nsComputedDOMStyle.h"
+#include "ActiveLayerTracker.h"
+#include "mozilla/gfx/2D.h"
+#include "gfx2DGlue.h"
+#include "mozilla/LookAndFeel.h"
+#include "UnitTransforms.h"
+#include "TiledLayerBuffer.h" // For TILEDLAYERBUFFER_TILE_SIZE
+#include "ClientLayerManager.h"
+#include "nsRefreshDriver.h"
+#include "nsIContentViewer.h"
+#include "LayersLogging.h"
+#include "mozilla/Preferences.h"
+#include "nsFrameSelection.h"
+#include "FrameLayerBuilder.h"
+#include "mozilla/layers/APZCTreeManager.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/RuleNodeCacheConditions.h"
+#include "mozilla/StyleSetHandle.h"
+#include "mozilla/StyleSetHandleInlines.h"
+#include "RegionBuilder.h"
+
+#ifdef MOZ_XUL
+#include "nsXULPopupManager.h"
+#endif
+
+#include "GeckoProfiler.h"
+#include "nsAnimationManager.h"
+#include "nsTransitionManager.h"
+#include "mozilla/RestyleManagerHandle.h"
+#include "mozilla/RestyleManagerHandleInlines.h"
+#include "LayoutLogging.h"
+
+// Make sure getpid() works.
+#ifdef XP_WIN
+#include <process.h>
+#define getpid _getpid
+#else
+#include <unistd.h>
+#endif
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::image;
+using namespace mozilla::layers;
+using namespace mozilla::layout;
+using namespace mozilla::gfx;
+
+#define GRID_ENABLED_PREF_NAME "layout.css.grid.enabled"
+#define GRID_TEMPLATE_SUBGRID_ENABLED_PREF_NAME "layout.css.grid-template-subgrid-value.enabled"
+#define WEBKIT_PREFIXES_ENABLED_PREF_NAME "layout.css.prefixes.webkit"
+#define DISPLAY_CONTENTS_ENABLED_PREF_NAME "layout.css.display-contents.enabled"
+#define TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME "layout.css.text-align-unsafe-value.enabled"
+#define FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME "layout.css.float-logical-values.enabled"
+#define BG_CLIP_TEXT_ENABLED_PREF_NAME "layout.css.background-clip-text.enabled"
+
+// The time in number of frames that we estimate for a refresh driver
+// to be quiescent
+#define DEFAULT_QUIESCENT_FRAMES 2
+// The time (milliseconds) we estimate is needed between the end of an
+// idle time and the next Tick.
+#define DEFAULT_IDLE_PERIOD_TIME_LIMIT 1.0f
+
+#ifdef DEBUG
+// TODO: remove, see bug 598468.
+bool nsLayoutUtils::gPreventAssertInCompareTreePosition = false;
+#endif // DEBUG
+
+typedef FrameMetrics::ViewID ViewID;
+typedef nsStyleTransformMatrix::TransformReferenceBox TransformReferenceBox;
+
+/* static */ uint32_t nsLayoutUtils::sFontSizeInflationEmPerLine;
+/* static */ uint32_t nsLayoutUtils::sFontSizeInflationMinTwips;
+/* static */ uint32_t nsLayoutUtils::sFontSizeInflationLineThreshold;
+/* static */ int32_t nsLayoutUtils::sFontSizeInflationMappingIntercept;
+/* static */ uint32_t nsLayoutUtils::sFontSizeInflationMaxRatio;
+/* static */ bool nsLayoutUtils::sFontSizeInflationForceEnabled;
+/* static */ bool nsLayoutUtils::sFontSizeInflationDisabledInMasterProcess;
+/* static */ bool nsLayoutUtils::sInvalidationDebuggingIsEnabled;
+/* static */ bool nsLayoutUtils::sCSSVariablesEnabled;
+/* static */ bool nsLayoutUtils::sInterruptibleReflowEnabled;
+/* static */ bool nsLayoutUtils::sSVGTransformBoxEnabled;
+/* static */ bool nsLayoutUtils::sTextCombineUprightDigitsEnabled;
+#ifdef MOZ_STYLO
+/* static */ bool nsLayoutUtils::sStyloEnabled;
+#endif
+/* static */ uint32_t nsLayoutUtils::sIdlePeriodDeadlineLimit;
+/* static */ uint32_t nsLayoutUtils::sQuiescentFramesBeforeIdlePeriod;
+
+static ViewID sScrollIdCounter = FrameMetrics::START_SCROLL_ID;
+
+typedef nsDataHashtable<nsUint64HashKey, nsIContent*> ContentMap;
+static ContentMap* sContentMap = nullptr;
+static ContentMap& GetContentMap() {
+ if (!sContentMap) {
+ sContentMap = new ContentMap();
+ }
+ return *sContentMap;
+}
+
+// When the pref "layout.css.grid.enabled" changes, this function is invoked
+// to let us update kDisplayKTable, to selectively disable or restore the
+// entries for "grid" and "inline-grid" in that table.
+static void
+GridEnabledPrefChangeCallback(const char* aPrefName, void* aClosure)
+{
+ MOZ_ASSERT(strncmp(aPrefName, GRID_ENABLED_PREF_NAME,
+ ArrayLength(GRID_ENABLED_PREF_NAME)) == 0,
+ "We only registered this callback for a single pref, so it "
+ "should only be called for that pref");
+
+ static int32_t sIndexOfGridInDisplayTable;
+ static int32_t sIndexOfInlineGridInDisplayTable;
+ static bool sAreGridKeywordIndicesInitialized; // initialized to false
+
+ bool isGridEnabled =
+ Preferences::GetBool(GRID_ENABLED_PREF_NAME, false);
+ if (!sAreGridKeywordIndicesInitialized) {
+ // First run: find the position of "grid" and "inline-grid" in
+ // kDisplayKTable.
+ sIndexOfGridInDisplayTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_grid,
+ nsCSSProps::kDisplayKTable);
+ MOZ_ASSERT(sIndexOfGridInDisplayTable >= 0,
+ "Couldn't find grid in kDisplayKTable");
+ sIndexOfInlineGridInDisplayTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_grid,
+ nsCSSProps::kDisplayKTable);
+ MOZ_ASSERT(sIndexOfInlineGridInDisplayTable >= 0,
+ "Couldn't find inline-grid in kDisplayKTable");
+ sAreGridKeywordIndicesInitialized = true;
+ }
+
+ // OK -- now, stomp on or restore the "grid" entries in kDisplayKTable,
+ // depending on whether the grid pref is enabled vs. disabled.
+ if (sIndexOfGridInDisplayTable >= 0) {
+ nsCSSProps::kDisplayKTable[sIndexOfGridInDisplayTable].mKeyword =
+ isGridEnabled ? eCSSKeyword_grid : eCSSKeyword_UNKNOWN;
+ }
+ if (sIndexOfInlineGridInDisplayTable >= 0) {
+ nsCSSProps::kDisplayKTable[sIndexOfInlineGridInDisplayTable].mKeyword =
+ isGridEnabled ? eCSSKeyword_inline_grid : eCSSKeyword_UNKNOWN;
+ }
+}
+
+// When the pref "layout.css.prefixes.webkit" changes, this function is invoked
+// to let us update kDisplayKTable, to selectively disable or restore the
+// entries for "-webkit-box" and "-webkit-inline-box" in that table.
+static void
+WebkitPrefixEnabledPrefChangeCallback(const char* aPrefName, void* aClosure)
+{
+ MOZ_ASSERT(strncmp(aPrefName, WEBKIT_PREFIXES_ENABLED_PREF_NAME,
+ ArrayLength(WEBKIT_PREFIXES_ENABLED_PREF_NAME)) == 0,
+ "We only registered this callback for a single pref, so it "
+ "should only be called for that pref");
+
+ static int32_t sIndexOfWebkitBoxInDisplayTable;
+ static int32_t sIndexOfWebkitInlineBoxInDisplayTable;
+ static int32_t sIndexOfWebkitFlexInDisplayTable;
+ static int32_t sIndexOfWebkitInlineFlexInDisplayTable;
+
+ static bool sAreKeywordIndicesInitialized; // initialized to false
+
+ bool isWebkitPrefixSupportEnabled =
+ Preferences::GetBool(WEBKIT_PREFIXES_ENABLED_PREF_NAME, false);
+ if (!sAreKeywordIndicesInitialized) {
+ // First run: find the position of the keywords in kDisplayKTable.
+ sIndexOfWebkitBoxInDisplayTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword__webkit_box,
+ nsCSSProps::kDisplayKTable);
+ MOZ_ASSERT(sIndexOfWebkitBoxInDisplayTable >= 0,
+ "Couldn't find -webkit-box in kDisplayKTable");
+ sIndexOfWebkitInlineBoxInDisplayTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword__webkit_inline_box,
+ nsCSSProps::kDisplayKTable);
+ MOZ_ASSERT(sIndexOfWebkitInlineBoxInDisplayTable >= 0,
+ "Couldn't find -webkit-inline-box in kDisplayKTable");
+
+ sIndexOfWebkitFlexInDisplayTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword__webkit_flex,
+ nsCSSProps::kDisplayKTable);
+ MOZ_ASSERT(sIndexOfWebkitFlexInDisplayTable >= 0,
+ "Couldn't find -webkit-flex in kDisplayKTable");
+ sIndexOfWebkitInlineFlexInDisplayTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword__webkit_inline_flex,
+ nsCSSProps::kDisplayKTable);
+ MOZ_ASSERT(sIndexOfWebkitInlineFlexInDisplayTable >= 0,
+ "Couldn't find -webkit-inline-flex in kDisplayKTable");
+ sAreKeywordIndicesInitialized = true;
+ }
+
+ // OK -- now, stomp on or restore the "-webkit-{box|flex}" entries in
+ // kDisplayKTable, depending on whether the webkit prefix pref is enabled
+ // vs. disabled.
+ if (sIndexOfWebkitBoxInDisplayTable >= 0) {
+ nsCSSProps::kDisplayKTable[sIndexOfWebkitBoxInDisplayTable].mKeyword =
+ isWebkitPrefixSupportEnabled ?
+ eCSSKeyword__webkit_box : eCSSKeyword_UNKNOWN;
+ }
+ if (sIndexOfWebkitInlineBoxInDisplayTable >= 0) {
+ nsCSSProps::kDisplayKTable[sIndexOfWebkitInlineBoxInDisplayTable].mKeyword =
+ isWebkitPrefixSupportEnabled ?
+ eCSSKeyword__webkit_inline_box : eCSSKeyword_UNKNOWN;
+ }
+ if (sIndexOfWebkitFlexInDisplayTable >= 0) {
+ nsCSSProps::kDisplayKTable[sIndexOfWebkitFlexInDisplayTable].mKeyword =
+ isWebkitPrefixSupportEnabled ?
+ eCSSKeyword__webkit_flex : eCSSKeyword_UNKNOWN;
+ }
+ if (sIndexOfWebkitInlineFlexInDisplayTable >= 0) {
+ nsCSSProps::kDisplayKTable[sIndexOfWebkitInlineFlexInDisplayTable].mKeyword =
+ isWebkitPrefixSupportEnabled ?
+ eCSSKeyword__webkit_inline_flex : eCSSKeyword_UNKNOWN;
+ }
+}
+
+// When the pref "layout.css.display-contents.enabled" changes, this function is
+// invoked to let us update kDisplayKTable, to selectively disable or restore
+// the entries for "contents" in that table.
+static void
+DisplayContentsEnabledPrefChangeCallback(const char* aPrefName, void* aClosure)
+{
+ NS_ASSERTION(strcmp(aPrefName, DISPLAY_CONTENTS_ENABLED_PREF_NAME) == 0,
+ "Did you misspell " DISPLAY_CONTENTS_ENABLED_PREF_NAME " ?");
+
+ static bool sIsDisplayContentsKeywordIndexInitialized;
+ static int32_t sIndexOfContentsInDisplayTable;
+ bool isDisplayContentsEnabled =
+ Preferences::GetBool(DISPLAY_CONTENTS_ENABLED_PREF_NAME, false);
+
+ if (!sIsDisplayContentsKeywordIndexInitialized) {
+ // First run: find the position of "contents" in kDisplayKTable.
+ sIndexOfContentsInDisplayTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_contents,
+ nsCSSProps::kDisplayKTable);
+ sIsDisplayContentsKeywordIndexInitialized = true;
+ }
+
+ // OK -- now, stomp on or restore the "contents" entry in kDisplayKTable,
+ // depending on whether the pref is enabled vs. disabled.
+ if (sIndexOfContentsInDisplayTable >= 0) {
+ nsCSSProps::kDisplayKTable[sIndexOfContentsInDisplayTable].mKeyword =
+ isDisplayContentsEnabled ? eCSSKeyword_contents : eCSSKeyword_UNKNOWN;
+ }
+}
+
+// When the pref "layout.css.text-align-unsafe-value.enabled" changes, this
+// function is called to let us update kTextAlignKTable & kTextAlignLastKTable,
+// to selectively disable or restore the entries for "unsafe" in those tables.
+static void
+TextAlignUnsafeEnabledPrefChangeCallback(const char* aPrefName, void* aClosure)
+{
+ NS_ASSERTION(strcmp(aPrefName, TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME) == 0,
+ "Did you misspell " TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME " ?");
+
+ static bool sIsInitialized;
+ static int32_t sIndexOfUnsafeInTextAlignTable;
+ static int32_t sIndexOfUnsafeInTextAlignLastTable;
+ bool isTextAlignUnsafeEnabled =
+ Preferences::GetBool(TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME, false);
+
+ if (!sIsInitialized) {
+ // First run: find the position of "unsafe" in kTextAlignKTable.
+ sIndexOfUnsafeInTextAlignTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_unsafe,
+ nsCSSProps::kTextAlignKTable);
+ // First run: find the position of "unsafe" in kTextAlignLastKTable.
+ sIndexOfUnsafeInTextAlignLastTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_unsafe,
+ nsCSSProps::kTextAlignLastKTable);
+ sIsInitialized = true;
+ }
+
+ // OK -- now, stomp on or restore the "unsafe" entry in the keyword tables,
+ // depending on whether the pref is enabled vs. disabled.
+ MOZ_ASSERT(sIndexOfUnsafeInTextAlignTable >= 0);
+ nsCSSProps::kTextAlignKTable[sIndexOfUnsafeInTextAlignTable].mKeyword =
+ isTextAlignUnsafeEnabled ? eCSSKeyword_unsafe : eCSSKeyword_UNKNOWN;
+ MOZ_ASSERT(sIndexOfUnsafeInTextAlignLastTable >= 0);
+ nsCSSProps::kTextAlignLastKTable[sIndexOfUnsafeInTextAlignLastTable].mKeyword =
+ isTextAlignUnsafeEnabled ? eCSSKeyword_unsafe : eCSSKeyword_UNKNOWN;
+}
+
+// When the pref "layout.css.float-logical-values.enabled" changes, this
+// function is called to let us update kFloatKTable & kClearKTable,
+// to selectively disable or restore the entries for logical values
+// (inline-start and inline-end) in those tables.
+static void
+FloatLogicalValuesEnabledPrefChangeCallback(const char* aPrefName,
+ void* aClosure)
+{
+ NS_ASSERTION(strcmp(aPrefName, FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME) == 0,
+ "Did you misspell " FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME " ?");
+
+ static bool sIsInitialized;
+ static int32_t sIndexOfInlineStartInFloatTable;
+ static int32_t sIndexOfInlineEndInFloatTable;
+ static int32_t sIndexOfInlineStartInClearTable;
+ static int32_t sIndexOfInlineEndInClearTable;
+ bool isFloatLogicalValuesEnabled =
+ Preferences::GetBool(FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME, false);
+
+ if (!sIsInitialized) {
+ // First run: find the position of "inline-start" in kFloatKTable.
+ sIndexOfInlineStartInFloatTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_start,
+ nsCSSProps::kFloatKTable);
+ // First run: find the position of "inline-end" in kFloatKTable.
+ sIndexOfInlineEndInFloatTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_end,
+ nsCSSProps::kFloatKTable);
+ // First run: find the position of "inline-start" in kClearKTable.
+ sIndexOfInlineStartInClearTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_start,
+ nsCSSProps::kClearKTable);
+ // First run: find the position of "inline-end" in kClearKTable.
+ sIndexOfInlineEndInClearTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_inline_end,
+ nsCSSProps::kClearKTable);
+ sIsInitialized = true;
+ }
+
+ // OK -- now, stomp on or restore the logical entries in the keyword tables,
+ // depending on whether the pref is enabled vs. disabled.
+ MOZ_ASSERT(sIndexOfInlineStartInFloatTable >= 0);
+ nsCSSProps::kFloatKTable[sIndexOfInlineStartInFloatTable].mKeyword =
+ isFloatLogicalValuesEnabled ? eCSSKeyword_inline_start : eCSSKeyword_UNKNOWN;
+ MOZ_ASSERT(sIndexOfInlineEndInFloatTable >= 0);
+ nsCSSProps::kFloatKTable[sIndexOfInlineEndInFloatTable].mKeyword =
+ isFloatLogicalValuesEnabled ? eCSSKeyword_inline_end : eCSSKeyword_UNKNOWN;
+ MOZ_ASSERT(sIndexOfInlineStartInClearTable >= 0);
+ nsCSSProps::kClearKTable[sIndexOfInlineStartInClearTable].mKeyword =
+ isFloatLogicalValuesEnabled ? eCSSKeyword_inline_start : eCSSKeyword_UNKNOWN;
+ MOZ_ASSERT(sIndexOfInlineEndInClearTable >= 0);
+ nsCSSProps::kClearKTable[sIndexOfInlineEndInClearTable].mKeyword =
+ isFloatLogicalValuesEnabled ? eCSSKeyword_inline_end : eCSSKeyword_UNKNOWN;
+}
+
+
+// When the pref "layout.css.background-clip-text.enabled" changes, this
+// function is invoked to let us update kBackgroundClipKTable, to selectively
+// disable or restore the entries for "text" in that table.
+static void
+BackgroundClipTextEnabledPrefChangeCallback(const char* aPrefName,
+ void* aClosure)
+{
+ NS_ASSERTION(strcmp(aPrefName, BG_CLIP_TEXT_ENABLED_PREF_NAME) == 0,
+ "Did you misspell " BG_CLIP_TEXT_ENABLED_PREF_NAME " ?");
+
+ static bool sIsBGClipKeywordIndexInitialized;
+ static int32_t sIndexOfTextInBGClipTable;
+ bool isBGClipTextEnabled =
+ Preferences::GetBool(BG_CLIP_TEXT_ENABLED_PREF_NAME, false);
+
+ if (!sIsBGClipKeywordIndexInitialized) {
+ // First run: find the position of "text" in kBackgroundClipKTable.
+ sIndexOfTextInBGClipTable =
+ nsCSSProps::FindIndexOfKeyword(eCSSKeyword_text,
+ nsCSSProps::kBackgroundClipKTable);
+
+ sIsBGClipKeywordIndexInitialized = true;
+ }
+
+ // OK -- now, stomp on or restore the "text" entry in kBackgroundClipKTable,
+ // depending on whether the pref is enabled vs. disabled.
+ if (sIndexOfTextInBGClipTable >= 0) {
+ nsCSSProps::kBackgroundClipKTable[sIndexOfTextInBGClipTable].mKeyword =
+ isBGClipTextEnabled ? eCSSKeyword_text : eCSSKeyword_UNKNOWN;
+ }
+}
+
+template<typename TestType>
+static bool
+HasMatchingAnimations(const nsIFrame* aFrame, TestType&& aTest)
+{
+ EffectSet* effects = EffectSet::GetEffectSet(aFrame);
+ if (!effects) {
+ return false;
+ }
+
+ for (KeyframeEffectReadOnly* effect : *effects) {
+ if (aTest(*effect)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool
+nsLayoutUtils::HasCurrentTransitions(const nsIFrame* aFrame)
+{
+ return HasMatchingAnimations(aFrame,
+ [](KeyframeEffectReadOnly& aEffect)
+ {
+ // Since |aEffect| is current, it must have an associated Animation
+ // so we don't need to null-check the result of GetAnimation().
+ return aEffect.IsCurrent() && aEffect.GetAnimation()->AsCSSTransition();
+ }
+ );
+}
+
+bool
+nsLayoutUtils::HasAnimationOfProperty(const nsIFrame* aFrame,
+ nsCSSPropertyID aProperty)
+{
+ return HasMatchingAnimations(aFrame,
+ [&aProperty](KeyframeEffectReadOnly& aEffect)
+ {
+ return (aEffect.IsInEffect() || aEffect.IsCurrent()) &&
+ aEffect.HasAnimationOfProperty(aProperty);
+ }
+ );
+}
+
+bool
+nsLayoutUtils::HasEffectiveAnimation(const nsIFrame* aFrame,
+ nsCSSPropertyID aProperty)
+{
+ return HasMatchingAnimations(aFrame,
+ [&aProperty](KeyframeEffectReadOnly& aEffect)
+ {
+ return (aEffect.IsInEffect() || aEffect.IsCurrent()) &&
+ aEffect.HasEffectiveAnimationOfProperty(aProperty);
+ }
+ );
+}
+
+static float
+GetSuitableScale(float aMaxScale, float aMinScale,
+ nscoord aVisibleDimension, nscoord aDisplayDimension)
+{
+ float displayVisibleRatio = float(aDisplayDimension) /
+ float(aVisibleDimension);
+ // We want to rasterize based on the largest scale used during the
+ // transform animation, unless that would make us rasterize something
+ // larger than the screen. But we never want to go smaller than the
+ // minimum scale over the animation.
+ if (FuzzyEqualsMultiplicative(displayVisibleRatio, aMaxScale, .01f)) {
+ // Using aMaxScale may make us rasterize something a fraction larger than
+ // the screen. However, if aMaxScale happens to be the final scale of a
+ // transform animation it is better to use aMaxScale so that for the
+ // fraction of a second before we delayerize the composited texture it has
+ // a better chance of being pixel aligned and composited without resampling
+ // (avoiding visually clunky delayerization).
+ return aMaxScale;
+ }
+ return std::max(std::min(aMaxScale, displayVisibleRatio), aMinScale);
+}
+
+static void
+GetMinAndMaxScaleForAnimationProperty(const nsIFrame* aFrame,
+ nsTArray<RefPtr<dom::Animation>>&
+ aAnimations,
+ gfxSize& aMaxScale,
+ gfxSize& aMinScale)
+{
+ for (dom::Animation* anim : aAnimations) {
+ // This method is only expected to be passed animations that are running on
+ // the compositor and we only pass playing animations to the compositor,
+ // which are, by definition, "relevant" animations (animations that are
+ // not yet finished or which are filling forwards).
+ MOZ_ASSERT(anim->IsRelevant());
+
+ dom::KeyframeEffectReadOnly* effect =
+ anim->GetEffect() ? anim->GetEffect()->AsKeyframeEffect() : nullptr;
+ MOZ_ASSERT(effect, "A playing animation should have a keyframe effect");
+ for (size_t propIdx = effect->Properties().Length(); propIdx-- != 0; ) {
+ const AnimationProperty& prop = effect->Properties()[propIdx];
+ if (prop.mProperty == eCSSProperty_transform) {
+ for (uint32_t segIdx = prop.mSegments.Length(); segIdx-- != 0; ) {
+ const AnimationPropertySegment& segment = prop.mSegments[segIdx];
+ gfxSize from = segment.mFromValue.GetScaleValue(aFrame);
+ aMaxScale.width = std::max<float>(aMaxScale.width, from.width);
+ aMaxScale.height = std::max<float>(aMaxScale.height, from.height);
+ aMinScale.width = std::min<float>(aMinScale.width, from.width);
+ aMinScale.height = std::min<float>(aMinScale.height, from.height);
+ gfxSize to = segment.mToValue.GetScaleValue(aFrame);
+ aMaxScale.width = std::max<float>(aMaxScale.width, to.width);
+ aMaxScale.height = std::max<float>(aMaxScale.height, to.height);
+ aMinScale.width = std::min<float>(aMinScale.width, to.width);
+ aMinScale.height = std::min<float>(aMinScale.height, to.height);
+ }
+ }
+ }
+ }
+}
+
+gfxSize
+nsLayoutUtils::ComputeSuitableScaleForAnimation(const nsIFrame* aFrame,
+ const nsSize& aVisibleSize,
+ const nsSize& aDisplaySize)
+{
+ gfxSize maxScale(std::numeric_limits<gfxFloat>::min(),
+ std::numeric_limits<gfxFloat>::min());
+ gfxSize minScale(std::numeric_limits<gfxFloat>::max(),
+ std::numeric_limits<gfxFloat>::max());
+
+ nsTArray<RefPtr<dom::Animation>> compositorAnimations =
+ EffectCompositor::GetAnimationsForCompositor(aFrame,
+ eCSSProperty_transform);
+ GetMinAndMaxScaleForAnimationProperty(aFrame, compositorAnimations,
+ maxScale, minScale);
+
+ if (maxScale.width == std::numeric_limits<gfxFloat>::min()) {
+ // We didn't encounter a transform
+ return gfxSize(1.0, 1.0);
+ }
+
+ return gfxSize(GetSuitableScale(maxScale.width, minScale.width,
+ aVisibleSize.width, aDisplaySize.width),
+ GetSuitableScale(maxScale.height, minScale.height,
+ aVisibleSize.height, aDisplaySize.height));
+}
+
+bool
+nsLayoutUtils::AreAsyncAnimationsEnabled()
+{
+ static bool sAreAsyncAnimationsEnabled;
+ static bool sAsyncPrefCached = false;
+
+ if (!sAsyncPrefCached) {
+ sAsyncPrefCached = true;
+ Preferences::AddBoolVarCache(&sAreAsyncAnimationsEnabled,
+ "layers.offmainthreadcomposition.async-animations");
+ }
+
+ return sAreAsyncAnimationsEnabled &&
+ gfxPlatform::OffMainThreadCompositingEnabled();
+}
+
+bool
+nsLayoutUtils::IsAnimationLoggingEnabled()
+{
+ static bool sShouldLog;
+ static bool sShouldLogPrefCached;
+
+ if (!sShouldLogPrefCached) {
+ sShouldLogPrefCached = true;
+ Preferences::AddBoolVarCache(&sShouldLog,
+ "layers.offmainthreadcomposition.log-animations");
+ }
+
+ return sShouldLog;
+}
+
+bool
+nsLayoutUtils::GPUImageScalingEnabled()
+{
+ static bool sGPUImageScalingEnabled;
+ static bool sGPUImageScalingPrefInitialised = false;
+
+ if (!sGPUImageScalingPrefInitialised) {
+ sGPUImageScalingPrefInitialised = true;
+ sGPUImageScalingEnabled =
+ Preferences::GetBool("layout.gpu-image-scaling.enabled", false);
+ }
+
+ return sGPUImageScalingEnabled;
+}
+
+bool
+nsLayoutUtils::AnimatedImageLayersEnabled()
+{
+ static bool sAnimatedImageLayersEnabled;
+ static bool sAnimatedImageLayersPrefCached = false;
+
+ if (!sAnimatedImageLayersPrefCached) {
+ sAnimatedImageLayersPrefCached = true;
+ Preferences::AddBoolVarCache(&sAnimatedImageLayersEnabled,
+ "layout.animated-image-layers.enabled",
+ false);
+ }
+
+ return sAnimatedImageLayersEnabled;
+}
+
+bool
+nsLayoutUtils::CSSFiltersEnabled()
+{
+ static bool sCSSFiltersEnabled;
+ static bool sCSSFiltersPrefCached = false;
+
+ if (!sCSSFiltersPrefCached) {
+ sCSSFiltersPrefCached = true;
+ Preferences::AddBoolVarCache(&sCSSFiltersEnabled,
+ "layout.css.filters.enabled",
+ false);
+ }
+
+ return sCSSFiltersEnabled;
+}
+
+bool
+nsLayoutUtils::CSSClipPathShapesEnabled()
+{
+ static bool sCSSClipPathShapesEnabled;
+ static bool sCSSClipPathShapesPrefCached = false;
+
+ if (!sCSSClipPathShapesPrefCached) {
+ sCSSClipPathShapesPrefCached = true;
+ Preferences::AddBoolVarCache(&sCSSClipPathShapesEnabled,
+ "layout.css.clip-path-shapes.enabled",
+ false);
+ }
+
+ return sCSSClipPathShapesEnabled;
+}
+
+bool
+nsLayoutUtils::UnsetValueEnabled()
+{
+ static bool sUnsetValueEnabled;
+ static bool sUnsetValuePrefCached = false;
+
+ if (!sUnsetValuePrefCached) {
+ sUnsetValuePrefCached = true;
+ Preferences::AddBoolVarCache(&sUnsetValueEnabled,
+ "layout.css.unset-value.enabled",
+ false);
+ }
+
+ return sUnsetValueEnabled;
+}
+
+bool
+nsLayoutUtils::IsGridTemplateSubgridValueEnabled()
+{
+ static bool sGridTemplateSubgridValueEnabled;
+ static bool sGridTemplateSubgridValueEnabledPrefCached = false;
+
+ if (!sGridTemplateSubgridValueEnabledPrefCached) {
+ sGridTemplateSubgridValueEnabledPrefCached = true;
+ Preferences::AddBoolVarCache(&sGridTemplateSubgridValueEnabled,
+ GRID_TEMPLATE_SUBGRID_ENABLED_PREF_NAME,
+ false);
+ }
+
+ return sGridTemplateSubgridValueEnabled;
+}
+
+bool
+nsLayoutUtils::IsTextAlignUnsafeValueEnabled()
+{
+ static bool sTextAlignUnsafeValueEnabled;
+ static bool sTextAlignUnsafeValueEnabledPrefCached = false;
+
+ if (!sTextAlignUnsafeValueEnabledPrefCached) {
+ sTextAlignUnsafeValueEnabledPrefCached = true;
+ Preferences::AddBoolVarCache(&sTextAlignUnsafeValueEnabled,
+ TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME,
+ false);
+ }
+
+ return sTextAlignUnsafeValueEnabled;
+}
+
+void
+nsLayoutUtils::UnionChildOverflow(nsIFrame* aFrame,
+ nsOverflowAreas& aOverflowAreas,
+ FrameChildListIDs aSkipChildLists)
+{
+ // Iterate over all children except pop-ups.
+ FrameChildListIDs skip = aSkipChildLists |
+ nsIFrame::kSelectPopupList | nsIFrame::kPopupList;
+ for (nsIFrame::ChildListIterator childLists(aFrame);
+ !childLists.IsDone(); childLists.Next()) {
+ if (skip.Contains(childLists.CurrentID())) {
+ continue;
+ }
+
+ nsFrameList children = childLists.CurrentList();
+ for (nsFrameList::Enumerator e(children); !e.AtEnd(); e.Next()) {
+ nsIFrame* child = e.get();
+ nsOverflowAreas childOverflow =
+ child->GetOverflowAreas() + child->GetPosition();
+ aOverflowAreas.UnionWith(childOverflow);
+ }
+ }
+}
+
+static void DestroyViewID(void* aObject, nsIAtom* aPropertyName,
+ void* aPropertyValue, void* aData)
+{
+ ViewID* id = static_cast<ViewID*>(aPropertyValue);
+ GetContentMap().Remove(*id);
+ delete id;
+}
+
+/**
+ * A namespace class for static layout utilities.
+ */
+
+bool
+nsLayoutUtils::FindIDFor(const nsIContent* aContent, ViewID* aOutViewId)
+{
+ void* scrollIdProperty = aContent->GetProperty(nsGkAtoms::RemoteId);
+ if (scrollIdProperty) {
+ *aOutViewId = *static_cast<ViewID*>(scrollIdProperty);
+ return true;
+ }
+ return false;
+}
+
+ViewID
+nsLayoutUtils::FindOrCreateIDFor(nsIContent* aContent)
+{
+ ViewID scrollId;
+
+ if (!FindIDFor(aContent, &scrollId)) {
+ scrollId = sScrollIdCounter++;
+ aContent->SetProperty(nsGkAtoms::RemoteId, new ViewID(scrollId),
+ DestroyViewID);
+ GetContentMap().Put(scrollId, aContent);
+ }
+
+ return scrollId;
+}
+
+nsIContent*
+nsLayoutUtils::FindContentFor(ViewID aId)
+{
+ MOZ_ASSERT(aId != FrameMetrics::NULL_SCROLL_ID,
+ "Cannot find a content element in map for null IDs.");
+ nsIContent* content;
+ bool exists = GetContentMap().Get(aId, &content);
+
+ if (exists) {
+ return content;
+ } else {
+ return nullptr;
+ }
+}
+
+nsIFrame*
+GetScrollFrameFromContent(nsIContent* aContent)
+{
+ nsIFrame* frame = aContent->GetPrimaryFrame();
+ if (aContent->OwnerDoc()->GetRootElement() == aContent) {
+ nsIPresShell* presShell = frame ? frame->PresContext()->PresShell() : nullptr;
+ if (!presShell) {
+ presShell = aContent->OwnerDoc()->GetShell();
+ }
+ // We want the scroll frame, the root scroll frame differs from all
+ // others in that the primary frame is not the scroll frame.
+ nsIFrame* rootScrollFrame = presShell ? presShell->GetRootScrollFrame() : nullptr;
+ if (rootScrollFrame) {
+ frame = rootScrollFrame;
+ }
+ }
+ return frame;
+}
+
+nsIScrollableFrame*
+nsLayoutUtils::FindScrollableFrameFor(ViewID aId)
+{
+ nsIContent* content = FindContentFor(aId);
+ if (!content) {
+ return nullptr;
+ }
+
+ nsIFrame* scrollFrame = GetScrollFrameFromContent(content);
+ return scrollFrame ? scrollFrame->GetScrollTargetFrame() : nullptr;
+}
+
+static nsRect
+ApplyRectMultiplier(nsRect aRect, float aMultiplier)
+{
+ if (aMultiplier == 1.0f) {
+ return aRect;
+ }
+ float newWidth = aRect.width * aMultiplier;
+ float newHeight = aRect.height * aMultiplier;
+ float newX = aRect.x - ((newWidth - aRect.width) / 2.0f);
+ float newY = aRect.y - ((newHeight - aRect.height) / 2.0f);
+ // Rounding doesn't matter too much here, do a round-in
+ return nsRect(ceil(newX), ceil(newY), floor(newWidth), floor(newHeight));
+}
+
+bool
+nsLayoutUtils::UsesAsyncScrolling(nsIFrame* aFrame)
+{
+#ifdef MOZ_WIDGET_ANDROID
+ // We always have async scrolling for android
+ return true;
+#endif
+
+ return AsyncPanZoomEnabled(aFrame);
+}
+
+bool
+nsLayoutUtils::AsyncPanZoomEnabled(nsIFrame* aFrame)
+{
+ // We use this as a shortcut, since if the compositor will never use APZ,
+ // no widget will either.
+ if (!gfxPlatform::AsyncPanZoomEnabled()) {
+ return false;
+ }
+
+ nsIFrame *frame = nsLayoutUtils::GetDisplayRootFrame(aFrame);
+ nsIWidget* widget = frame->GetNearestWidget();
+ if (!widget) {
+ return false;
+ }
+ return widget->AsyncPanZoomEnabled();
+}
+
+float
+nsLayoutUtils::GetCurrentAPZResolutionScale(nsIPresShell* aShell) {
+ return aShell ? aShell->GetCumulativeNonRootScaleResolution() : 1.0;
+}
+
+// Return the maximum displayport size, based on the LayerManager's maximum
+// supported texture size. The result is in app units.
+static nscoord
+GetMaxDisplayPortSize(nsIContent* aContent)
+{
+ MOZ_ASSERT(!gfxPrefs::LayersTilesEnabled(), "Do not clamp displayports if tiling is enabled");
+
+ nsIFrame* frame = aContent->GetPrimaryFrame();
+ if (!frame) {
+ return nscoord_MAX;
+ }
+ frame = nsLayoutUtils::GetDisplayRootFrame(frame);
+
+ nsIWidget* widget = frame->GetNearestWidget();
+ if (!widget) {
+ return nscoord_MAX;
+ }
+ LayerManager* lm = widget->GetLayerManager();
+ if (!lm) {
+ return nscoord_MAX;
+ }
+ nsPresContext* presContext = frame->PresContext();
+
+ int32_t maxSizeInDevPixels = lm->GetMaxTextureSize();
+ if (maxSizeInDevPixels < 0 || maxSizeInDevPixels == INT_MAX) {
+ return nscoord_MAX;
+ }
+ return presContext->DevPixelsToAppUnits(maxSizeInDevPixels);
+}
+
+static nsRect
+GetDisplayPortFromRectData(nsIContent* aContent,
+ DisplayPortPropertyData* aRectData,
+ float aMultiplier)
+{
+ // In the case where the displayport is set as a rect, we assume it is
+ // already aligned and clamped as necessary. The burden to do that is
+ // on the setter of the displayport. In practice very few places set the
+ // displayport directly as a rect (mostly tests). We still do need to
+ // expand it by the multiplier though.
+ return ApplyRectMultiplier(aRectData->mRect, aMultiplier);
+}
+
+static nsRect
+GetDisplayPortFromMarginsData(nsIContent* aContent,
+ DisplayPortMarginsPropertyData* aMarginsData,
+ float aMultiplier)
+{
+ // In the case where the displayport is set via margins, we apply the margins
+ // to a base rect. Then we align the expanded rect based on the alignment
+ // requested, further expand the rect by the multiplier, and finally, clamp it
+ // to the size of the scrollable rect.
+
+ nsRect base;
+ if (nsRect* baseData = static_cast<nsRect*>(aContent->GetProperty(nsGkAtoms::DisplayPortBase))) {
+ base = *baseData;
+ } else {
+ // In theory we shouldn't get here, but we do sometimes (see bug 1212136).
+ // Fall through for graceful handling.
+ }
+
+ nsIFrame* frame = GetScrollFrameFromContent(aContent);
+ if (!frame) {
+ // Turns out we can't really compute it. Oops. We still should return
+ // something sane. Note that since we can't clamp the rect without a
+ // frame, we don't apply the multiplier either as it can cause the result
+ // to leak outside the scrollable area.
+ NS_WARNING("Attempting to get a displayport from a content with no primary frame!");
+ return base;
+ }
+
+ bool isRoot = false;
+ if (aContent->OwnerDoc()->GetRootElement() == aContent) {
+ isRoot = true;
+ }
+
+ nsPoint scrollPos;
+ if (nsIScrollableFrame* scrollableFrame = frame->GetScrollTargetFrame()) {
+ scrollPos = scrollableFrame->GetScrollPosition();
+ }
+
+ nsPresContext* presContext = frame->PresContext();
+ int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
+
+ LayoutDeviceToScreenScale2D res(presContext->PresShell()->GetCumulativeResolution()
+ * nsLayoutUtils::GetTransformToAncestorScale(frame));
+
+ // Calculate the expanded scrollable rect, which we'll be clamping the
+ // displayport to.
+ nsRect expandedScrollableRect =
+ nsLayoutUtils::CalculateExpandedScrollableRect(frame);
+
+ // GetTransformToAncestorScale() can return 0. In this case, just return the
+ // base rect (clamped to the expanded scrollable rect), as other calculations
+ // would run into divisions by zero.
+ if (res == LayoutDeviceToScreenScale2D(0, 0)) {
+ // Make sure the displayport remains within the scrollable rect.
+ return base.MoveInsideAndClamp(expandedScrollableRect - scrollPos);
+ }
+
+ // First convert the base rect to screen pixels
+ LayoutDeviceToScreenScale2D parentRes = res;
+ if (isRoot) {
+ // the base rect for root scroll frames is specified in the parent document
+ // coordinate space, so it doesn't include the local resolution.
+ float localRes = presContext->PresShell()->GetResolution();
+ parentRes.xScale /= localRes;
+ parentRes.yScale /= localRes;
+ }
+ ScreenRect screenRect = LayoutDeviceRect::FromAppUnits(base, auPerDevPixel)
+ * parentRes;
+
+ // Note on the correctness of applying the alignment in Screen space:
+ // The correct space to apply the alignment in would be Layer space, but
+ // we don't necessarily know the scale to convert to Layer space at this
+ // point because Layout may not yet have chosen the resolution at which to
+ // render (it chooses that in FrameLayerBuilder, but this can be called
+ // during display list building). Therefore, we perform the alignment in
+ // Screen space, which basically assumes that Layout chose to render at
+ // screen resolution; since this is what Layout does most of the time,
+ // this is a good approximation. A proper solution would involve moving
+ // the choosing of the resolution to display-list building time.
+ ScreenSize alignment;
+
+ if (APZCCallbackHelper::IsDisplayportSuppressed()) {
+ alignment = ScreenSize(1, 1);
+ } else if (gfxPrefs::LayersTilesEnabled()) {
+ // Don't align to tiles if they are too large, because we could expand
+ // the displayport by a lot which can take more paint time. It's a tradeoff
+ // though because if we don't align to tiles we have more waste on upload.
+ IntSize tileSize = gfxVars::TileSize();
+ alignment = ScreenSize(std::min(256, tileSize.width), std::min(256, tileSize.height));
+ } else {
+ // If we're not drawing with tiles then we need to be careful about not
+ // hitting the max texture size and we only need 1 draw call per layer
+ // so we can align to a smaller multiple.
+ alignment = ScreenSize(128, 128);
+ }
+
+ // Avoid division by zero.
+ if (alignment.width == 0) {
+ alignment.width = 128;
+ }
+ if (alignment.height == 0) {
+ alignment.height = 128;
+ }
+
+ if (gfxPrefs::LayersTilesEnabled()) {
+ // Expand the rect by the margins
+ screenRect.Inflate(aMarginsData->mMargins);
+ } else {
+ // Calculate the displayport to make sure we fit within the max texture size
+ // when not tiling.
+ nscoord maxSizeAppUnits = GetMaxDisplayPortSize(aContent);
+ if (maxSizeAppUnits == nscoord_MAX) {
+ // Pick a safe maximum displayport size for sanity purposes. This is the
+ // lowest maximum texture size on tileless-platforms (Windows, D3D10).
+ maxSizeAppUnits = presContext->DevPixelsToAppUnits(8192);
+ }
+
+ // The alignment code can round up to 3 tiles, we want to make sure
+ // that the displayport can grow by up to 3 tiles without going
+ // over the max texture size.
+ const int MAX_ALIGN_ROUNDING = 3;
+
+ // Find the maximum size in screen pixels.
+ int32_t maxSizeDevPx = presContext->AppUnitsToDevPixels(maxSizeAppUnits);
+ int32_t maxWidthScreenPx = floor(double(maxSizeDevPx) * res.xScale) -
+ MAX_ALIGN_ROUNDING * alignment.width;
+ int32_t maxHeightScreenPx = floor(double(maxSizeDevPx) * res.yScale) -
+ MAX_ALIGN_ROUNDING * alignment.height;
+
+ // For each axis, inflate the margins up to the maximum size.
+ const ScreenMargin& margins = aMarginsData->mMargins;
+ if (screenRect.height < maxHeightScreenPx) {
+ int32_t budget = maxHeightScreenPx - screenRect.height;
+ // Scale the margins down to fit into the budget if necessary, maintaining
+ // their relative ratio.
+ float scale = std::min(1.0f, float(budget) / margins.TopBottom());
+ float top = margins.top * scale;
+ float bottom = margins.bottom * scale;
+ screenRect.y -= top;
+ screenRect.height += top + bottom;
+ }
+ if (screenRect.width < maxWidthScreenPx) {
+ int32_t budget = maxWidthScreenPx - screenRect.width;
+ float scale = std::min(1.0f, float(budget) / margins.LeftRight());
+ float left = margins.left * scale;
+ float right = margins.right * scale;
+ screenRect.x -= left;
+ screenRect.width += left + right;
+ }
+ }
+
+ ScreenPoint scrollPosScreen = LayoutDevicePoint::FromAppUnits(scrollPos, auPerDevPixel)
+ * res;
+
+ // Round-out the display port to the nearest alignment (tiles)
+ screenRect += scrollPosScreen;
+ float x = alignment.width * floor(screenRect.x / alignment.width);
+ float y = alignment.height * floor(screenRect.y / alignment.height);
+ float w = alignment.width * ceil(screenRect.width / alignment.width + 1);
+ float h = alignment.height * ceil(screenRect.height / alignment.height + 1);
+ screenRect = ScreenRect(x, y, w, h);
+ screenRect -= scrollPosScreen;
+
+ // Convert the aligned rect back into app units.
+ nsRect result = LayoutDeviceRect::ToAppUnits(screenRect / res, auPerDevPixel);
+
+ // If we have non-zero margins, expand the displayport for the low-res buffer
+ // if that's what we're drawing. If we have zero margins, we want the
+ // displayport to reflect the scrollport.
+ if (aMarginsData->mMargins != ScreenMargin()) {
+ result = ApplyRectMultiplier(result, aMultiplier);
+ }
+
+ // Make sure the displayport remains within the scrollable rect.
+ result = result.MoveInsideAndClamp(expandedScrollableRect - scrollPos);
+
+ return result;
+}
+
+static bool
+ShouldDisableApzForElement(nsIContent* aContent)
+{
+ if (gfxPrefs::APZDisableForScrollLinkedEffects() && aContent) {
+ nsIDocument* doc = aContent->GetComposedDoc();
+ return (doc && doc->HasScrollLinkedEffect());
+ }
+ return false;
+}
+
+static bool
+GetDisplayPortImpl(nsIContent* aContent, nsRect *aResult, float aMultiplier)
+{
+ DisplayPortPropertyData* rectData =
+ static_cast<DisplayPortPropertyData*>(aContent->GetProperty(nsGkAtoms::DisplayPort));
+ DisplayPortMarginsPropertyData* marginsData =
+ static_cast<DisplayPortMarginsPropertyData*>(aContent->GetProperty(nsGkAtoms::DisplayPortMargins));
+
+ if (!rectData && !marginsData) {
+ // This content element has no displayport data at all
+ return false;
+ }
+
+ if (!aResult) {
+ // We have displayport data, but the caller doesn't want the actual
+ // rect, so we don't need to actually compute it.
+ return true;
+ }
+
+ if (rectData && marginsData) {
+ // choose margins if equal priority
+ if (rectData->mPriority > marginsData->mPriority) {
+ marginsData = nullptr;
+ } else {
+ rectData = nullptr;
+ }
+ }
+
+ NS_ASSERTION((rectData == nullptr) != (marginsData == nullptr),
+ "Only one of rectData or marginsData should be set!");
+
+ nsRect result;
+ if (rectData) {
+ result = GetDisplayPortFromRectData(aContent, rectData, aMultiplier);
+ } else if (APZCCallbackHelper::IsDisplayportSuppressed() || ShouldDisableApzForElement(aContent)) {
+ DisplayPortMarginsPropertyData noMargins(ScreenMargin(), 1);
+ result = GetDisplayPortFromMarginsData(aContent, &noMargins, aMultiplier);
+ } else {
+ result = GetDisplayPortFromMarginsData(aContent, marginsData, aMultiplier);
+ }
+
+ if (!gfxPrefs::LayersTilesEnabled()) {
+ // Either we should have gotten a valid rect directly from the displayport
+ // base, or we should have computed a valid rect from the margins.
+ NS_ASSERTION(result.width <= GetMaxDisplayPortSize(aContent),
+ "Displayport must be a valid texture size");
+ NS_ASSERTION(result.height <= GetMaxDisplayPortSize(aContent),
+ "Displayport must be a valid texture size");
+ }
+
+ *aResult = result;
+ return true;
+}
+
+void
+TranslateFromScrollPortToScrollFrame(nsIContent* aContent, nsRect* aRect)
+{
+ MOZ_ASSERT(aRect);
+ nsIFrame* frame = GetScrollFrameFromContent(aContent);
+ nsIScrollableFrame* scrollableFrame = frame ? frame->GetScrollTargetFrame() : nullptr;
+ if (scrollableFrame) {
+ *aRect += scrollableFrame->GetScrollPortRect().TopLeft();
+ }
+}
+
+bool
+nsLayoutUtils::GetDisplayPort(nsIContent* aContent, nsRect *aResult,
+ RelativeTo aRelativeTo /* = RelativeTo::ScrollPort */)
+{
+ float multiplier =
+ gfxPrefs::UseLowPrecisionBuffer() ? 1.0f / gfxPrefs::LowPrecisionResolution() : 1.0f;
+ bool usingDisplayPort = GetDisplayPortImpl(aContent, aResult, multiplier);
+ if (aResult && usingDisplayPort && aRelativeTo == RelativeTo::ScrollFrame) {
+ TranslateFromScrollPortToScrollFrame(aContent, aResult);
+ }
+ return usingDisplayPort;
+}
+
+bool
+nsLayoutUtils::HasDisplayPort(nsIContent* aContent) {
+ return GetDisplayPort(aContent, nullptr);
+}
+
+/* static */ bool
+nsLayoutUtils::GetDisplayPortForVisibilityTesting(
+ nsIContent* aContent,
+ nsRect* aResult,
+ RelativeTo aRelativeTo /* = RelativeTo::ScrollPort */)
+{
+ MOZ_ASSERT(aResult);
+ bool usingDisplayPort = GetDisplayPortImpl(aContent, aResult, 1.0f);
+ if (usingDisplayPort && aRelativeTo == RelativeTo::ScrollFrame) {
+ TranslateFromScrollPortToScrollFrame(aContent, aResult);
+ }
+ return usingDisplayPort;
+}
+
+bool
+nsLayoutUtils::SetDisplayPortMargins(nsIContent* aContent,
+ nsIPresShell* aPresShell,
+ const ScreenMargin& aMargins,
+ uint32_t aPriority,
+ RepaintMode aRepaintMode)
+{
+ MOZ_ASSERT(aContent);
+ MOZ_ASSERT(aContent->GetComposedDoc() == aPresShell->GetDocument());
+
+ DisplayPortMarginsPropertyData* currentData =
+ static_cast<DisplayPortMarginsPropertyData*>(aContent->GetProperty(nsGkAtoms::DisplayPortMargins));
+ if (currentData && currentData->mPriority > aPriority) {
+ return false;
+ }
+
+ nsRect oldDisplayPort;
+ bool hadDisplayPort = GetHighResolutionDisplayPort(aContent, &oldDisplayPort);
+
+ aContent->SetProperty(nsGkAtoms::DisplayPortMargins,
+ new DisplayPortMarginsPropertyData(
+ aMargins, aPriority),
+ nsINode::DeleteProperty<DisplayPortMarginsPropertyData>);
+
+ nsRect newDisplayPort;
+ DebugOnly<bool> hasDisplayPort = GetHighResolutionDisplayPort(aContent, &newDisplayPort);
+ MOZ_ASSERT(hasDisplayPort);
+
+ bool changed = !hadDisplayPort ||
+ !oldDisplayPort.IsEqualEdges(newDisplayPort);
+
+ if (gfxPrefs::LayoutUseContainersForRootFrames()) {
+ nsIFrame* rootScrollFrame = aPresShell->GetRootScrollFrame();
+ if (rootScrollFrame &&
+ aContent == rootScrollFrame->GetContent() &&
+ nsLayoutUtils::UsesAsyncScrolling(rootScrollFrame))
+ {
+ // We are setting a root displayport for a document.
+ // If we have APZ, then set a special flag on the pres shell so
+ // that we don't get scrollbars drawn.
+ aPresShell->SetIgnoreViewportScrolling(true);
+ }
+ }
+
+ if (changed && aRepaintMode == RepaintMode::Repaint) {
+ nsIFrame* frame = aContent->GetPrimaryFrame();
+ if (frame) {
+ frame->SchedulePaint();
+ }
+ }
+
+ nsIFrame* frame = GetScrollFrameFromContent(aContent);
+ nsIScrollableFrame* scrollableFrame = frame ? frame->GetScrollTargetFrame() : nullptr;
+ if (!scrollableFrame) {
+ return true;
+ }
+
+ scrollableFrame->TriggerDisplayPortExpiration();
+
+ // Display port margins changing means that the set of visible frames may
+ // have drastically changed. Check if we should schedule an update.
+ hadDisplayPort =
+ scrollableFrame->GetDisplayPortAtLastApproximateFrameVisibilityUpdate(&oldDisplayPort);
+
+ bool needVisibilityUpdate = !hadDisplayPort;
+ // Check if the total size has changed by a large factor.
+ if (!needVisibilityUpdate) {
+ if ((newDisplayPort.width > 2 * oldDisplayPort.width) ||
+ (oldDisplayPort.width > 2 * newDisplayPort.width) ||
+ (newDisplayPort.height > 2 * oldDisplayPort.height) ||
+ (oldDisplayPort.height > 2 * newDisplayPort.height)) {
+ needVisibilityUpdate = true;
+ }
+ }
+ // Check if it's moved by a significant amount.
+ if (!needVisibilityUpdate) {
+ if (nsRect* baseData = static_cast<nsRect*>(aContent->GetProperty(nsGkAtoms::DisplayPortBase))) {
+ nsRect base = *baseData;
+ if ((std::abs(newDisplayPort.X() - oldDisplayPort.X()) > base.width) ||
+ (std::abs(newDisplayPort.XMost() - oldDisplayPort.XMost()) > base.width) ||
+ (std::abs(newDisplayPort.Y() - oldDisplayPort.Y()) > base.height) ||
+ (std::abs(newDisplayPort.YMost() - oldDisplayPort.YMost()) > base.height)) {
+ needVisibilityUpdate = true;
+ }
+ }
+ }
+ if (needVisibilityUpdate) {
+ aPresShell->ScheduleApproximateFrameVisibilityUpdateNow();
+ }
+
+ return true;
+}
+
+void
+nsLayoutUtils::SetDisplayPortBase(nsIContent* aContent, const nsRect& aBase)
+{
+ aContent->SetProperty(nsGkAtoms::DisplayPortBase, new nsRect(aBase),
+ nsINode::DeleteProperty<nsRect>);
+}
+
+void
+nsLayoutUtils::SetDisplayPortBaseIfNotSet(nsIContent* aContent, const nsRect& aBase)
+{
+ if (!aContent->GetProperty(nsGkAtoms::DisplayPortBase)) {
+ SetDisplayPortBase(aContent, aBase);
+ }
+}
+
+bool
+nsLayoutUtils::GetCriticalDisplayPort(nsIContent* aContent, nsRect* aResult)
+{
+ if (gfxPrefs::UseLowPrecisionBuffer()) {
+ return GetDisplayPortImpl(aContent, aResult, 1.0f);
+ }
+ return false;
+}
+
+bool
+nsLayoutUtils::HasCriticalDisplayPort(nsIContent* aContent)
+{
+ return GetCriticalDisplayPort(aContent, nullptr);
+}
+
+bool
+nsLayoutUtils::GetHighResolutionDisplayPort(nsIContent* aContent, nsRect* aResult)
+{
+ if (gfxPrefs::UseLowPrecisionBuffer()) {
+ return GetCriticalDisplayPort(aContent, aResult);
+ }
+ return GetDisplayPort(aContent, aResult);
+}
+
+void
+nsLayoutUtils::RemoveDisplayPort(nsIContent* aContent)
+{
+ aContent->DeleteProperty(nsGkAtoms::DisplayPort);
+ aContent->DeleteProperty(nsGkAtoms::DisplayPortMargins);
+}
+
+nsContainerFrame*
+nsLayoutUtils::LastContinuationWithChild(nsContainerFrame* aFrame)
+{
+ NS_PRECONDITION(aFrame, "NULL frame pointer");
+ nsIFrame* f = aFrame->LastContinuation();
+ while (!f->PrincipalChildList().FirstChild() && f->GetPrevContinuation()) {
+ f = f->GetPrevContinuation();
+ }
+ return static_cast<nsContainerFrame*>(f);
+}
+
+//static
+FrameChildListID
+nsLayoutUtils::GetChildListNameFor(nsIFrame* aChildFrame)
+{
+ nsIFrame::ChildListID id = nsIFrame::kPrincipalList;
+
+ if (aChildFrame->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER) {
+ nsIFrame* pif = aChildFrame->GetPrevInFlow();
+ if (pif->GetParent() == aChildFrame->GetParent()) {
+ id = nsIFrame::kExcessOverflowContainersList;
+ }
+ else {
+ id = nsIFrame::kOverflowContainersList;
+ }
+ }
+ // See if the frame is moved out of the flow
+ else if (aChildFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW) {
+ // Look at the style information to tell
+ const nsStyleDisplay* disp = aChildFrame->StyleDisplay();
+
+ if (NS_STYLE_POSITION_ABSOLUTE == disp->mPosition) {
+ id = nsIFrame::kAbsoluteList;
+ } else if (NS_STYLE_POSITION_FIXED == disp->mPosition) {
+ if (nsLayoutUtils::IsReallyFixedPos(aChildFrame)) {
+ id = nsIFrame::kFixedList;
+ } else {
+ id = nsIFrame::kAbsoluteList;
+ }
+#ifdef MOZ_XUL
+ } else if (StyleDisplay::Popup == disp->mDisplay) {
+ // Out-of-flows that are DISPLAY_POPUP must be kids of the root popup set
+#ifdef DEBUG
+ nsIFrame* parent = aChildFrame->GetParent();
+ NS_ASSERTION(parent && parent->GetType() == nsGkAtoms::popupSetFrame,
+ "Unexpected parent");
+#endif // DEBUG
+
+ id = nsIFrame::kPopupList;
+#endif // MOZ_XUL
+ } else {
+ NS_ASSERTION(aChildFrame->IsFloating(), "not a floated frame");
+ id = nsIFrame::kFloatList;
+ }
+
+ } else {
+ nsIAtom* childType = aChildFrame->GetType();
+ if (nsGkAtoms::menuPopupFrame == childType) {
+ nsIFrame* parent = aChildFrame->GetParent();
+ MOZ_ASSERT(parent, "nsMenuPopupFrame can't be the root frame");
+ if (parent) {
+ if (parent->GetType() == nsGkAtoms::popupSetFrame) {
+ id = nsIFrame::kPopupList;
+ } else {
+ nsIFrame* firstPopup = parent->GetChildList(nsIFrame::kPopupList).FirstChild();
+ MOZ_ASSERT(!firstPopup || !firstPopup->GetNextSibling(),
+ "We assume popupList only has one child, but it has more.");
+ id = firstPopup == aChildFrame
+ ? nsIFrame::kPopupList
+ : nsIFrame::kPrincipalList;
+ }
+ } else {
+ id = nsIFrame::kPrincipalList;
+ }
+ } else if (nsGkAtoms::tableColGroupFrame == childType) {
+ id = nsIFrame::kColGroupList;
+ } else if (aChildFrame->IsTableCaption()) {
+ id = nsIFrame::kCaptionList;
+ } else {
+ id = nsIFrame::kPrincipalList;
+ }
+ }
+
+#ifdef DEBUG
+ // Verify that the frame is actually in that child list or in the
+ // corresponding overflow list.
+ nsContainerFrame* parent = aChildFrame->GetParent();
+ bool found = parent->GetChildList(id).ContainsFrame(aChildFrame);
+ if (!found) {
+ if (!(aChildFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
+ found = parent->GetChildList(nsIFrame::kOverflowList)
+ .ContainsFrame(aChildFrame);
+ }
+ else if (aChildFrame->IsFloating()) {
+ found = parent->GetChildList(nsIFrame::kOverflowOutOfFlowList)
+ .ContainsFrame(aChildFrame);
+ if (!found) {
+ found = parent->GetChildList(nsIFrame::kPushedFloatsList)
+ .ContainsFrame(aChildFrame);
+ }
+ }
+ // else it's positioned and should have been on the 'id' child list.
+ NS_POSTCONDITION(found, "not in child list");
+ }
+#endif
+
+ return id;
+}
+
+/*static*/ nsIFrame*
+nsLayoutUtils::GetBeforeFrameForContent(nsIFrame* aFrame,
+ const nsIContent* aContent)
+{
+ // We need to call GetGenConPseudos() on the first continuation/ib-split.
+ // Find it, for symmetry with GetAfterFrameForContent.
+ nsContainerFrame* genConParentFrame =
+ FirstContinuationOrIBSplitSibling(aFrame)->GetContentInsertionFrame();
+ if (!genConParentFrame) {
+ return nullptr;
+ }
+ nsTArray<nsIContent*>* prop = genConParentFrame->GetGenConPseudos();
+ if (prop) {
+ const nsTArray<nsIContent*>& pseudos(*prop);
+ for (uint32_t i = 0; i < pseudos.Length(); ++i) {
+ if (pseudos[i]->GetParent() == aContent &&
+ pseudos[i]->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore) {
+ return pseudos[i]->GetPrimaryFrame();
+ }
+ }
+ }
+ // If the first child frame is a pseudo-frame, then try that.
+ // Note that the frame we create for the generated content is also a
+ // pseudo-frame and so don't drill down in that case.
+ nsIFrame* childFrame = genConParentFrame->PrincipalChildList().FirstChild();
+ if (childFrame &&
+ childFrame->IsPseudoFrame(aContent) &&
+ !childFrame->IsGeneratedContentFrame()) {
+ return GetBeforeFrameForContent(childFrame, aContent);
+ }
+ return nullptr;
+}
+
+/*static*/ nsIFrame*
+nsLayoutUtils::GetBeforeFrame(nsIFrame* aFrame)
+{
+ return GetBeforeFrameForContent(aFrame, aFrame->GetContent());
+}
+
+/*static*/ nsIFrame*
+nsLayoutUtils::GetAfterFrameForContent(nsIFrame* aFrame,
+ const nsIContent* aContent)
+{
+ // We need to call GetGenConPseudos() on the first continuation,
+ // but callers are likely to pass the last.
+ nsContainerFrame* genConParentFrame =
+ FirstContinuationOrIBSplitSibling(aFrame)->GetContentInsertionFrame();
+ if (!genConParentFrame) {
+ return nullptr;
+ }
+ nsTArray<nsIContent*>* prop = genConParentFrame->GetGenConPseudos();
+ if (prop) {
+ const nsTArray<nsIContent*>& pseudos(*prop);
+ for (uint32_t i = 0; i < pseudos.Length(); ++i) {
+ if (pseudos[i]->GetParent() == aContent &&
+ pseudos[i]->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentafter) {
+ return pseudos[i]->GetPrimaryFrame();
+ }
+ }
+ }
+ // If the last child frame is a pseudo-frame, then try that.
+ // Note that the frame we create for the generated content is also a
+ // pseudo-frame and so don't drill down in that case.
+ genConParentFrame = aFrame->GetContentInsertionFrame();
+ if (!genConParentFrame) {
+ return nullptr;
+ }
+ nsIFrame* lastParentContinuation =
+ LastContinuationWithChild(static_cast<nsContainerFrame*>(
+ LastContinuationOrIBSplitSibling(genConParentFrame)));
+ nsIFrame* childFrame =
+ lastParentContinuation->GetChildList(nsIFrame::kPrincipalList).LastChild();
+ if (childFrame &&
+ childFrame->IsPseudoFrame(aContent) &&
+ !childFrame->IsGeneratedContentFrame()) {
+ return GetAfterFrameForContent(childFrame->FirstContinuation(), aContent);
+ }
+ return nullptr;
+}
+
+/*static*/ nsIFrame*
+nsLayoutUtils::GetAfterFrame(nsIFrame* aFrame)
+{
+ return GetAfterFrameForContent(aFrame, aFrame->GetContent());
+}
+
+// static
+nsIFrame*
+nsLayoutUtils::GetClosestFrameOfType(nsIFrame* aFrame,
+ nsIAtom* aFrameType,
+ nsIFrame* aStopAt)
+{
+ for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent()) {
+ if (frame->GetType() == aFrameType) {
+ return frame;
+ }
+ if (frame == aStopAt) {
+ break;
+ }
+ }
+ return nullptr;
+}
+
+// static
+nsIFrame*
+nsLayoutUtils::GetStyleFrame(nsIFrame* aFrame)
+{
+ if (aFrame->GetType() == nsGkAtoms::tableWrapperFrame) {
+ nsIFrame* inner = aFrame->PrincipalChildList().FirstChild();
+ // inner may be null, if aFrame is mid-destruction
+ return inner;
+ }
+
+ return aFrame;
+}
+
+nsIFrame*
+nsLayoutUtils::GetStyleFrame(const nsIContent* aContent)
+{
+ nsIFrame *frame = aContent->GetPrimaryFrame();
+ if (!frame) {
+ return nullptr;
+ }
+
+ return nsLayoutUtils::GetStyleFrame(frame);
+}
+
+/* static */ nsIFrame*
+nsLayoutUtils::GetRealPrimaryFrameFor(const nsIContent* aContent)
+{
+ nsIFrame *frame = aContent->GetPrimaryFrame();
+ if (!frame) {
+ return nullptr;
+ }
+
+ return nsPlaceholderFrame::GetRealFrameFor(frame);
+}
+
+nsIFrame*
+nsLayoutUtils::GetFloatFromPlaceholder(nsIFrame* aFrame) {
+ NS_ASSERTION(nsGkAtoms::placeholderFrame == aFrame->GetType(),
+ "Must have a placeholder here");
+ if (aFrame->GetStateBits() & PLACEHOLDER_FOR_FLOAT) {
+ nsIFrame *outOfFlowFrame =
+ nsPlaceholderFrame::GetRealFrameForPlaceholder(aFrame);
+ NS_ASSERTION(outOfFlowFrame->IsFloating(),
+ "How did that happen?");
+ return outOfFlowFrame;
+ }
+
+ return nullptr;
+}
+
+// static
+bool
+nsLayoutUtils::IsGeneratedContentFor(nsIContent* aContent,
+ nsIFrame* aFrame,
+ nsIAtom* aPseudoElement)
+{
+ NS_PRECONDITION(aFrame, "Must have a frame");
+ NS_PRECONDITION(aPseudoElement, "Must have a pseudo name");
+
+ if (!aFrame->IsGeneratedContentFrame()) {
+ return false;
+ }
+ nsIFrame* parent = aFrame->GetParent();
+ NS_ASSERTION(parent, "Generated content can't be root frame");
+ if (parent->IsGeneratedContentFrame()) {
+ // Not the root of the generated content
+ return false;
+ }
+
+ if (aContent && parent->GetContent() != aContent) {
+ return false;
+ }
+
+ return (aFrame->GetContent()->NodeInfo()->NameAtom() == nsGkAtoms::mozgeneratedcontentbefore) ==
+ (aPseudoElement == nsCSSPseudoElements::before);
+}
+
+// static
+nsIFrame*
+nsLayoutUtils::GetCrossDocParentFrame(const nsIFrame* aFrame,
+ nsPoint* aExtraOffset)
+{
+ nsIFrame* p = aFrame->GetParent();
+ if (p)
+ return p;
+
+ nsView* v = aFrame->GetView();
+ if (!v)
+ return nullptr;
+ v = v->GetParent(); // anonymous inner view
+ if (!v)
+ return nullptr;
+ if (aExtraOffset) {
+ *aExtraOffset += v->GetPosition();
+ }
+ v = v->GetParent(); // subdocumentframe's view
+ return v ? v->GetFrame() : nullptr;
+}
+
+// static
+bool
+nsLayoutUtils::IsProperAncestorFrameCrossDoc(nsIFrame* aAncestorFrame, nsIFrame* aFrame,
+ nsIFrame* aCommonAncestor)
+{
+ if (aFrame == aAncestorFrame)
+ return false;
+ return IsAncestorFrameCrossDoc(aAncestorFrame, aFrame, aCommonAncestor);
+}
+
+// static
+bool
+nsLayoutUtils::IsAncestorFrameCrossDoc(const nsIFrame* aAncestorFrame, const nsIFrame* aFrame,
+ const nsIFrame* aCommonAncestor)
+{
+ for (const nsIFrame* f = aFrame; f != aCommonAncestor;
+ f = GetCrossDocParentFrame(f)) {
+ if (f == aAncestorFrame)
+ return true;
+ }
+ return aCommonAncestor == aAncestorFrame;
+}
+
+// static
+bool
+nsLayoutUtils::IsProperAncestorFrame(nsIFrame* aAncestorFrame, nsIFrame* aFrame,
+ nsIFrame* aCommonAncestor)
+{
+ if (aFrame == aAncestorFrame)
+ return false;
+ for (nsIFrame* f = aFrame; f != aCommonAncestor; f = f->GetParent()) {
+ if (f == aAncestorFrame)
+ return true;
+ }
+ return aCommonAncestor == aAncestorFrame;
+}
+
+// static
+int32_t
+nsLayoutUtils::DoCompareTreePosition(nsIContent* aContent1,
+ nsIContent* aContent2,
+ int32_t aIf1Ancestor,
+ int32_t aIf2Ancestor,
+ const nsIContent* aCommonAncestor)
+{
+ NS_PRECONDITION(aContent1, "aContent1 must not be null");
+ NS_PRECONDITION(aContent2, "aContent2 must not be null");
+
+ AutoTArray<nsINode*, 32> content1Ancestors;
+ nsINode* c1;
+ for (c1 = aContent1; c1 && c1 != aCommonAncestor; c1 = c1->GetParentNode()) {
+ content1Ancestors.AppendElement(c1);
+ }
+ if (!c1 && aCommonAncestor) {
+ // So, it turns out aCommonAncestor was not an ancestor of c1. Oops.
+ // Never mind. We can continue as if aCommonAncestor was null.
+ aCommonAncestor = nullptr;
+ }
+
+ AutoTArray<nsINode*, 32> content2Ancestors;
+ nsINode* c2;
+ for (c2 = aContent2; c2 && c2 != aCommonAncestor; c2 = c2->GetParentNode()) {
+ content2Ancestors.AppendElement(c2);
+ }
+ if (!c2 && aCommonAncestor) {
+ // So, it turns out aCommonAncestor was not an ancestor of c2.
+ // We need to retry with no common ancestor hint.
+ return DoCompareTreePosition(aContent1, aContent2,
+ aIf1Ancestor, aIf2Ancestor, nullptr);
+ }
+
+ int last1 = content1Ancestors.Length() - 1;
+ int last2 = content2Ancestors.Length() - 1;
+ nsINode* content1Ancestor = nullptr;
+ nsINode* content2Ancestor = nullptr;
+ while (last1 >= 0 && last2 >= 0
+ && ((content1Ancestor = content1Ancestors.ElementAt(last1)) ==
+ (content2Ancestor = content2Ancestors.ElementAt(last2)))) {
+ last1--;
+ last2--;
+ }
+
+ if (last1 < 0) {
+ if (last2 < 0) {
+ NS_ASSERTION(aContent1 == aContent2, "internal error?");
+ return 0;
+ }
+ // aContent1 is an ancestor of aContent2
+ return aIf1Ancestor;
+ }
+
+ if (last2 < 0) {
+ // aContent2 is an ancestor of aContent1
+ return aIf2Ancestor;
+ }
+
+ // content1Ancestor != content2Ancestor, so they must be siblings with the same parent
+ nsINode* parent = content1Ancestor->GetParentNode();
+#ifdef DEBUG
+ // TODO: remove the uglyness, see bug 598468.
+ NS_ASSERTION(gPreventAssertInCompareTreePosition || parent,
+ "no common ancestor at all???");
+#endif // DEBUG
+ if (!parent) { // different documents??
+ return 0;
+ }
+
+ int32_t index1 = parent->IndexOf(content1Ancestor);
+ int32_t index2 = parent->IndexOf(content2Ancestor);
+ if (index1 < 0 || index2 < 0) {
+ // one of them must be anonymous; we can't determine the order
+ return 0;
+ }
+
+ return index1 - index2;
+}
+
+// static
+nsIFrame*
+nsLayoutUtils::FillAncestors(nsIFrame* aFrame,
+ nsIFrame* aStopAtAncestor,
+ nsTArray<nsIFrame*>* aAncestors)
+{
+ while (aFrame && aFrame != aStopAtAncestor) {
+ aAncestors->AppendElement(aFrame);
+ aFrame = nsLayoutUtils::GetParentOrPlaceholderFor(aFrame);
+ }
+ return aFrame;
+}
+
+// Return true if aFrame1 is after aFrame2
+static bool IsFrameAfter(nsIFrame* aFrame1, nsIFrame* aFrame2)
+{
+ nsIFrame* f = aFrame2;
+ do {
+ f = f->GetNextSibling();
+ if (f == aFrame1)
+ return true;
+ } while (f);
+ return false;
+}
+
+// static
+int32_t
+nsLayoutUtils::DoCompareTreePosition(nsIFrame* aFrame1,
+ nsIFrame* aFrame2,
+ int32_t aIf1Ancestor,
+ int32_t aIf2Ancestor,
+ nsIFrame* aCommonAncestor)
+{
+ NS_PRECONDITION(aFrame1, "aFrame1 must not be null");
+ NS_PRECONDITION(aFrame2, "aFrame2 must not be null");
+
+ AutoTArray<nsIFrame*,20> frame2Ancestors;
+ nsIFrame* nonCommonAncestor =
+ FillAncestors(aFrame2, aCommonAncestor, &frame2Ancestors);
+
+ return DoCompareTreePosition(aFrame1, aFrame2, frame2Ancestors,
+ aIf1Ancestor, aIf2Ancestor,
+ nonCommonAncestor ? aCommonAncestor : nullptr);
+}
+
+// static
+int32_t
+nsLayoutUtils::DoCompareTreePosition(nsIFrame* aFrame1,
+ nsIFrame* aFrame2,
+ nsTArray<nsIFrame*>& aFrame2Ancestors,
+ int32_t aIf1Ancestor,
+ int32_t aIf2Ancestor,
+ nsIFrame* aCommonAncestor)
+{
+ NS_PRECONDITION(aFrame1, "aFrame1 must not be null");
+ NS_PRECONDITION(aFrame2, "aFrame2 must not be null");
+
+ nsPresContext* presContext = aFrame1->PresContext();
+ if (presContext != aFrame2->PresContext()) {
+ NS_ERROR("no common ancestor at all, different documents");
+ return 0;
+ }
+
+ AutoTArray<nsIFrame*,20> frame1Ancestors;
+ if (aCommonAncestor &&
+ !FillAncestors(aFrame1, aCommonAncestor, &frame1Ancestors)) {
+ // We reached the root of the frame tree ... if aCommonAncestor was set,
+ // it is wrong
+ return DoCompareTreePosition(aFrame1, aFrame2,
+ aIf1Ancestor, aIf2Ancestor, nullptr);
+ }
+
+ int32_t last1 = int32_t(frame1Ancestors.Length()) - 1;
+ int32_t last2 = int32_t(aFrame2Ancestors.Length()) - 1;
+ while (last1 >= 0 && last2 >= 0 &&
+ frame1Ancestors[last1] == aFrame2Ancestors[last2]) {
+ last1--;
+ last2--;
+ }
+
+ if (last1 < 0) {
+ if (last2 < 0) {
+ NS_ASSERTION(aFrame1 == aFrame2, "internal error?");
+ return 0;
+ }
+ // aFrame1 is an ancestor of aFrame2
+ return aIf1Ancestor;
+ }
+
+ if (last2 < 0) {
+ // aFrame2 is an ancestor of aFrame1
+ return aIf2Ancestor;
+ }
+
+ nsIFrame* ancestor1 = frame1Ancestors[last1];
+ nsIFrame* ancestor2 = aFrame2Ancestors[last2];
+ // Now we should be able to walk sibling chains to find which one is first
+ if (IsFrameAfter(ancestor2, ancestor1))
+ return -1;
+ if (IsFrameAfter(ancestor1, ancestor2))
+ return 1;
+ NS_WARNING("Frames were in different child lists???");
+ return 0;
+}
+
+// static
+nsIFrame* nsLayoutUtils::GetLastSibling(nsIFrame* aFrame) {
+ if (!aFrame) {
+ return nullptr;
+ }
+
+ nsIFrame* next;
+ while ((next = aFrame->GetNextSibling()) != nullptr) {
+ aFrame = next;
+ }
+ return aFrame;
+}
+
+// static
+nsView*
+nsLayoutUtils::FindSiblingViewFor(nsView* aParentView, nsIFrame* aFrame) {
+ nsIFrame* parentViewFrame = aParentView->GetFrame();
+ nsIContent* parentViewContent = parentViewFrame ? parentViewFrame->GetContent() : nullptr;
+ for (nsView* insertBefore = aParentView->GetFirstChild(); insertBefore;
+ insertBefore = insertBefore->GetNextSibling()) {
+ nsIFrame* f = insertBefore->GetFrame();
+ if (!f) {
+ // this view could be some anonymous view attached to a meaningful parent
+ for (nsView* searchView = insertBefore->GetParent(); searchView;
+ searchView = searchView->GetParent()) {
+ f = searchView->GetFrame();
+ if (f) {
+ break;
+ }
+ }
+ NS_ASSERTION(f, "Can't find a frame anywhere!");
+ }
+ if (!f || !aFrame->GetContent() || !f->GetContent() ||
+ CompareTreePosition(aFrame->GetContent(), f->GetContent(), parentViewContent) > 0) {
+ // aFrame's content is after f's content (or we just don't know),
+ // so put our view before f's view
+ return insertBefore;
+ }
+ }
+ return nullptr;
+}
+
+//static
+nsIScrollableFrame*
+nsLayoutUtils::GetScrollableFrameFor(const nsIFrame *aScrolledFrame)
+{
+ nsIFrame *frame = aScrolledFrame->GetParent();
+ nsIScrollableFrame *sf = do_QueryFrame(frame);
+ return (sf && sf->GetScrolledFrame() == aScrolledFrame) ? sf : nullptr;
+}
+
+/* static */ void
+nsLayoutUtils::SetFixedPositionLayerData(Layer* aLayer,
+ const nsIFrame* aViewportFrame,
+ const nsRect& aAnchorRect,
+ const nsIFrame* aFixedPosFrame,
+ nsPresContext* aPresContext,
+ const ContainerLayerParameters& aContainerParameters) {
+ // Find out the rect of the viewport frame relative to the reference frame.
+ // This, in conjunction with the container scale, will correspond to the
+ // coordinate-space of the built layer.
+ float factor = aPresContext->AppUnitsPerDevPixel();
+ Rect anchorRect(NSAppUnitsToFloatPixels(aAnchorRect.x, factor) *
+ aContainerParameters.mXScale,
+ NSAppUnitsToFloatPixels(aAnchorRect.y, factor) *
+ aContainerParameters.mYScale,
+ NSAppUnitsToFloatPixels(aAnchorRect.width, factor) *
+ aContainerParameters.mXScale,
+ NSAppUnitsToFloatPixels(aAnchorRect.height, factor) *
+ aContainerParameters.mYScale);
+ // Need to transform anchorRect from the container layer's coordinate system
+ // into aLayer's coordinate system.
+ Matrix transform2d;
+ if (aLayer->GetTransform().Is2D(&transform2d)) {
+ transform2d.Invert();
+ anchorRect = transform2d.TransformBounds(anchorRect);
+ } else {
+ NS_ERROR("3D transform found between fixedpos content and its viewport (should never happen)");
+ anchorRect = Rect(0,0,0,0);
+ }
+
+ // Work out the anchor point for this fixed position layer. We assume that
+ // any positioning set (left/top/right/bottom) indicates that the
+ // corresponding side of its container should be the anchor point,
+ // defaulting to top-left.
+ LayerPoint anchor(anchorRect.x, anchorRect.y);
+
+ int32_t sides = eSideBitsNone;
+ if (aFixedPosFrame != aViewportFrame) {
+ const nsStylePosition* position = aFixedPosFrame->StylePosition();
+ if (position->mOffset.GetRightUnit() != eStyleUnit_Auto) {
+ sides |= eSideBitsRight;
+ if (position->mOffset.GetLeftUnit() != eStyleUnit_Auto) {
+ sides |= eSideBitsLeft;
+ anchor.x = anchorRect.x + anchorRect.width / 2.f;
+ } else {
+ anchor.x = anchorRect.XMost();
+ }
+ }
+ if (position->mOffset.GetBottomUnit() != eStyleUnit_Auto) {
+ sides |= eSideBitsBottom;
+ if (position->mOffset.GetTopUnit() != eStyleUnit_Auto) {
+ sides |= eSideBitsTop;
+ anchor.y = anchorRect.y + anchorRect.height / 2.f;
+ } else {
+ anchor.y = anchorRect.YMost();
+ }
+ }
+ }
+
+ ViewID id = FrameMetrics::NULL_SCROLL_ID;
+ if (nsIFrame* rootScrollFrame = aPresContext->PresShell()->GetRootScrollFrame()) {
+ if (nsIContent* content = rootScrollFrame->GetContent()) {
+ id = FindOrCreateIDFor(content);
+ }
+ }
+ aLayer->SetFixedPositionData(id, anchor, sides);
+}
+
+bool
+nsLayoutUtils::ViewportHasDisplayPort(nsPresContext* aPresContext)
+{
+ nsIFrame* rootScrollFrame =
+ aPresContext->PresShell()->GetRootScrollFrame();
+ return rootScrollFrame &&
+ nsLayoutUtils::HasDisplayPort(rootScrollFrame->GetContent());
+}
+
+bool
+nsLayoutUtils::IsFixedPosFrameInDisplayPort(const nsIFrame* aFrame)
+{
+ // Fixed-pos frames are parented by the viewport frame or the page content frame.
+ // We'll assume that printing/print preview don't have displayports for their
+ // pages!
+ nsIFrame* parent = aFrame->GetParent();
+ if (!parent || parent->GetParent() ||
+ aFrame->StyleDisplay()->mPosition != NS_STYLE_POSITION_FIXED) {
+ return false;
+ }
+ return ViewportHasDisplayPort(aFrame->PresContext());
+}
+
+NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(ScrollbarThumbLayerized, bool)
+
+/* static */ void
+nsLayoutUtils::SetScrollbarThumbLayerization(nsIFrame* aThumbFrame, bool aLayerize)
+{
+ aThumbFrame->Properties().Set(ScrollbarThumbLayerized(), aLayerize);
+}
+
+bool
+nsLayoutUtils::IsScrollbarThumbLayerized(nsIFrame* aThumbFrame)
+{
+ return aThumbFrame->Properties().Get(ScrollbarThumbLayerized());
+}
+
+// static
+nsIScrollableFrame*
+nsLayoutUtils::GetNearestScrollableFrameForDirection(nsIFrame* aFrame,
+ Direction aDirection)
+{
+ NS_ASSERTION(aFrame, "GetNearestScrollableFrameForDirection expects a non-null frame");
+ for (nsIFrame* f = aFrame; f; f = nsLayoutUtils::GetCrossDocParentFrame(f)) {
+ nsIScrollableFrame* scrollableFrame = do_QueryFrame(f);
+ if (scrollableFrame) {
+ ScrollbarStyles ss = scrollableFrame->GetScrollbarStyles();
+ uint32_t directions = scrollableFrame->GetPerceivedScrollingDirections();
+ if (aDirection == eVertical ?
+ (ss.mVertical != NS_STYLE_OVERFLOW_HIDDEN &&
+ (directions & nsIScrollableFrame::VERTICAL)) :
+ (ss.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN &&
+ (directions & nsIScrollableFrame::HORIZONTAL)))
+ return scrollableFrame;
+ }
+ }
+ return nullptr;
+}
+
+// static
+nsIScrollableFrame*
+nsLayoutUtils::GetNearestScrollableFrame(nsIFrame* aFrame, uint32_t aFlags)
+{
+ NS_ASSERTION(aFrame, "GetNearestScrollableFrame expects a non-null frame");
+ for (nsIFrame* f = aFrame; f; f = (aFlags & SCROLLABLE_SAME_DOC) ?
+ f->GetParent() : nsLayoutUtils::GetCrossDocParentFrame(f)) {
+ nsIScrollableFrame* scrollableFrame = do_QueryFrame(f);
+ if (scrollableFrame) {
+ if (aFlags & SCROLLABLE_ONLY_ASYNC_SCROLLABLE) {
+ if (scrollableFrame->WantAsyncScroll()) {
+ return scrollableFrame;
+ }
+ } else {
+ ScrollbarStyles ss = scrollableFrame->GetScrollbarStyles();
+ if ((aFlags & SCROLLABLE_INCLUDE_HIDDEN) ||
+ ss.mVertical != NS_STYLE_OVERFLOW_HIDDEN ||
+ ss.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN) {
+ return scrollableFrame;
+ }
+ }
+ if (aFlags & SCROLLABLE_ALWAYS_MATCH_ROOT) {
+ nsIPresShell* ps = f->PresContext()->PresShell();
+ if (ps->GetRootScrollFrame() == f &&
+ ps->GetDocument() && ps->GetDocument()->IsRootDisplayDocument()) {
+ return scrollableFrame;
+ }
+ }
+ }
+ if ((aFlags & SCROLLABLE_FIXEDPOS_FINDS_ROOT) &&
+ f->StyleDisplay()->mPosition == NS_STYLE_POSITION_FIXED &&
+ nsLayoutUtils::IsReallyFixedPos(f)) {
+ return f->PresContext()->PresShell()->GetRootScrollFrameAsScrollable();
+ }
+ }
+ return nullptr;
+}
+
+// static
+nsRect
+nsLayoutUtils::GetScrolledRect(nsIFrame* aScrolledFrame,
+ const nsRect& aScrolledFrameOverflowArea,
+ const nsSize& aScrollPortSize,
+ uint8_t aDirection)
+{
+ WritingMode wm = aScrolledFrame->GetWritingMode();
+ // Potentially override the frame's direction to use the direction found
+ // by ScrollFrameHelper::GetScrolledFrameDir()
+ wm.SetDirectionFromBidiLevel(aDirection == NS_STYLE_DIRECTION_RTL ? 1 : 0);
+
+ nscoord x1 = aScrolledFrameOverflowArea.x,
+ x2 = aScrolledFrameOverflowArea.XMost(),
+ y1 = aScrolledFrameOverflowArea.y,
+ y2 = aScrolledFrameOverflowArea.YMost();
+
+ bool horizontal = !wm.IsVertical();
+
+ // Clamp the horizontal start-edge (x1 or x2, depending whether the logical
+ // axis that corresponds to horizontal progresses from L-R or R-L).
+ // In horizontal writing mode, we need to check IsInlineReversed() to see
+ // which side to clamp; in vertical mode, it depends on the block direction.
+ if ((horizontal && !wm.IsInlineReversed()) || wm.IsVerticalLR()) {
+ if (x1 < 0) {
+ x1 = 0;
+ }
+ } else {
+ if (x2 > aScrollPortSize.width) {
+ x2 = aScrollPortSize.width;
+ }
+ // When the scrolled frame chooses a size larger than its available width
+ // (because its padding alone is larger than the available width), we need
+ // to keep the start-edge of the scroll frame anchored to the start-edge of
+ // the scrollport.
+ // When the scrolled frame is RTL, this means moving it in our left-based
+ // coordinate system, so we need to compensate for its extra width here by
+ // effectively repositioning the frame.
+ nscoord extraWidth =
+ std::max(0, aScrolledFrame->GetSize().width - aScrollPortSize.width);
+ x2 += extraWidth;
+ }
+
+ // Similarly, clamp the vertical start-edge.
+ // In horizontal writing mode, the block direction is always top-to-bottom;
+ // in vertical writing mode, we need to check IsInlineReversed().
+ if (horizontal || !wm.IsInlineReversed()) {
+ if (y1 < 0) {
+ y1 = 0;
+ }
+ } else {
+ if (y2 > aScrollPortSize.height) {
+ y2 = aScrollPortSize.height;
+ }
+ nscoord extraHeight =
+ std::max(0, aScrolledFrame->GetSize().height - aScrollPortSize.height);
+ y2 += extraHeight;
+ }
+
+ return nsRect(x1, y1, x2 - x1, y2 - y1);
+}
+
+//static
+bool
+nsLayoutUtils::HasPseudoStyle(nsIContent* aContent,
+ nsStyleContext* aStyleContext,
+ CSSPseudoElementType aPseudoElement,
+ nsPresContext* aPresContext)
+{
+ NS_PRECONDITION(aPresContext, "Must have a prescontext");
+
+ RefPtr<nsStyleContext> pseudoContext;
+ if (aContent) {
+ pseudoContext = aPresContext->StyleSet()->
+ ProbePseudoElementStyle(aContent->AsElement(), aPseudoElement,
+ aStyleContext);
+ }
+ return pseudoContext != nullptr;
+}
+
+nsPoint
+nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(nsIDOMEvent* aDOMEvent, nsIFrame* aFrame)
+{
+ if (!aDOMEvent)
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ WidgetEvent* event = aDOMEvent->WidgetEventPtr();
+ if (!event)
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ return GetEventCoordinatesRelativeTo(event, aFrame);
+}
+
+nsPoint
+nsLayoutUtils::GetEventCoordinatesRelativeTo(const WidgetEvent* aEvent,
+ nsIFrame* aFrame)
+{
+ if (!aEvent || (aEvent->mClass != eMouseEventClass &&
+ aEvent->mClass != eMouseScrollEventClass &&
+ aEvent->mClass != eWheelEventClass &&
+ aEvent->mClass != eDragEventClass &&
+ aEvent->mClass != eSimpleGestureEventClass &&
+ aEvent->mClass != ePointerEventClass &&
+ aEvent->mClass != eGestureNotifyEventClass &&
+ aEvent->mClass != eTouchEventClass &&
+ aEvent->mClass != eQueryContentEventClass))
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+
+ return GetEventCoordinatesRelativeTo(aEvent,
+ aEvent->AsGUIEvent()->mRefPoint,
+ aFrame);
+}
+
+nsPoint
+nsLayoutUtils::GetEventCoordinatesRelativeTo(const WidgetEvent* aEvent,
+ const LayoutDeviceIntPoint& aPoint,
+ nsIFrame* aFrame)
+{
+ if (!aFrame) {
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+
+ nsIWidget* widget = aEvent->AsGUIEvent()->mWidget;
+ if (!widget) {
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+
+ return GetEventCoordinatesRelativeTo(widget, aPoint, aFrame);
+}
+
+nsPoint
+nsLayoutUtils::GetEventCoordinatesRelativeTo(nsIWidget* aWidget,
+ const LayoutDeviceIntPoint& aPoint,
+ nsIFrame* aFrame)
+{
+ if (!aFrame || !aWidget) {
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+
+ nsView* view = aFrame->GetView();
+ if (view) {
+ nsIWidget* frameWidget = view->GetWidget();
+ if (frameWidget && frameWidget == aWidget) {
+ // Special case this cause it happens a lot.
+ // This also fixes bug 664707, events in the extra-special case of select
+ // dropdown popups that are transformed.
+ nsPresContext* presContext = aFrame->PresContext();
+ nsPoint pt(presContext->DevPixelsToAppUnits(aPoint.x),
+ presContext->DevPixelsToAppUnits(aPoint.y));
+ pt = pt - view->ViewToWidgetOffset();
+ pt = pt.RemoveResolution(GetCurrentAPZResolutionScale(presContext->PresShell()));
+ return pt;
+ }
+ }
+
+ /* If we walk up the frame tree and discover that any of the frames are
+ * transformed, we need to do extra work to convert from the global
+ * space to the local space.
+ */
+ nsIFrame* rootFrame = aFrame;
+ bool transformFound = false;
+ for (nsIFrame* f = aFrame; f; f = GetCrossDocParentFrame(f)) {
+ if (f->IsTransformed()) {
+ transformFound = true;
+ }
+
+ rootFrame = f;
+ }
+
+ nsView* rootView = rootFrame->GetView();
+ if (!rootView) {
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+
+ nsPoint widgetToView = TranslateWidgetToView(rootFrame->PresContext(),
+ aWidget, aPoint, rootView);
+
+ if (widgetToView == nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE)) {
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+
+ // Convert from root document app units to app units of the document aFrame
+ // is in.
+ int32_t rootAPD = rootFrame->PresContext()->AppUnitsPerDevPixel();
+ int32_t localAPD = aFrame->PresContext()->AppUnitsPerDevPixel();
+ widgetToView = widgetToView.ScaleToOtherAppUnits(rootAPD, localAPD);
+ nsIPresShell* shell = aFrame->PresContext()->PresShell();
+
+ // XXX Bug 1224748 - Update nsLayoutUtils functions to correctly handle nsPresShell resolution
+ widgetToView = widgetToView.RemoveResolution(GetCurrentAPZResolutionScale(shell));
+
+ /* If we encountered a transform, we can't do simple arithmetic to figure
+ * out how to convert back to aFrame's coordinates and must use the CTM.
+ */
+ if (transformFound || aFrame->IsSVGText()) {
+ return TransformRootPointToFrame(aFrame, widgetToView);
+ }
+
+ /* Otherwise, all coordinate systems are translations of one another,
+ * so we can just subtract out the difference.
+ */
+ return widgetToView - aFrame->GetOffsetToCrossDoc(rootFrame);
+}
+
+nsIFrame*
+nsLayoutUtils::GetPopupFrameForEventCoordinates(nsPresContext* aPresContext,
+ const WidgetEvent* aEvent)
+{
+#ifdef MOZ_XUL
+ nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+ if (!pm) {
+ return nullptr;
+ }
+ nsTArray<nsIFrame*> popups;
+ pm->GetVisiblePopups(popups);
+ uint32_t i;
+ // Search from top to bottom
+ for (i = 0; i < popups.Length(); i++) {
+ nsIFrame* popup = popups[i];
+ if (popup->PresContext()->GetRootPresContext() == aPresContext &&
+ popup->GetScrollableOverflowRect().Contains(
+ GetEventCoordinatesRelativeTo(aEvent, popup))) {
+ return popup;
+ }
+ }
+#endif
+ return nullptr;
+}
+
+static void ConstrainToCoordValues(float& aStart, float& aSize)
+{
+ MOZ_ASSERT(aSize >= 0);
+
+ // Here we try to make sure that the resulting nsRect will continue to cover
+ // as much of the area that was covered by the original gfx Rect as possible.
+
+ // We clamp the bounds of the rect to {nscoord_MIN,nscoord_MAX} since
+ // nsRect::X/Y() and nsRect::XMost/YMost() can't return values outwith this
+ // range:
+ float end = aStart + aSize;
+ aStart = clamped(aStart, float(nscoord_MIN), float(nscoord_MAX));
+ end = clamped(end, float(nscoord_MIN), float(nscoord_MAX));
+
+ aSize = end - aStart;
+
+ // We must also clamp aSize to {0,nscoord_MAX} since nsRect::Width/Height()
+ // can't return a value greater than nscoord_MAX. If aSize is greater than
+ // nscoord_MAX then we reduce it to nscoord_MAX while keeping the rect
+ // centered:
+ if (aSize > nscoord_MAX) {
+ float excess = aSize - nscoord_MAX;
+ excess /= 2;
+ aStart += excess;
+ aSize = nscoord_MAX;
+ }
+}
+
+/**
+ * Given a gfxFloat, constrains its value to be between nscoord_MIN and nscoord_MAX.
+ *
+ * @param aVal The value to constrain (in/out)
+ */
+static void ConstrainToCoordValues(gfxFloat& aVal)
+{
+ if (aVal <= nscoord_MIN)
+ aVal = nscoord_MIN;
+ else if (aVal >= nscoord_MAX)
+ aVal = nscoord_MAX;
+}
+
+static void ConstrainToCoordValues(gfxFloat& aStart, gfxFloat& aSize)
+{
+ gfxFloat max = aStart + aSize;
+
+ // Clamp the end points to within nscoord range
+ ConstrainToCoordValues(aStart);
+ ConstrainToCoordValues(max);
+
+ aSize = max - aStart;
+ // If the width if still greater than the max nscoord, then bring both
+ // endpoints in by the same amount until it fits.
+ if (aSize > nscoord_MAX) {
+ gfxFloat excess = aSize - nscoord_MAX;
+ excess /= 2;
+
+ aStart += excess;
+ aSize = nscoord_MAX;
+ } else if (aSize < nscoord_MIN) {
+ gfxFloat excess = aSize - nscoord_MIN;
+ excess /= 2;
+
+ aStart -= excess;
+ aSize = nscoord_MIN;
+ }
+}
+
+nsRect
+nsLayoutUtils::RoundGfxRectToAppRect(const Rect &aRect, float aFactor)
+{
+ /* Get a new Rect whose units are app units by scaling by the specified factor. */
+ Rect scaledRect = aRect;
+ scaledRect.ScaleRoundOut(aFactor);
+
+ /* We now need to constrain our results to the max and min values for coords. */
+ ConstrainToCoordValues(scaledRect.x, scaledRect.width);
+ ConstrainToCoordValues(scaledRect.y, scaledRect.height);
+
+ /* Now typecast everything back. This is guaranteed to be safe. */
+ return nsRect(nscoord(scaledRect.X()), nscoord(scaledRect.Y()),
+ nscoord(scaledRect.Width()), nscoord(scaledRect.Height()));
+}
+
+nsRect
+nsLayoutUtils::RoundGfxRectToAppRect(const gfxRect &aRect, float aFactor)
+{
+ /* Get a new gfxRect whose units are app units by scaling by the specified factor. */
+ gfxRect scaledRect = aRect;
+ scaledRect.ScaleRoundOut(aFactor);
+
+ /* We now need to constrain our results to the max and min values for coords. */
+ ConstrainToCoordValues(scaledRect.x, scaledRect.width);
+ ConstrainToCoordValues(scaledRect.y, scaledRect.height);
+
+ /* Now typecast everything back. This is guaranteed to be safe. */
+ return nsRect(nscoord(scaledRect.X()), nscoord(scaledRect.Y()),
+ nscoord(scaledRect.Width()), nscoord(scaledRect.Height()));
+}
+
+
+nsRegion
+nsLayoutUtils::RoundedRectIntersectRect(const nsRect& aRoundedRect,
+ const nscoord aRadii[8],
+ const nsRect& aContainedRect)
+{
+ // rectFullHeight and rectFullWidth together will approximately contain
+ // the total area of the frame minus the rounded corners.
+ nsRect rectFullHeight = aRoundedRect;
+ nscoord xDiff = std::max(aRadii[NS_CORNER_TOP_LEFT_X], aRadii[NS_CORNER_BOTTOM_LEFT_X]);
+ rectFullHeight.x += xDiff;
+ rectFullHeight.width -= std::max(aRadii[NS_CORNER_TOP_RIGHT_X],
+ aRadii[NS_CORNER_BOTTOM_RIGHT_X]) + xDiff;
+ nsRect r1;
+ r1.IntersectRect(rectFullHeight, aContainedRect);
+
+ nsRect rectFullWidth = aRoundedRect;
+ nscoord yDiff = std::max(aRadii[NS_CORNER_TOP_LEFT_Y], aRadii[NS_CORNER_TOP_RIGHT_Y]);
+ rectFullWidth.y += yDiff;
+ rectFullWidth.height -= std::max(aRadii[NS_CORNER_BOTTOM_LEFT_Y],
+ aRadii[NS_CORNER_BOTTOM_RIGHT_Y]) + yDiff;
+ nsRect r2;
+ r2.IntersectRect(rectFullWidth, aContainedRect);
+
+ nsRegion result;
+ result.Or(r1, r2);
+ return result;
+}
+
+nsIntRegion
+nsLayoutUtils::RoundedRectIntersectIntRect(const nsIntRect& aRoundedRect,
+ const RectCornerRadii& aCornerRadii,
+ const nsIntRect& aContainedRect)
+{
+ // rectFullHeight and rectFullWidth together will approximately contain
+ // the total area of the frame minus the rounded corners.
+ nsIntRect rectFullHeight = aRoundedRect;
+ uint32_t xDiff = std::max(aCornerRadii.TopLeft().width,
+ aCornerRadii.BottomLeft().width);
+ rectFullHeight.x += xDiff;
+ rectFullHeight.width -= std::max(aCornerRadii.TopRight().width,
+ aCornerRadii.BottomRight().width) + xDiff;
+ nsIntRect r1;
+ r1.IntersectRect(rectFullHeight, aContainedRect);
+
+ nsIntRect rectFullWidth = aRoundedRect;
+ uint32_t yDiff = std::max(aCornerRadii.TopLeft().height,
+ aCornerRadii.TopRight().height);
+ rectFullWidth.y += yDiff;
+ rectFullWidth.height -= std::max(aCornerRadii.BottomLeft().height,
+ aCornerRadii.BottomRight().height) + yDiff;
+ nsIntRect r2;
+ r2.IntersectRect(rectFullWidth, aContainedRect);
+
+ nsIntRegion result;
+ result.Or(r1, r2);
+ return result;
+}
+
+// Helper for RoundedRectIntersectsRect.
+static bool
+CheckCorner(nscoord aXOffset, nscoord aYOffset,
+ nscoord aXRadius, nscoord aYRadius)
+{
+ MOZ_ASSERT(aXOffset > 0 && aYOffset > 0,
+ "must not pass nonpositives to CheckCorner");
+ MOZ_ASSERT(aXRadius >= 0 && aYRadius >= 0,
+ "must not pass negatives to CheckCorner");
+
+ // Avoid floating point math unless we're either (1) within the
+ // quarter-ellipse area at the rounded corner or (2) outside the
+ // rounding.
+ if (aXOffset >= aXRadius || aYOffset >= aYRadius)
+ return true;
+
+ // Convert coordinates to a unit circle with (0,0) as the center of
+ // curvature, and see if we're inside the circle or outside.
+ float scaledX = float(aXRadius - aXOffset) / float(aXRadius);
+ float scaledY = float(aYRadius - aYOffset) / float(aYRadius);
+ return scaledX * scaledX + scaledY * scaledY < 1.0f;
+}
+
+bool
+nsLayoutUtils::RoundedRectIntersectsRect(const nsRect& aRoundedRect,
+ const nscoord aRadii[8],
+ const nsRect& aTestRect)
+{
+ if (!aTestRect.Intersects(aRoundedRect))
+ return false;
+
+ // distances from this edge of aRoundedRect to opposite edge of aTestRect,
+ // which we know are positive due to the Intersects check above.
+ nsMargin insets;
+ insets.top = aTestRect.YMost() - aRoundedRect.y;
+ insets.right = aRoundedRect.XMost() - aTestRect.x;
+ insets.bottom = aRoundedRect.YMost() - aTestRect.y;
+ insets.left = aTestRect.XMost() - aRoundedRect.x;
+
+ // Check whether the bottom-right corner of aTestRect is inside the
+ // top left corner of aBounds when rounded by aRadii, etc. If any
+ // corner is not, then fail; otherwise succeed.
+ return CheckCorner(insets.left, insets.top,
+ aRadii[NS_CORNER_TOP_LEFT_X],
+ aRadii[NS_CORNER_TOP_LEFT_Y]) &&
+ CheckCorner(insets.right, insets.top,
+ aRadii[NS_CORNER_TOP_RIGHT_X],
+ aRadii[NS_CORNER_TOP_RIGHT_Y]) &&
+ CheckCorner(insets.right, insets.bottom,
+ aRadii[NS_CORNER_BOTTOM_RIGHT_X],
+ aRadii[NS_CORNER_BOTTOM_RIGHT_Y]) &&
+ CheckCorner(insets.left, insets.bottom,
+ aRadii[NS_CORNER_BOTTOM_LEFT_X],
+ aRadii[NS_CORNER_BOTTOM_LEFT_Y]);
+}
+
+nsRect
+nsLayoutUtils::MatrixTransformRect(const nsRect &aBounds,
+ const Matrix4x4 &aMatrix, float aFactor)
+{
+ RectDouble image = RectDouble(NSAppUnitsToDoublePixels(aBounds.x, aFactor),
+ NSAppUnitsToDoublePixels(aBounds.y, aFactor),
+ NSAppUnitsToDoublePixels(aBounds.width, aFactor),
+ NSAppUnitsToDoublePixels(aBounds.height, aFactor));
+
+ RectDouble maxBounds = RectDouble(double(nscoord_MIN) / aFactor * 0.5,
+ double(nscoord_MIN) / aFactor * 0.5,
+ double(nscoord_MAX) / aFactor,
+ double(nscoord_MAX) / aFactor);
+
+ image = aMatrix.TransformAndClipBounds(image, maxBounds);
+
+ return RoundGfxRectToAppRect(ThebesRect(image), aFactor);
+}
+
+nsPoint
+nsLayoutUtils::MatrixTransformPoint(const nsPoint &aPoint,
+ const Matrix4x4 &aMatrix, float aFactor)
+{
+ gfxPoint image = gfxPoint(NSAppUnitsToFloatPixels(aPoint.x, aFactor),
+ NSAppUnitsToFloatPixels(aPoint.y, aFactor));
+ image.Transform(aMatrix);
+ return nsPoint(NSFloatPixelsToAppUnits(float(image.x), aFactor),
+ NSFloatPixelsToAppUnits(float(image.y), aFactor));
+}
+
+void
+nsLayoutUtils::PostTranslate(Matrix4x4& aTransform, const nsPoint& aOrigin, float aAppUnitsPerPixel, bool aRounded)
+{
+ Point3D gfxOrigin =
+ Point3D(NSAppUnitsToFloatPixels(aOrigin.x, aAppUnitsPerPixel),
+ NSAppUnitsToFloatPixels(aOrigin.y, aAppUnitsPerPixel),
+ 0.0f);
+ if (aRounded) {
+ gfxOrigin.x = NS_round(gfxOrigin.x);
+ gfxOrigin.y = NS_round(gfxOrigin.y);
+ }
+ aTransform.PostTranslate(gfxOrigin);
+}
+
+Matrix4x4
+nsLayoutUtils::GetTransformToAncestor(nsIFrame *aFrame, const nsIFrame *aAncestor)
+{
+ nsIFrame* parent;
+ Matrix4x4 ctm;
+ if (aFrame == aAncestor) {
+ return ctm;
+ }
+ ctm = aFrame->GetTransformMatrix(aAncestor, &parent);
+ while (parent && parent != aAncestor) {
+ if (!parent->Extend3DContext()) {
+ ctm.ProjectTo2D();
+ }
+ ctm = ctm * parent->GetTransformMatrix(aAncestor, &parent);
+ }
+ return ctm;
+}
+
+gfxSize
+nsLayoutUtils::GetTransformToAncestorScale(nsIFrame* aFrame)
+{
+ Matrix4x4 transform = GetTransformToAncestor(aFrame,
+ nsLayoutUtils::GetDisplayRootFrame(aFrame));
+ Matrix transform2D;
+ if (transform.Is2D(&transform2D)) {
+ return ThebesMatrix(transform2D).ScaleFactors(true);
+ }
+ return gfxSize(1, 1);
+}
+
+static Matrix4x4
+GetTransformToAncestorExcludingAnimated(nsIFrame* aFrame,
+ const nsIFrame* aAncestor)
+{
+ nsIFrame* parent;
+ Matrix4x4 ctm;
+ if (aFrame == aAncestor) {
+ return ctm;
+ }
+ if (ActiveLayerTracker::IsScaleSubjectToAnimation(aFrame)) {
+ return ctm;
+ }
+ ctm = aFrame->GetTransformMatrix(aAncestor, &parent);
+ while (parent && parent != aAncestor) {
+ if (ActiveLayerTracker::IsScaleSubjectToAnimation(parent)) {
+ return Matrix4x4();
+ }
+ if (!parent->Extend3DContext()) {
+ ctm.ProjectTo2D();
+ }
+ ctm = ctm * parent->GetTransformMatrix(aAncestor, &parent);
+ }
+ return ctm;
+}
+
+gfxSize
+nsLayoutUtils::GetTransformToAncestorScaleExcludingAnimated(nsIFrame* aFrame)
+{
+ Matrix4x4 transform = GetTransformToAncestorExcludingAnimated(aFrame,
+ nsLayoutUtils::GetDisplayRootFrame(aFrame));
+ Matrix transform2D;
+ if (transform.Is2D(&transform2D)) {
+ return ThebesMatrix(transform2D).ScaleFactors(true);
+ }
+ return gfxSize(1, 1);
+}
+
+nsIFrame*
+nsLayoutUtils::FindNearestCommonAncestorFrame(nsIFrame* aFrame1, nsIFrame* aFrame2)
+{
+ AutoTArray<nsIFrame*,100> ancestors1;
+ AutoTArray<nsIFrame*,100> ancestors2;
+ nsIFrame* commonAncestor = nullptr;
+ if (aFrame1->PresContext() == aFrame2->PresContext()) {
+ commonAncestor = aFrame1->PresContext()->PresShell()->GetRootFrame();
+ }
+ for (nsIFrame* f = aFrame1; f != commonAncestor;
+ f = nsLayoutUtils::GetCrossDocParentFrame(f)) {
+ ancestors1.AppendElement(f);
+ }
+ for (nsIFrame* f = aFrame2; f != commonAncestor;
+ f = nsLayoutUtils::GetCrossDocParentFrame(f)) {
+ ancestors2.AppendElement(f);
+ }
+ uint32_t minLengths = std::min(ancestors1.Length(), ancestors2.Length());
+ for (uint32_t i = 1; i <= minLengths; ++i) {
+ if (ancestors1[ancestors1.Length() - i] == ancestors2[ancestors2.Length() - i]) {
+ commonAncestor = ancestors1[ancestors1.Length() - i];
+ } else {
+ break;
+ }
+ }
+ return commonAncestor;
+}
+
+nsLayoutUtils::TransformResult
+nsLayoutUtils::TransformPoints(nsIFrame* aFromFrame, nsIFrame* aToFrame,
+ uint32_t aPointCount, CSSPoint* aPoints)
+{
+ nsIFrame* nearestCommonAncestor = FindNearestCommonAncestorFrame(aFromFrame, aToFrame);
+ if (!nearestCommonAncestor) {
+ return NO_COMMON_ANCESTOR;
+ }
+ Matrix4x4 downToDest = GetTransformToAncestor(aToFrame, nearestCommonAncestor);
+ if (downToDest.IsSingular()) {
+ return NONINVERTIBLE_TRANSFORM;
+ }
+ downToDest.Invert();
+ Matrix4x4 upToAncestor = GetTransformToAncestor(aFromFrame, nearestCommonAncestor);
+ CSSToLayoutDeviceScale devPixelsPerCSSPixelFromFrame =
+ aFromFrame->PresContext()->CSSToDevPixelScale();
+ CSSToLayoutDeviceScale devPixelsPerCSSPixelToFrame =
+ aToFrame->PresContext()->CSSToDevPixelScale();
+ for (uint32_t i = 0; i < aPointCount; ++i) {
+ LayoutDevicePoint devPixels = aPoints[i] * devPixelsPerCSSPixelFromFrame;
+ // What should the behaviour be if some of the points aren't invertible
+ // and others are? Just assume all points are for now.
+ Point toDevPixels = downToDest.ProjectPoint(
+ (upToAncestor.TransformPoint(Point(devPixels.x, devPixels.y)))).As2DPoint();
+ // Divide here so that when the devPixelsPerCSSPixels are the same, we get the correct
+ // answer instead of some inaccuracy multiplying a number by its reciprocal.
+ aPoints[i] = LayoutDevicePoint(toDevPixels.x, toDevPixels.y) /
+ devPixelsPerCSSPixelToFrame;
+ }
+ return TRANSFORM_SUCCEEDED;
+}
+
+nsLayoutUtils::TransformResult
+nsLayoutUtils::TransformPoint(nsIFrame* aFromFrame, nsIFrame* aToFrame,
+ nsPoint& aPoint)
+{
+ nsIFrame* nearestCommonAncestor = FindNearestCommonAncestorFrame(aFromFrame, aToFrame);
+ if (!nearestCommonAncestor) {
+ return NO_COMMON_ANCESTOR;
+ }
+ Matrix4x4 downToDest = GetTransformToAncestor(aToFrame, nearestCommonAncestor);
+ if (downToDest.IsSingular()) {
+ return NONINVERTIBLE_TRANSFORM;
+ }
+ downToDest.Invert();
+ Matrix4x4 upToAncestor = GetTransformToAncestor(aFromFrame, nearestCommonAncestor);
+
+ float devPixelsPerAppUnitFromFrame =
+ 1.0f / aFromFrame->PresContext()->AppUnitsPerDevPixel();
+ float devPixelsPerAppUnitToFrame =
+ 1.0f / aToFrame->PresContext()->AppUnitsPerDevPixel();
+ Point4D toDevPixels = downToDest.ProjectPoint(
+ upToAncestor.TransformPoint(Point(aPoint.x * devPixelsPerAppUnitFromFrame,
+ aPoint.y * devPixelsPerAppUnitFromFrame)));
+ if (!toDevPixels.HasPositiveWCoord()) {
+ // Not strictly true, but we failed to get a valid point in this
+ // coordinate space.
+ return NONINVERTIBLE_TRANSFORM;
+ }
+ aPoint.x = NSToCoordRound(toDevPixels.x / devPixelsPerAppUnitToFrame);
+ aPoint.y = NSToCoordRound(toDevPixels.y / devPixelsPerAppUnitToFrame);
+ return TRANSFORM_SUCCEEDED;
+}
+
+nsLayoutUtils::TransformResult
+nsLayoutUtils::TransformRect(nsIFrame* aFromFrame, nsIFrame* aToFrame,
+ nsRect& aRect)
+{
+ nsIFrame* nearestCommonAncestor = FindNearestCommonAncestorFrame(aFromFrame, aToFrame);
+ if (!nearestCommonAncestor) {
+ return NO_COMMON_ANCESTOR;
+ }
+ Matrix4x4 downToDest = GetTransformToAncestor(aToFrame, nearestCommonAncestor);
+ if (downToDest.IsSingular()) {
+ return NONINVERTIBLE_TRANSFORM;
+ }
+ downToDest.Invert();
+ Matrix4x4 upToAncestor = GetTransformToAncestor(aFromFrame, nearestCommonAncestor);
+
+ float devPixelsPerAppUnitFromFrame =
+ 1.0f / aFromFrame->PresContext()->AppUnitsPerDevPixel();
+ float devPixelsPerAppUnitToFrame =
+ 1.0f / aToFrame->PresContext()->AppUnitsPerDevPixel();
+ gfx::Rect toDevPixels = downToDest.ProjectRectBounds(
+ upToAncestor.ProjectRectBounds(
+ gfx::Rect(aRect.x * devPixelsPerAppUnitFromFrame,
+ aRect.y * devPixelsPerAppUnitFromFrame,
+ aRect.width * devPixelsPerAppUnitFromFrame,
+ aRect.height * devPixelsPerAppUnitFromFrame),
+ Rect(-std::numeric_limits<Float>::max() * 0.5f,
+ -std::numeric_limits<Float>::max() * 0.5f,
+ std::numeric_limits<Float>::max(),
+ std::numeric_limits<Float>::max())),
+ Rect(-std::numeric_limits<Float>::max() * devPixelsPerAppUnitFromFrame * 0.5f,
+ -std::numeric_limits<Float>::max() * devPixelsPerAppUnitFromFrame * 0.5f,
+ std::numeric_limits<Float>::max() * devPixelsPerAppUnitFromFrame,
+ std::numeric_limits<Float>::max() * devPixelsPerAppUnitFromFrame));
+ aRect.x = toDevPixels.x / devPixelsPerAppUnitToFrame;
+ aRect.y = toDevPixels.y / devPixelsPerAppUnitToFrame;
+ aRect.width = toDevPixels.width / devPixelsPerAppUnitToFrame;
+ aRect.height = toDevPixels.height / devPixelsPerAppUnitToFrame;
+ return TRANSFORM_SUCCEEDED;
+}
+
+nsRect
+nsLayoutUtils::GetRectRelativeToFrame(Element* aElement, nsIFrame* aFrame)
+{
+ if (!aElement || !aFrame) {
+ return nsRect();
+ }
+
+ nsIFrame* frame = aElement->GetPrimaryFrame();
+ if (!frame) {
+ return nsRect();
+ }
+
+ nsRect rect = frame->GetRectRelativeToSelf();
+ nsLayoutUtils::TransformResult rv =
+ nsLayoutUtils::TransformRect(frame, aFrame, rect);
+ if (rv != nsLayoutUtils::TRANSFORM_SUCCEEDED) {
+ return nsRect();
+ }
+
+ return rect;
+}
+
+bool
+nsLayoutUtils::ContainsPoint(const nsRect& aRect, const nsPoint& aPoint,
+ nscoord aInflateSize)
+{
+ nsRect rect = aRect;
+ rect.Inflate(aInflateSize);
+ return rect.Contains(aPoint);
+}
+
+nsRect
+nsLayoutUtils::ClampRectToScrollFrames(nsIFrame* aFrame, const nsRect& aRect)
+{
+ nsIFrame* closestScrollFrame =
+ nsLayoutUtils::GetClosestFrameOfType(aFrame, nsGkAtoms::scrollFrame);
+
+ nsRect resultRect = aRect;
+
+ while (closestScrollFrame) {
+ nsIScrollableFrame* sf = do_QueryFrame(closestScrollFrame);
+
+ nsRect scrollPortRect = sf->GetScrollPortRect();
+ nsLayoutUtils::TransformRect(closestScrollFrame, aFrame, scrollPortRect);
+
+ resultRect = resultRect.Intersect(scrollPortRect);
+
+ // Check whether aRect is visible in the scroll frame or not.
+ if (resultRect.IsEmpty()) {
+ break;
+ }
+
+ // Get next ancestor scroll frame.
+ closestScrollFrame =
+ nsLayoutUtils::GetClosestFrameOfType(closestScrollFrame->GetParent(),
+ nsGkAtoms::scrollFrame);
+ }
+
+ return resultRect;
+}
+
+bool
+nsLayoutUtils::GetLayerTransformForFrame(nsIFrame* aFrame,
+ Matrix4x4* aTransform)
+{
+ // FIXME/bug 796690: we can sometimes compute a transform in these
+ // cases, it just increases complexity considerably. Punt for now.
+ if (aFrame->Extend3DContext() || aFrame->HasTransformGetter()) {
+ return false;
+ }
+
+ nsIFrame* root = nsLayoutUtils::GetDisplayRootFrame(aFrame);
+ if (root->HasAnyStateBits(NS_FRAME_UPDATE_LAYER_TREE)) {
+ // Content may have been invalidated, so we can't reliably compute
+ // the "layer transform" in general.
+ return false;
+ }
+ // If the caller doesn't care about the value, early-return to skip
+ // overhead below.
+ if (!aTransform) {
+ return true;
+ }
+
+ nsDisplayListBuilder builder(root,
+ nsDisplayListBuilderMode::TRANSFORM_COMPUTATION,
+ false/*don't build caret*/);
+ nsDisplayList list;
+ nsDisplayTransform* item =
+ new (&builder) nsDisplayTransform(&builder, aFrame, &list, nsRect());
+
+ *aTransform = item->GetTransform();
+ item->~nsDisplayTransform();
+
+ return true;
+}
+
+static bool
+TransformGfxPointFromAncestor(nsIFrame *aFrame,
+ const Point &aPoint,
+ nsIFrame *aAncestor,
+ Point* aOut)
+{
+ Matrix4x4 ctm = nsLayoutUtils::GetTransformToAncestor(aFrame, aAncestor);
+ ctm.Invert();
+ Point4D point = ctm.ProjectPoint(aPoint);
+ if (!point.HasPositiveWCoord()) {
+ return false;
+ }
+ *aOut = point.As2DPoint();
+ return true;
+}
+
+static Rect
+TransformGfxRectToAncestor(nsIFrame *aFrame,
+ const Rect &aRect,
+ const nsIFrame *aAncestor,
+ bool* aPreservesAxisAlignedRectangles = nullptr,
+ Maybe<Matrix4x4>* aMatrixCache = nullptr)
+{
+ Matrix4x4 ctm;
+ if (aMatrixCache && *aMatrixCache) {
+ // We are given a matrix to use, so use it
+ ctm = aMatrixCache->value();
+ } else {
+ // Else, compute it
+ ctm = nsLayoutUtils::GetTransformToAncestor(aFrame, aAncestor);
+ if (aMatrixCache) {
+ // and put it in the cache, if provided
+ *aMatrixCache = Some(ctm);
+ }
+ }
+ // Fill out the axis-alignment flag
+ if (aPreservesAxisAlignedRectangles) {
+ Matrix matrix2d;
+ *aPreservesAxisAlignedRectangles =
+ ctm.Is2D(&matrix2d) && matrix2d.PreservesAxisAlignedRectangles();
+ }
+ Rect maxBounds = Rect(-std::numeric_limits<float>::max() * 0.5,
+ -std::numeric_limits<float>::max() * 0.5,
+ std::numeric_limits<float>::max(),
+ std::numeric_limits<float>::max());
+ return ctm.TransformAndClipBounds(aRect, maxBounds);
+}
+
+static SVGTextFrame*
+GetContainingSVGTextFrame(nsIFrame* aFrame)
+{
+ if (!aFrame->IsSVGText()) {
+ return nullptr;
+ }
+
+ return static_cast<SVGTextFrame*>
+ (nsLayoutUtils::GetClosestFrameOfType(aFrame->GetParent(),
+ nsGkAtoms::svgTextFrame));
+}
+
+nsPoint
+nsLayoutUtils::TransformAncestorPointToFrame(nsIFrame* aFrame,
+ const nsPoint& aPoint,
+ nsIFrame* aAncestor)
+{
+ SVGTextFrame* text = GetContainingSVGTextFrame(aFrame);
+
+ float factor = aFrame->PresContext()->AppUnitsPerDevPixel();
+ Point result(NSAppUnitsToFloatPixels(aPoint.x, factor),
+ NSAppUnitsToFloatPixels(aPoint.y, factor));
+
+ if (text) {
+ if (!TransformGfxPointFromAncestor(text, result, aAncestor, &result)) {
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+ result = text->TransformFramePointToTextChild(result, aFrame);
+ } else {
+ if (!TransformGfxPointFromAncestor(aFrame, result, nullptr, &result)) {
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+ }
+
+ return nsPoint(NSFloatPixelsToAppUnits(float(result.x), factor),
+ NSFloatPixelsToAppUnits(float(result.y), factor));
+}
+
+nsRect
+nsLayoutUtils::TransformFrameRectToAncestor(nsIFrame* aFrame,
+ const nsRect& aRect,
+ const nsIFrame* aAncestor,
+ bool* aPreservesAxisAlignedRectangles /* = nullptr */,
+ Maybe<Matrix4x4>* aMatrixCache /* = nullptr */)
+{
+ SVGTextFrame* text = GetContainingSVGTextFrame(aFrame);
+
+ float srcAppUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
+ Rect result;
+
+ if (text) {
+ result = ToRect(text->TransformFrameRectFromTextChild(aRect, aFrame));
+ result = TransformGfxRectToAncestor(text, result, aAncestor, nullptr, aMatrixCache);
+ // TransformFrameRectFromTextChild could involve any kind of transform, we
+ // could drill down into it to get an answer out of it but we don't yet.
+ if (aPreservesAxisAlignedRectangles)
+ *aPreservesAxisAlignedRectangles = false;
+ } else {
+ result = Rect(NSAppUnitsToFloatPixels(aRect.x, srcAppUnitsPerDevPixel),
+ NSAppUnitsToFloatPixels(aRect.y, srcAppUnitsPerDevPixel),
+ NSAppUnitsToFloatPixels(aRect.width, srcAppUnitsPerDevPixel),
+ NSAppUnitsToFloatPixels(aRect.height, srcAppUnitsPerDevPixel));
+ result = TransformGfxRectToAncestor(aFrame, result, aAncestor, aPreservesAxisAlignedRectangles, aMatrixCache);
+ }
+
+ float destAppUnitsPerDevPixel = aAncestor->PresContext()->AppUnitsPerDevPixel();
+ return nsRect(NSFloatPixelsToAppUnits(float(result.x), destAppUnitsPerDevPixel),
+ NSFloatPixelsToAppUnits(float(result.y), destAppUnitsPerDevPixel),
+ NSFloatPixelsToAppUnits(float(result.width), destAppUnitsPerDevPixel),
+ NSFloatPixelsToAppUnits(float(result.height), destAppUnitsPerDevPixel));
+}
+
+static LayoutDeviceIntPoint GetWidgetOffset(nsIWidget* aWidget, nsIWidget*& aRootWidget) {
+ LayoutDeviceIntPoint offset(0, 0);
+ while ((aWidget->WindowType() == eWindowType_child ||
+ aWidget->IsPlugin())) {
+ nsIWidget* parent = aWidget->GetParent();
+ if (!parent) {
+ break;
+ }
+ LayoutDeviceIntRect bounds = aWidget->GetBounds();
+ offset += bounds.TopLeft();
+ aWidget = parent;
+ }
+ aRootWidget = aWidget;
+ return offset;
+}
+
+static LayoutDeviceIntPoint
+WidgetToWidgetOffset(nsIWidget* aFrom, nsIWidget* aTo) {
+ nsIWidget* fromRoot;
+ LayoutDeviceIntPoint fromOffset = GetWidgetOffset(aFrom, fromRoot);
+ nsIWidget* toRoot;
+ LayoutDeviceIntPoint toOffset = GetWidgetOffset(aTo, toRoot);
+
+ if (fromRoot == toRoot) {
+ return fromOffset - toOffset;
+ }
+ return aFrom->WidgetToScreenOffset() - aTo->WidgetToScreenOffset();
+}
+
+nsPoint
+nsLayoutUtils::TranslateWidgetToView(nsPresContext* aPresContext,
+ nsIWidget* aWidget, const LayoutDeviceIntPoint& aPt,
+ nsView* aView)
+{
+ nsPoint viewOffset;
+ nsIWidget* viewWidget = aView->GetNearestWidget(&viewOffset);
+ if (!viewWidget) {
+ return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+
+ LayoutDeviceIntPoint widgetPoint = aPt + WidgetToWidgetOffset(aWidget, viewWidget);
+ nsPoint widgetAppUnits(aPresContext->DevPixelsToAppUnits(widgetPoint.x),
+ aPresContext->DevPixelsToAppUnits(widgetPoint.y));
+ return widgetAppUnits - viewOffset;
+}
+
+LayoutDeviceIntPoint
+nsLayoutUtils::TranslateViewToWidget(nsPresContext* aPresContext,
+ nsView* aView, nsPoint aPt,
+ nsIWidget* aWidget)
+{
+ nsPoint viewOffset;
+ nsIWidget* viewWidget = aView->GetNearestWidget(&viewOffset);
+ if (!viewWidget) {
+ return LayoutDeviceIntPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+ }
+
+ nsPoint pt = (aPt +
+ viewOffset).ApplyResolution(GetCurrentAPZResolutionScale(aPresContext->PresShell()));
+ LayoutDeviceIntPoint relativeToViewWidget(aPresContext->AppUnitsToDevPixels(pt.x),
+ aPresContext->AppUnitsToDevPixels(pt.y));
+ return relativeToViewWidget + WidgetToWidgetOffset(viewWidget, aWidget);
+}
+
+// Combine aNewBreakType with aOrigBreakType, but limit the break types
+// to StyleClear::Left, Right, Both.
+StyleClear
+nsLayoutUtils::CombineBreakType(StyleClear aOrigBreakType,
+ StyleClear aNewBreakType)
+{
+ StyleClear breakType = aOrigBreakType;
+ switch(breakType) {
+ case StyleClear::Left:
+ if (StyleClear::Right == aNewBreakType ||
+ StyleClear::Both == aNewBreakType) {
+ breakType = StyleClear::Both;
+ }
+ break;
+ case StyleClear::Right:
+ if (StyleClear::Left == aNewBreakType ||
+ StyleClear::Both == aNewBreakType) {
+ breakType = StyleClear::Both;
+ }
+ break;
+ case StyleClear::None:
+ if (StyleClear::Left == aNewBreakType ||
+ StyleClear::Right == aNewBreakType ||
+ StyleClear::Both == aNewBreakType) {
+ breakType = aNewBreakType;
+ }
+ break;
+ default:
+ break;
+ }
+ return breakType;
+}
+
+#ifdef MOZ_DUMP_PAINTING
+#include <stdio.h>
+
+static bool gDumpEventList = false;
+
+// nsLayoutUtils::PaintFrame() can call itself recursively, so rather than
+// maintaining a single paint count, we need a stack.
+StaticAutoPtr<nsTArray<int>> gPaintCountStack;
+
+struct AutoNestedPaintCount {
+ AutoNestedPaintCount() {
+ gPaintCountStack->AppendElement(0);
+ }
+ ~AutoNestedPaintCount() {
+ gPaintCountStack->RemoveElementAt(gPaintCountStack->Length() - 1);
+ }
+};
+
+#endif
+
+nsIFrame*
+nsLayoutUtils::GetFrameForPoint(nsIFrame* aFrame, nsPoint aPt, uint32_t aFlags)
+{
+ PROFILER_LABEL("nsLayoutUtils", "GetFrameForPoint",
+ js::ProfileEntry::Category::GRAPHICS);
+
+ nsresult rv;
+ AutoTArray<nsIFrame*,8> outFrames;
+ rv = GetFramesForArea(aFrame, nsRect(aPt, nsSize(1, 1)), outFrames, aFlags);
+ NS_ENSURE_SUCCESS(rv, nullptr);
+ return outFrames.Length() ? outFrames.ElementAt(0) : nullptr;
+}
+
+nsresult
+nsLayoutUtils::GetFramesForArea(nsIFrame* aFrame, const nsRect& aRect,
+ nsTArray<nsIFrame*> &aOutFrames,
+ uint32_t aFlags)
+{
+ PROFILER_LABEL("nsLayoutUtils", "GetFramesForArea",
+ js::ProfileEntry::Category::GRAPHICS);
+
+ nsDisplayListBuilder builder(aFrame,
+ nsDisplayListBuilderMode::EVENT_DELIVERY,
+ false);
+ nsDisplayList list;
+
+ if (aFlags & IGNORE_PAINT_SUPPRESSION) {
+ builder.IgnorePaintSuppression();
+ }
+
+ if (aFlags & IGNORE_ROOT_SCROLL_FRAME) {
+ nsIFrame* rootScrollFrame =
+ aFrame->PresContext()->PresShell()->GetRootScrollFrame();
+ if (rootScrollFrame) {
+ builder.SetIgnoreScrollFrame(rootScrollFrame);
+ }
+ }
+ if (aFlags & IGNORE_CROSS_DOC) {
+ builder.SetDescendIntoSubdocuments(false);
+ }
+
+ builder.EnterPresShell(aFrame);
+ aFrame->BuildDisplayListForStackingContext(&builder, aRect, &list);
+ builder.LeavePresShell(aFrame, nullptr);
+
+#ifdef MOZ_DUMP_PAINTING
+ if (gDumpEventList) {
+ fprintf_stderr(stderr, "Event handling --- (%d,%d):\n", aRect.x, aRect.y);
+
+ std::stringstream ss;
+ nsFrame::PrintDisplayList(&builder, list, ss);
+ print_stderr(ss);
+ }
+#endif
+
+ nsDisplayItem::HitTestState hitTestState;
+ list.HitTest(&builder, aRect, &hitTestState, &aOutFrames);
+ list.DeleteAll();
+ return NS_OK;
+}
+
+// aScrollFrameAsScrollable must be non-nullptr and queryable to an nsIFrame
+FrameMetrics
+nsLayoutUtils::CalculateBasicFrameMetrics(nsIScrollableFrame* aScrollFrame) {
+ nsIFrame* frame = do_QueryFrame(aScrollFrame);
+ MOZ_ASSERT(frame);
+
+ // Calculate the metrics necessary for calculating the displayport.
+ // This code has a lot in common with the code in ComputeFrameMetrics();
+ // we may want to refactor this at some point.
+ FrameMetrics metrics;
+ nsPresContext* presContext = frame->PresContext();
+ nsIPresShell* presShell = presContext->PresShell();
+ CSSToLayoutDeviceScale deviceScale = presContext->CSSToDevPixelScale();
+ float resolution = 1.0f;
+ if (frame == presShell->GetRootScrollFrame()) {
+ // Only the root scrollable frame for a given presShell should pick up
+ // the presShell's resolution. All the other frames are 1.0.
+ resolution = presShell->GetResolution();
+ }
+ // Note: unlike in ComputeFrameMetrics(), we don't know the full cumulative
+ // resolution including FrameMetrics::mExtraResolution, because layout hasn't
+ // chosen a resolution to paint at yet. However, the display port calculation
+ // divides out mExtraResolution anyways, so we get the correct result by
+ // setting the mCumulativeResolution to everything except the extra resolution
+ // and leaving mExtraResolution at 1.
+ LayoutDeviceToLayerScale2D cumulativeResolution(
+ presShell->GetCumulativeResolution()
+ * nsLayoutUtils::GetTransformToAncestorScale(frame));
+
+ LayerToParentLayerScale layerToParentLayerScale(1.0f);
+ metrics.SetDevPixelsPerCSSPixel(deviceScale);
+ metrics.SetPresShellResolution(resolution);
+ metrics.SetCumulativeResolution(cumulativeResolution);
+ metrics.SetZoom(deviceScale * cumulativeResolution * layerToParentLayerScale);
+
+ // Only the size of the composition bounds is relevant to the
+ // displayport calculation, not its origin.
+ nsSize compositionSize = nsLayoutUtils::CalculateCompositionSizeForFrame(frame);
+ LayoutDeviceToParentLayerScale2D compBoundsScale;
+ if (frame == presShell->GetRootScrollFrame() && presContext->IsRootContentDocument()) {
+ if (presContext->GetParentPresContext()) {
+ float res = presContext->GetParentPresContext()->PresShell()->GetCumulativeResolution();
+ compBoundsScale = LayoutDeviceToParentLayerScale2D(
+ LayoutDeviceToParentLayerScale(res));
+ }
+ } else {
+ compBoundsScale = cumulativeResolution * layerToParentLayerScale;
+ }
+ metrics.SetCompositionBounds(
+ LayoutDeviceRect::FromAppUnits(nsRect(nsPoint(0, 0), compositionSize),
+ presContext->AppUnitsPerDevPixel())
+ * compBoundsScale);
+
+ metrics.SetRootCompositionSize(
+ nsLayoutUtils::CalculateRootCompositionSize(frame, false, metrics));
+
+ metrics.SetScrollOffset(CSSPoint::FromAppUnits(
+ aScrollFrame->GetScrollPosition()));
+
+ metrics.SetScrollableRect(CSSRect::FromAppUnits(
+ nsLayoutUtils::CalculateScrollableRectForFrame(aScrollFrame, nullptr)));
+
+ return metrics;
+}
+
+bool
+nsLayoutUtils::CalculateAndSetDisplayPortMargins(nsIScrollableFrame* aScrollFrame,
+ RepaintMode aRepaintMode) {
+ nsIFrame* frame = do_QueryFrame(aScrollFrame);
+ MOZ_ASSERT(frame);
+ nsIContent* content = frame->GetContent();
+ MOZ_ASSERT(content);
+
+ FrameMetrics metrics = CalculateBasicFrameMetrics(aScrollFrame);
+ ScreenMargin displayportMargins = APZCTreeManager::CalculatePendingDisplayPort(
+ metrics, ParentLayerPoint(0.0f, 0.0f));
+ nsIPresShell* presShell = frame->PresContext()->GetPresShell();
+ return nsLayoutUtils::SetDisplayPortMargins(
+ content, presShell, displayportMargins, 0, aRepaintMode);
+}
+
+void
+nsLayoutUtils::MaybeCreateDisplayPort(nsDisplayListBuilder& aBuilder,
+ nsIFrame* aScrollFrame) {
+ nsIContent* content = aScrollFrame->GetContent();
+ nsIScrollableFrame* scrollableFrame = do_QueryFrame(aScrollFrame);
+ if (!content || !scrollableFrame) {
+ return;
+ }
+
+ bool haveDisplayPort = HasDisplayPort(content);
+
+ // We perform an optimization where we ensure that at least one
+ // async-scrollable frame (i.e. one that WantsAsyncScroll()) has a displayport.
+ // If that's not the case yet, and we are async-scrollable, we will get a
+ // displayport.
+ if (aBuilder.IsPaintingToWindow() &&
+ nsLayoutUtils::AsyncPanZoomEnabled(aScrollFrame) &&
+ !aBuilder.HaveScrollableDisplayPort() &&
+ scrollableFrame->WantAsyncScroll()) {
+
+ // If we don't already have a displayport, calculate and set one.
+ if (!haveDisplayPort) {
+ CalculateAndSetDisplayPortMargins(scrollableFrame, nsLayoutUtils::RepaintMode::DoNotRepaint);
+#ifdef DEBUG
+ haveDisplayPort = HasDisplayPort(content);
+ MOZ_ASSERT(haveDisplayPort, "should have a displayport after having just set it");
+#endif
+ }
+
+ // Record that the we now have a scrollable display port.
+ aBuilder.SetHaveScrollableDisplayPort();
+ }
+}
+
+nsIScrollableFrame*
+nsLayoutUtils::GetAsyncScrollableAncestorFrame(nsIFrame* aTarget)
+{
+ uint32_t flags = nsLayoutUtils::SCROLLABLE_ALWAYS_MATCH_ROOT
+ | nsLayoutUtils::SCROLLABLE_ONLY_ASYNC_SCROLLABLE
+ | nsLayoutUtils::SCROLLABLE_FIXEDPOS_FINDS_ROOT;
+ return nsLayoutUtils::GetNearestScrollableFrame(aTarget, flags);
+}
+
+void
+nsLayoutUtils::SetZeroMarginDisplayPortOnAsyncScrollableAncestors(nsIFrame* aFrame,
+ RepaintMode aRepaintMode)
+{
+ nsIFrame* frame = aFrame;
+ while (frame) {
+ frame = nsLayoutUtils::GetCrossDocParentFrame(frame);
+ if (!frame) {
+ break;
+ }
+ nsIScrollableFrame* scrollAncestor = GetAsyncScrollableAncestorFrame(frame);
+ if (!scrollAncestor) {
+ break;
+ }
+ frame = do_QueryFrame(scrollAncestor);
+ MOZ_ASSERT(frame);
+ MOZ_ASSERT(scrollAncestor->WantAsyncScroll() ||
+ frame->PresContext()->PresShell()->GetRootScrollFrame() == frame);
+ if (nsLayoutUtils::AsyncPanZoomEnabled(frame) &&
+ !nsLayoutUtils::HasDisplayPort(frame->GetContent())) {
+ nsLayoutUtils::SetDisplayPortMargins(
+ frame->GetContent(), frame->PresContext()->PresShell(), ScreenMargin(), 0,
+ aRepaintMode);
+ }
+ }
+}
+
+void
+nsLayoutUtils::ExpireDisplayPortOnAsyncScrollableAncestor(nsIFrame* aFrame)
+{
+ nsIFrame* frame = aFrame;
+ while (frame) {
+ frame = nsLayoutUtils::GetCrossDocParentFrame(frame);
+ if (!frame) {
+ break;
+ }
+ nsIScrollableFrame* scrollAncestor = GetAsyncScrollableAncestorFrame(frame);
+ if (!scrollAncestor) {
+ break;
+ }
+ frame = do_QueryFrame(scrollAncestor);
+ MOZ_ASSERT(frame);
+ if (!frame) {
+ break;
+ }
+ MOZ_ASSERT(scrollAncestor->WantAsyncScroll() ||
+ frame->PresContext()->PresShell()->GetRootScrollFrame() == frame);
+ if (nsLayoutUtils::HasDisplayPort(frame->GetContent())) {
+ scrollAncestor->TriggerDisplayPortExpiration();
+ // Stop after the first trigger. If it failed, there's no point in
+ // continuing because all the rest of the frames we encounter are going
+ // to be ancestors of |scrollAncestor| which will keep its displayport.
+ // If the trigger succeeded, we stop because when the trigger executes
+ // it will call this function again to trigger the next ancestor up the
+ // chain.
+ break;
+ }
+ }
+}
+
+nsresult
+nsLayoutUtils::PaintFrame(nsRenderingContext* aRenderingContext, nsIFrame* aFrame,
+ const nsRegion& aDirtyRegion, nscolor aBackstop,
+ nsDisplayListBuilderMode aBuilderMode,
+ PaintFrameFlags aFlags)
+{
+ PROFILER_LABEL("nsLayoutUtils", "PaintFrame",
+ js::ProfileEntry::Category::GRAPHICS);
+
+#ifdef MOZ_DUMP_PAINTING
+ if (!gPaintCountStack) {
+ gPaintCountStack = new nsTArray<int>();
+ ClearOnShutdown(&gPaintCountStack);
+
+ gPaintCountStack->AppendElement(0);
+ }
+ ++gPaintCountStack->LastElement();
+ AutoNestedPaintCount nestedPaintCount;
+#endif
+
+ if (aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) {
+ nsView* view = aFrame->GetView();
+ if (!(view && view->GetWidget() && GetDisplayRootFrame(aFrame) == aFrame)) {
+ aFlags &= ~PaintFrameFlags::PAINT_WIDGET_LAYERS;
+ NS_ASSERTION(aRenderingContext, "need a rendering context");
+ }
+ }
+
+ nsPresContext* presContext = aFrame->PresContext();
+ nsIPresShell* presShell = presContext->PresShell();
+ nsRootPresContext* rootPresContext = presContext->GetRootPresContext();
+ if (!rootPresContext) {
+ return NS_OK;
+ }
+
+ TimeStamp startBuildDisplayList = TimeStamp::Now();
+ nsDisplayListBuilder builder(aFrame, aBuilderMode,
+ !(aFlags & PaintFrameFlags::PAINT_HIDE_CARET));
+ if (aFlags & PaintFrameFlags::PAINT_IN_TRANSFORM) {
+ builder.SetInTransform(true);
+ }
+ if (aFlags & PaintFrameFlags::PAINT_SYNC_DECODE_IMAGES) {
+ builder.SetSyncDecodeImages(true);
+ }
+ if (aFlags & (PaintFrameFlags::PAINT_WIDGET_LAYERS |
+ PaintFrameFlags::PAINT_TO_WINDOW)) {
+ builder.SetPaintingToWindow(true);
+ }
+ if (aFlags & PaintFrameFlags::PAINT_IGNORE_SUPPRESSION) {
+ builder.IgnorePaintSuppression();
+ }
+
+ nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
+ if (rootScrollFrame && !aFrame->GetParent()) {
+ nsIScrollableFrame* rootScrollableFrame = presShell->GetRootScrollFrameAsScrollable();
+ MOZ_ASSERT(rootScrollableFrame);
+ nsRect displayPortBase = aFrame->GetVisualOverflowRectRelativeToSelf();
+ Unused << rootScrollableFrame->DecideScrollableLayer(&builder, &displayPortBase,
+ /* aAllowCreateDisplayPort = */ true);
+ }
+
+ nsRegion visibleRegion;
+ if (aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) {
+ // This layer tree will be reused, so we'll need to calculate it
+ // for the whole "visible" area of the window
+ //
+ // |ignoreViewportScrolling| and |usingDisplayPort| are persistent
+ // document-rendering state. We rely on PresShell to flush
+ // retained layers as needed when that persistent state changes.
+ visibleRegion = aFrame->GetVisualOverflowRectRelativeToSelf();
+ } else {
+ visibleRegion = aDirtyRegion;
+ }
+
+ nsDisplayList list;
+
+ // If the root has embedded plugins, flag the builder so we know we'll need
+ // to update plugin geometry after painting.
+ if ((aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) &&
+ !(aFlags & PaintFrameFlags::PAINT_DOCUMENT_RELATIVE) &&
+ rootPresContext->NeedToComputePluginGeometryUpdates()) {
+ builder.SetWillComputePluginGeometry(true);
+ }
+
+ nsRect canvasArea(nsPoint(0, 0), aFrame->GetSize());
+ bool ignoreViewportScrolling =
+ aFrame->GetParent() ? false : presShell->IgnoringViewportScrolling();
+ if (ignoreViewportScrolling && rootScrollFrame) {
+ nsIScrollableFrame* rootScrollableFrame =
+ presShell->GetRootScrollFrameAsScrollable();
+ if (aFlags & PaintFrameFlags::PAINT_DOCUMENT_RELATIVE) {
+ // Make visibleRegion and aRenderingContext relative to the
+ // scrolled frame instead of the root frame.
+ nsPoint pos = rootScrollableFrame->GetScrollPosition();
+ visibleRegion.MoveBy(-pos);
+ if (aRenderingContext) {
+ gfxPoint devPixelOffset =
+ nsLayoutUtils::PointToGfxPoint(pos,
+ presContext->AppUnitsPerDevPixel());
+ aRenderingContext->ThebesContext()->SetMatrix(
+ aRenderingContext->ThebesContext()->CurrentMatrix().Translate(devPixelOffset));
+ }
+ }
+ builder.SetIgnoreScrollFrame(rootScrollFrame);
+
+ nsCanvasFrame* canvasFrame =
+ do_QueryFrame(rootScrollableFrame->GetScrolledFrame());
+ if (canvasFrame) {
+ // Use UnionRect here to ensure that areas where the scrollbars
+ // were are still filled with the background color.
+ canvasArea.UnionRect(canvasArea,
+ canvasFrame->CanvasArea() + builder.ToReferenceFrame(canvasFrame));
+ }
+ }
+
+ builder.EnterPresShell(aFrame);
+ nsRect dirtyRect = visibleRegion.GetBounds();
+ {
+ // If a scrollable container layer is created in nsDisplayList::PaintForFrame,
+ // it will be the scroll parent for display items that are built in the
+ // BuildDisplayListForStackingContext call below. We need to set the scroll
+ // parent on the display list builder while we build those items, so that they
+ // can pick up their scroll parent's id.
+ ViewID id = FrameMetrics::NULL_SCROLL_ID;
+ if (ignoreViewportScrolling && presContext->IsRootContentDocument()) {
+ if (nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame()) {
+ if (nsIContent* content = rootScrollFrame->GetContent()) {
+ id = nsLayoutUtils::FindOrCreateIDFor(content);
+ }
+ }
+ }
+ else if (presShell->GetDocument() && presShell->GetDocument()->IsRootDisplayDocument()
+ && !presShell->GetRootScrollFrame()) {
+ // In cases where the root document is a XUL document, we want to take
+ // the ViewID from the root element, as that will be the ViewID of the
+ // root APZC in the tree. Skip doing this in cases where we know
+ // nsGfxScrollFrame::BuilDisplayList will do it instead.
+ if (dom::Element* element = presShell->GetDocument()->GetDocumentElement()) {
+ id = nsLayoutUtils::FindOrCreateIDFor(element);
+ }
+ }
+
+ nsDisplayListBuilder::AutoCurrentScrollParentIdSetter idSetter(&builder, id);
+
+ PROFILER_LABEL("nsLayoutUtils", "PaintFrame::BuildDisplayList",
+ js::ProfileEntry::Category::GRAPHICS);
+
+
+ PaintTelemetry::AutoRecord record(PaintTelemetry::Metric::DisplayList);
+ aFrame->BuildDisplayListForStackingContext(&builder, dirtyRect, &list);
+ }
+
+ nsIAtom* frameType = aFrame->GetType();
+
+ // For the viewport frame in print preview/page layout we want to paint
+ // the grey background behind the page, not the canvas color.
+ if (frameType == nsGkAtoms::viewportFrame &&
+ nsLayoutUtils::NeedsPrintPreviewBackground(presContext)) {
+ nsRect bounds = nsRect(builder.ToReferenceFrame(aFrame),
+ aFrame->GetSize());
+ nsDisplayListBuilder::AutoBuildingDisplayList
+ buildingDisplayList(&builder, aFrame, bounds, false);
+ presShell->AddPrintPreviewBackgroundItem(builder, list, aFrame, bounds);
+ } else if (frameType != nsGkAtoms::pageFrame) {
+ // For printing, this function is first called on an nsPageFrame, which
+ // creates a display list with a PageContent item. The PageContent item's
+ // paint function calls this function on the nsPageFrame's child which is
+ // an nsPageContentFrame. We only want to add the canvas background color
+ // item once, for the nsPageContentFrame.
+
+ // Add the canvas background color to the bottom of the list. This
+ // happens after we've built the list so that AddCanvasBackgroundColorItem
+ // can monkey with the contents if necessary.
+ canvasArea.IntersectRect(canvasArea, visibleRegion.GetBounds());
+ nsDisplayListBuilder::AutoBuildingDisplayList
+ buildingDisplayList(&builder, aFrame, canvasArea, false);
+ presShell->AddCanvasBackgroundColorItem(
+ builder, list, aFrame, canvasArea, aBackstop);
+ }
+
+ builder.LeavePresShell(aFrame, &list);
+ Telemetry::AccumulateTimeDelta(Telemetry::PAINT_BUILD_DISPLAYLIST_TIME,
+ startBuildDisplayList);
+
+ bool profilerNeedsDisplayList = profiler_feature_active("displaylistdump");
+ bool consoleNeedsDisplayList = gfxUtils::DumpDisplayList() || gfxEnv::DumpPaint();
+#ifdef MOZ_DUMP_PAINTING
+ FILE* savedDumpFile = gfxUtils::sDumpPaintFile;
+#endif
+
+ UniquePtr<std::stringstream> ss;
+ if (consoleNeedsDisplayList || profilerNeedsDisplayList) {
+ ss = MakeUnique<std::stringstream>();
+#ifdef MOZ_DUMP_PAINTING
+ if (gfxEnv::DumpPaintToFile()) {
+ nsCString string("dump-");
+ // Include the process ID in the dump file name, to make sure that in an
+ // e10s setup different processes don't clobber each other's dump files.
+ string.AppendInt(getpid());
+ for (int paintCount : *gPaintCountStack) {
+ string.AppendLiteral("-");
+ string.AppendInt(paintCount);
+ }
+ string.AppendLiteral(".html");
+ gfxUtils::sDumpPaintFile = fopen(string.BeginReading(), "w");
+ } else {
+ gfxUtils::sDumpPaintFile = stderr;
+ }
+ if (gfxEnv::DumpPaintToFile()) {
+ *ss << "<html><head><script>\n"
+ "var array = {};\n"
+ "function ViewImage(index) { \n"
+ " var image = document.getElementById(index);\n"
+ " if (image.src) {\n"
+ " image.removeAttribute('src');\n"
+ " } else {\n"
+ " image.src = array[index];\n"
+ " }\n"
+ "}</script></head><body>";
+ }
+#endif
+ *ss << nsPrintfCString("Painting --- before optimization (dirty %d,%d,%d,%d):\n",
+ dirtyRect.x, dirtyRect.y, dirtyRect.width, dirtyRect.height).get();
+ nsFrame::PrintDisplayList(&builder, list, *ss, gfxEnv::DumpPaintToFile());
+
+ if (gfxEnv::DumpPaint() || gfxEnv::DumpPaintItems()) {
+ // Flush stream now to avoid reordering dump output relative to
+ // messages dumped by PaintRoot below.
+ if (profilerNeedsDisplayList && !consoleNeedsDisplayList) {
+ profiler_log(ss->str().c_str());
+ } else {
+ // Send to the console which will send to the profiler if required.
+ fprint_stderr(gfxUtils::sDumpPaintFile, *ss);
+ }
+ ss = MakeUnique<std::stringstream>();
+ }
+ }
+
+ uint32_t flags = nsDisplayList::PAINT_DEFAULT;
+ if (aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) {
+ flags |= nsDisplayList::PAINT_USE_WIDGET_LAYERS;
+ if (!(aFlags & PaintFrameFlags::PAINT_DOCUMENT_RELATIVE)) {
+ nsIWidget *widget = aFrame->GetNearestWidget();
+ if (widget) {
+ // If we're finished building display list items for painting of the outermost
+ // pres shell, notify the widget about any toolbars we've encountered.
+ widget->UpdateThemeGeometries(builder.GetThemeGeometries());
+ }
+ }
+ }
+ if (aFlags & PaintFrameFlags::PAINT_EXISTING_TRANSACTION) {
+ flags |= nsDisplayList::PAINT_EXISTING_TRANSACTION;
+ }
+ if (aFlags & PaintFrameFlags::PAINT_NO_COMPOSITE) {
+ flags |= nsDisplayList::PAINT_NO_COMPOSITE;
+ }
+ if (aFlags & PaintFrameFlags::PAINT_COMPRESSED) {
+ flags |= nsDisplayList::PAINT_COMPRESSED;
+ }
+
+ TimeStamp paintStart = TimeStamp::Now();
+ RefPtr<LayerManager> layerManager
+ = list.PaintRoot(&builder, aRenderingContext, flags);
+ Telemetry::AccumulateTimeDelta(Telemetry::PAINT_RASTERIZE_TIME,
+ paintStart);
+
+ if (gfxPrefs::GfxLoggingPaintedPixelCountEnabled()) {
+ TimeStamp now = TimeStamp::Now();
+ float rasterizeTime = (now - paintStart).ToMilliseconds();
+ uint32_t pixelCount = layerManager->GetAndClearPaintedPixelCount();
+ static std::vector<std::pair<TimeStamp, uint32_t>> history;
+ if (pixelCount) {
+ history.push_back(std::make_pair(now, pixelCount));
+ }
+ uint32_t paintedInLastSecond = 0;
+ for (auto i = history.begin(); i != history.end(); i++) {
+ if ((now - i->first).ToMilliseconds() > 1000.0f) {
+ // more than 1000ms ago, don't count it
+ continue;
+ }
+ if (paintedInLastSecond == 0) {
+ // This is the first one in the last 1000ms, so drop everything earlier
+ history.erase(history.begin(), i);
+ i = history.begin();
+ }
+ paintedInLastSecond += i->second;
+ MOZ_ASSERT(paintedInLastSecond); // all historical pixel counts are > 0
+ }
+ printf_stderr("Painted %u pixels in %fms (%u in the last 1000ms)\n",
+ pixelCount, rasterizeTime, paintedInLastSecond);
+ }
+
+ if (consoleNeedsDisplayList || profilerNeedsDisplayList) {
+ *ss << "Painting --- after optimization:\n";
+ nsFrame::PrintDisplayList(&builder, list, *ss, gfxEnv::DumpPaintToFile());
+
+ *ss << "Painting --- layer tree:\n";
+ if (layerManager) {
+ FrameLayerBuilder::DumpRetainedLayerTree(layerManager, *ss,
+ gfxEnv::DumpPaintToFile());
+ }
+
+ if (profilerNeedsDisplayList && !consoleNeedsDisplayList) {
+ profiler_log(ss->str().c_str());
+ } else {
+ // Send to the console which will send to the profiler if required.
+ fprint_stderr(gfxUtils::sDumpPaintFile, *ss);
+ }
+
+#ifdef MOZ_DUMP_PAINTING
+ if (gfxEnv::DumpPaintToFile()) {
+ *ss << "</body></html>";
+ }
+ if (gfxEnv::DumpPaintToFile()) {
+ fclose(gfxUtils::sDumpPaintFile);
+ }
+ gfxUtils::sDumpPaintFile = savedDumpFile;
+#endif
+
+ std::stringstream lsStream;
+ nsFrame::PrintDisplayList(&builder, list, lsStream);
+ layerManager->GetRoot()->SetDisplayListLog(lsStream.str().c_str());
+ }
+
+#ifdef MOZ_DUMP_PAINTING
+ if (gfxPrefs::DumpClientLayers()) {
+ std::stringstream ss;
+ FrameLayerBuilder::DumpRetainedLayerTree(layerManager, ss, false);
+ print_stderr(ss);
+ }
+#endif
+
+ // Update the widget's opaque region information. This sets
+ // glass boundaries on Windows. Also set up the window dragging region
+ // and plugin clip regions and bounds.
+ if ((aFlags & PaintFrameFlags::PAINT_WIDGET_LAYERS) &&
+ !(aFlags & PaintFrameFlags::PAINT_DOCUMENT_RELATIVE)) {
+ nsIWidget *widget = aFrame->GetNearestWidget();
+ if (widget) {
+ nsRegion opaqueRegion;
+ opaqueRegion.And(builder.GetWindowExcludeGlassRegion(), builder.GetWindowOpaqueRegion());
+ widget->UpdateOpaqueRegion(
+ LayoutDeviceIntRegion::FromUnknownRegion(
+ opaqueRegion.ToNearestPixels(presContext->AppUnitsPerDevPixel())));
+
+ widget->UpdateWindowDraggingRegion(builder.GetWindowDraggingRegion());
+ }
+ }
+
+ if (builder.WillComputePluginGeometry()) {
+ // For single process compute and apply plugin geometry updates to plugin
+ // windows, then request composition. For content processes skip eveything
+ // except requesting composition. Geometry updates were calculated and
+ // shipped to the chrome process in nsDisplayList when the layer
+ // transaction completed.
+ if (XRE_IsParentProcess()) {
+ rootPresContext->ComputePluginGeometryUpdates(aFrame, &builder, &list);
+ // We're not going to get a WillPaintWindow event here if we didn't do
+ // widget invalidation, so just apply the plugin geometry update here
+ // instead. We could instead have the compositor send back an equivalent
+ // to WillPaintWindow, but it should be close enough to now not to matter.
+ if (layerManager && !layerManager->NeedsWidgetInvalidation()) {
+ rootPresContext->ApplyPluginGeometryUpdates();
+ }
+ }
+
+ // We told the compositor thread not to composite when it received the
+ // transaction because we wanted to update plugins first. Schedule the
+ // composite now.
+ if (layerManager) {
+ layerManager->Composite();
+ }
+ }
+
+
+ // Flush the list so we don't trigger the IsEmpty-on-destruction assertion
+ list.DeleteAll();
+ return NS_OK;
+}
+
+/**
+ * Uses a binary search for find where the cursor falls in the line of text
+ * It also keeps track of the part of the string that has already been measured
+ * so it doesn't have to keep measuring the same text over and over
+ *
+ * @param "aBaseWidth" contains the width in twips of the portion
+ * of the text that has already been measured, and aBaseInx contains
+ * the index of the text that has already been measured.
+ *
+ * @param aTextWidth returns the (in twips) the length of the text that falls
+ * before the cursor aIndex contains the index of the text where the cursor falls
+ */
+bool
+nsLayoutUtils::BinarySearchForPosition(DrawTarget* aDrawTarget,
+ nsFontMetrics& aFontMetrics,
+ const char16_t* aText,
+ int32_t aBaseWidth,
+ int32_t aBaseInx,
+ int32_t aStartInx,
+ int32_t aEndInx,
+ int32_t aCursorPos,
+ int32_t& aIndex,
+ int32_t& aTextWidth)
+{
+ int32_t range = aEndInx - aStartInx;
+ if ((range == 1) || (range == 2 && NS_IS_HIGH_SURROGATE(aText[aStartInx]))) {
+ aIndex = aStartInx + aBaseInx;
+ aTextWidth = nsLayoutUtils::AppUnitWidthOfString(aText, aIndex,
+ aFontMetrics, aDrawTarget);
+ return true;
+ }
+
+ int32_t inx = aStartInx + (range / 2);
+
+ // Make sure we don't leave a dangling low surrogate
+ if (NS_IS_HIGH_SURROGATE(aText[inx-1]))
+ inx++;
+
+ int32_t textWidth = nsLayoutUtils::AppUnitWidthOfString(aText, inx,
+ aFontMetrics,
+ aDrawTarget);
+
+ int32_t fullWidth = aBaseWidth + textWidth;
+ if (fullWidth == aCursorPos) {
+ aTextWidth = textWidth;
+ aIndex = inx;
+ return true;
+ } else if (aCursorPos < fullWidth) {
+ aTextWidth = aBaseWidth;
+ if (BinarySearchForPosition(aDrawTarget, aFontMetrics, aText, aBaseWidth,
+ aBaseInx, aStartInx, inx, aCursorPos, aIndex,
+ aTextWidth)) {
+ return true;
+ }
+ } else {
+ aTextWidth = fullWidth;
+ if (BinarySearchForPosition(aDrawTarget, aFontMetrics, aText, aBaseWidth,
+ aBaseInx, inx, aEndInx, aCursorPos, aIndex,
+ aTextWidth)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static void
+AddBoxesForFrame(nsIFrame* aFrame,
+ nsLayoutUtils::BoxCallback* aCallback)
+{
+ nsIAtom* pseudoType = aFrame->StyleContext()->GetPseudo();
+
+ if (pseudoType == nsCSSAnonBoxes::tableWrapper) {
+ AddBoxesForFrame(aFrame->PrincipalChildList().FirstChild(), aCallback);
+ if (aCallback->mIncludeCaptionBoxForTable) {
+ nsIFrame* kid = aFrame->GetChildList(nsIFrame::kCaptionList).FirstChild();
+ if (kid) {
+ AddBoxesForFrame(kid, aCallback);
+ }
+ }
+ } else if (pseudoType == nsCSSAnonBoxes::mozAnonymousBlock ||
+ pseudoType == nsCSSAnonBoxes::mozAnonymousPositionedBlock ||
+ pseudoType == nsCSSAnonBoxes::mozMathMLAnonymousBlock ||
+ pseudoType == nsCSSAnonBoxes::mozXULAnonymousBlock) {
+ for (nsIFrame* kid : aFrame->PrincipalChildList()) {
+ AddBoxesForFrame(kid, aCallback);
+ }
+ } else {
+ aCallback->AddBox(aFrame);
+ }
+}
+
+void
+nsLayoutUtils::GetAllInFlowBoxes(nsIFrame* aFrame, BoxCallback* aCallback)
+{
+ while (aFrame) {
+ AddBoxesForFrame(aFrame, aCallback);
+ aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame);
+ }
+}
+
+nsIFrame*
+nsLayoutUtils::GetFirstNonAnonymousFrame(nsIFrame* aFrame)
+{
+ while (aFrame) {
+ nsIAtom* pseudoType = aFrame->StyleContext()->GetPseudo();
+
+ if (pseudoType == nsCSSAnonBoxes::tableWrapper) {
+ nsIFrame* f = GetFirstNonAnonymousFrame(aFrame->PrincipalChildList().FirstChild());
+ if (f) {
+ return f;
+ }
+ nsIFrame* kid = aFrame->GetChildList(nsIFrame::kCaptionList).FirstChild();
+ if (kid) {
+ f = GetFirstNonAnonymousFrame(kid);
+ if (f) {
+ return f;
+ }
+ }
+ } else if (pseudoType == nsCSSAnonBoxes::mozAnonymousBlock ||
+ pseudoType == nsCSSAnonBoxes::mozAnonymousPositionedBlock ||
+ pseudoType == nsCSSAnonBoxes::mozMathMLAnonymousBlock ||
+ pseudoType == nsCSSAnonBoxes::mozXULAnonymousBlock) {
+ for (nsIFrame* kid : aFrame->PrincipalChildList()) {
+ nsIFrame* f = GetFirstNonAnonymousFrame(kid);
+ if (f) {
+ return f;
+ }
+ }
+ } else {
+ return aFrame;
+ }
+
+ aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame);
+ }
+ return nullptr;
+}
+
+struct BoxToRect : public nsLayoutUtils::BoxCallback {
+ nsIFrame* mRelativeTo;
+ nsLayoutUtils::RectCallback* mCallback;
+ uint32_t mFlags;
+
+ BoxToRect(nsIFrame* aRelativeTo, nsLayoutUtils::RectCallback* aCallback,
+ uint32_t aFlags)
+ : mRelativeTo(aRelativeTo), mCallback(aCallback), mFlags(aFlags) {}
+
+ virtual void AddBox(nsIFrame* aFrame) override {
+ nsRect r;
+ nsIFrame* outer = nsSVGUtils::GetOuterSVGFrameAndCoveredRegion(aFrame, &r);
+ if (!outer) {
+ outer = aFrame;
+ switch (mFlags & nsLayoutUtils::RECTS_WHICH_BOX_MASK) {
+ case nsLayoutUtils::RECTS_USE_CONTENT_BOX:
+ r = aFrame->GetContentRectRelativeToSelf();
+ break;
+ case nsLayoutUtils::RECTS_USE_PADDING_BOX:
+ r = aFrame->GetPaddingRectRelativeToSelf();
+ break;
+ case nsLayoutUtils::RECTS_USE_MARGIN_BOX:
+ r = aFrame->GetMarginRectRelativeToSelf();
+ break;
+ default: // Use the border box
+ r = aFrame->GetRectRelativeToSelf();
+ }
+ }
+ if (mFlags & nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS) {
+ r = nsLayoutUtils::TransformFrameRectToAncestor(outer, r, mRelativeTo);
+ } else {
+ r += outer->GetOffsetTo(mRelativeTo);
+ }
+ mCallback->AddRect(r);
+ }
+};
+
+struct BoxToRectAndText : public BoxToRect {
+ mozilla::dom::DOMStringList* mTextList;
+
+ BoxToRectAndText(nsIFrame* aRelativeTo, nsLayoutUtils::RectCallback* aCallback,
+ mozilla::dom::DOMStringList* aTextList, uint32_t aFlags)
+ : BoxToRect(aRelativeTo, aCallback, aFlags), mTextList(aTextList) {}
+
+ virtual void AddBox(nsIFrame* aFrame) override {
+ BoxToRect::AddBox(aFrame);
+ if (mTextList) {
+ nsIContent* content = aFrame->GetContent();
+ nsAutoString textContent;
+ mozilla::ErrorResult err; // ignored
+ content->GetTextContent(textContent, err);
+ mTextList->Add(textContent);
+ }
+ }
+};
+
+void
+nsLayoutUtils::GetAllInFlowRects(nsIFrame* aFrame, nsIFrame* aRelativeTo,
+ RectCallback* aCallback, uint32_t aFlags)
+{
+ BoxToRect converter(aRelativeTo, aCallback, aFlags);
+ GetAllInFlowBoxes(aFrame, &converter);
+}
+
+void
+nsLayoutUtils::GetAllInFlowRectsAndTexts(nsIFrame* aFrame, nsIFrame* aRelativeTo,
+ RectCallback* aCallback,
+ mozilla::dom::DOMStringList* aTextList,
+ uint32_t aFlags)
+{
+ BoxToRectAndText converter(aRelativeTo, aCallback, aTextList, aFlags);
+ GetAllInFlowBoxes(aFrame, &converter);
+}
+
+nsLayoutUtils::RectAccumulator::RectAccumulator() : mSeenFirstRect(false) {}
+
+void nsLayoutUtils::RectAccumulator::AddRect(const nsRect& aRect) {
+ mResultRect.UnionRect(mResultRect, aRect);
+ if (!mSeenFirstRect) {
+ mSeenFirstRect = true;
+ mFirstRect = aRect;
+ }
+}
+
+nsLayoutUtils::RectListBuilder::RectListBuilder(DOMRectList* aList)
+ : mRectList(aList)
+{
+}
+
+void nsLayoutUtils::RectListBuilder::AddRect(const nsRect& aRect) {
+ RefPtr<DOMRect> rect = new DOMRect(mRectList);
+
+ rect->SetLayoutRect(aRect);
+ mRectList->Append(rect);
+}
+
+nsIFrame* nsLayoutUtils::GetContainingBlockForClientRect(nsIFrame* aFrame)
+{
+ return aFrame->PresContext()->PresShell()->GetRootFrame();
+}
+
+nsRect
+nsLayoutUtils::GetAllInFlowRectsUnion(nsIFrame* aFrame, nsIFrame* aRelativeTo,
+ uint32_t aFlags) {
+ RectAccumulator accumulator;
+ GetAllInFlowRects(aFrame, aRelativeTo, &accumulator, aFlags);
+ return accumulator.mResultRect.IsEmpty() ? accumulator.mFirstRect
+ : accumulator.mResultRect;
+}
+
+nsRect
+nsLayoutUtils::GetTextShadowRectsUnion(const nsRect& aTextAndDecorationsRect,
+ nsIFrame* aFrame,
+ uint32_t aFlags)
+{
+ const nsStyleText* textStyle = aFrame->StyleText();
+ if (!textStyle->HasTextShadow())
+ return aTextAndDecorationsRect;
+
+ nsRect resultRect = aTextAndDecorationsRect;
+ int32_t A2D = aFrame->PresContext()->AppUnitsPerDevPixel();
+ for (uint32_t i = 0; i < textStyle->mTextShadow->Length(); ++i) {
+ nsCSSShadowItem* shadow = textStyle->mTextShadow->ShadowAt(i);
+ nsMargin blur = nsContextBoxBlur::GetBlurRadiusMargin(shadow->mRadius, A2D);
+ if ((aFlags & EXCLUDE_BLUR_SHADOWS) && blur != nsMargin(0, 0, 0, 0))
+ continue;
+
+ nsRect tmpRect(aTextAndDecorationsRect);
+
+ tmpRect.MoveBy(nsPoint(shadow->mXOffset, shadow->mYOffset));
+ tmpRect.Inflate(blur);
+
+ resultRect.UnionRect(resultRect, tmpRect);
+ }
+ return resultRect;
+}
+
+enum ObjectDimensionType { eWidth, eHeight };
+static nscoord
+ComputeMissingDimension(const nsSize& aDefaultObjectSize,
+ const nsSize& aIntrinsicRatio,
+ const Maybe<nscoord>& aSpecifiedWidth,
+ const Maybe<nscoord>& aSpecifiedHeight,
+ ObjectDimensionType aDimensionToCompute)
+{
+ // The "default sizing algorithm" computes the missing dimension as follows:
+ // (source: http://dev.w3.org/csswg/css-images-3/#default-sizing )
+
+ // 1. "If the object has an intrinsic aspect ratio, the missing dimension of
+ // the concrete object size is calculated using the intrinsic aspect
+ // ratio and the present dimension."
+ if (aIntrinsicRatio.width > 0 && aIntrinsicRatio.height > 0) {
+ // Fill in the missing dimension using the intrinsic aspect ratio.
+ nscoord knownDimensionSize;
+ float ratio;
+ if (aDimensionToCompute == eWidth) {
+ knownDimensionSize = *aSpecifiedHeight;
+ ratio = aIntrinsicRatio.width / aIntrinsicRatio.height;
+ } else {
+ knownDimensionSize = *aSpecifiedWidth;
+ ratio = aIntrinsicRatio.height / aIntrinsicRatio.width;
+ }
+ return NSCoordSaturatingNonnegativeMultiply(knownDimensionSize, ratio);
+ }
+
+ // 2. "Otherwise, if the missing dimension is present in the object’s
+ // intrinsic dimensions, [...]"
+ // NOTE: *Skipping* this case, because we already know it's not true -- we're
+ // in this function because the missing dimension is *not* present in
+ // the object's intrinsic dimensions.
+
+ // 3. "Otherwise, the missing dimension of the concrete object size is taken
+ // from the default object size. "
+ return (aDimensionToCompute == eWidth) ?
+ aDefaultObjectSize.width : aDefaultObjectSize.height;
+}
+
+/*
+ * This computes & returns the concrete object size of replaced content, if
+ * that content were to be rendered with "object-fit: none". (Or, if the
+ * element has neither an intrinsic height nor width, this method returns an
+ * empty Maybe<> object.)
+ *
+ * As specced...
+ * http://dev.w3.org/csswg/css-images-3/#valdef-object-fit-none
+ * ..we use "the default sizing algorithm with no specified size,
+ * and a default object size equal to the replaced element's used width and
+ * height."
+ *
+ * The default sizing algorithm is described here:
+ * http://dev.w3.org/csswg/css-images-3/#default-sizing
+ * Quotes in the function-impl are taken from that ^ spec-text.
+ *
+ * Per its final bulleted section: since there's no specified size,
+ * we run the default sizing algorithm using the object's intrinsic size in
+ * place of the specified size. But if the object has neither an intrinsic
+ * height nor an intrinsic width, then we instead return without populating our
+ * outparam, and we let the caller figure out the size (using a contain
+ * constraint).
+ */
+static Maybe<nsSize>
+MaybeComputeObjectFitNoneSize(const nsSize& aDefaultObjectSize,
+ const IntrinsicSize& aIntrinsicSize,
+ const nsSize& aIntrinsicRatio)
+{
+ // "If the object has an intrinsic height or width, its size is resolved as
+ // if its intrinsic dimensions were given as the specified size."
+ //
+ // So, first we check if we have an intrinsic height and/or width:
+ Maybe<nscoord> specifiedWidth;
+ if (aIntrinsicSize.width.GetUnit() == eStyleUnit_Coord) {
+ specifiedWidth.emplace(aIntrinsicSize.width.GetCoordValue());
+ }
+
+ Maybe<nscoord> specifiedHeight;
+ if (aIntrinsicSize.height.GetUnit() == eStyleUnit_Coord) {
+ specifiedHeight.emplace(aIntrinsicSize.height.GetCoordValue());
+ }
+
+ Maybe<nsSize> noneSize; // (the value we'll return)
+ if (specifiedWidth || specifiedHeight) {
+ // We have at least one specified dimension; use whichever dimension is
+ // specified, and compute the other one using our intrinsic ratio, or (if
+ // no valid ratio) using the default object size.
+ noneSize.emplace();
+
+ noneSize->width = specifiedWidth ?
+ *specifiedWidth :
+ ComputeMissingDimension(aDefaultObjectSize, aIntrinsicRatio,
+ specifiedWidth, specifiedHeight,
+ eWidth);
+
+ noneSize->height = specifiedHeight ?
+ *specifiedHeight :
+ ComputeMissingDimension(aDefaultObjectSize, aIntrinsicRatio,
+ specifiedWidth, specifiedHeight,
+ eHeight);
+ }
+ // [else:] "Otherwise [if there's neither an intrinsic height nor width], its
+ // size is resolved as a contain constraint against the default object size."
+ // We'll let our caller do that, to share code & avoid redundant
+ // computations; so, we return w/out populating noneSize.
+ return noneSize;
+}
+
+// Computes the concrete object size to render into, as described at
+// http://dev.w3.org/csswg/css-images-3/#concrete-size-resolution
+static nsSize
+ComputeConcreteObjectSize(const nsSize& aConstraintSize,
+ const IntrinsicSize& aIntrinsicSize,
+ const nsSize& aIntrinsicRatio,
+ uint8_t aObjectFit)
+{
+ // Handle default behavior (filling the container) w/ fast early return.
+ // (Also: if there's no valid intrinsic ratio, then we have the "fill"
+ // behavior & just use the constraint size.)
+ if (MOZ_LIKELY(aObjectFit == NS_STYLE_OBJECT_FIT_FILL) ||
+ aIntrinsicRatio.width == 0 ||
+ aIntrinsicRatio.height == 0) {
+ return aConstraintSize;
+ }
+
+ // The type of constraint to compute (cover/contain), if needed:
+ Maybe<nsImageRenderer::FitType> fitType;
+
+ Maybe<nsSize> noneSize;
+ if (aObjectFit == NS_STYLE_OBJECT_FIT_NONE ||
+ aObjectFit == NS_STYLE_OBJECT_FIT_SCALE_DOWN) {
+ noneSize = MaybeComputeObjectFitNoneSize(aConstraintSize, aIntrinsicSize,
+ aIntrinsicRatio);
+ if (!noneSize || aObjectFit == NS_STYLE_OBJECT_FIT_SCALE_DOWN) {
+ // Need to compute a 'CONTAIN' constraint (either for the 'none' size
+ // itself, or for comparison w/ the 'none' size to resolve 'scale-down'.)
+ fitType.emplace(nsImageRenderer::CONTAIN);
+ }
+ } else if (aObjectFit == NS_STYLE_OBJECT_FIT_COVER) {
+ fitType.emplace(nsImageRenderer::COVER);
+ } else if (aObjectFit == NS_STYLE_OBJECT_FIT_CONTAIN) {
+ fitType.emplace(nsImageRenderer::CONTAIN);
+ }
+
+ Maybe<nsSize> constrainedSize;
+ if (fitType) {
+ constrainedSize.emplace(
+ nsImageRenderer::ComputeConstrainedSize(aConstraintSize,
+ aIntrinsicRatio,
+ *fitType));
+ }
+
+ // Now, we should have all the sizing information that we need.
+ switch (aObjectFit) {
+ // skipping NS_STYLE_OBJECT_FIT_FILL; we handled it w/ early-return.
+ case NS_STYLE_OBJECT_FIT_CONTAIN:
+ case NS_STYLE_OBJECT_FIT_COVER:
+ MOZ_ASSERT(constrainedSize);
+ return *constrainedSize;
+
+ case NS_STYLE_OBJECT_FIT_NONE:
+ if (noneSize) {
+ return *noneSize;
+ }
+ MOZ_ASSERT(constrainedSize);
+ return *constrainedSize;
+
+ case NS_STYLE_OBJECT_FIT_SCALE_DOWN:
+ MOZ_ASSERT(constrainedSize);
+ if (noneSize) {
+ constrainedSize->width =
+ std::min(constrainedSize->width, noneSize->width);
+ constrainedSize->height =
+ std::min(constrainedSize->height, noneSize->height);
+ }
+ return *constrainedSize;
+
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unexpected enum value for 'object-fit'");
+ return aConstraintSize; // fall back to (default) 'fill' behavior
+ }
+}
+
+// (Helper for HasInitialObjectFitAndPosition, to check
+// each "object-position" coord.)
+static bool
+IsCoord50Pct(const mozilla::Position::Coord& aCoord)
+{
+ return (aCoord.mLength == 0 &&
+ aCoord.mHasPercent &&
+ aCoord.mPercent == 0.5f);
+}
+
+// Indicates whether the given nsStylePosition has the initial values
+// for the "object-fit" and "object-position" properties.
+static bool
+HasInitialObjectFitAndPosition(const nsStylePosition* aStylePos)
+{
+ const mozilla::Position& objectPos = aStylePos->mObjectPosition;
+
+ return aStylePos->mObjectFit == NS_STYLE_OBJECT_FIT_FILL &&
+ IsCoord50Pct(objectPos.mXPosition) &&
+ IsCoord50Pct(objectPos.mYPosition);
+}
+
+/* static */ nsRect
+nsLayoutUtils::ComputeObjectDestRect(const nsRect& aConstraintRect,
+ const IntrinsicSize& aIntrinsicSize,
+ const nsSize& aIntrinsicRatio,
+ const nsStylePosition* aStylePos,
+ nsPoint* aAnchorPoint)
+{
+ // Step 1: Figure out our "concrete object size"
+ // (the size of the region we'll actually draw our image's pixels into).
+ nsSize concreteObjectSize =
+ ComputeConcreteObjectSize(aConstraintRect.Size(), aIntrinsicSize,
+ aIntrinsicRatio, aStylePos->mObjectFit);
+
+ // Step 2: Figure out how to align that region in the element's content-box.
+ nsPoint imageTopLeftPt, imageAnchorPt;
+ nsImageRenderer::ComputeObjectAnchorPoint(aStylePos->mObjectPosition,
+ aConstraintRect.Size(),
+ concreteObjectSize,
+ &imageTopLeftPt, &imageAnchorPt);
+ // Right now, we're with respect to aConstraintRect's top-left point. We add
+ // that point here, to convert to the same broader coordinate space that
+ // aConstraintRect is in.
+ imageTopLeftPt += aConstraintRect.TopLeft();
+ imageAnchorPt += aConstraintRect.TopLeft();
+
+ if (aAnchorPoint) {
+ // Special-case: if our "object-fit" and "object-position" properties have
+ // their default values ("object-fit: fill; object-position:50% 50%"), then
+ // we'll override the calculated imageAnchorPt, and instead use the
+ // object's top-left corner.
+ //
+ // This special case is partly for backwards compatibility (since
+ // traditionally we've pixel-aligned the top-left corner of e.g. <img>
+ // elements), and partly because ComputeSnappedDrawingParameters produces
+ // less error if the anchor point is at the top-left corner. So, all other
+ // things being equal, we prefer that code path with less error.
+ if (HasInitialObjectFitAndPosition(aStylePos)) {
+ *aAnchorPoint = imageTopLeftPt;
+ } else {
+ *aAnchorPoint = imageAnchorPt;
+ }
+ }
+ return nsRect(imageTopLeftPt, concreteObjectSize);
+}
+
+already_AddRefed<nsFontMetrics>
+nsLayoutUtils::GetFontMetricsForFrame(const nsIFrame* aFrame, float aInflation)
+{
+ nsStyleContext* styleContext = aFrame->StyleContext();
+ uint8_t variantWidth = NS_FONT_VARIANT_WIDTH_NORMAL;
+ if (styleContext->IsTextCombined()) {
+ MOZ_ASSERT(aFrame->GetType() == nsGkAtoms::textFrame);
+ auto textFrame = static_cast<const nsTextFrame*>(aFrame);
+ auto clusters = textFrame->CountGraphemeClusters();
+ if (clusters == 2) {
+ variantWidth = NS_FONT_VARIANT_WIDTH_HALF;
+ } else if (clusters == 3) {
+ variantWidth = NS_FONT_VARIANT_WIDTH_THIRD;
+ } else if (clusters == 4) {
+ variantWidth = NS_FONT_VARIANT_WIDTH_QUARTER;
+ }
+ }
+ return GetFontMetricsForStyleContext(styleContext, aInflation, variantWidth);
+}
+
+already_AddRefed<nsFontMetrics>
+nsLayoutUtils::GetFontMetricsForStyleContext(nsStyleContext* aStyleContext,
+ float aInflation,
+ uint8_t aVariantWidth)
+{
+ nsPresContext* pc = aStyleContext->PresContext();
+
+ WritingMode wm(aStyleContext);
+ const nsStyleFont* styleFont = aStyleContext->StyleFont();
+ nsFontMetrics::Params params;
+ params.language = styleFont->mLanguage;
+ params.explicitLanguage = styleFont->mExplicitLanguage;
+ params.orientation =
+ wm.IsVertical() && !wm.IsSideways() ? gfxFont::eVertical
+ : gfxFont::eHorizontal;
+ // pass the user font set object into the device context to
+ // pass along to CreateFontGroup
+ params.userFontSet = pc->GetUserFontSet();
+ params.textPerf = pc->GetTextPerfMetrics();
+
+ // When aInflation is 1.0 and we don't require width variant, avoid
+ // making a local copy of the nsFont.
+ // This also avoids running font.size through floats when it is large,
+ // which would be lossy. Fortunately, in such cases, aInflation is
+ // guaranteed to be 1.0f.
+ if (aInflation == 1.0f && aVariantWidth == NS_FONT_VARIANT_WIDTH_NORMAL) {
+ return pc->DeviceContext()->GetMetricsFor(styleFont->mFont, params);
+ }
+
+ nsFont font = styleFont->mFont;
+ font.size = NSToCoordRound(font.size * aInflation);
+ font.variantWidth = aVariantWidth;
+ return pc->DeviceContext()->GetMetricsFor(font, params);
+}
+
+nsIFrame*
+nsLayoutUtils::FindChildContainingDescendant(nsIFrame* aParent, nsIFrame* aDescendantFrame)
+{
+ nsIFrame* result = aDescendantFrame;
+
+ while (result) {
+ nsIFrame* parent = result->GetParent();
+ if (parent == aParent) {
+ break;
+ }
+
+ // The frame is not an immediate child of aParent so walk up another level
+ result = parent;
+ }
+
+ return result;
+}
+
+nsBlockFrame*
+nsLayoutUtils::GetAsBlock(nsIFrame* aFrame)
+{
+ nsBlockFrame* block = do_QueryFrame(aFrame);
+ return block;
+}
+
+nsBlockFrame*
+nsLayoutUtils::FindNearestBlockAncestor(nsIFrame* aFrame)
+{
+ nsIFrame* nextAncestor;
+ for (nextAncestor = aFrame->GetParent(); nextAncestor;
+ nextAncestor = nextAncestor->GetParent()) {
+ nsBlockFrame* block = GetAsBlock(nextAncestor);
+ if (block)
+ return block;
+ }
+ return nullptr;
+}
+
+nsIFrame*
+nsLayoutUtils::GetNonGeneratedAncestor(nsIFrame* aFrame)
+{
+ if (!(aFrame->GetStateBits() & NS_FRAME_GENERATED_CONTENT))
+ return aFrame;
+
+ nsIFrame* f = aFrame;
+ do {
+ f = GetParentOrPlaceholderFor(f);
+ } while (f->GetStateBits() & NS_FRAME_GENERATED_CONTENT);
+ return f;
+}
+
+nsIFrame*
+nsLayoutUtils::GetParentOrPlaceholderFor(nsIFrame* aFrame)
+{
+ if ((aFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)
+ && !aFrame->GetPrevInFlow()) {
+ return aFrame->PresContext()->PresShell()->FrameManager()->
+ GetPlaceholderFrameFor(aFrame);
+ }
+ return aFrame->GetParent();
+}
+
+nsIFrame*
+nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(nsIFrame* aFrame)
+{
+ nsIFrame* f = GetParentOrPlaceholderFor(aFrame);
+ if (f)
+ return f;
+ return GetCrossDocParentFrame(aFrame);
+}
+
+nsIFrame*
+nsLayoutUtils::GetNextContinuationOrIBSplitSibling(nsIFrame *aFrame)
+{
+ nsIFrame *result = aFrame->GetNextContinuation();
+ if (result)
+ return result;
+
+ if ((aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) != 0) {
+ // We only store the ib-split sibling annotation with the first
+ // frame in the continuation chain. Walk back to find that frame now.
+ aFrame = aFrame->FirstContinuation();
+
+ return aFrame->Properties().Get(nsIFrame::IBSplitSibling());
+ }
+
+ return nullptr;
+}
+
+nsIFrame*
+nsLayoutUtils::FirstContinuationOrIBSplitSibling(nsIFrame *aFrame)
+{
+ nsIFrame *result = aFrame->FirstContinuation();
+ if (result->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) {
+ while (true) {
+ nsIFrame* f =
+ result->Properties().Get(nsIFrame::IBSplitPrevSibling());
+ if (!f)
+ break;
+ result = f;
+ }
+ }
+
+ return result;
+}
+
+nsIFrame*
+nsLayoutUtils::LastContinuationOrIBSplitSibling(nsIFrame *aFrame)
+{
+ nsIFrame *result = aFrame->FirstContinuation();
+ if (result->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) {
+ while (true) {
+ nsIFrame* f =
+ result->Properties().Get(nsIFrame::IBSplitSibling());
+ if (!f)
+ break;
+ result = f;
+ }
+ }
+
+ result = result->LastContinuation();
+
+ return result;
+}
+
+bool
+nsLayoutUtils::IsFirstContinuationOrIBSplitSibling(nsIFrame *aFrame)
+{
+ if (aFrame->GetPrevContinuation()) {
+ return false;
+ }
+ if ((aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT) &&
+ aFrame->Properties().Get(nsIFrame::IBSplitPrevSibling())) {
+ return false;
+ }
+
+ return true;
+}
+
+bool
+nsLayoutUtils::IsViewportScrollbarFrame(nsIFrame* aFrame)
+{
+ if (!aFrame)
+ return false;
+
+ nsIFrame* rootScrollFrame =
+ aFrame->PresContext()->PresShell()->GetRootScrollFrame();
+ if (!rootScrollFrame)
+ return false;
+
+ nsIScrollableFrame* rootScrollableFrame = do_QueryFrame(rootScrollFrame);
+ NS_ASSERTION(rootScrollableFrame, "The root scorollable frame is null");
+
+ if (!IsProperAncestorFrame(rootScrollFrame, aFrame))
+ return false;
+
+ nsIFrame* rootScrolledFrame = rootScrollableFrame->GetScrolledFrame();
+ return !(rootScrolledFrame == aFrame ||
+ IsProperAncestorFrame(rootScrolledFrame, aFrame));
+}
+
+// Use only for widths/heights (or their min/max), since it clamps
+// negative calc() results to 0.
+static bool GetAbsoluteCoord(const nsStyleCoord& aStyle, nscoord& aResult)
+{
+ if (aStyle.IsCalcUnit()) {
+ if (aStyle.CalcHasPercent()) {
+ return false;
+ }
+ // If it has no percents, we can pass 0 for the percentage basis.
+ aResult = nsRuleNode::ComputeComputedCalc(aStyle, 0);
+ if (aResult < 0)
+ aResult = 0;
+ return true;
+ }
+
+ if (eStyleUnit_Coord != aStyle.GetUnit())
+ return false;
+
+ aResult = aStyle.GetCoordValue();
+ NS_ASSERTION(aResult >= 0, "negative widths not allowed");
+ return true;
+}
+
+static nscoord
+GetBSizeTakenByBoxSizing(StyleBoxSizing aBoxSizing,
+ nsIFrame* aFrame,
+ bool aHorizontalAxis,
+ bool aIgnorePadding);
+
+// Only call on style coords for which GetAbsoluteCoord returned false.
+static bool
+GetPercentBSize(const nsStyleCoord& aStyle,
+ nsIFrame* aFrame,
+ bool aHorizontalAxis,
+ nscoord& aResult)
+{
+ if (eStyleUnit_Percent != aStyle.GetUnit() &&
+ !aStyle.IsCalcUnit())
+ return false;
+
+ MOZ_ASSERT(!aStyle.IsCalcUnit() || aStyle.CalcHasPercent(),
+ "GetAbsoluteCoord should have handled this");
+
+ // During reflow, nsHTMLScrollFrame::ReflowScrolledFrame uses
+ // SetComputedHeight on the reflow state for its child to propagate its
+ // computed height to the scrolled content. So here we skip to the scroll
+ // frame that contains this scrolled content in order to get the same
+ // behavior as layout when computing percentage heights.
+ nsIFrame *f = aFrame->GetContainingBlock(nsIFrame::SKIP_SCROLLED_FRAME);
+ if (!f) {
+ NS_NOTREACHED("top of frame tree not a containing block");
+ return false;
+ }
+
+ WritingMode wm = f->GetWritingMode();
+
+ const nsStylePosition *pos = f->StylePosition();
+ const nsStyleCoord& bSizeCoord = pos->BSize(wm);
+ nscoord h;
+ if (!GetAbsoluteCoord(bSizeCoord, h) &&
+ !GetPercentBSize(bSizeCoord, f, aHorizontalAxis, h)) {
+ NS_ASSERTION(bSizeCoord.GetUnit() == eStyleUnit_Auto ||
+ bSizeCoord.HasPercent(),
+ "unknown block-size unit");
+ nsIAtom* fType = f->GetType();
+ if (fType != nsGkAtoms::viewportFrame && fType != nsGkAtoms::canvasFrame &&
+ fType != nsGkAtoms::pageContentFrame) {
+ // There's no basis for the percentage height, so it acts like auto.
+ // Should we consider a max-height < min-height pair a basis for
+ // percentage heights? The spec is somewhat unclear, and not doing
+ // so is simpler and avoids troubling discontinuities in behavior,
+ // so I'll choose not to. -LDB
+ return false;
+ }
+
+ NS_ASSERTION(bSizeCoord.GetUnit() == eStyleUnit_Auto,
+ "Unexpected block-size unit for viewport or canvas or page-content");
+ // For the viewport, canvas, and page-content kids, the percentage
+ // basis is just the parent block-size.
+ h = f->BSize(wm);
+ if (h == NS_UNCONSTRAINEDSIZE) {
+ // We don't have a percentage basis after all
+ return false;
+ }
+ }
+
+ const nsStyleCoord& maxBSizeCoord = pos->MaxBSize(wm);
+
+ nscoord maxh;
+ if (GetAbsoluteCoord(maxBSizeCoord, maxh) ||
+ GetPercentBSize(maxBSizeCoord, f, aHorizontalAxis, maxh)) {
+ if (maxh < h)
+ h = maxh;
+ } else {
+ NS_ASSERTION(maxBSizeCoord.GetUnit() == eStyleUnit_None ||
+ maxBSizeCoord.HasPercent(),
+ "unknown max block-size unit");
+ }
+
+ const nsStyleCoord& minBSizeCoord = pos->MinBSize(wm);
+
+ nscoord minh;
+ if (GetAbsoluteCoord(minBSizeCoord, minh) ||
+ GetPercentBSize(minBSizeCoord, f, aHorizontalAxis, minh)) {
+ if (minh > h)
+ h = minh;
+ } else {
+ NS_ASSERTION(minBSizeCoord.HasPercent() ||
+ minBSizeCoord.GetUnit() == eStyleUnit_Auto,
+ "unknown min block-size unit");
+ }
+
+ // Now adjust h for box-sizing styles on the parent. We never ignore padding
+ // here. That could conceivably cause some problems with fieldsets (which are
+ // the one place that wants to ignore padding), but solving that here without
+ // hardcoding a check for f being a fieldset-content frame is a bit of a pain.
+ nscoord bSizeTakenByBoxSizing =
+ GetBSizeTakenByBoxSizing(pos->mBoxSizing, f, aHorizontalAxis, false);
+ h = std::max(0, h - bSizeTakenByBoxSizing);
+
+ if (aStyle.IsCalcUnit()) {
+ aResult = std::max(nsRuleNode::ComputeComputedCalc(aStyle, h), 0);
+ return true;
+ }
+
+ aResult = NSToCoordRound(aStyle.GetPercentValue() * h);
+ return true;
+}
+
+// Get the amount of vertical space taken out of aFrame's content area due to
+// its borders and paddings given the box-sizing value in aBoxSizing. We don't
+// get aBoxSizing from the frame because some callers want to compute this for
+// specific box-sizing values. aHorizontalAxis is true if our inline direction
+// is horisontal and our block direction is vertical. aIgnorePadding is true if
+// padding should be ignored.
+static nscoord
+GetBSizeTakenByBoxSizing(StyleBoxSizing aBoxSizing,
+ nsIFrame* aFrame,
+ bool aHorizontalAxis,
+ bool aIgnorePadding)
+{
+ nscoord bSizeTakenByBoxSizing = 0;
+ if (aBoxSizing == StyleBoxSizing::Border) {
+ const nsStyleBorder* styleBorder = aFrame->StyleBorder();
+ bSizeTakenByBoxSizing +=
+ aHorizontalAxis ? styleBorder->GetComputedBorder().TopBottom()
+ : styleBorder->GetComputedBorder().LeftRight();
+ if (!aIgnorePadding) {
+ const nsStyleSides& stylePadding =
+ aFrame->StylePadding()->mPadding;
+ const nsStyleCoord& paddingStart =
+ stylePadding.Get(aHorizontalAxis ? NS_SIDE_TOP : NS_SIDE_LEFT);
+ const nsStyleCoord& paddingEnd =
+ stylePadding.Get(aHorizontalAxis ? NS_SIDE_BOTTOM : NS_SIDE_RIGHT);
+ nscoord pad;
+ // XXXbz Calling GetPercentBSize on padding values looks bogus, since
+ // percent padding is always a percentage of the inline-size of the
+ // containing block. We should perhaps just treat non-absolute paddings
+ // here as 0 instead, except that in some cases the width may in fact be
+ // known. See bug 1231059.
+ if (GetAbsoluteCoord(paddingStart, pad) ||
+ GetPercentBSize(paddingStart, aFrame, aHorizontalAxis, pad)) {
+ bSizeTakenByBoxSizing += pad;
+ }
+ if (GetAbsoluteCoord(paddingEnd, pad) ||
+ GetPercentBSize(paddingEnd, aFrame, aHorizontalAxis, pad)) {
+ bSizeTakenByBoxSizing += pad;
+ }
+ }
+ }
+ return bSizeTakenByBoxSizing;
+}
+
+// Handles only -moz-max-content and -moz-min-content, and
+// -moz-fit-content for min-width and max-width, since the others
+// (-moz-fit-content for width, and -moz-available) have no effect on
+// intrinsic widths.
+enum eWidthProperty { PROP_WIDTH, PROP_MAX_WIDTH, PROP_MIN_WIDTH };
+static bool
+GetIntrinsicCoord(const nsStyleCoord& aStyle,
+ nsRenderingContext* aRenderingContext,
+ nsIFrame* aFrame,
+ eWidthProperty aProperty,
+ nscoord& aResult)
+{
+ NS_PRECONDITION(aProperty == PROP_WIDTH || aProperty == PROP_MAX_WIDTH ||
+ aProperty == PROP_MIN_WIDTH, "unexpected property");
+ if (aStyle.GetUnit() != eStyleUnit_Enumerated)
+ return false;
+ int32_t val = aStyle.GetIntValue();
+ NS_ASSERTION(val == NS_STYLE_WIDTH_MAX_CONTENT ||
+ val == NS_STYLE_WIDTH_MIN_CONTENT ||
+ val == NS_STYLE_WIDTH_FIT_CONTENT ||
+ val == NS_STYLE_WIDTH_AVAILABLE,
+ "unexpected enumerated value for width property");
+ if (val == NS_STYLE_WIDTH_AVAILABLE)
+ return false;
+ if (val == NS_STYLE_WIDTH_FIT_CONTENT) {
+ if (aProperty == PROP_WIDTH)
+ return false; // handle like 'width: auto'
+ if (aProperty == PROP_MAX_WIDTH)
+ // constrain large 'width' values down to -moz-max-content
+ val = NS_STYLE_WIDTH_MAX_CONTENT;
+ else
+ // constrain small 'width' or 'max-width' values up to -moz-min-content
+ val = NS_STYLE_WIDTH_MIN_CONTENT;
+ }
+
+ NS_ASSERTION(val == NS_STYLE_WIDTH_MAX_CONTENT ||
+ val == NS_STYLE_WIDTH_MIN_CONTENT,
+ "should have reduced everything remaining to one of these");
+
+ // If aFrame is a container for font size inflation, then shrink
+ // wrapping inside of it should not apply font size inflation.
+ AutoMaybeDisableFontInflation an(aFrame);
+
+ if (val == NS_STYLE_WIDTH_MAX_CONTENT)
+ aResult = aFrame->GetPrefISize(aRenderingContext);
+ else
+ aResult = aFrame->GetMinISize(aRenderingContext);
+ return true;
+}
+
+#undef DEBUG_INTRINSIC_WIDTH
+
+#ifdef DEBUG_INTRINSIC_WIDTH
+static int32_t gNoiseIndent = 0;
+#endif
+
+// Return true for form controls whose minimum intrinsic inline-size
+// shrinks to 0 when they have a percentage inline-size (but not
+// percentage max-inline-size). (Proper replaced elements, whose
+// intrinsic minimium inline-size shrinks to 0 for both percentage
+// inline-size and percentage max-inline-size, are handled elsewhere.)
+inline static bool
+FormControlShrinksForPercentISize(nsIFrame* aFrame)
+{
+ if (!aFrame->IsFrameOfType(nsIFrame::eReplaced)) {
+ // Quick test to reject most frames.
+ return false;
+ }
+
+ nsIAtom* fType = aFrame->GetType();
+ if (fType == nsGkAtoms::meterFrame || fType == nsGkAtoms::progressFrame) {
+ // progress and meter do have this shrinking behavior
+ // FIXME: Maybe these should be nsIFormControlFrame?
+ return true;
+ }
+
+ if (!static_cast<nsIFormControlFrame*>(do_QueryFrame(aFrame))) {
+ // Not a form control. This includes fieldsets, which do not
+ // shrink.
+ return false;
+ }
+
+ if (fType == nsGkAtoms::gfxButtonControlFrame ||
+ fType == nsGkAtoms::HTMLButtonControlFrame) {
+ // Buttons don't have this shrinking behavior. (Note that color
+ // inputs do, even though they inherit from button, so we can't use
+ // do_QueryFrame here.)
+ return false;
+ }
+
+ return true;
+}
+
+/**
+ * Add aOffsets which describes what to add on outside of the content box
+ * aContentSize (controlled by 'box-sizing') and apply min/max properties.
+ * We have to account for these properties after getting all the offsets
+ * (margin, border, padding) because percentages do not operate linearly.
+ * Doing this is ok because although percentages aren't handled linearly,
+ * they are handled monotonically.
+ *
+ * @param aContentSize the content size calculated so far
+ (@see IntrinsicForContainer)
+ * @param aContentMinSize ditto min content size
+ * @param aStyleSize a 'width' or 'height' property value
+ * @param aFixedMinSize if aStyleMinSize is a definite size then this points to
+ * the value, otherwise nullptr
+ * @param aStyleMinSize a 'min-width' or 'min-height' property value
+ * @param aFixedMaxSize if aStyleMaxSize is a definite size then this points to
+ * the value, otherwise nullptr
+ * @param aStyleMaxSize a 'max-width' or 'max-height' property value
+ * @param aFlags same as for IntrinsicForContainer
+ * @param aContainerWM the container's WM
+ */
+static nscoord
+AddIntrinsicSizeOffset(nsRenderingContext* aRenderingContext,
+ nsIFrame* aFrame,
+ const nsIFrame::IntrinsicISizeOffsetData& aOffsets,
+ nsLayoutUtils::IntrinsicISizeType aType,
+ StyleBoxSizing aBoxSizing,
+ nscoord aContentSize,
+ nscoord aContentMinSize,
+ const nsStyleCoord& aStyleSize,
+ const nscoord* aFixedMinSize,
+ const nsStyleCoord& aStyleMinSize,
+ const nscoord* aFixedMaxSize,
+ const nsStyleCoord& aStyleMaxSize,
+ uint32_t aFlags,
+ PhysicalAxis aAxis)
+{
+ nscoord result = aContentSize;
+ nscoord min = aContentMinSize;
+ nscoord coordOutsideSize = 0;
+ float pctOutsideSize = 0;
+ float pctTotal = 0.0f;
+
+ if (!(aFlags & nsLayoutUtils::IGNORE_PADDING)) {
+ coordOutsideSize += aOffsets.hPadding;
+ pctOutsideSize += aOffsets.hPctPadding;
+ }
+
+ coordOutsideSize += aOffsets.hBorder;
+
+ if (aBoxSizing == StyleBoxSizing::Border) {
+ min += coordOutsideSize;
+ result = NSCoordSaturatingAdd(result, coordOutsideSize);
+ pctTotal += pctOutsideSize;
+
+ coordOutsideSize = 0;
+ pctOutsideSize = 0.0f;
+ }
+
+ coordOutsideSize += aOffsets.hMargin;
+ pctOutsideSize += aOffsets.hPctMargin;
+
+ min += coordOutsideSize;
+ result = NSCoordSaturatingAdd(result, coordOutsideSize);
+ pctTotal += pctOutsideSize;
+
+ const bool shouldAddPercent = aType == nsLayoutUtils::PREF_ISIZE ||
+ (aFlags & nsLayoutUtils::ADD_PERCENTS);
+ nscoord size;
+ if (aType == nsLayoutUtils::MIN_ISIZE &&
+ (((aStyleSize.HasPercent() || aStyleMaxSize.HasPercent()) &&
+ aFrame->IsFrameOfType(nsIFrame::eReplacedSizing)) ||
+ (aStyleSize.HasPercent() &&
+ FormControlShrinksForPercentISize(aFrame)))) {
+ // A percentage width or max-width on replaced elements means they
+ // can shrink to 0.
+ // This is also true for percentage widths (but not max-widths) on
+ // text inputs.
+ // Note that if this is max-width, this overrides the fixed-width
+ // rule in the next condition.
+ result = 0; // let |min| handle padding/border/margin
+ } else if (GetAbsoluteCoord(aStyleSize, size) ||
+ GetIntrinsicCoord(aStyleSize, aRenderingContext, aFrame,
+ PROP_WIDTH, size)) {
+ result = size + coordOutsideSize;
+ if (shouldAddPercent) {
+ result = nsLayoutUtils::AddPercents(result, pctOutsideSize);
+ }
+ } else {
+ // NOTE: We could really do a lot better for percents and for some
+ // cases of calc() containing percent (certainly including any where
+ // the coefficient on the percent is positive and there are no max()
+ // expressions). However, doing better for percents wouldn't be
+ // backwards compatible.
+ if (shouldAddPercent) {
+ result = nsLayoutUtils::AddPercents(result, pctTotal);
+ }
+ }
+
+ nscoord maxSize = aFixedMaxSize ? *aFixedMaxSize : 0;
+ if (aFixedMaxSize ||
+ GetIntrinsicCoord(aStyleMaxSize, aRenderingContext, aFrame,
+ PROP_MAX_WIDTH, maxSize)) {
+ maxSize += coordOutsideSize;
+ if (shouldAddPercent) {
+ maxSize = nsLayoutUtils::AddPercents(maxSize, pctOutsideSize);
+ }
+ if (result > maxSize) {
+ result = maxSize;
+ }
+ }
+
+ nscoord minSize = aFixedMinSize ? *aFixedMinSize : 0;
+ if (aFixedMinSize ||
+ GetIntrinsicCoord(aStyleMinSize, aRenderingContext, aFrame,
+ PROP_MIN_WIDTH, minSize)) {
+ minSize += coordOutsideSize;
+ if (shouldAddPercent) {
+ minSize = nsLayoutUtils::AddPercents(minSize, pctOutsideSize);
+ }
+ if (result < minSize) {
+ result = minSize;
+ }
+ }
+
+ if (shouldAddPercent) {
+ min = nsLayoutUtils::AddPercents(min, pctTotal);
+ }
+ if (result < min) {
+ result = min;
+ }
+
+ const nsStyleDisplay* disp = aFrame->StyleDisplay();
+ if (aFrame->IsThemed(disp)) {
+ LayoutDeviceIntSize devSize;
+ bool canOverride = true;
+ nsPresContext* pc = aFrame->PresContext();
+ pc->GetTheme()->GetMinimumWidgetSize(pc, aFrame, disp->mAppearance,
+ &devSize, &canOverride);
+ nscoord themeSize =
+ pc->DevPixelsToAppUnits(aAxis == eAxisVertical ? devSize.height
+ : devSize.width);
+ // GetMinimumWidgetSize() returns a border-box width.
+ themeSize += aOffsets.hMargin;
+ if (shouldAddPercent) {
+ themeSize = nsLayoutUtils::AddPercents(themeSize, aOffsets.hPctMargin);
+ }
+ if (themeSize > result || !canOverride) {
+ result = themeSize;
+ }
+ }
+ return result;
+}
+
+static void
+AddStateBitToAncestors(nsIFrame* aFrame, nsFrameState aBit)
+{
+ for (nsIFrame* f = aFrame; f; f = f->GetParent()) {
+ if (f->HasAnyStateBits(aBit)) {
+ break;
+ }
+ f->AddStateBits(aBit);
+ }
+}
+
+/* static */ nscoord
+nsLayoutUtils::IntrinsicForAxis(PhysicalAxis aAxis,
+ nsRenderingContext* aRenderingContext,
+ nsIFrame* aFrame,
+ IntrinsicISizeType aType,
+ uint32_t aFlags,
+ nscoord aMarginBoxMinSizeClamp)
+{
+ NS_PRECONDITION(aFrame, "null frame");
+ NS_PRECONDITION(aFrame->GetParent(),
+ "IntrinsicForAxis called on frame not in tree");
+ NS_PRECONDITION(aType == MIN_ISIZE || aType == PREF_ISIZE, "bad type");
+
+ const bool horizontalAxis = MOZ_LIKELY(aAxis == eAxisHorizontal);
+#ifdef DEBUG_INTRINSIC_WIDTH
+ nsFrame::IndentBy(stderr, gNoiseIndent);
+ static_cast<nsFrame*>(aFrame)->ListTag(stderr);
+ printf_stderr(" %s %s intrinsic size for container:\n",
+ aType == MIN_ISIZE ? "min" : "pref",
+ horizontalAxis ? "horizontal" : "vertical");
+#endif
+
+ // If aFrame is a container for font size inflation, then shrink
+ // wrapping inside of it should not apply font size inflation.
+ AutoMaybeDisableFontInflation an(aFrame);
+
+ // We want the size this frame will contribute to the parent's inline-size,
+ // so we work in the parent's writing mode; but if aFrame is orthogonal to
+ // its parent, we'll need to look at its BSize instead of min/pref-ISize.
+ const nsStylePosition* stylePos = aFrame->StylePosition();
+ StyleBoxSizing boxSizing = stylePos->mBoxSizing;
+
+ const nsStyleCoord& styleMinISize =
+ horizontalAxis ? stylePos->mMinWidth : stylePos->mMinHeight;
+ const nsStyleCoord& styleISize =
+ (aFlags & MIN_INTRINSIC_ISIZE) ? styleMinISize :
+ (horizontalAxis ? stylePos->mWidth : stylePos->mHeight);
+ MOZ_ASSERT(!(aFlags & MIN_INTRINSIC_ISIZE) ||
+ styleISize.GetUnit() == eStyleUnit_Auto ||
+ styleISize.GetUnit() == eStyleUnit_Enumerated,
+ "should only use MIN_INTRINSIC_ISIZE for intrinsic values");
+ const nsStyleCoord& styleMaxISize =
+ horizontalAxis ? stylePos->mMaxWidth : stylePos->mMaxHeight;
+
+ // We build up two values starting with the content box, and then
+ // adding padding, border and margin. The result is normally
+ // |result|. Then, when we handle 'width', 'min-width', and
+ // 'max-width', we use the results we've been building in |min| as a
+ // minimum, overriding 'min-width'. This ensures two things:
+ // * that we don't let a value of 'box-sizing' specifying a width
+ // smaller than the padding/border inside the box-sizing box give
+ // a content width less than zero
+ // * that we prevent tables from becoming smaller than their
+ // intrinsic minimum width
+ nscoord result = 0, min = 0;
+
+ nscoord maxISize;
+ bool haveFixedMaxISize = GetAbsoluteCoord(styleMaxISize, maxISize);
+ nscoord minISize;
+
+ // Treat "min-width: auto" as 0.
+ bool haveFixedMinISize;
+ if (eStyleUnit_Auto == styleMinISize.GetUnit()) {
+ // NOTE: Technically, "auto" is supposed to behave like "min-content" on
+ // flex items. However, we don't need to worry about that here, because
+ // flex items' min-sizes are intentionally ignored until the flex
+ // container explicitly considers them during space distribution.
+ minISize = 0;
+ haveFixedMinISize = true;
+ } else {
+ haveFixedMinISize = GetAbsoluteCoord(styleMinISize, minISize);
+ }
+
+ PhysicalAxis ourInlineAxis =
+ aFrame->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
+ // If we have a specified width (or a specified 'min-width' greater
+ // than the specified 'max-width', which works out to the same thing),
+ // don't even bother getting the frame's intrinsic width, because in
+ // this case GetAbsoluteCoord(styleISize, w) will always succeed, so
+ // we'll never need the intrinsic dimensions.
+ if (styleISize.GetUnit() == eStyleUnit_Enumerated &&
+ (styleISize.GetIntValue() == NS_STYLE_WIDTH_MAX_CONTENT ||
+ styleISize.GetIntValue() == NS_STYLE_WIDTH_MIN_CONTENT)) {
+ // -moz-fit-content and -moz-available enumerated widths compute intrinsic
+ // widths just like auto.
+ // For -moz-max-content and -moz-min-content, we handle them like
+ // specified widths, but ignore box-sizing.
+ boxSizing = StyleBoxSizing::Content;
+ if (aMarginBoxMinSizeClamp != NS_MAXSIZE &&
+ styleISize.GetIntValue() == NS_STYLE_WIDTH_MIN_CONTENT) {
+ // We need |result| to be the 'min-content size' for the clamping below.
+ result = aFrame->GetMinISize(aRenderingContext);
+ }
+ } else if (!styleISize.ConvertsToLength() &&
+ !(haveFixedMinISize && haveFixedMaxISize && maxISize <= minISize)) {
+#ifdef DEBUG_INTRINSIC_WIDTH
+ ++gNoiseIndent;
+#endif
+ if (aType != MIN_ISIZE) {
+ // At this point, |styleISize| is auto/-moz-fit-content/-moz-available or
+ // has a percentage. The intrinisic size for those under a max-content
+ // constraint is the max-content contribution which we shouldn't clamp.
+ aMarginBoxMinSizeClamp = NS_MAXSIZE;
+ }
+ if (MOZ_UNLIKELY(aAxis != ourInlineAxis)) {
+ IntrinsicSize intrinsicSize = aFrame->GetIntrinsicSize();
+ const nsStyleCoord intrinsicBCoord =
+ horizontalAxis ? intrinsicSize.width : intrinsicSize.height;
+ if (intrinsicBCoord.GetUnit() == eStyleUnit_Coord) {
+ result = intrinsicBCoord.GetCoordValue();
+ } else {
+ // We don't have an intrinsic bsize and we need aFrame's block-dir size.
+ if (aFlags & BAIL_IF_REFLOW_NEEDED) {
+ return NS_INTRINSIC_WIDTH_UNKNOWN;
+ }
+ // XXX Unfortunately, we probably don't know this yet, so this is wrong...
+ // but it's not clear what we should do. If aFrame's inline size hasn't
+ // been determined yet, we can't necessarily figure out its block size
+ // either. For now, authors who put orthogonal elements into things like
+ // buttons or table cells may have to explicitly provide sizes rather
+ // than expecting intrinsic sizing to work "perfectly" in underspecified
+ // cases.
+ result = aFrame->BSize();
+ }
+ } else {
+ result = aType == MIN_ISIZE
+ ? aFrame->GetMinISize(aRenderingContext)
+ : aFrame->GetPrefISize(aRenderingContext);
+ }
+#ifdef DEBUG_INTRINSIC_WIDTH
+ --gNoiseIndent;
+ nsFrame::IndentBy(stderr, gNoiseIndent);
+ static_cast<nsFrame*>(aFrame)->ListTag(stderr);
+ printf_stderr(" %s %s intrinsic size from frame is %d.\n",
+ aType == MIN_ISIZE ? "min" : "pref",
+ horizontalAxis ? "horizontal" : "vertical",
+ result);
+#endif
+
+ // Handle elements with an intrinsic ratio (or size) and a specified
+ // height, min-height, or max-height.
+ // NOTE: We treat "min-height:auto" as "0" for the purpose of this code,
+ // since that's what it means in all cases except for on flex items -- and
+ // even there, we're supposed to ignore it (i.e. treat it as 0) until the
+ // flex container explicitly considers it.
+ const nsStyleCoord& styleBSize =
+ horizontalAxis ? stylePos->mHeight : stylePos->mWidth;
+ const nsStyleCoord& styleMinBSize =
+ horizontalAxis ? stylePos->mMinHeight : stylePos->mMinWidth;
+ const nsStyleCoord& styleMaxBSize =
+ horizontalAxis ? stylePos->mMaxHeight : stylePos->mMaxWidth;
+
+ if (styleBSize.GetUnit() != eStyleUnit_Auto ||
+ !(styleMinBSize.GetUnit() == eStyleUnit_Auto ||
+ (styleMinBSize.GetUnit() == eStyleUnit_Coord &&
+ styleMinBSize.GetCoordValue() == 0)) ||
+ styleMaxBSize.GetUnit() != eStyleUnit_None) {
+
+ nsSize ratio(aFrame->GetIntrinsicRatio());
+ nscoord ratioISize = (horizontalAxis ? ratio.width : ratio.height);
+ nscoord ratioBSize = (horizontalAxis ? ratio.height : ratio.width);
+ if (ratioBSize != 0) {
+ AddStateBitToAncestors(aFrame,
+ NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE);
+
+ nscoord bSizeTakenByBoxSizing =
+ GetBSizeTakenByBoxSizing(boxSizing, aFrame, horizontalAxis,
+ aFlags & IGNORE_PADDING);
+
+ // NOTE: This is only the minContentSize if we've been passed MIN_INTRINSIC_ISIZE
+ // (which is fine, because this should only be used inside a check for that flag).
+ nscoord minContentSize = result;
+ nscoord h;
+ if (GetAbsoluteCoord(styleBSize, h) ||
+ GetPercentBSize(styleBSize, aFrame, horizontalAxis, h)) {
+ h = std::max(0, h - bSizeTakenByBoxSizing);
+ result = NSCoordMulDiv(h, ratioISize, ratioBSize);
+ }
+
+ if (GetAbsoluteCoord(styleMaxBSize, h) ||
+ GetPercentBSize(styleMaxBSize, aFrame, horizontalAxis, h)) {
+ h = std::max(0, h - bSizeTakenByBoxSizing);
+ nscoord maxISize = NSCoordMulDiv(h, ratioISize, ratioBSize);
+ if (maxISize < result) {
+ result = maxISize;
+ }
+ if (maxISize < minContentSize) {
+ minContentSize = maxISize;
+ }
+ }
+
+ if (GetAbsoluteCoord(styleMinBSize, h) ||
+ GetPercentBSize(styleMinBSize, aFrame, horizontalAxis, h)) {
+ h = std::max(0, h - bSizeTakenByBoxSizing);
+ nscoord minISize = NSCoordMulDiv(h, ratioISize, ratioBSize);
+ if (minISize > result) {
+ result = minISize;
+ }
+ if (minISize > minContentSize) {
+ minContentSize = minISize;
+ }
+ }
+ if (MOZ_UNLIKELY(aFlags & nsLayoutUtils::MIN_INTRINSIC_ISIZE)) {
+ // This is the 'min-width/height:auto' "transferred size" piece of:
+ // https://www.w3.org/TR/css-flexbox-1/#min-width-automatic-minimum-size
+ // https://drafts.csswg.org/css-grid/#min-size-auto
+ result = std::min(result, minContentSize);
+ }
+ }
+ }
+ }
+
+ if (aFrame->GetType() == nsGkAtoms::tableFrame) {
+ // Tables can't shrink smaller than their intrinsic minimum width,
+ // no matter what.
+ min = aFrame->GetMinISize(aRenderingContext);
+ }
+
+ nsIFrame::IntrinsicISizeOffsetData offsets =
+ MOZ_LIKELY(aAxis == ourInlineAxis) ? aFrame->IntrinsicISizeOffsets()
+ : aFrame->IntrinsicBSizeOffsets();
+ nscoord contentBoxSize = result;
+ result = AddIntrinsicSizeOffset(aRenderingContext, aFrame, offsets, aType,
+ boxSizing, result, min, styleISize,
+ haveFixedMinISize ? &minISize : nullptr,
+ styleMinISize,
+ haveFixedMaxISize ? &maxISize : nullptr,
+ styleMaxISize,
+ aFlags, aAxis);
+ nscoord overflow = result - aMarginBoxMinSizeClamp;
+ if (MOZ_UNLIKELY(overflow > 0)) {
+ nscoord newContentBoxSize = std::max(nscoord(0), contentBoxSize - overflow);
+ result -= contentBoxSize - newContentBoxSize;
+ }
+
+#ifdef DEBUG_INTRINSIC_WIDTH
+ nsFrame::IndentBy(stderr, gNoiseIndent);
+ static_cast<nsFrame*>(aFrame)->ListTag(stderr);
+ printf_stderr(" %s %s intrinsic size for container is %d twips.\n",
+ aType == MIN_ISIZE ? "min" : "pref",
+ horizontalAxis ? "horizontal" : "vertical",
+ result);
+#endif
+
+ return result;
+}
+
+/* static */ nscoord
+nsLayoutUtils::IntrinsicForContainer(nsRenderingContext* aRenderingContext,
+ nsIFrame* aFrame,
+ IntrinsicISizeType aType,
+ uint32_t aFlags)
+{
+ MOZ_ASSERT(aFrame && aFrame->GetParent());
+ // We want the size aFrame will contribute to its parent's inline-size.
+ PhysicalAxis axis =
+ aFrame->GetParent()->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
+ return IntrinsicForAxis(axis, aRenderingContext, aFrame, aType, aFlags);
+}
+
+/* static */ nscoord
+nsLayoutUtils::MinSizeContributionForAxis(PhysicalAxis aAxis,
+ nsRenderingContext* aRC,
+ nsIFrame* aFrame,
+ IntrinsicISizeType aType,
+ uint32_t aFlags)
+{
+ MOZ_ASSERT(aFrame);
+ MOZ_ASSERT(aFrame->IsFlexOrGridItem(),
+ "only grid/flex items have this behavior currently");
+
+#ifdef DEBUG_INTRINSIC_WIDTH
+ nsFrame::IndentBy(stderr, gNoiseIndent);
+ static_cast<nsFrame*>(aFrame)->ListTag(stderr);
+ printf_stderr(" %s min-isize for %s WM:\n",
+ aType == MIN_ISIZE ? "min" : "pref",
+ aWM.IsVertical() ? "vertical" : "horizontal");
+#endif
+
+ // Note: this method is only meant for grid/flex items which always
+ // include percentages in their intrinsic size.
+ aFlags |= nsLayoutUtils::ADD_PERCENTS;
+ const nsStylePosition* const stylePos = aFrame->StylePosition();
+ const nsStyleCoord* style = aAxis == eAxisHorizontal ? &stylePos->mMinWidth
+ : &stylePos->mMinHeight;
+ nscoord minSize;
+ nscoord* fixedMinSize = nullptr;
+ auto minSizeUnit = style->GetUnit();
+ if (minSizeUnit == eStyleUnit_Auto) {
+ if (aFrame->StyleDisplay()->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE) {
+ style = aAxis == eAxisHorizontal ? &stylePos->mWidth
+ : &stylePos->mHeight;
+ if (GetAbsoluteCoord(*style, minSize)) {
+ // We have a definite width/height. This is the "specified size" in:
+ // https://drafts.csswg.org/css-grid/#min-size-auto
+ fixedMinSize = &minSize;
+ }
+ // fall through - the caller will have to deal with "transferred size"
+ } else {
+ // min-[width|height]:auto with overflow != visible computes to zero.
+ minSize = 0;
+ fixedMinSize = &minSize;
+ }
+ } else if (GetAbsoluteCoord(*style, minSize)) {
+ fixedMinSize = &minSize;
+ } else if (minSizeUnit != eStyleUnit_Enumerated) {
+ MOZ_ASSERT(style->HasPercent());
+ minSize = 0;
+ fixedMinSize = &minSize;
+ }
+
+ if (!fixedMinSize) {
+ // Let the caller deal with the "content size" cases.
+#ifdef DEBUG_INTRINSIC_WIDTH
+ nsFrame::IndentBy(stderr, gNoiseIndent);
+ static_cast<nsFrame*>(aFrame)->ListTag(stderr);
+ printf_stderr(" %s min-isize is indefinite.\n",
+ aType == MIN_ISIZE ? "min" : "pref");
+#endif
+ return NS_UNCONSTRAINEDSIZE;
+ }
+
+ // If aFrame is a container for font size inflation, then shrink
+ // wrapping inside of it should not apply font size inflation.
+ AutoMaybeDisableFontInflation an(aFrame);
+
+ PhysicalAxis ourInlineAxis =
+ aFrame->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
+ nsIFrame::IntrinsicISizeOffsetData offsets =
+ ourInlineAxis == aAxis ? aFrame->IntrinsicISizeOffsets()
+ : aFrame->IntrinsicBSizeOffsets();
+ nscoord result = 0;
+ nscoord min = 0;
+
+ const nsStyleCoord& maxISize =
+ aAxis == eAxisHorizontal ? stylePos->mMaxWidth : stylePos->mMaxHeight;
+ result = AddIntrinsicSizeOffset(aRC, aFrame, offsets, aType,
+ stylePos->mBoxSizing,
+ result, min, *style, fixedMinSize,
+ *style, nullptr, maxISize, aFlags, aAxis);
+
+#ifdef DEBUG_INTRINSIC_WIDTH
+ nsFrame::IndentBy(stderr, gNoiseIndent);
+ static_cast<nsFrame*>(aFrame)->ListTag(stderr);
+ printf_stderr(" %s min-isize is %d twips.\n",
+ aType == MIN_ISIZE ? "min" : "pref", result);
+#endif
+
+ return result;
+}
+
+/* static */ nscoord
+nsLayoutUtils::ComputeCBDependentValue(nscoord aPercentBasis,
+ const nsStyleCoord& aCoord)
+{
+ NS_WARNING_ASSERTION(
+ aPercentBasis != NS_UNCONSTRAINEDSIZE,
+ "have unconstrained width or height; this should only result from very "
+ "large sizes, not attempts at intrinsic size calculation");
+
+ if (aCoord.IsCoordPercentCalcUnit()) {
+ return nsRuleNode::ComputeCoordPercentCalc(aCoord, aPercentBasis);
+ }
+ NS_ASSERTION(aCoord.GetUnit() == eStyleUnit_None ||
+ aCoord.GetUnit() == eStyleUnit_Auto,
+ "unexpected width value");
+ return 0;
+}
+
+/* static */ nscoord
+nsLayoutUtils::ComputeBSizeDependentValue(
+ nscoord aContainingBlockBSize,
+ const nsStyleCoord& aCoord)
+{
+ // XXXldb Some callers explicitly check aContainingBlockBSize
+ // against NS_AUTOHEIGHT *and* unit against eStyleUnit_Percent or
+ // calc()s containing percents before calling this function.
+ // However, it would be much more likely to catch problems without
+ // the unit conditions.
+ // XXXldb Many callers pass a non-'auto' containing block height when
+ // according to CSS2.1 they should be passing 'auto'.
+ NS_PRECONDITION(NS_AUTOHEIGHT != aContainingBlockBSize ||
+ !aCoord.HasPercent(),
+ "unexpected containing block block-size");
+
+ if (aCoord.IsCoordPercentCalcUnit()) {
+ return nsRuleNode::ComputeCoordPercentCalc(aCoord, aContainingBlockBSize);
+ }
+
+ NS_ASSERTION(aCoord.GetUnit() == eStyleUnit_None ||
+ aCoord.GetUnit() == eStyleUnit_Auto,
+ "unexpected block-size value");
+ return 0;
+}
+
+/* static */ void
+nsLayoutUtils::MarkDescendantsDirty(nsIFrame *aSubtreeRoot)
+{
+ AutoTArray<nsIFrame*, 4> subtrees;
+ subtrees.AppendElement(aSubtreeRoot);
+
+ // dirty descendants, iterating over subtrees that may include
+ // additional subtrees associated with placeholders
+ do {
+ nsIFrame *subtreeRoot = subtrees.ElementAt(subtrees.Length() - 1);
+ subtrees.RemoveElementAt(subtrees.Length() - 1);
+
+ // Mark all descendants dirty (using an nsTArray stack rather than
+ // recursion).
+ // Note that ReflowInput::InitResizeFlags has some similar
+ // code; see comments there for how and why it differs.
+ AutoTArray<nsIFrame*, 32> stack;
+ stack.AppendElement(subtreeRoot);
+
+ do {
+ nsIFrame *f = stack.ElementAt(stack.Length() - 1);
+ stack.RemoveElementAt(stack.Length() - 1);
+
+ f->MarkIntrinsicISizesDirty();
+
+ if (f->GetType() == nsGkAtoms::placeholderFrame) {
+ nsIFrame *oof = nsPlaceholderFrame::GetRealFrameForPlaceholder(f);
+ if (!nsLayoutUtils::IsProperAncestorFrame(subtreeRoot, oof)) {
+ // We have another distinct subtree we need to mark.
+ subtrees.AppendElement(oof);
+ }
+ }
+
+ nsIFrame::ChildListIterator lists(f);
+ for (; !lists.IsDone(); lists.Next()) {
+ nsFrameList::Enumerator childFrames(lists.CurrentList());
+ for (; !childFrames.AtEnd(); childFrames.Next()) {
+ nsIFrame* kid = childFrames.get();
+ stack.AppendElement(kid);
+ }
+ }
+ } while (stack.Length() != 0);
+ } while (subtrees.Length() != 0);
+}
+
+/* static */
+void
+nsLayoutUtils::MarkIntrinsicISizesDirtyIfDependentOnBSize(nsIFrame* aFrame)
+{
+ AutoTArray<nsIFrame*, 32> stack;
+ stack.AppendElement(aFrame);
+
+ do {
+ nsIFrame* f = stack.ElementAt(stack.Length() - 1);
+ stack.RemoveElementAt(stack.Length() - 1);
+
+ if (!f->HasAnyStateBits(
+ NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
+ continue;
+ }
+ f->MarkIntrinsicISizesDirty();
+
+ for (nsIFrame::ChildListIterator lists(f); !lists.IsDone(); lists.Next()) {
+ for (nsIFrame* kid : lists.CurrentList()) {
+ stack.AppendElement(kid);
+ }
+ }
+ } while (stack.Length() != 0);
+}
+
+nsSize
+nsLayoutUtils::ComputeAutoSizeWithIntrinsicDimensions(nscoord minWidth, nscoord minHeight,
+ nscoord maxWidth, nscoord maxHeight,
+ nscoord tentWidth, nscoord tentHeight)
+{
+ // Now apply min/max-width/height - CSS 2.1 sections 10.4 and 10.7:
+
+ if (minWidth > maxWidth)
+ maxWidth = minWidth;
+ if (minHeight > maxHeight)
+ maxHeight = minHeight;
+
+ nscoord heightAtMaxWidth, heightAtMinWidth,
+ widthAtMaxHeight, widthAtMinHeight;
+
+ if (tentWidth > 0) {
+ heightAtMaxWidth = NSCoordMulDiv(maxWidth, tentHeight, tentWidth);
+ if (heightAtMaxWidth < minHeight)
+ heightAtMaxWidth = minHeight;
+ heightAtMinWidth = NSCoordMulDiv(minWidth, tentHeight, tentWidth);
+ if (heightAtMinWidth > maxHeight)
+ heightAtMinWidth = maxHeight;
+ } else {
+ heightAtMaxWidth = heightAtMinWidth = NS_CSS_MINMAX(tentHeight, minHeight, maxHeight);
+ }
+
+ if (tentHeight > 0) {
+ widthAtMaxHeight = NSCoordMulDiv(maxHeight, tentWidth, tentHeight);
+ if (widthAtMaxHeight < minWidth)
+ widthAtMaxHeight = minWidth;
+ widthAtMinHeight = NSCoordMulDiv(minHeight, tentWidth, tentHeight);
+ if (widthAtMinHeight > maxWidth)
+ widthAtMinHeight = maxWidth;
+ } else {
+ widthAtMaxHeight = widthAtMinHeight = NS_CSS_MINMAX(tentWidth, minWidth, maxWidth);
+ }
+
+ // The table at http://www.w3.org/TR/CSS21/visudet.html#min-max-widths :
+
+ nscoord width, height;
+
+ if (tentWidth > maxWidth) {
+ if (tentHeight > maxHeight) {
+ if (int64_t(maxWidth) * int64_t(tentHeight) <=
+ int64_t(maxHeight) * int64_t(tentWidth)) {
+ width = maxWidth;
+ height = heightAtMaxWidth;
+ } else {
+ width = widthAtMaxHeight;
+ height = maxHeight;
+ }
+ } else {
+ // This also covers "(w > max-width) and (h < min-height)" since in
+ // that case (max-width/w < 1), and with (h < min-height):
+ // max(max-width * h/w, min-height) == min-height
+ width = maxWidth;
+ height = heightAtMaxWidth;
+ }
+ } else if (tentWidth < minWidth) {
+ if (tentHeight < minHeight) {
+ if (int64_t(minWidth) * int64_t(tentHeight) <=
+ int64_t(minHeight) * int64_t(tentWidth)) {
+ width = widthAtMinHeight;
+ height = minHeight;
+ } else {
+ width = minWidth;
+ height = heightAtMinWidth;
+ }
+ } else {
+ // This also covers "(w < min-width) and (h > max-height)" since in
+ // that case (min-width/w > 1), and with (h > max-height):
+ // min(min-width * h/w, max-height) == max-height
+ width = minWidth;
+ height = heightAtMinWidth;
+ }
+ } else {
+ if (tentHeight > maxHeight) {
+ width = widthAtMaxHeight;
+ height = maxHeight;
+ } else if (tentHeight < minHeight) {
+ width = widthAtMinHeight;
+ height = minHeight;
+ } else {
+ width = tentWidth;
+ height = tentHeight;
+ }
+ }
+
+ return nsSize(width, height);
+}
+
+/* static */ nscoord
+nsLayoutUtils::MinISizeFromInline(nsIFrame* aFrame,
+ nsRenderingContext* aRenderingContext)
+{
+ NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
+ "should not be container for font size inflation");
+
+ nsIFrame::InlineMinISizeData data;
+ DISPLAY_MIN_WIDTH(aFrame, data.mPrevLines);
+ aFrame->AddInlineMinISize(aRenderingContext, &data);
+ data.ForceBreak();
+ return data.mPrevLines;
+}
+
+/* static */ nscoord
+nsLayoutUtils::PrefISizeFromInline(nsIFrame* aFrame,
+ nsRenderingContext* aRenderingContext)
+{
+ NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
+ "should not be container for font size inflation");
+
+ nsIFrame::InlinePrefISizeData data;
+ DISPLAY_PREF_WIDTH(aFrame, data.mPrevLines);
+ aFrame->AddInlinePrefISize(aRenderingContext, &data);
+ data.ForceBreak();
+ return data.mPrevLines;
+}
+
+static nscolor
+DarkenColor(nscolor aColor)
+{
+ uint16_t hue, sat, value;
+ uint8_t alpha;
+
+ // convert the RBG to HSV so we can get the lightness (which is the v)
+ NS_RGB2HSV(aColor, hue, sat, value, alpha);
+
+ // The goal here is to send white to black while letting colored
+ // stuff stay colored... So we adopt the following approach.
+ // Something with sat = 0 should end up with value = 0. Something
+ // with a high sat can end up with a high value and it's ok.... At
+ // the same time, we don't want to make things lighter. Do
+ // something simple, since it seems to work.
+ if (value > sat) {
+ value = sat;
+ // convert this color back into the RGB color space.
+ NS_HSV2RGB(aColor, hue, sat, value, alpha);
+ }
+ return aColor;
+}
+
+// Check whether we should darken text/decoration colors. We need to do this if
+// background images and colors are being suppressed, because that means
+// light text will not be visible against the (presumed light-colored) background.
+static bool
+ShouldDarkenColors(nsPresContext* aPresContext)
+{
+ return !aPresContext->GetBackgroundColorDraw() &&
+ !aPresContext->GetBackgroundImageDraw();
+}
+
+nscolor
+nsLayoutUtils::GetColor(nsIFrame* aFrame, nsCSSPropertyID aProperty)
+{
+ nscolor color = aFrame->GetVisitedDependentColor(aProperty);
+ if (ShouldDarkenColors(aFrame->PresContext())) {
+ color = DarkenColor(color);
+ }
+ return color;
+}
+
+gfxFloat
+nsLayoutUtils::GetSnappedBaselineY(nsIFrame* aFrame, gfxContext* aContext,
+ nscoord aY, nscoord aAscent)
+{
+ gfxFloat appUnitsPerDevUnit = aFrame->PresContext()->AppUnitsPerDevPixel();
+ gfxFloat baseline = gfxFloat(aY) + aAscent;
+ gfxRect putativeRect(0, baseline/appUnitsPerDevUnit, 1, 1);
+ if (!aContext->UserToDevicePixelSnapped(putativeRect, true))
+ return baseline;
+ return aContext->DeviceToUser(putativeRect.TopLeft()).y * appUnitsPerDevUnit;
+}
+
+gfxFloat
+nsLayoutUtils::GetSnappedBaselineX(nsIFrame* aFrame, gfxContext* aContext,
+ nscoord aX, nscoord aAscent)
+{
+ gfxFloat appUnitsPerDevUnit = aFrame->PresContext()->AppUnitsPerDevPixel();
+ gfxFloat baseline = gfxFloat(aX) + aAscent;
+ gfxRect putativeRect(baseline / appUnitsPerDevUnit, 0, 1, 1);
+ if (!aContext->UserToDevicePixelSnapped(putativeRect, true)) {
+ return baseline;
+ }
+ return aContext->DeviceToUser(putativeRect.TopLeft()).x * appUnitsPerDevUnit;
+}
+
+// Hard limit substring lengths to 8000 characters ... this lets us statically
+// size the cluster buffer array in FindSafeLength
+#define MAX_GFX_TEXT_BUF_SIZE 8000
+
+static int32_t FindSafeLength(const char16_t *aString, uint32_t aLength,
+ uint32_t aMaxChunkLength)
+{
+ if (aLength <= aMaxChunkLength)
+ return aLength;
+
+ int32_t len = aMaxChunkLength;
+
+ // Ensure that we don't break inside a surrogate pair
+ while (len > 0 && NS_IS_LOW_SURROGATE(aString[len])) {
+ len--;
+ }
+ if (len == 0) {
+ // We don't want our caller to go into an infinite loop, so don't
+ // return zero. It's hard to imagine how we could actually get here
+ // unless there are languages that allow clusters of arbitrary size.
+ // If there are and someone feeds us a 500+ character cluster, too
+ // bad.
+ return aMaxChunkLength;
+ }
+ return len;
+}
+
+static int32_t GetMaxChunkLength(nsFontMetrics& aFontMetrics)
+{
+ return std::min(aFontMetrics.GetMaxStringLength(), MAX_GFX_TEXT_BUF_SIZE);
+}
+
+nscoord
+nsLayoutUtils::AppUnitWidthOfString(const char16_t *aString,
+ uint32_t aLength,
+ nsFontMetrics& aFontMetrics,
+ DrawTarget* aDrawTarget)
+{
+ uint32_t maxChunkLength = GetMaxChunkLength(aFontMetrics);
+ nscoord width = 0;
+ while (aLength > 0) {
+ int32_t len = FindSafeLength(aString, aLength, maxChunkLength);
+ width += aFontMetrics.GetWidth(aString, len, aDrawTarget);
+ aLength -= len;
+ aString += len;
+ }
+ return width;
+}
+
+nscoord
+nsLayoutUtils::AppUnitWidthOfStringBidi(const char16_t* aString,
+ uint32_t aLength,
+ const nsIFrame* aFrame,
+ nsFontMetrics& aFontMetrics,
+ nsRenderingContext& aContext)
+{
+ nsPresContext* presContext = aFrame->PresContext();
+ if (presContext->BidiEnabled()) {
+ nsBidiLevel level =
+ nsBidiPresUtils::BidiLevelFromStyle(aFrame->StyleContext());
+ return nsBidiPresUtils::MeasureTextWidth(aString, aLength, level,
+ presContext, aContext,
+ aFontMetrics);
+ }
+ aFontMetrics.SetTextRunRTL(false);
+ aFontMetrics.SetVertical(aFrame->GetWritingMode().IsVertical());
+ aFontMetrics.SetTextOrientation(aFrame->StyleVisibility()->mTextOrientation);
+ return nsLayoutUtils::AppUnitWidthOfString(aString, aLength, aFontMetrics,
+ aContext.GetDrawTarget());
+}
+
+bool
+nsLayoutUtils::StringWidthIsGreaterThan(const nsString& aString,
+ nsFontMetrics& aFontMetrics,
+ DrawTarget* aDrawTarget,
+ nscoord aWidth)
+{
+ const char16_t *string = aString.get();
+ uint32_t length = aString.Length();
+ uint32_t maxChunkLength = GetMaxChunkLength(aFontMetrics);
+ nscoord width = 0;
+ while (length > 0) {
+ int32_t len = FindSafeLength(string, length, maxChunkLength);
+ width += aFontMetrics.GetWidth(string, len, aDrawTarget);
+ if (width > aWidth) {
+ return true;
+ }
+ length -= len;
+ string += len;
+ }
+ return false;
+}
+
+nsBoundingMetrics
+nsLayoutUtils::AppUnitBoundsOfString(const char16_t* aString,
+ uint32_t aLength,
+ nsFontMetrics& aFontMetrics,
+ DrawTarget* aDrawTarget)
+{
+ uint32_t maxChunkLength = GetMaxChunkLength(aFontMetrics);
+ int32_t len = FindSafeLength(aString, aLength, maxChunkLength);
+ // Assign directly in the first iteration. This ensures that
+ // negative ascent/descent can be returned and the left bearing
+ // is properly initialized.
+ nsBoundingMetrics totalMetrics =
+ aFontMetrics.GetBoundingMetrics(aString, len, aDrawTarget);
+ aLength -= len;
+ aString += len;
+
+ while (aLength > 0) {
+ len = FindSafeLength(aString, aLength, maxChunkLength);
+ nsBoundingMetrics metrics =
+ aFontMetrics.GetBoundingMetrics(aString, len, aDrawTarget);
+ totalMetrics += metrics;
+ aLength -= len;
+ aString += len;
+ }
+ return totalMetrics;
+}
+
+void
+nsLayoutUtils::DrawString(const nsIFrame* aFrame,
+ nsFontMetrics& aFontMetrics,
+ nsRenderingContext* aContext,
+ const char16_t* aString,
+ int32_t aLength,
+ nsPoint aPoint,
+ nsStyleContext* aStyleContext)
+{
+ nsresult rv = NS_ERROR_FAILURE;
+
+ // If caller didn't pass a style context, use the frame's.
+ if (!aStyleContext) {
+ aStyleContext = aFrame->StyleContext();
+ }
+ aFontMetrics.SetVertical(WritingMode(aStyleContext).IsVertical());
+ aFontMetrics.SetTextOrientation(
+ aStyleContext->StyleVisibility()->mTextOrientation);
+
+ nsPresContext* presContext = aFrame->PresContext();
+ if (presContext->BidiEnabled()) {
+ nsBidiLevel level =
+ nsBidiPresUtils::BidiLevelFromStyle(aStyleContext);
+ rv = nsBidiPresUtils::RenderText(aString, aLength, level,
+ presContext, *aContext,
+ aContext->GetDrawTarget(), aFontMetrics,
+ aPoint.x, aPoint.y);
+ }
+ if (NS_FAILED(rv))
+ {
+ aFontMetrics.SetTextRunRTL(false);
+ DrawUniDirString(aString, aLength, aPoint, aFontMetrics, *aContext);
+ }
+}
+
+void
+nsLayoutUtils::DrawUniDirString(const char16_t* aString,
+ uint32_t aLength,
+ nsPoint aPoint,
+ nsFontMetrics& aFontMetrics,
+ nsRenderingContext& aContext)
+{
+ nscoord x = aPoint.x;
+ nscoord y = aPoint.y;
+
+ uint32_t maxChunkLength = GetMaxChunkLength(aFontMetrics);
+ if (aLength <= maxChunkLength) {
+ aFontMetrics.DrawString(aString, aLength, x, y, &aContext,
+ aContext.GetDrawTarget());
+ return;
+ }
+
+ bool isRTL = aFontMetrics.GetTextRunRTL();
+
+ // If we're drawing right to left, we must start at the end.
+ if (isRTL) {
+ x += nsLayoutUtils::AppUnitWidthOfString(aString, aLength, aFontMetrics,
+ aContext.GetDrawTarget());
+ }
+
+ while (aLength > 0) {
+ int32_t len = FindSafeLength(aString, aLength, maxChunkLength);
+ nscoord width = aFontMetrics.GetWidth(aString, len, aContext.GetDrawTarget());
+ if (isRTL) {
+ x -= width;
+ }
+ aFontMetrics.DrawString(aString, len, x, y, &aContext,
+ aContext.GetDrawTarget());
+ if (!isRTL) {
+ x += width;
+ }
+ aLength -= len;
+ aString += len;
+ }
+}
+
+/* static */ void
+nsLayoutUtils::PaintTextShadow(const nsIFrame* aFrame,
+ nsRenderingContext* aContext,
+ const nsRect& aTextRect,
+ const nsRect& aDirtyRect,
+ const nscolor& aForegroundColor,
+ TextShadowCallback aCallback,
+ void* aCallbackData)
+{
+ const nsStyleText* textStyle = aFrame->StyleText();
+ if (!textStyle->HasTextShadow())
+ return;
+
+ // Text shadow happens with the last value being painted at the back,
+ // ie. it is painted first.
+ gfxContext* aDestCtx = aContext->ThebesContext();
+ for (uint32_t i = textStyle->mTextShadow->Length(); i > 0; --i) {
+ nsCSSShadowItem* shadowDetails = textStyle->mTextShadow->ShadowAt(i - 1);
+ nsPoint shadowOffset(shadowDetails->mXOffset,
+ shadowDetails->mYOffset);
+ nscoord blurRadius = std::max(shadowDetails->mRadius, 0);
+
+ nsRect shadowRect(aTextRect);
+ shadowRect.MoveBy(shadowOffset);
+
+ nsPresContext* presCtx = aFrame->PresContext();
+ nsContextBoxBlur contextBoxBlur;
+ gfxContext* shadowContext = contextBoxBlur.Init(shadowRect, 0, blurRadius,
+ presCtx->AppUnitsPerDevPixel(),
+ aDestCtx, aDirtyRect, nullptr);
+ if (!shadowContext)
+ continue;
+
+ nscolor shadowColor;
+ if (shadowDetails->mHasColor)
+ shadowColor = shadowDetails->mColor;
+ else
+ shadowColor = aForegroundColor;
+
+ // Conjure an nsRenderingContext from a gfxContext for drawing the text
+ // to blur.
+ nsRenderingContext renderingContext(shadowContext);
+
+ aDestCtx->Save();
+ aDestCtx->NewPath();
+ aDestCtx->SetColor(Color::FromABGR(shadowColor));
+
+ // The callback will draw whatever we want to blur as a shadow.
+ aCallback(&renderingContext, shadowOffset, shadowColor, aCallbackData);
+
+ contextBoxBlur.DoPaint();
+ aDestCtx->Restore();
+ }
+}
+
+/* static */ nscoord
+nsLayoutUtils::GetCenteredFontBaseline(nsFontMetrics* aFontMetrics,
+ nscoord aLineHeight,
+ bool aIsInverted)
+{
+ nscoord fontAscent = aIsInverted ? aFontMetrics->MaxDescent()
+ : aFontMetrics->MaxAscent();
+ nscoord fontHeight = aFontMetrics->MaxHeight();
+
+ nscoord leading = aLineHeight - fontHeight;
+ return fontAscent + leading/2;
+}
+
+
+/* static */ bool
+nsLayoutUtils::GetFirstLineBaseline(WritingMode aWritingMode,
+ const nsIFrame* aFrame, nscoord* aResult)
+{
+ LinePosition position;
+ if (!GetFirstLinePosition(aWritingMode, aFrame, &position))
+ return false;
+ *aResult = position.mBaseline;
+ return true;
+}
+
+/* static */ bool
+nsLayoutUtils::GetFirstLinePosition(WritingMode aWM,
+ const nsIFrame* aFrame,
+ LinePosition* aResult)
+{
+ const nsBlockFrame* block = nsLayoutUtils::GetAsBlock(const_cast<nsIFrame*>(aFrame));
+ if (!block) {
+ // For the first-line baseline we also have to check for a table, and if
+ // so, use the baseline of its first row.
+ nsIAtom* fType = aFrame->GetType();
+ if (fType == nsGkAtoms::tableWrapperFrame ||
+ fType == nsGkAtoms::flexContainerFrame ||
+ fType == nsGkAtoms::gridContainerFrame) {
+ if ((fType == nsGkAtoms::gridContainerFrame &&
+ aFrame->HasAnyStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE)) ||
+ (fType == nsGkAtoms::flexContainerFrame &&
+ aFrame->HasAnyStateBits(NS_STATE_FLEX_SYNTHESIZE_BASELINE)) ||
+ (fType == nsGkAtoms::tableWrapperFrame &&
+ static_cast<const nsTableWrapperFrame*>(aFrame)->GetRowCount() == 0)) {
+ // empty grid/flex/table container
+ aResult->mBStart = 0;
+ aResult->mBaseline = aFrame->SynthesizeBaselineBOffsetFromBorderBox(aWM,
+ BaselineSharingGroup::eFirst);
+ aResult->mBEnd = aFrame->BSize(aWM);
+ return true;
+ }
+ aResult->mBStart = 0;
+ aResult->mBaseline = aFrame->GetLogicalBaseline(aWM);
+ // This is what we want for the list bullet caller; not sure if
+ // other future callers will want the same.
+ aResult->mBEnd = aFrame->BSize(aWM);
+ return true;
+ }
+
+ // For first-line baselines, we have to consider scroll frames.
+ if (fType == nsGkAtoms::scrollFrame) {
+ nsIScrollableFrame *sFrame = do_QueryFrame(const_cast<nsIFrame*>(aFrame));
+ if (!sFrame) {
+ NS_NOTREACHED("not scroll frame");
+ }
+ LinePosition kidPosition;
+ if (GetFirstLinePosition(aWM,
+ sFrame->GetScrolledFrame(), &kidPosition)) {
+ // Consider only the border and padding that contributes to the
+ // kid's position, not the scrolling, so we get the initial
+ // position.
+ *aResult = kidPosition +
+ aFrame->GetLogicalUsedBorderAndPadding(aWM).BStart(aWM);
+ return true;
+ }
+ return false;
+ }
+
+ if (fType == nsGkAtoms::fieldSetFrame) {
+ LinePosition kidPosition;
+ nsIFrame* kid = aFrame->PrincipalChildList().FirstChild();
+ // kid might be a legend frame here, but that's ok.
+ if (GetFirstLinePosition(aWM, kid, &kidPosition)) {
+ *aResult = kidPosition +
+ kid->GetLogicalNormalPosition(aWM, aFrame->GetSize()).B(aWM);
+ return true;
+ }
+ return false;
+ }
+
+ // No baseline.
+ return false;
+ }
+
+ for (nsBlockFrame::ConstLineIterator line = block->LinesBegin(),
+ line_end = block->LinesEnd();
+ line != line_end; ++line) {
+ if (line->IsBlock()) {
+ nsIFrame *kid = line->mFirstChild;
+ LinePosition kidPosition;
+ if (GetFirstLinePosition(aWM, kid, &kidPosition)) {
+ //XXX Not sure if this is the correct value to use for container
+ // width here. It will only be used in vertical-rl layout,
+ // which we don't have full support and testing for yet.
+ const nsSize& containerSize = line->mContainerSize;
+ *aResult = kidPosition +
+ kid->GetLogicalNormalPosition(aWM, containerSize).B(aWM);
+ return true;
+ }
+ } else {
+ // XXX Is this the right test? We have some bogus empty lines
+ // floating around, but IsEmpty is perhaps too weak.
+ if (line->BSize() != 0 || !line->IsEmpty()) {
+ nscoord bStart = line->BStart();
+ aResult->mBStart = bStart;
+ aResult->mBaseline = bStart + line->GetLogicalAscent();
+ aResult->mBEnd = bStart + line->BSize();
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+/* static */ bool
+nsLayoutUtils::GetLastLineBaseline(WritingMode aWM,
+ const nsIFrame* aFrame, nscoord* aResult)
+{
+ const nsBlockFrame* block = nsLayoutUtils::GetAsBlock(const_cast<nsIFrame*>(aFrame));
+ if (!block)
+ // No baseline. (We intentionally don't descend into scroll frames.)
+ return false;
+
+ for (nsBlockFrame::ConstReverseLineIterator line = block->LinesRBegin(),
+ line_end = block->LinesREnd();
+ line != line_end; ++line) {
+ if (line->IsBlock()) {
+ nsIFrame *kid = line->mFirstChild;
+ nscoord kidBaseline;
+ const nsSize& containerSize = line->mContainerSize;
+ if (GetLastLineBaseline(aWM, kid, &kidBaseline)) {
+ // Ignore relative positioning for baseline calculations
+ *aResult = kidBaseline +
+ kid->GetLogicalNormalPosition(aWM, containerSize).B(aWM);
+ return true;
+ } else if (kid->GetType() == nsGkAtoms::scrollFrame) {
+ // Use the bottom of the scroll frame.
+ // XXX CSS2.1 really doesn't say what to do here.
+ *aResult = kid->GetLogicalNormalPosition(aWM, containerSize).B(aWM) +
+ kid->BSize(aWM);
+ return true;
+ }
+ } else {
+ // XXX Is this the right test? We have some bogus empty lines
+ // floating around, but IsEmpty is perhaps too weak.
+ if (line->BSize() != 0 || !line->IsEmpty()) {
+ *aResult = line->BStart() + line->GetLogicalAscent();
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+static nscoord
+CalculateBlockContentBEnd(WritingMode aWM, nsBlockFrame* aFrame)
+{
+ NS_PRECONDITION(aFrame, "null ptr");
+
+ nscoord contentBEnd = 0;
+
+ for (nsBlockFrame::LineIterator line = aFrame->LinesBegin(),
+ line_end = aFrame->LinesEnd();
+ line != line_end; ++line) {
+ if (line->IsBlock()) {
+ nsIFrame* child = line->mFirstChild;
+ const nsSize& containerSize = line->mContainerSize;
+ nscoord offset =
+ child->GetLogicalNormalPosition(aWM, containerSize).B(aWM);
+ contentBEnd =
+ std::max(contentBEnd,
+ nsLayoutUtils::CalculateContentBEnd(aWM, child) + offset);
+ }
+ else {
+ contentBEnd = std::max(contentBEnd, line->BEnd());
+ }
+ }
+ return contentBEnd;
+}
+
+/* static */ nscoord
+nsLayoutUtils::CalculateContentBEnd(WritingMode aWM, nsIFrame* aFrame)
+{
+ NS_PRECONDITION(aFrame, "null ptr");
+
+ nscoord contentBEnd = aFrame->BSize(aWM);
+
+ // We want scrollable overflow rather than visual because this
+ // calculation is intended to affect layout.
+ LogicalSize overflowSize(aWM, aFrame->GetScrollableOverflowRect().Size());
+ if (overflowSize.BSize(aWM) > contentBEnd) {
+ nsIFrame::ChildListIDs skip(nsIFrame::kOverflowList |
+ nsIFrame::kExcessOverflowContainersList |
+ nsIFrame::kOverflowOutOfFlowList);
+ nsBlockFrame* blockFrame = GetAsBlock(aFrame);
+ if (blockFrame) {
+ contentBEnd =
+ std::max(contentBEnd, CalculateBlockContentBEnd(aWM, blockFrame));
+ skip |= nsIFrame::kPrincipalList;
+ }
+ nsIFrame::ChildListIterator lists(aFrame);
+ for (; !lists.IsDone(); lists.Next()) {
+ if (!skip.Contains(lists.CurrentID())) {
+ nsFrameList::Enumerator childFrames(lists.CurrentList());
+ for (; !childFrames.AtEnd(); childFrames.Next()) {
+ nsIFrame* child = childFrames.get();
+ nscoord offset =
+ child->GetLogicalNormalPosition(aWM,
+ aFrame->GetSize()).B(aWM);
+ contentBEnd = std::max(contentBEnd,
+ CalculateContentBEnd(aWM, child) + offset);
+ }
+ }
+ }
+ }
+ return contentBEnd;
+}
+
+/* static */ nsIFrame*
+nsLayoutUtils::GetClosestLayer(nsIFrame* aFrame)
+{
+ nsIFrame* layer;
+ for (layer = aFrame; layer; layer = layer->GetParent()) {
+ if (layer->IsAbsPosContainingBlock() ||
+ (layer->GetParent() &&
+ layer->GetParent()->GetType() == nsGkAtoms::scrollFrame))
+ break;
+ }
+ if (layer)
+ return layer;
+ return aFrame->PresContext()->PresShell()->FrameManager()->GetRootFrame();
+}
+
+SamplingFilter
+nsLayoutUtils::GetSamplingFilterForFrame(nsIFrame* aForFrame)
+{
+ SamplingFilter defaultFilter = SamplingFilter::GOOD;
+ nsStyleContext *sc;
+ if (nsCSSRendering::IsCanvasFrame(aForFrame)) {
+ nsCSSRendering::FindBackground(aForFrame, &sc);
+ } else {
+ sc = aForFrame->StyleContext();
+ }
+
+ switch (sc->StyleVisibility()->mImageRendering) {
+ case NS_STYLE_IMAGE_RENDERING_OPTIMIZESPEED:
+ return SamplingFilter::POINT;
+ case NS_STYLE_IMAGE_RENDERING_OPTIMIZEQUALITY:
+ return SamplingFilter::LINEAR;
+ case NS_STYLE_IMAGE_RENDERING_CRISPEDGES:
+ return SamplingFilter::POINT;
+ default:
+ return defaultFilter;
+ }
+}
+
+/**
+ * Given an image being drawn into an appunit coordinate system, and
+ * a point in that coordinate system, map the point back into image
+ * pixel space.
+ * @param aSize the size of the image, in pixels
+ * @param aDest the rectangle that the image is being mapped into
+ * @param aPt a point in the same coordinate system as the rectangle
+ */
+static gfxPoint
+MapToFloatImagePixels(const gfxSize& aSize,
+ const gfxRect& aDest, const gfxPoint& aPt)
+{
+ return gfxPoint(((aPt.x - aDest.X())*aSize.width)/aDest.Width(),
+ ((aPt.y - aDest.Y())*aSize.height)/aDest.Height());
+}
+
+/**
+ * Given an image being drawn into an pixel-based coordinate system, and
+ * a point in image space, map the point into the pixel-based coordinate
+ * system.
+ * @param aSize the size of the image, in pixels
+ * @param aDest the rectangle that the image is being mapped into
+ * @param aPt a point in image space
+ */
+static gfxPoint
+MapToFloatUserPixels(const gfxSize& aSize,
+ const gfxRect& aDest, const gfxPoint& aPt)
+{
+ return gfxPoint(aPt.x*aDest.Width()/aSize.width + aDest.X(),
+ aPt.y*aDest.Height()/aSize.height + aDest.Y());
+}
+
+/* static */ gfxRect
+nsLayoutUtils::RectToGfxRect(const nsRect& aRect, int32_t aAppUnitsPerDevPixel)
+{
+ return gfxRect(gfxFloat(aRect.x) / aAppUnitsPerDevPixel,
+ gfxFloat(aRect.y) / aAppUnitsPerDevPixel,
+ gfxFloat(aRect.width) / aAppUnitsPerDevPixel,
+ gfxFloat(aRect.height) / aAppUnitsPerDevPixel);
+}
+
+struct SnappedImageDrawingParameters {
+ // A transform from image space to device space.
+ gfxMatrix imageSpaceToDeviceSpace;
+ // The size at which the image should be drawn (which may not be its
+ // intrinsic size due to, for example, HQ scaling).
+ nsIntSize size;
+ // The region in tiled image space which will be drawn, with an associated
+ // region to which sampling should be restricted.
+ ImageRegion region;
+ // The default viewport size for SVG images, which we use unless a different
+ // one has been explicitly specified. This is the same as |size| except that
+ // it does not take into account any transformation on the gfxContext we're
+ // drawing to - for example, CSS transforms are not taken into account.
+ CSSIntSize svgViewportSize;
+ // Whether there's anything to draw at all.
+ bool shouldDraw;
+
+ SnappedImageDrawingParameters()
+ : region(ImageRegion::Empty())
+ , shouldDraw(false)
+ {}
+
+ SnappedImageDrawingParameters(const gfxMatrix& aImageSpaceToDeviceSpace,
+ const nsIntSize& aSize,
+ const ImageRegion& aRegion,
+ const CSSIntSize& aSVGViewportSize)
+ : imageSpaceToDeviceSpace(aImageSpaceToDeviceSpace)
+ , size(aSize)
+ , region(aRegion)
+ , svgViewportSize(aSVGViewportSize)
+ , shouldDraw(true)
+ {}
+};
+
+/**
+ * Given two axis-aligned rectangles, returns the transformation that maps the
+ * first onto the second.
+ *
+ * @param aFrom The rect to be transformed.
+ * @param aTo The rect that aFrom should be mapped onto by the transformation.
+ */
+static gfxMatrix
+TransformBetweenRects(const gfxRect& aFrom, const gfxRect& aTo)
+{
+ gfxSize scale(aTo.width / aFrom.width,
+ aTo.height / aFrom.height);
+ gfxPoint translation(aTo.x - aFrom.x * scale.width,
+ aTo.y - aFrom.y * scale.height);
+ return gfxMatrix(scale.width, 0, 0, scale.height,
+ translation.x, translation.y);
+}
+
+static nsRect
+TileNearRect(const nsRect& aAnyTile, const nsRect& aTargetRect)
+{
+ nsPoint distance = aTargetRect.TopLeft() - aAnyTile.TopLeft();
+ return aAnyTile + nsPoint(distance.x / aAnyTile.width * aAnyTile.width,
+ distance.y / aAnyTile.height * aAnyTile.height);
+}
+
+static gfxFloat
+StableRound(gfxFloat aValue)
+{
+ // Values slightly less than 0.5 should round up like 0.5 would; we're
+ // assuming they were meant to be 0.5.
+ return floor(aValue + 0.5001);
+}
+
+static gfxPoint
+StableRound(const gfxPoint& aPoint)
+{
+ return gfxPoint(StableRound(aPoint.x), StableRound(aPoint.y));
+}
+
+/**
+ * Given a set of input parameters, compute certain output parameters
+ * for drawing an image with the image snapping algorithm.
+ * See https://wiki.mozilla.org/Gecko:Image_Snapping_and_Rendering
+ *
+ * @see nsLayoutUtils::DrawImage() for the descriptions of input parameters
+ */
+static SnappedImageDrawingParameters
+ComputeSnappedImageDrawingParameters(gfxContext* aCtx,
+ int32_t aAppUnitsPerDevPixel,
+ const nsRect aDest,
+ const nsRect aFill,
+ const nsPoint aAnchor,
+ const nsRect aDirty,
+ imgIContainer* aImage,
+ const SamplingFilter aSamplingFilter,
+ uint32_t aImageFlags,
+ ExtendMode aExtendMode)
+{
+ if (aDest.IsEmpty() || aFill.IsEmpty())
+ return SnappedImageDrawingParameters();
+
+ // Avoid unnecessarily large offsets.
+ bool doTile = !aDest.Contains(aFill);
+ nsRect appUnitDest = doTile ? TileNearRect(aDest, aFill.Intersect(aDirty))
+ : aDest;
+ nsPoint anchor = aAnchor + (appUnitDest.TopLeft() - aDest.TopLeft());
+
+ gfxRect devPixelDest =
+ nsLayoutUtils::RectToGfxRect(appUnitDest, aAppUnitsPerDevPixel);
+ gfxRect devPixelFill =
+ nsLayoutUtils::RectToGfxRect(aFill, aAppUnitsPerDevPixel);
+ gfxRect devPixelDirty =
+ nsLayoutUtils::RectToGfxRect(aDirty, aAppUnitsPerDevPixel);
+
+ gfxMatrix currentMatrix = aCtx->CurrentMatrix();
+ gfxRect fill = devPixelFill;
+ gfxRect dest = devPixelDest;
+ bool didSnap;
+ // Snap even if we have a scale in the context. But don't snap if
+ // we have something that's not translation+scale, or if the scale flips in
+ // the X or Y direction, because snapped image drawing can't handle that yet.
+ if (!currentMatrix.HasNonAxisAlignedTransform() &&
+ currentMatrix._11 > 0.0 && currentMatrix._22 > 0.0 &&
+ aCtx->UserToDevicePixelSnapped(fill, true) &&
+ aCtx->UserToDevicePixelSnapped(dest, true)) {
+ // We snapped. On this code path, |fill| and |dest| take into account
+ // currentMatrix's transform.
+ didSnap = true;
+ } else {
+ // We didn't snap. On this code path, |fill| and |dest| do not take into
+ // account currentMatrix's transform.
+ didSnap = false;
+ fill = devPixelFill;
+ dest = devPixelDest;
+ }
+
+ // If we snapped above, |dest| already takes into account |currentMatrix|'s scale
+ // and has integer coordinates. If not, we need these properties to compute
+ // the optimal drawn image size, so compute |snappedDestSize| here.
+ gfxSize snappedDestSize = dest.Size();
+ if (!didSnap) {
+ gfxSize scaleFactors = currentMatrix.ScaleFactors(true);
+ snappedDestSize.Scale(scaleFactors.width, scaleFactors.height);
+ snappedDestSize.width = NS_round(snappedDestSize.width);
+ snappedDestSize.height = NS_round(snappedDestSize.height);
+ }
+
+ // We need to be sure that this is at least one pixel in width and height,
+ // or we'll end up drawing nothing even if we have a nonempty fill.
+ snappedDestSize.width = std::max(snappedDestSize.width, 1.0);
+ snappedDestSize.height = std::max(snappedDestSize.height, 1.0);
+
+ // Bail if we're not going to end up drawing anything.
+ if (fill.IsEmpty() || snappedDestSize.IsEmpty()) {
+ return SnappedImageDrawingParameters();
+ }
+
+ nsIntSize intImageSize =
+ aImage->OptimalImageSizeForDest(snappedDestSize,
+ imgIContainer::FRAME_CURRENT,
+ aSamplingFilter, aImageFlags);
+ gfxSize imageSize(intImageSize.width, intImageSize.height);
+
+ // XXX(seth): May be buggy; see bug 1151016.
+ CSSIntSize svgViewportSize = currentMatrix.IsIdentity()
+ ? CSSIntSize(intImageSize.width, intImageSize.height)
+ : CSSIntSize::Truncate(devPixelDest.width, devPixelDest.height);
+
+ // Compute the set of pixels that would be sampled by an ideal rendering
+ gfxPoint subimageTopLeft =
+ MapToFloatImagePixels(imageSize, devPixelDest, devPixelFill.TopLeft());
+ gfxPoint subimageBottomRight =
+ MapToFloatImagePixels(imageSize, devPixelDest, devPixelFill.BottomRight());
+ gfxRect subimage;
+ subimage.MoveTo(NSToIntFloor(subimageTopLeft.x),
+ NSToIntFloor(subimageTopLeft.y));
+ subimage.SizeTo(NSToIntCeil(subimageBottomRight.x) - subimage.x,
+ NSToIntCeil(subimageBottomRight.y) - subimage.y);
+
+ if (subimage.IsEmpty()) {
+ // Bail if the subimage is empty (we're not going to be drawing anything).
+ return SnappedImageDrawingParameters();
+ }
+
+ gfxMatrix transform;
+ gfxMatrix invTransform;
+
+ bool anchorAtUpperLeft = anchor.x == appUnitDest.x &&
+ anchor.y == appUnitDest.y;
+ bool exactlyOneImageCopy = aFill.IsEqualEdges(appUnitDest);
+ if (anchorAtUpperLeft && exactlyOneImageCopy) {
+ // The simple case: we can ignore the anchor point and compute the
+ // transformation from the sampled region (the subimage) to the fill rect.
+ // This approach is preferable when it works since it tends to produce
+ // less numerical error.
+ transform = TransformBetweenRects(subimage, fill);
+ invTransform = TransformBetweenRects(fill, subimage);
+ } else {
+ // The more complicated case: we compute the transformation from the
+ // image rect positioned at the image space anchor point to the dest rect
+ // positioned at the device space anchor point.
+
+ // Compute the anchor point in both device space and image space. This
+ // code assumes that pixel-based devices have one pixel per device unit!
+ gfxPoint anchorPoint(gfxFloat(anchor.x)/aAppUnitsPerDevPixel,
+ gfxFloat(anchor.y)/aAppUnitsPerDevPixel);
+ gfxPoint imageSpaceAnchorPoint =
+ MapToFloatImagePixels(imageSize, devPixelDest, anchorPoint);
+
+ if (didSnap) {
+ imageSpaceAnchorPoint = StableRound(imageSpaceAnchorPoint);
+ anchorPoint = imageSpaceAnchorPoint;
+ anchorPoint = MapToFloatUserPixels(imageSize, devPixelDest, anchorPoint);
+ anchorPoint = currentMatrix.Transform(anchorPoint);
+ anchorPoint = StableRound(anchorPoint);
+ }
+
+ // Compute an unsnapped version of the dest rect's size. We continue to
+ // follow the pattern that we take |currentMatrix| into account only if
+ // |didSnap| is true.
+ gfxSize unsnappedDestSize
+ = didSnap ? devPixelDest.Size() * currentMatrix.ScaleFactors(true)
+ : devPixelDest.Size();
+
+ gfxRect anchoredDestRect(anchorPoint, unsnappedDestSize);
+ gfxRect anchoredImageRect(imageSpaceAnchorPoint, imageSize);
+
+ // Calculate anchoredDestRect with snapped fill rect when the devPixelFill rect
+ // corresponds to just a single tile in that direction
+ if (fill.Width() != devPixelFill.Width() &&
+ devPixelDest.x == devPixelFill.x &&
+ devPixelDest.XMost() == devPixelFill.XMost()) {
+ anchoredDestRect.width = fill.width;
+ }
+ if (fill.Height() != devPixelFill.Height() &&
+ devPixelDest.y == devPixelFill.y &&
+ devPixelDest.YMost() == devPixelFill.YMost()) {
+ anchoredDestRect.height = fill.height;
+ }
+
+ transform = TransformBetweenRects(anchoredImageRect, anchoredDestRect);
+ invTransform = TransformBetweenRects(anchoredDestRect, anchoredImageRect);
+ }
+
+ // If the transform is not a straight translation by integers, then
+ // filtering will occur, and restricting the fill rect to the dirty rect
+ // would change the values computed for edge pixels, which we can't allow.
+ // Also, if 'didSnap' is false then rounding out 'devPixelDirty' might not
+ // produce pixel-aligned coordinates, which would also break the values
+ // computed for edge pixels.
+ if (didSnap && !invTransform.HasNonIntegerTranslation()) {
+ // This form of Transform is safe to call since non-axis-aligned
+ // transforms wouldn't be snapped.
+ devPixelDirty = currentMatrix.Transform(devPixelDirty);
+ devPixelDirty.RoundOut();
+ fill = fill.Intersect(devPixelDirty);
+ }
+ if (fill.IsEmpty())
+ return SnappedImageDrawingParameters();
+
+ gfxRect imageSpaceFill(didSnap ? invTransform.Transform(fill)
+ : invTransform.TransformBounds(fill));
+
+ // If we didn't snap, we need to post-multiply the matrix on the context to
+ // get the final matrix we'll draw with, because we didn't take it into
+ // account when computing the matrices above.
+ if (!didSnap) {
+ transform = transform * currentMatrix;
+ }
+
+ ExtendMode extendMode = (aImageFlags & imgIContainer::FLAG_CLAMP)
+ ? ExtendMode::CLAMP
+ : aExtendMode;
+ // We were passed in the default extend mode but need to tile.
+ if (extendMode == ExtendMode::CLAMP && doTile) {
+ MOZ_ASSERT(!(aImageFlags & imgIContainer::FLAG_CLAMP));
+ extendMode = ExtendMode::REPEAT;
+ }
+
+ ImageRegion region =
+ ImageRegion::CreateWithSamplingRestriction(imageSpaceFill, subimage, extendMode);
+
+ return SnappedImageDrawingParameters(transform, intImageSize,
+ region, svgViewportSize);
+}
+
+static DrawResult
+DrawImageInternal(gfxContext& aContext,
+ nsPresContext* aPresContext,
+ imgIContainer* aImage,
+ const SamplingFilter aSamplingFilter,
+ const nsRect& aDest,
+ const nsRect& aFill,
+ const nsPoint& aAnchor,
+ const nsRect& aDirty,
+ const SVGImageContext* aSVGContext,
+ uint32_t aImageFlags,
+ ExtendMode aExtendMode = ExtendMode::CLAMP)
+{
+ DrawResult result = DrawResult::SUCCESS;
+
+ if (aPresContext->Type() == nsPresContext::eContext_Print) {
+ // We want vector images to be passed on as vector commands, not a raster
+ // image.
+ aImageFlags |= imgIContainer::FLAG_BYPASS_SURFACE_CACHE;
+ }
+ if (aDest.Contains(aFill)) {
+ aImageFlags |= imgIContainer::FLAG_CLAMP;
+ }
+ int32_t appUnitsPerDevPixel =
+ aPresContext->AppUnitsPerDevPixel();
+
+ SnappedImageDrawingParameters params =
+ ComputeSnappedImageDrawingParameters(&aContext, appUnitsPerDevPixel, aDest,
+ aFill, aAnchor, aDirty, aImage,
+ aSamplingFilter, aImageFlags, aExtendMode);
+
+ if (!params.shouldDraw) {
+ return result;
+ }
+
+ {
+ gfxContextMatrixAutoSaveRestore contextMatrixRestorer(&aContext);
+
+ RefPtr<gfxContext> destCtx = &aContext;
+
+ destCtx->SetMatrix(params.imageSpaceToDeviceSpace);
+
+ Maybe<SVGImageContext> svgContext = ToMaybe(aSVGContext);
+ if (!svgContext) {
+ // Use the default viewport.
+ svgContext = Some(SVGImageContext(params.svgViewportSize, Nothing()));
+ }
+
+ result = aImage->Draw(destCtx, params.size, params.region,
+ imgIContainer::FRAME_CURRENT, aSamplingFilter,
+ svgContext, aImageFlags);
+
+ }
+
+ return result;
+}
+
+/* static */ DrawResult
+nsLayoutUtils::DrawSingleUnscaledImage(gfxContext& aContext,
+ nsPresContext* aPresContext,
+ imgIContainer* aImage,
+ const SamplingFilter aSamplingFilter,
+ const nsPoint& aDest,
+ const nsRect* aDirty,
+ uint32_t aImageFlags,
+ const nsRect* aSourceArea)
+{
+ CSSIntSize imageSize;
+ aImage->GetWidth(&imageSize.width);
+ aImage->GetHeight(&imageSize.height);
+ if (imageSize.width < 1 || imageSize.height < 1) {
+ NS_WARNING("Image width or height is non-positive");
+ return DrawResult::TEMPORARY_ERROR;
+ }
+
+ nsSize size(CSSPixel::ToAppUnits(imageSize));
+ nsRect source;
+ if (aSourceArea) {
+ source = *aSourceArea;
+ } else {
+ source.SizeTo(size);
+ }
+
+ nsRect dest(aDest - source.TopLeft(), size);
+ nsRect fill(aDest, source.Size());
+ // Ensure that only a single image tile is drawn. If aSourceArea extends
+ // outside the image bounds, we want to honor the aSourceArea-to-aDest
+ // translation but we don't want to actually tile the image.
+ fill.IntersectRect(fill, dest);
+ return DrawImageInternal(aContext, aPresContext,
+ aImage, aSamplingFilter,
+ dest, fill, aDest, aDirty ? *aDirty : dest,
+ nullptr, aImageFlags);
+}
+
+/* static */ DrawResult
+nsLayoutUtils::DrawSingleImage(gfxContext& aContext,
+ nsPresContext* aPresContext,
+ imgIContainer* aImage,
+ const SamplingFilter aSamplingFilter,
+ const nsRect& aDest,
+ const nsRect& aDirty,
+ const SVGImageContext* aSVGContext,
+ uint32_t aImageFlags,
+ const nsPoint* aAnchorPoint,
+ const nsRect* aSourceArea)
+{
+ nscoord appUnitsPerCSSPixel = nsDeviceContext::AppUnitsPerCSSPixel();
+ CSSIntSize pixelImageSize(ComputeSizeForDrawingWithFallback(aImage, aDest.Size()));
+ if (pixelImageSize.width < 1 || pixelImageSize.height < 1) {
+ NS_WARNING("Image width or height is non-positive");
+ return DrawResult::TEMPORARY_ERROR;
+ }
+
+ nsSize imageSize(CSSPixel::ToAppUnits(pixelImageSize));
+ nsRect source;
+ nsCOMPtr<imgIContainer> image;
+ if (aSourceArea) {
+ source = *aSourceArea;
+ nsIntRect subRect(source.x, source.y, source.width, source.height);
+ subRect.ScaleInverseRoundOut(appUnitsPerCSSPixel);
+ image = ImageOps::Clip(aImage, subRect);
+
+ nsRect imageRect;
+ imageRect.SizeTo(imageSize);
+ nsRect clippedSource = imageRect.Intersect(source);
+
+ source -= clippedSource.TopLeft();
+ imageSize = clippedSource.Size();
+ } else {
+ source.SizeTo(imageSize);
+ image = aImage;
+ }
+
+ nsRect dest = GetWholeImageDestination(imageSize, source, aDest);
+
+ // Ensure that only a single image tile is drawn. If aSourceArea extends
+ // outside the image bounds, we want to honor the aSourceArea-to-aDest
+ // transform but we don't want to actually tile the image.
+ nsRect fill;
+ fill.IntersectRect(aDest, dest);
+ return DrawImageInternal(aContext, aPresContext, image,
+ aSamplingFilter, dest, fill,
+ aAnchorPoint ? *aAnchorPoint : fill.TopLeft(),
+ aDirty, aSVGContext, aImageFlags);
+}
+
+/* static */ void
+nsLayoutUtils::ComputeSizeForDrawing(imgIContainer *aImage,
+ CSSIntSize& aImageSize, /*outparam*/
+ nsSize& aIntrinsicRatio, /*outparam*/
+ bool& aGotWidth, /*outparam*/
+ bool& aGotHeight /*outparam*/)
+{
+ aGotWidth = NS_SUCCEEDED(aImage->GetWidth(&aImageSize.width));
+ aGotHeight = NS_SUCCEEDED(aImage->GetHeight(&aImageSize.height));
+ bool gotRatio = NS_SUCCEEDED(aImage->GetIntrinsicRatio(&aIntrinsicRatio));
+
+ if (!(aGotWidth && aGotHeight) && !gotRatio) {
+ // We hit an error (say, because the image failed to load or couldn't be
+ // decoded) and should return zero size.
+ aGotWidth = aGotHeight = true;
+ aImageSize = CSSIntSize(0, 0);
+ aIntrinsicRatio = nsSize(0, 0);
+ }
+}
+
+/* static */ CSSIntSize
+nsLayoutUtils::ComputeSizeForDrawingWithFallback(imgIContainer* aImage,
+ const nsSize& aFallbackSize)
+{
+ CSSIntSize imageSize;
+ nsSize imageRatio;
+ bool gotHeight, gotWidth;
+ ComputeSizeForDrawing(aImage, imageSize, imageRatio, gotWidth, gotHeight);
+
+ // If we didn't get both width and height, try to compute them using the
+ // intrinsic ratio of the image.
+ if (gotWidth != gotHeight) {
+ if (!gotWidth) {
+ if (imageRatio.height != 0) {
+ imageSize.width =
+ NSCoordSaturatingNonnegativeMultiply(imageSize.height,
+ float(imageRatio.width) /
+ float(imageRatio.height));
+ gotWidth = true;
+ }
+ } else {
+ if (imageRatio.width != 0) {
+ imageSize.height =
+ NSCoordSaturatingNonnegativeMultiply(imageSize.width,
+ float(imageRatio.height) /
+ float(imageRatio.width));
+ gotHeight = true;
+ }
+ }
+ }
+
+ // If we still don't have a width or height, just use the fallback size the
+ // caller provided.
+ if (!gotWidth) {
+ imageSize.width = nsPresContext::AppUnitsToIntCSSPixels(aFallbackSize.width);
+ }
+ if (!gotHeight) {
+ imageSize.height = nsPresContext::AppUnitsToIntCSSPixels(aFallbackSize.height);
+ }
+
+ return imageSize;
+}
+
+/* static */ DrawResult
+nsLayoutUtils::DrawBackgroundImage(gfxContext& aContext,
+ nsPresContext* aPresContext,
+ imgIContainer* aImage,
+ const CSSIntSize& aImageSize,
+ SamplingFilter aSamplingFilter,
+ const nsRect& aDest,
+ const nsRect& aFill,
+ const nsSize& aRepeatSize,
+ const nsPoint& aAnchor,
+ const nsRect& aDirty,
+ uint32_t aImageFlags,
+ ExtendMode aExtendMode)
+{
+ PROFILER_LABEL("layout", "nsLayoutUtils::DrawBackgroundImage",
+ js::ProfileEntry::Category::GRAPHICS);
+
+ SVGImageContext svgContext(aImageSize, Nothing());
+
+ /* Fast path when there is no need for image spacing */
+ if (aRepeatSize.width == aDest.width && aRepeatSize.height == aDest.height) {
+ return DrawImageInternal(aContext, aPresContext, aImage,
+ aSamplingFilter, aDest, aFill, aAnchor,
+ aDirty, &svgContext, aImageFlags, aExtendMode);
+ }
+
+ nsPoint firstTilePos = aDest.TopLeft() +
+ nsPoint(NSToIntFloor(float(aFill.x - aDest.x) / aRepeatSize.width) * aRepeatSize.width,
+ NSToIntFloor(float(aFill.y - aDest.y) / aRepeatSize.height) * aRepeatSize.height);
+ for (int32_t i = firstTilePos.x; i < aFill.XMost(); i += aRepeatSize.width) {
+ for (int32_t j = firstTilePos.y; j < aFill.YMost(); j += aRepeatSize.height) {
+ nsRect dest(i, j, aDest.width, aDest.height);
+ DrawResult result = DrawImageInternal(aContext, aPresContext, aImage, aSamplingFilter,
+ dest, dest, aAnchor, aDirty, &svgContext,
+ aImageFlags, ExtendMode::CLAMP);
+ if (result != DrawResult::SUCCESS) {
+ return result;
+ }
+ }
+ }
+
+ return DrawResult::SUCCESS;
+}
+
+/* static */ DrawResult
+nsLayoutUtils::DrawImage(gfxContext& aContext,
+ nsPresContext* aPresContext,
+ imgIContainer* aImage,
+ const SamplingFilter aSamplingFilter,
+ const nsRect& aDest,
+ const nsRect& aFill,
+ const nsPoint& aAnchor,
+ const nsRect& aDirty,
+ uint32_t aImageFlags)
+{
+ return DrawImageInternal(aContext, aPresContext, aImage,
+ aSamplingFilter, aDest, aFill, aAnchor,
+ aDirty, nullptr, aImageFlags);
+}
+
+/* static */ nsRect
+nsLayoutUtils::GetWholeImageDestination(const nsSize& aWholeImageSize,
+ const nsRect& aImageSourceArea,
+ const nsRect& aDestArea)
+{
+ double scaleX = double(aDestArea.width)/aImageSourceArea.width;
+ double scaleY = double(aDestArea.height)/aImageSourceArea.height;
+ nscoord destOffsetX = NSToCoordRound(aImageSourceArea.x*scaleX);
+ nscoord destOffsetY = NSToCoordRound(aImageSourceArea.y*scaleY);
+ nscoord wholeSizeX = NSToCoordRound(aWholeImageSize.width*scaleX);
+ nscoord wholeSizeY = NSToCoordRound(aWholeImageSize.height*scaleY);
+ return nsRect(aDestArea.TopLeft() - nsPoint(destOffsetX, destOffsetY),
+ nsSize(wholeSizeX, wholeSizeY));
+}
+
+/* static */ already_AddRefed<imgIContainer>
+nsLayoutUtils::OrientImage(imgIContainer* aContainer,
+ const nsStyleImageOrientation& aOrientation)
+{
+ MOZ_ASSERT(aContainer, "Should have an image container");
+ nsCOMPtr<imgIContainer> img(aContainer);
+
+ if (aOrientation.IsFromImage()) {
+ img = ImageOps::Orient(img, img->GetOrientation());
+ } else if (!aOrientation.IsDefault()) {
+ Angle angle = aOrientation.Angle();
+ Flip flip = aOrientation.IsFlipped() ? Flip::Horizontal
+ : Flip::Unflipped;
+ img = ImageOps::Orient(img, Orientation(angle, flip));
+ }
+
+ return img.forget();
+}
+
+static bool NonZeroStyleCoord(const nsStyleCoord& aCoord)
+{
+ if (aCoord.IsCoordPercentCalcUnit()) {
+ // Since negative results are clamped to 0, check > 0.
+ return nsRuleNode::ComputeCoordPercentCalc(aCoord, nscoord_MAX) > 0 ||
+ nsRuleNode::ComputeCoordPercentCalc(aCoord, 0) > 0;
+ }
+
+ return true;
+}
+
+/* static */ bool
+nsLayoutUtils::HasNonZeroCorner(const nsStyleCorners& aCorners)
+{
+ NS_FOR_CSS_HALF_CORNERS(corner) {
+ if (NonZeroStyleCoord(aCorners.Get(corner)))
+ return true;
+ }
+ return false;
+}
+
+// aCorner is a "full corner" value, i.e. NS_CORNER_TOP_LEFT etc
+static bool IsCornerAdjacentToSide(uint8_t aCorner, css::Side aSide)
+{
+ static_assert((int)NS_SIDE_TOP == NS_CORNER_TOP_LEFT, "Check for Full Corner");
+ static_assert((int)NS_SIDE_RIGHT == NS_CORNER_TOP_RIGHT, "Check for Full Corner");
+ static_assert((int)NS_SIDE_BOTTOM == NS_CORNER_BOTTOM_RIGHT, "Check for Full Corner");
+ static_assert((int)NS_SIDE_LEFT == NS_CORNER_BOTTOM_LEFT, "Check for Full Corner");
+ static_assert((int)NS_SIDE_TOP == ((NS_CORNER_TOP_RIGHT - 1)&3), "Check for Full Corner");
+ static_assert((int)NS_SIDE_RIGHT == ((NS_CORNER_BOTTOM_RIGHT - 1)&3), "Check for Full Corner");
+ static_assert((int)NS_SIDE_BOTTOM == ((NS_CORNER_BOTTOM_LEFT - 1)&3), "Check for Full Corner");
+ static_assert((int)NS_SIDE_LEFT == ((NS_CORNER_TOP_LEFT - 1)&3), "Check for Full Corner");
+
+ return aSide == aCorner || aSide == ((aCorner - 1)&3);
+}
+
+/* static */ bool
+nsLayoutUtils::HasNonZeroCornerOnSide(const nsStyleCorners& aCorners,
+ css::Side aSide)
+{
+ static_assert(NS_CORNER_TOP_LEFT_X/2 == NS_CORNER_TOP_LEFT, "Check for Non Zero on side");
+ static_assert(NS_CORNER_TOP_LEFT_Y/2 == NS_CORNER_TOP_LEFT, "Check for Non Zero on side");
+ static_assert(NS_CORNER_TOP_RIGHT_X/2 == NS_CORNER_TOP_RIGHT, "Check for Non Zero on side");
+ static_assert(NS_CORNER_TOP_RIGHT_Y/2 == NS_CORNER_TOP_RIGHT, "Check for Non Zero on side");
+ static_assert(NS_CORNER_BOTTOM_RIGHT_X/2 == NS_CORNER_BOTTOM_RIGHT, "Check for Non Zero on side");
+ static_assert(NS_CORNER_BOTTOM_RIGHT_Y/2 == NS_CORNER_BOTTOM_RIGHT, "Check for Non Zero on side");
+ static_assert(NS_CORNER_BOTTOM_LEFT_X/2 == NS_CORNER_BOTTOM_LEFT, "Check for Non Zero on side");
+ static_assert(NS_CORNER_BOTTOM_LEFT_Y/2 == NS_CORNER_BOTTOM_LEFT, "Check for Non Zero on side");
+
+ NS_FOR_CSS_HALF_CORNERS(corner) {
+ // corner is a "half corner" value, so dividing by two gives us a
+ // "full corner" value.
+ if (NonZeroStyleCoord(aCorners.Get(corner)) &&
+ IsCornerAdjacentToSide(corner/2, aSide))
+ return true;
+ }
+ return false;
+}
+
+/* static */ nsTransparencyMode
+nsLayoutUtils::GetFrameTransparency(nsIFrame* aBackgroundFrame,
+ nsIFrame* aCSSRootFrame) {
+ if (aCSSRootFrame->StyleEffects()->mOpacity < 1.0f)
+ return eTransparencyTransparent;
+
+ if (HasNonZeroCorner(aCSSRootFrame->StyleBorder()->mBorderRadius))
+ return eTransparencyTransparent;
+
+ if (aCSSRootFrame->StyleDisplay()->mAppearance == NS_THEME_WIN_GLASS)
+ return eTransparencyGlass;
+
+ if (aCSSRootFrame->StyleDisplay()->mAppearance == NS_THEME_WIN_BORDERLESS_GLASS)
+ return eTransparencyBorderlessGlass;
+
+ nsITheme::Transparency transparency;
+ if (aCSSRootFrame->IsThemed(&transparency))
+ return transparency == nsITheme::eTransparent
+ ? eTransparencyTransparent
+ : eTransparencyOpaque;
+
+ // We need an uninitialized window to be treated as opaque because
+ // doing otherwise breaks window display effects on some platforms,
+ // specifically Vista. (bug 450322)
+ if (aBackgroundFrame->GetType() == nsGkAtoms::viewportFrame &&
+ !aBackgroundFrame->PrincipalChildList().FirstChild()) {
+ return eTransparencyOpaque;
+ }
+
+ nsStyleContext* bgSC;
+ if (!nsCSSRendering::FindBackground(aBackgroundFrame, &bgSC)) {
+ return eTransparencyTransparent;
+ }
+ const nsStyleBackground* bg = bgSC->StyleBackground();
+ if (NS_GET_A(bg->mBackgroundColor) < 255 ||
+ // bottom layer's clip is used for the color
+ bg->BottomLayer().mClip != NS_STYLE_IMAGELAYER_CLIP_BORDER)
+ return eTransparencyTransparent;
+ return eTransparencyOpaque;
+}
+
+static bool IsPopupFrame(nsIFrame* aFrame)
+{
+ // aFrame is a popup it's the list control frame dropdown for a combobox.
+ nsIAtom* frameType = aFrame->GetType();
+ if (frameType == nsGkAtoms::listControlFrame) {
+ nsListControlFrame* lcf = static_cast<nsListControlFrame*>(aFrame);
+ return lcf->IsInDropDownMode();
+ }
+
+ // ... or if it's a XUL menupopup frame.
+ return frameType == nsGkAtoms::menuPopupFrame;
+}
+
+/* static */ bool
+nsLayoutUtils::IsPopup(nsIFrame* aFrame)
+{
+ // Optimization: the frame can't possibly be a popup if it has no view.
+ if (!aFrame->HasView()) {
+ NS_ASSERTION(!IsPopupFrame(aFrame), "popup frame must have a view");
+ return false;
+ }
+ return IsPopupFrame(aFrame);
+}
+
+/* static */ nsIFrame*
+nsLayoutUtils::GetDisplayRootFrame(nsIFrame* aFrame)
+{
+ // We could use GetRootPresContext() here if the
+ // NS_FRAME_IN_POPUP frame bit is set.
+ nsIFrame* f = aFrame;
+ for (;;) {
+ if (!f->HasAnyStateBits(NS_FRAME_IN_POPUP)) {
+ f = f->PresContext()->FrameManager()->GetRootFrame();
+ } else if (IsPopup(f)) {
+ return f;
+ }
+ nsIFrame* parent = GetCrossDocParentFrame(f);
+ if (!parent)
+ return f;
+ f = parent;
+ }
+}
+
+/* static */ nsIFrame*
+nsLayoutUtils::GetReferenceFrame(nsIFrame* aFrame)
+{
+ nsIFrame *f = aFrame;
+ for (;;) {
+ if (f->IsTransformed() || f->IsPreserve3DLeaf() || IsPopup(f)) {
+ return f;
+ }
+ nsIFrame* parent = GetCrossDocParentFrame(f);
+ if (!parent) {
+ return f;
+ }
+ f = parent;
+ }
+}
+
+/* static */ uint32_t
+nsLayoutUtils::GetTextRunFlagsForStyle(nsStyleContext* aStyleContext,
+ const nsStyleFont* aStyleFont,
+ const nsStyleText* aStyleText,
+ nscoord aLetterSpacing)
+{
+ uint32_t result = 0;
+ if (aLetterSpacing != 0) {
+ result |= gfxTextRunFactory::TEXT_DISABLE_OPTIONAL_LIGATURES;
+ }
+ if (aStyleText->mControlCharacterVisibility == NS_STYLE_CONTROL_CHARACTER_VISIBILITY_HIDDEN) {
+ result |= gfxTextRunFactory::TEXT_HIDE_CONTROL_CHARACTERS;
+ }
+ switch (aStyleContext->StyleText()->mTextRendering) {
+ case NS_STYLE_TEXT_RENDERING_OPTIMIZESPEED:
+ result |= gfxTextRunFactory::TEXT_OPTIMIZE_SPEED;
+ break;
+ case NS_STYLE_TEXT_RENDERING_AUTO:
+ if (aStyleFont->mFont.size <
+ aStyleContext->PresContext()->GetAutoQualityMinFontSize()) {
+ result |= gfxTextRunFactory::TEXT_OPTIMIZE_SPEED;
+ }
+ break;
+ default:
+ break;
+ }
+ return result | GetTextRunOrientFlagsForStyle(aStyleContext);
+}
+
+/* static */ uint32_t
+nsLayoutUtils::GetTextRunOrientFlagsForStyle(nsStyleContext* aStyleContext)
+{
+ uint8_t writingMode = aStyleContext->StyleVisibility()->mWritingMode;
+ switch (writingMode) {
+ case NS_STYLE_WRITING_MODE_HORIZONTAL_TB:
+ return gfxTextRunFactory::TEXT_ORIENT_HORIZONTAL;
+
+ case NS_STYLE_WRITING_MODE_VERTICAL_LR:
+ case NS_STYLE_WRITING_MODE_VERTICAL_RL:
+ switch (aStyleContext->StyleVisibility()->mTextOrientation) {
+ case NS_STYLE_TEXT_ORIENTATION_MIXED:
+ return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_MIXED;
+ case NS_STYLE_TEXT_ORIENTATION_UPRIGHT:
+ return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_UPRIGHT;
+ case NS_STYLE_TEXT_ORIENTATION_SIDEWAYS:
+ return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
+ default:
+ NS_NOTREACHED("unknown text-orientation");
+ return 0;
+ }
+
+ case NS_STYLE_WRITING_MODE_SIDEWAYS_LR:
+ return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT;
+
+ case NS_STYLE_WRITING_MODE_SIDEWAYS_RL:
+ return gfxTextRunFactory::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
+
+ default:
+ NS_NOTREACHED("unknown writing-mode");
+ return 0;
+ }
+}
+
+/* static */ void
+nsLayoutUtils::GetRectDifferenceStrips(const nsRect& aR1, const nsRect& aR2,
+ nsRect* aHStrip, nsRect* aVStrip) {
+ NS_ASSERTION(aR1.TopLeft() == aR2.TopLeft(),
+ "expected rects at the same position");
+ nsRect unionRect(aR1.x, aR1.y, std::max(aR1.width, aR2.width),
+ std::max(aR1.height, aR2.height));
+ nscoord VStripStart = std::min(aR1.width, aR2.width);
+ nscoord HStripStart = std::min(aR1.height, aR2.height);
+ *aVStrip = unionRect;
+ aVStrip->x += VStripStart;
+ aVStrip->width -= VStripStart;
+ *aHStrip = unionRect;
+ aHStrip->y += HStripStart;
+ aHStrip->height -= HStripStart;
+}
+
+nsDeviceContext*
+nsLayoutUtils::GetDeviceContextForScreenInfo(nsPIDOMWindowOuter* aWindow)
+{
+ if (!aWindow) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsIDocShell> docShell = aWindow->GetDocShell();
+ while (docShell) {
+ // Now make sure our size is up to date. That will mean that the device
+ // context does the right thing on multi-monitor systems when we return it to
+ // the caller. It will also make sure that our prescontext has been created,
+ // if we're supposed to have one.
+ nsCOMPtr<nsPIDOMWindowOuter> win = docShell->GetWindow();
+ if (!win) {
+ // No reason to go on
+ return nullptr;
+ }
+
+ win->EnsureSizeUpToDate();
+
+ RefPtr<nsPresContext> presContext;
+ docShell->GetPresContext(getter_AddRefs(presContext));
+ if (presContext) {
+ nsDeviceContext* context = presContext->DeviceContext();
+ if (context) {
+ return context;
+ }
+ }
+
+ nsCOMPtr<nsIDocShellTreeItem> parentItem;
+ docShell->GetParent(getter_AddRefs(parentItem));
+ docShell = do_QueryInterface(parentItem);
+ }
+
+ return nullptr;
+}
+
+/* static */ bool
+nsLayoutUtils::IsReallyFixedPos(nsIFrame* aFrame)
+{
+ NS_PRECONDITION(aFrame->GetParent(),
+ "IsReallyFixedPos called on frame not in tree");
+ NS_PRECONDITION(aFrame->StyleDisplay()->mPosition ==
+ NS_STYLE_POSITION_FIXED,
+ "IsReallyFixedPos called on non-'position:fixed' frame");
+
+ nsIAtom *parentType = aFrame->GetParent()->GetType();
+ return parentType == nsGkAtoms::viewportFrame ||
+ parentType == nsGkAtoms::pageContentFrame;
+}
+
+nsLayoutUtils::SurfaceFromElementResult
+nsLayoutUtils::SurfaceFromOffscreenCanvas(OffscreenCanvas* aOffscreenCanvas,
+ uint32_t aSurfaceFlags,
+ RefPtr<DrawTarget>& aTarget)
+{
+ SurfaceFromElementResult result;
+
+ bool* isPremultiplied = nullptr;
+ if (aSurfaceFlags & SFE_PREFER_NO_PREMULTIPLY_ALPHA) {
+ isPremultiplied = &result.mIsPremultiplied;
+ }
+
+ nsIntSize size = aOffscreenCanvas->GetWidthHeight();
+
+ result.mSourceSurface = aOffscreenCanvas->GetSurfaceSnapshot(isPremultiplied);
+ if (!result.mSourceSurface) {
+ // If the element doesn't have a context then we won't get a snapshot. The canvas spec wants us to not error and just
+ // draw nothing, so return an empty surface.
+ DrawTarget *ref = aTarget ? aTarget.get() : gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
+ RefPtr<DrawTarget> dt = ref->CreateSimilarDrawTarget(IntSize(size.width, size.height),
+ SurfaceFormat::B8G8R8A8);
+ if (dt) {
+ result.mSourceSurface = dt->Snapshot();
+ }
+ } else if (aTarget) {
+ RefPtr<SourceSurface> opt = aTarget->OptimizeSourceSurface(result.mSourceSurface);
+ if (opt) {
+ result.mSourceSurface = opt;
+ }
+ }
+
+ result.mHasSize = true;
+ result.mSize = size;
+ result.mIsWriteOnly = aOffscreenCanvas->IsWriteOnly();
+
+ return result;
+}
+
+nsLayoutUtils::SurfaceFromElementResult
+nsLayoutUtils::SurfaceFromElement(nsIImageLoadingContent* aElement,
+ uint32_t aSurfaceFlags,
+ RefPtr<DrawTarget>& aTarget)
+{
+ SurfaceFromElementResult result;
+ nsresult rv;
+
+ nsCOMPtr<imgIRequest> imgRequest;
+ rv = aElement->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+ getter_AddRefs(imgRequest));
+ if (NS_FAILED(rv)) {
+ return result;
+ }
+
+ if (!imgRequest) {
+ // There's no image request. This is either because a request for
+ // a non-empty URI failed, or the URI is the empty string.
+ nsCOMPtr<nsIURI> currentURI;
+ aElement->GetCurrentURI(getter_AddRefs(currentURI));
+ if (!currentURI) {
+ // Treat the empty URI as available instead of broken state.
+ result.mHasSize = true;
+ }
+ return result;
+ }
+
+ uint32_t status;
+ imgRequest->GetImageStatus(&status);
+ result.mHasSize = status & imgIRequest::STATUS_SIZE_AVAILABLE;
+ if ((status & imgIRequest::STATUS_LOAD_COMPLETE) == 0) {
+ // Spec says to use GetComplete, but that only works on
+ // nsIDOMHTMLImageElement, and we support all sorts of other stuff
+ // here. Do this for now pending spec clarification.
+ result.mIsStillLoading = (status & imgIRequest::STATUS_ERROR) == 0;
+ return result;
+ }
+
+ nsCOMPtr<nsIPrincipal> principal;
+ rv = imgRequest->GetImagePrincipal(getter_AddRefs(principal));
+ if (NS_FAILED(rv)) {
+ return result;
+ }
+
+ nsCOMPtr<imgIContainer> imgContainer;
+ rv = imgRequest->GetImage(getter_AddRefs(imgContainer));
+ if (NS_FAILED(rv)) {
+ return result;
+ }
+
+ uint32_t noRasterize = aSurfaceFlags & SFE_NO_RASTERIZING_VECTORS;
+
+ uint32_t whichFrame = (aSurfaceFlags & SFE_WANT_FIRST_FRAME)
+ ? (uint32_t) imgIContainer::FRAME_FIRST
+ : (uint32_t) imgIContainer::FRAME_CURRENT;
+ uint32_t frameFlags = imgIContainer::FLAG_SYNC_DECODE;
+ if (aSurfaceFlags & SFE_NO_COLORSPACE_CONVERSION)
+ frameFlags |= imgIContainer::FLAG_DECODE_NO_COLORSPACE_CONVERSION;
+ if (aSurfaceFlags & SFE_PREFER_NO_PREMULTIPLY_ALPHA) {
+ frameFlags |= imgIContainer::FLAG_DECODE_NO_PREMULTIPLY_ALPHA;
+ result.mIsPremultiplied = false;
+ }
+
+ int32_t imgWidth, imgHeight;
+ nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
+ HTMLImageElement* element = HTMLImageElement::FromContentOrNull(content);
+ if (aSurfaceFlags & SFE_USE_ELEMENT_SIZE_IF_VECTOR &&
+ element &&
+ imgContainer->GetType() == imgIContainer::TYPE_VECTOR) {
+ imgWidth = element->Width();
+ imgHeight = element->Height();
+ } else {
+ rv = imgContainer->GetWidth(&imgWidth);
+ nsresult rv2 = imgContainer->GetHeight(&imgHeight);
+ if (NS_FAILED(rv) || NS_FAILED(rv2))
+ return result;
+ }
+ result.mSize = IntSize(imgWidth, imgHeight);
+
+ if (!noRasterize || imgContainer->GetType() == imgIContainer::TYPE_RASTER) {
+ if (aSurfaceFlags & SFE_WANT_IMAGE_SURFACE) {
+ frameFlags |= imgIContainer::FLAG_WANT_DATA_SURFACE;
+ }
+ result.mSourceSurface = imgContainer->GetFrameAtSize(result.mSize, whichFrame, frameFlags);
+ if (!result.mSourceSurface) {
+ return result;
+ }
+ // The surface we return is likely to be cached. We don't want to have to
+ // convert to a surface that's compatible with aTarget each time it's used
+ // (that would result in terrible performance), so we convert once here
+ // upfront if aTarget is specified.
+ if (aTarget) {
+ RefPtr<SourceSurface> optSurface =
+ aTarget->OptimizeSourceSurface(result.mSourceSurface);
+ if (optSurface) {
+ result.mSourceSurface = optSurface;
+ }
+ }
+ } else {
+ result.mDrawInfo.mImgContainer = imgContainer;
+ result.mDrawInfo.mWhichFrame = whichFrame;
+ result.mDrawInfo.mDrawingFlags = frameFlags;
+ }
+
+ int32_t corsmode;
+ if (NS_SUCCEEDED(imgRequest->GetCORSMode(&corsmode))) {
+ result.mCORSUsed = (corsmode != imgIRequest::CORS_NONE);
+ }
+
+ result.mPrincipal = principal.forget();
+ // no images, including SVG images, can load content from another domain.
+ result.mIsWriteOnly = false;
+ result.mImageRequest = imgRequest.forget();
+ return result;
+}
+
+nsLayoutUtils::SurfaceFromElementResult
+nsLayoutUtils::SurfaceFromElement(HTMLImageElement *aElement,
+ uint32_t aSurfaceFlags,
+ RefPtr<DrawTarget>& aTarget)
+{
+ return SurfaceFromElement(static_cast<nsIImageLoadingContent*>(aElement),
+ aSurfaceFlags, aTarget);
+}
+
+nsLayoutUtils::SurfaceFromElementResult
+nsLayoutUtils::SurfaceFromElement(HTMLCanvasElement* aElement,
+ uint32_t aSurfaceFlags,
+ RefPtr<DrawTarget>& aTarget)
+{
+ SurfaceFromElementResult result;
+
+ bool* isPremultiplied = nullptr;
+ if (aSurfaceFlags & SFE_PREFER_NO_PREMULTIPLY_ALPHA) {
+ isPremultiplied = &result.mIsPremultiplied;
+ }
+
+ IntSize size = aElement->GetSize();
+
+ result.mSourceSurface = aElement->GetSurfaceSnapshot(isPremultiplied);
+ if (!result.mSourceSurface) {
+ // If the element doesn't have a context then we won't get a snapshot. The canvas spec wants us to not error and just
+ // draw nothing, so return an empty surface.
+ DrawTarget *ref = aTarget ? aTarget.get() : gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
+ RefPtr<DrawTarget> dt = ref->CreateSimilarDrawTarget(IntSize(size.width, size.height),
+ SurfaceFormat::B8G8R8A8);
+ if (dt) {
+ result.mSourceSurface = dt->Snapshot();
+ }
+ } else if (aTarget) {
+ RefPtr<SourceSurface> opt = aTarget->OptimizeSourceSurface(result.mSourceSurface);
+ if (opt) {
+ result.mSourceSurface = opt;
+ }
+ }
+
+ // Ensure that any future changes to the canvas trigger proper invalidation,
+ // in case this is being used by -moz-element()
+ aElement->MarkContextClean();
+
+ result.mHasSize = true;
+ result.mSize = size;
+ result.mPrincipal = aElement->NodePrincipal();
+ result.mIsWriteOnly = aElement->IsWriteOnly();
+
+ return result;
+}
+
+nsLayoutUtils::SurfaceFromElementResult
+nsLayoutUtils::SurfaceFromElement(HTMLVideoElement* aElement,
+ uint32_t aSurfaceFlags,
+ RefPtr<DrawTarget>& aTarget)
+{
+ SurfaceFromElementResult result;
+
+ NS_WARNING_ASSERTION(
+ (aSurfaceFlags & SFE_PREFER_NO_PREMULTIPLY_ALPHA) == 0,
+ "We can't support non-premultiplied alpha for video!");
+
+ if (aElement->ContainsRestrictedContent()) {
+ return result;
+ }
+
+ uint16_t readyState;
+ if (NS_SUCCEEDED(aElement->GetReadyState(&readyState)) &&
+ (readyState == nsIDOMHTMLMediaElement::HAVE_NOTHING ||
+ readyState == nsIDOMHTMLMediaElement::HAVE_METADATA)) {
+ result.mIsStillLoading = true;
+ return result;
+ }
+
+ // If it doesn't have a principal, just bail
+ nsCOMPtr<nsIPrincipal> principal = aElement->GetCurrentVideoPrincipal();
+ if (!principal)
+ return result;
+
+ ImageContainer* container = aElement->GetImageContainer();
+ if (!container)
+ return result;
+
+ AutoLockImage lockImage(container);
+
+ result.mLayersImage = lockImage.GetImage();
+ if (!result.mLayersImage)
+ return result;
+
+ if (aTarget) {
+ // They gave us a DrawTarget to optimize for, so even though we have a layers::Image,
+ // we should unconditionally grab a SourceSurface and try to optimize it.
+ result.mSourceSurface = result.mLayersImage->GetAsSourceSurface();
+ if (!result.mSourceSurface)
+ return result;
+
+ RefPtr<SourceSurface> opt = aTarget->OptimizeSourceSurface(result.mSourceSurface);
+ if (opt) {
+ result.mSourceSurface = opt;
+ }
+ }
+
+ result.mCORSUsed = aElement->GetCORSMode() != CORS_NONE;
+ result.mHasSize = true;
+ result.mSize = result.mLayersImage->GetSize();
+ result.mPrincipal = principal.forget();
+ result.mIsWriteOnly = false;
+
+ return result;
+}
+
+nsLayoutUtils::SurfaceFromElementResult
+nsLayoutUtils::SurfaceFromElement(dom::Element* aElement,
+ uint32_t aSurfaceFlags,
+ RefPtr<DrawTarget>& aTarget)
+{
+ // If it's a <canvas>, we may be able to just grab its internal surface
+ if (HTMLCanvasElement* canvas =
+ HTMLCanvasElement::FromContentOrNull(aElement)) {
+ return SurfaceFromElement(canvas, aSurfaceFlags, aTarget);
+ }
+
+ // Maybe it's <video>?
+ if (HTMLVideoElement* video =
+ HTMLVideoElement::FromContentOrNull(aElement)) {
+ return SurfaceFromElement(video, aSurfaceFlags, aTarget);
+ }
+
+ // Finally, check if it's a normal image
+ nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(aElement);
+
+ if (!imageLoader) {
+ return SurfaceFromElementResult();
+ }
+
+ return SurfaceFromElement(imageLoader, aSurfaceFlags, aTarget);
+}
+
+/* static */
+nsIContent*
+nsLayoutUtils::GetEditableRootContentByContentEditable(nsIDocument* aDocument)
+{
+ // If the document is in designMode we should return nullptr.
+ if (!aDocument || aDocument->HasFlag(NODE_IS_EDITABLE)) {
+ return nullptr;
+ }
+
+ // contenteditable only works with HTML document.
+ // Note: Use nsIDOMHTMLDocument rather than nsIHTMLDocument for getting the
+ // body node because nsIDOMHTMLDocument::GetBody() does something
+ // additional work for some cases and EditorBase uses them.
+ nsCOMPtr<nsIDOMHTMLDocument> domHTMLDoc = do_QueryInterface(aDocument);
+ if (!domHTMLDoc) {
+ return nullptr;
+ }
+
+ Element* rootElement = aDocument->GetRootElement();
+ if (rootElement && rootElement->IsEditable()) {
+ return rootElement;
+ }
+
+ // If there are no editable root element, check its <body> element.
+ // Note that the body element could be <frameset> element.
+ nsCOMPtr<nsIDOMHTMLElement> body;
+ nsresult rv = domHTMLDoc->GetBody(getter_AddRefs(body));
+ nsCOMPtr<nsIContent> content = do_QueryInterface(body);
+ if (NS_SUCCEEDED(rv) && content && content->IsEditable()) {
+ return content;
+ }
+ return nullptr;
+}
+
+#ifdef DEBUG
+/* static */ void
+nsLayoutUtils::AssertNoDuplicateContinuations(nsIFrame* aContainer,
+ const nsFrameList& aFrameList)
+{
+ for (nsIFrame* f : aFrameList) {
+ // Check only later continuations of f; we deal with checking the
+ // earlier continuations when we hit those earlier continuations in
+ // the frame list.
+ for (nsIFrame *c = f; (c = c->GetNextInFlow());) {
+ NS_ASSERTION(c->GetParent() != aContainer ||
+ !aFrameList.ContainsFrame(c),
+ "Two continuations of the same frame in the same "
+ "frame list");
+ }
+ }
+}
+
+// Is one of aFrame's ancestors a letter frame?
+static bool
+IsInLetterFrame(nsIFrame *aFrame)
+{
+ for (nsIFrame *f = aFrame->GetParent(); f; f = f->GetParent()) {
+ if (f->GetType() == nsGkAtoms::letterFrame) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* static */ void
+nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(nsIFrame *aSubtreeRoot)
+{
+ NS_ASSERTION(aSubtreeRoot->GetPrevInFlow(),
+ "frame tree not empty, but caller reported complete status");
+
+ // Also assert that text frames map no text.
+ int32_t start, end;
+ nsresult rv = aSubtreeRoot->GetOffsets(start, end);
+ NS_ASSERTION(NS_SUCCEEDED(rv), "GetOffsets failed");
+ // In some cases involving :first-letter, we'll partially unlink a
+ // continuation in the middle of a continuation chain from its
+ // previous and next continuations before destroying it, presumably so
+ // that we don't also destroy the later continuations. Once we've
+ // done this, GetOffsets returns incorrect values.
+ // For examples, see list of tests in
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=619021#c29
+ NS_ASSERTION(start == end || IsInLetterFrame(aSubtreeRoot),
+ "frame tree not empty, but caller reported complete status");
+
+ nsIFrame::ChildListIterator lists(aSubtreeRoot);
+ for (; !lists.IsDone(); lists.Next()) {
+ nsFrameList::Enumerator childFrames(lists.CurrentList());
+ for (; !childFrames.AtEnd(); childFrames.Next()) {
+ nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(childFrames.get());
+ }
+ }
+}
+#endif
+
+static void
+GetFontFacesForFramesInner(nsIFrame* aFrame, nsFontFaceList* aFontFaceList)
+{
+ NS_PRECONDITION(aFrame, "NULL frame pointer");
+
+ if (aFrame->GetType() == nsGkAtoms::textFrame) {
+ if (!aFrame->GetPrevContinuation()) {
+ nsLayoutUtils::GetFontFacesForText(aFrame, 0, INT32_MAX, true,
+ aFontFaceList);
+ }
+ return;
+ }
+
+ nsIFrame::ChildListID childLists[] = { nsIFrame::kPrincipalList,
+ nsIFrame::kPopupList };
+ for (size_t i = 0; i < ArrayLength(childLists); ++i) {
+ nsFrameList children(aFrame->GetChildList(childLists[i]));
+ for (nsFrameList::Enumerator e(children); !e.AtEnd(); e.Next()) {
+ nsIFrame* child = e.get();
+ child = nsPlaceholderFrame::GetRealFrameFor(child);
+ GetFontFacesForFramesInner(child, aFontFaceList);
+ }
+ }
+}
+
+/* static */
+nsresult
+nsLayoutUtils::GetFontFacesForFrames(nsIFrame* aFrame,
+ nsFontFaceList* aFontFaceList)
+{
+ NS_PRECONDITION(aFrame, "NULL frame pointer");
+
+ while (aFrame) {
+ GetFontFacesForFramesInner(aFrame, aFontFaceList);
+ aFrame = GetNextContinuationOrIBSplitSibling(aFrame);
+ }
+
+ return NS_OK;
+}
+
+/* static */
+nsresult
+nsLayoutUtils::GetFontFacesForText(nsIFrame* aFrame,
+ int32_t aStartOffset, int32_t aEndOffset,
+ bool aFollowContinuations,
+ nsFontFaceList* aFontFaceList)
+{
+ NS_PRECONDITION(aFrame, "NULL frame pointer");
+
+ if (aFrame->GetType() != nsGkAtoms::textFrame) {
+ return NS_OK;
+ }
+
+ nsTextFrame* curr = static_cast<nsTextFrame*>(aFrame);
+ do {
+ int32_t fstart = std::max(curr->GetContentOffset(), aStartOffset);
+ int32_t fend = std::min(curr->GetContentEnd(), aEndOffset);
+ if (fstart >= fend) {
+ curr = static_cast<nsTextFrame*>(curr->GetNextContinuation());
+ continue;
+ }
+
+ // curr is overlapping with the offset we want
+ gfxSkipCharsIterator iter = curr->EnsureTextRun(nsTextFrame::eInflated);
+ gfxTextRun* textRun = curr->GetTextRun(nsTextFrame::eInflated);
+ NS_ENSURE_TRUE(textRun, NS_ERROR_OUT_OF_MEMORY);
+
+ // include continuations in the range that share the same textrun
+ nsTextFrame* next = nullptr;
+ if (aFollowContinuations && fend < aEndOffset) {
+ next = static_cast<nsTextFrame*>(curr->GetNextContinuation());
+ while (next && next->GetTextRun(nsTextFrame::eInflated) == textRun) {
+ fend = std::min(next->GetContentEnd(), aEndOffset);
+ next = fend < aEndOffset ?
+ static_cast<nsTextFrame*>(next->GetNextContinuation()) : nullptr;
+ }
+ }
+
+ uint32_t skipStart = iter.ConvertOriginalToSkipped(fstart);
+ uint32_t skipEnd = iter.ConvertOriginalToSkipped(fend);
+ aFontFaceList->AddFontsFromTextRun(textRun, skipStart, skipEnd - skipStart);
+ curr = next;
+ } while (aFollowContinuations && curr);
+
+ return NS_OK;
+}
+
+/* static */
+size_t
+nsLayoutUtils::SizeOfTextRunsForFrames(nsIFrame* aFrame,
+ MallocSizeOf aMallocSizeOf,
+ bool clear)
+{
+ NS_PRECONDITION(aFrame, "NULL frame pointer");
+
+ size_t total = 0;
+
+ if (aFrame->GetType() == nsGkAtoms::textFrame) {
+ nsTextFrame* textFrame = static_cast<nsTextFrame*>(aFrame);
+ for (uint32_t i = 0; i < 2; ++i) {
+ gfxTextRun *run = textFrame->GetTextRun(
+ (i != 0) ? nsTextFrame::eInflated : nsTextFrame::eNotInflated);
+ if (run) {
+ if (clear) {
+ run->ResetSizeOfAccountingFlags();
+ } else {
+ total += run->MaybeSizeOfIncludingThis(aMallocSizeOf);
+ }
+ }
+ }
+ return total;
+ }
+
+ AutoTArray<nsIFrame::ChildList,4> childListArray;
+ aFrame->GetChildLists(&childListArray);
+
+ for (nsIFrame::ChildListArrayIterator childLists(childListArray);
+ !childLists.IsDone(); childLists.Next()) {
+ for (nsFrameList::Enumerator e(childLists.CurrentList());
+ !e.AtEnd(); e.Next()) {
+ total += SizeOfTextRunsForFrames(e.get(), aMallocSizeOf, clear);
+ }
+ }
+ return total;
+}
+
+struct PrefCallbacks
+{
+ const char* name;
+ PrefChangedFunc func;
+};
+static const PrefCallbacks kPrefCallbacks[] = {
+ { GRID_ENABLED_PREF_NAME,
+ GridEnabledPrefChangeCallback },
+ { WEBKIT_PREFIXES_ENABLED_PREF_NAME,
+ WebkitPrefixEnabledPrefChangeCallback },
+ { TEXT_ALIGN_UNSAFE_ENABLED_PREF_NAME,
+ TextAlignUnsafeEnabledPrefChangeCallback },
+ { DISPLAY_CONTENTS_ENABLED_PREF_NAME,
+ DisplayContentsEnabledPrefChangeCallback },
+ { FLOAT_LOGICAL_VALUES_ENABLED_PREF_NAME,
+ FloatLogicalValuesEnabledPrefChangeCallback },
+ { BG_CLIP_TEXT_ENABLED_PREF_NAME,
+ BackgroundClipTextEnabledPrefChangeCallback },
+};
+
+/* static */
+void
+nsLayoutUtils::Initialize()
+{
+ Preferences::AddUintVarCache(&sFontSizeInflationMaxRatio,
+ "font.size.inflation.maxRatio");
+ Preferences::AddUintVarCache(&sFontSizeInflationEmPerLine,
+ "font.size.inflation.emPerLine");
+ Preferences::AddUintVarCache(&sFontSizeInflationMinTwips,
+ "font.size.inflation.minTwips");
+ Preferences::AddUintVarCache(&sFontSizeInflationLineThreshold,
+ "font.size.inflation.lineThreshold");
+ Preferences::AddIntVarCache(&sFontSizeInflationMappingIntercept,
+ "font.size.inflation.mappingIntercept");
+ Preferences::AddBoolVarCache(&sFontSizeInflationForceEnabled,
+ "font.size.inflation.forceEnabled");
+ Preferences::AddBoolVarCache(&sFontSizeInflationDisabledInMasterProcess,
+ "font.size.inflation.disabledInMasterProcess");
+ Preferences::AddBoolVarCache(&sInvalidationDebuggingIsEnabled,
+ "nglayout.debug.invalidation");
+ Preferences::AddBoolVarCache(&sCSSVariablesEnabled,
+ "layout.css.variables.enabled");
+ Preferences::AddBoolVarCache(&sInterruptibleReflowEnabled,
+ "layout.interruptible-reflow.enabled");
+ Preferences::AddBoolVarCache(&sSVGTransformBoxEnabled,
+ "svg.transform-box.enabled");
+ Preferences::AddBoolVarCache(&sTextCombineUprightDigitsEnabled,
+ "layout.css.text-combine-upright-digits.enabled");
+#ifdef MOZ_STYLO
+ Preferences::AddBoolVarCache(&sStyloEnabled,
+ "layout.css.servo.enabled");
+#endif
+ Preferences::AddUintVarCache(&sIdlePeriodDeadlineLimit,
+ "layout.idle_period.time_limit",
+ DEFAULT_IDLE_PERIOD_TIME_LIMIT);
+ Preferences::AddUintVarCache(&sQuiescentFramesBeforeIdlePeriod,
+ "layout.idle_period.required_quiescent_frames",
+ DEFAULT_QUIESCENT_FRAMES);
+
+ for (auto& callback : kPrefCallbacks) {
+ Preferences::RegisterCallbackAndCall(callback.func, callback.name);
+ }
+ nsComputedDOMStyle::RegisterPrefChangeCallbacks();
+}
+
+/* static */
+void
+nsLayoutUtils::Shutdown()
+{
+ if (sContentMap) {
+ delete sContentMap;
+ sContentMap = nullptr;
+ }
+
+ for (auto& callback : kPrefCallbacks) {
+ Preferences::UnregisterCallback(callback.func, callback.name);
+ }
+ nsComputedDOMStyle::UnregisterPrefChangeCallbacks();
+
+ // so the cached initial quotes array doesn't appear to be a leak
+ nsStyleList::Shutdown();
+}
+
+/* static */
+void
+nsLayoutUtils::RegisterImageRequest(nsPresContext* aPresContext,
+ imgIRequest* aRequest,
+ bool* aRequestRegistered)
+{
+ if (!aPresContext) {
+ return;
+ }
+
+ if (aRequestRegistered && *aRequestRegistered) {
+ // Our request is already registered with the refresh driver, so
+ // no need to register it again.
+ return;
+ }
+
+ if (aRequest) {
+ if (!aPresContext->RefreshDriver()->AddImageRequest(aRequest)) {
+ NS_WARNING("Unable to add image request");
+ return;
+ }
+
+ if (aRequestRegistered) {
+ *aRequestRegistered = true;
+ }
+ }
+}
+
+/* static */
+void
+nsLayoutUtils::RegisterImageRequestIfAnimated(nsPresContext* aPresContext,
+ imgIRequest* aRequest,
+ bool* aRequestRegistered)
+{
+ if (!aPresContext) {
+ return;
+ }
+
+ if (aRequestRegistered && *aRequestRegistered) {
+ // Our request is already registered with the refresh driver, so
+ // no need to register it again.
+ return;
+ }
+
+ if (aRequest) {
+ nsCOMPtr<imgIContainer> image;
+ if (NS_SUCCEEDED(aRequest->GetImage(getter_AddRefs(image)))) {
+ // Check to verify that the image is animated. If so, then add it to the
+ // list of images tracked by the refresh driver.
+ bool isAnimated = false;
+ nsresult rv = image->GetAnimated(&isAnimated);
+ if (NS_SUCCEEDED(rv) && isAnimated) {
+ if (!aPresContext->RefreshDriver()->AddImageRequest(aRequest)) {
+ NS_WARNING("Unable to add image request");
+ return;
+ }
+
+ if (aRequestRegistered) {
+ *aRequestRegistered = true;
+ }
+ }
+ }
+ }
+}
+
+/* static */
+void
+nsLayoutUtils::DeregisterImageRequest(nsPresContext* aPresContext,
+ imgIRequest* aRequest,
+ bool* aRequestRegistered)
+{
+ if (!aPresContext) {
+ return;
+ }
+
+ // Deregister our imgIRequest with the refresh driver to
+ // complete tear-down, but only if it has been registered
+ if (aRequestRegistered && !*aRequestRegistered) {
+ return;
+ }
+
+ if (aRequest) {
+ nsCOMPtr<imgIContainer> image;
+ if (NS_SUCCEEDED(aRequest->GetImage(getter_AddRefs(image)))) {
+ aPresContext->RefreshDriver()->RemoveImageRequest(aRequest);
+
+ if (aRequestRegistered) {
+ *aRequestRegistered = false;
+ }
+ }
+ }
+}
+
+/* static */
+void
+nsLayoutUtils::PostRestyleEvent(Element* aElement,
+ nsRestyleHint aRestyleHint,
+ nsChangeHint aMinChangeHint)
+{
+ nsIDocument* doc = aElement->GetComposedDoc();
+ if (doc) {
+ nsCOMPtr<nsIPresShell> presShell = doc->GetShell();
+ if (presShell) {
+ presShell->GetPresContext()->RestyleManager()->PostRestyleEvent(
+ aElement, aRestyleHint, aMinChangeHint);
+ }
+ }
+}
+
+nsSetAttrRunnable::nsSetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName,
+ const nsAString& aValue)
+ : mContent(aContent),
+ mAttrName(aAttrName),
+ mValue(aValue)
+{
+ NS_ASSERTION(aContent && aAttrName, "Missing stuff, prepare to crash");
+}
+
+nsSetAttrRunnable::nsSetAttrRunnable(nsIContent* aContent, nsIAtom* aAttrName,
+ int32_t aValue)
+ : mContent(aContent),
+ mAttrName(aAttrName)
+{
+ NS_ASSERTION(aContent && aAttrName, "Missing stuff, prepare to crash");
+ mValue.AppendInt(aValue);
+}
+
+NS_IMETHODIMP
+nsSetAttrRunnable::Run()
+{
+ return mContent->SetAttr(kNameSpaceID_None, mAttrName, mValue, true);
+}
+
+nsUnsetAttrRunnable::nsUnsetAttrRunnable(nsIContent* aContent,
+ nsIAtom* aAttrName)
+ : mContent(aContent),
+ mAttrName(aAttrName)
+{
+ NS_ASSERTION(aContent && aAttrName, "Missing stuff, prepare to crash");
+}
+
+NS_IMETHODIMP
+nsUnsetAttrRunnable::Run()
+{
+ return mContent->UnsetAttr(kNameSpaceID_None, mAttrName, true);
+}
+
+/**
+ * Compute the minimum font size inside of a container with the given
+ * width, such that **when the user zooms the container to fill the full
+ * width of the device**, the fonts satisfy our minima.
+ */
+static nscoord
+MinimumFontSizeFor(nsPresContext* aPresContext, WritingMode aWritingMode,
+ nscoord aContainerISize)
+{
+ nsIPresShell* presShell = aPresContext->PresShell();
+
+ uint32_t emPerLine = presShell->FontSizeInflationEmPerLine();
+ uint32_t minTwips = presShell->FontSizeInflationMinTwips();
+ if (emPerLine == 0 && minTwips == 0) {
+ return 0;
+ }
+
+ // Clamp the container width to the device dimensions
+ nscoord iFrameISize = aWritingMode.IsVertical()
+ ? aPresContext->GetVisibleArea().height
+ : aPresContext->GetVisibleArea().width;
+ nscoord effectiveContainerISize = std::min(iFrameISize, aContainerISize);
+
+ nscoord byLine = 0, byInch = 0;
+ if (emPerLine != 0) {
+ byLine = effectiveContainerISize / emPerLine;
+ }
+ if (minTwips != 0) {
+ // REVIEW: Is this giving us app units and sizes *not* counting
+ // viewport scaling?
+ gfxSize screenSize = aPresContext->ScreenSizeInchesForFontInflation();
+ float deviceISizeInches = aWritingMode.IsVertical()
+ ? screenSize.height : screenSize.width;
+ byInch = NSToCoordRound(effectiveContainerISize /
+ (deviceISizeInches * 1440 /
+ minTwips ));
+ }
+ return std::max(byLine, byInch);
+}
+
+/* static */ float
+nsLayoutUtils::FontSizeInflationInner(const nsIFrame *aFrame,
+ nscoord aMinFontSize)
+{
+ // Note that line heights should be inflated by the same ratio as the
+ // font size of the same text; thus we operate only on the font size
+ // even when we're scaling a line height.
+ nscoord styleFontSize = aFrame->StyleFont()->mFont.size;
+ if (styleFontSize <= 0) {
+ // Never scale zero font size.
+ return 1.0;
+ }
+
+ if (aMinFontSize <= 0) {
+ // No need to scale.
+ return 1.0;
+ }
+
+ // If between this current frame and its font inflation container there is a
+ // non-inline element with fixed width or height, then we should not inflate
+ // fonts for this frame.
+ for (const nsIFrame* f = aFrame;
+ f && !f->IsContainerForFontSizeInflation();
+ f = f->GetParent()) {
+ nsIContent* content = f->GetContent();
+ nsIAtom* fType = f->GetType();
+ nsIFrame* parent = f->GetParent();
+ // Also, if there is more than one frame corresponding to a single
+ // content node, we want the outermost one.
+ if (!(parent && parent->GetContent() == content) &&
+ // ignore width/height on inlines since they don't apply
+ fType != nsGkAtoms::inlineFrame &&
+ // ignore width on radios and checkboxes since we enlarge them and
+ // they have width/height in ua.css
+ fType != nsGkAtoms::formControlFrame) {
+ // ruby annotations should have the same inflation as its
+ // grandparent, which is the ruby frame contains the annotation.
+ if (fType == nsGkAtoms::rubyTextFrame) {
+ MOZ_ASSERT(parent &&
+ parent->GetType() == nsGkAtoms::rubyTextContainerFrame);
+ nsIFrame* grandparent = parent->GetParent();
+ MOZ_ASSERT(grandparent &&
+ grandparent->GetType() == nsGkAtoms::rubyFrame);
+ return FontSizeInflationFor(grandparent);
+ }
+ nsStyleCoord stylePosWidth = f->StylePosition()->mWidth;
+ nsStyleCoord stylePosHeight = f->StylePosition()->mHeight;
+ if (stylePosWidth.GetUnit() != eStyleUnit_Auto ||
+ stylePosHeight.GetUnit() != eStyleUnit_Auto) {
+
+ return 1.0;
+ }
+ }
+ }
+
+ int32_t interceptParam = nsLayoutUtils::FontSizeInflationMappingIntercept();
+ float maxRatio = (float)nsLayoutUtils::FontSizeInflationMaxRatio() / 100.0f;
+
+ float ratio = float(styleFontSize) / float(aMinFontSize);
+ float inflationRatio;
+
+ // Given a minimum inflated font size m, a specified font size s, we want to
+ // find the inflated font size i and then return the ratio of i to s (i/s).
+ if (interceptParam >= 0) {
+ // Since the mapping intercept parameter P is greater than zero, we use it
+ // to determine the point where our mapping function intersects the i=s
+ // line. This means that we have an equation of the form:
+ //
+ // i = m + s·(P/2)/(1 + P/2), if s <= (1 + P/2)·m
+ // i = s, if s >= (1 + P/2)·m
+
+ float intercept = 1 + float(interceptParam)/2.0f;
+ if (ratio >= intercept) {
+ // If we're already at 1+P/2 or more times the minimum, don't scale.
+ return 1.0;
+ }
+
+ // The point (intercept, intercept) is where the part of the i vs. s graph
+ // that's not slope 1 meets the i=s line. (This part of the
+ // graph is a line from (0, m), to that point). We calculate the
+ // intersection point to be ((1+P/2)m, (1+P/2)m), where P is the
+ // intercept parameter above. We then need to return i/s.
+ inflationRatio = (1.0f + (ratio * (intercept - 1) / intercept)) / ratio;
+ } else {
+ // This is the case where P is negative. We essentially want to implement
+ // the case for P=infinity here, so we make i = s + m, which means that
+ // i/s = s/s + m/s = 1 + 1/ratio
+ inflationRatio = 1 + 1.0f / ratio;
+ }
+
+ if (maxRatio > 1.0 && inflationRatio > maxRatio) {
+ return maxRatio;
+ } else {
+ return inflationRatio;
+ }
+}
+
+static bool
+ShouldInflateFontsForContainer(const nsIFrame *aFrame)
+{
+ // We only want to inflate fonts for text that is in a place
+ // with room to expand. The question is what the best heuristic for
+ // that is...
+ // For now, we're going to use NS_FRAME_IN_CONSTRAINED_BSIZE, which
+ // indicates whether the frame is inside something with a constrained
+ // block-size (propagating down the tree), but the propagation stops when
+ // we hit overflow-y [or -x, for vertical mode]: scroll or auto.
+ const nsStyleText* styleText = aFrame->StyleText();
+
+ return styleText->mTextSizeAdjust != NS_STYLE_TEXT_SIZE_ADJUST_NONE &&
+ !(aFrame->GetStateBits() & NS_FRAME_IN_CONSTRAINED_BSIZE) &&
+ // We also want to disable font inflation for containers that have
+ // preformatted text.
+ // MathML cells need special treatment. See bug 1002526 comment 56.
+ (styleText->WhiteSpaceCanWrap(aFrame) ||
+ aFrame->IsFrameOfType(nsIFrame::eMathML));
+}
+
+nscoord
+nsLayoutUtils::InflationMinFontSizeFor(const nsIFrame *aFrame)
+{
+ nsPresContext *presContext = aFrame->PresContext();
+ if (!FontSizeInflationEnabled(presContext) ||
+ presContext->mInflationDisabledForShrinkWrap) {
+ return 0;
+ }
+
+ for (const nsIFrame *f = aFrame; f; f = f->GetParent()) {
+ if (f->IsContainerForFontSizeInflation()) {
+ if (!ShouldInflateFontsForContainer(f)) {
+ return 0;
+ }
+
+ nsFontInflationData *data =
+ nsFontInflationData::FindFontInflationDataFor(aFrame);
+ // FIXME: The need to null-check here is sort of a bug, and might
+ // lead to incorrect results.
+ if (!data || !data->InflationEnabled()) {
+ return 0;
+ }
+
+ return MinimumFontSizeFor(aFrame->PresContext(),
+ aFrame->GetWritingMode(),
+ data->EffectiveISize());
+ }
+ }
+
+ MOZ_ASSERT(false, "root should always be container");
+
+ return 0;
+}
+
+float
+nsLayoutUtils::FontSizeInflationFor(const nsIFrame *aFrame)
+{
+ if (aFrame->IsSVGText()) {
+ const nsIFrame* container = aFrame;
+ while (container->GetType() != nsGkAtoms::svgTextFrame) {
+ container = container->GetParent();
+ }
+ NS_ASSERTION(container, "expected to find an ancestor SVGTextFrame");
+ return
+ static_cast<const SVGTextFrame*>(container)->GetFontSizeScaleFactor();
+ }
+
+ if (!FontSizeInflationEnabled(aFrame->PresContext())) {
+ return 1.0f;
+ }
+
+ return FontSizeInflationInner(aFrame, InflationMinFontSizeFor(aFrame));
+}
+
+/* static */ bool
+nsLayoutUtils::FontSizeInflationEnabled(nsPresContext *aPresContext)
+{
+ nsIPresShell* presShell = aPresContext->GetPresShell();
+
+ if (!presShell) {
+ return false;
+ }
+
+ return presShell->FontSizeInflationEnabled();
+}
+
+/* static */ nsRect
+nsLayoutUtils::GetBoxShadowRectForFrame(nsIFrame* aFrame,
+ const nsSize& aFrameSize)
+{
+ nsCSSShadowArray* boxShadows = aFrame->StyleEffects()->mBoxShadow;
+ if (!boxShadows) {
+ return nsRect();
+ }
+
+ bool nativeTheme;
+ const nsStyleDisplay* styleDisplay = aFrame->StyleDisplay();
+ nsITheme::Transparency transparency;
+ if (aFrame->IsThemed(styleDisplay, &transparency)) {
+ // For opaque (rectangular) theme widgets we can take the generic
+ // border-box path with border-radius disabled.
+ nativeTheme = transparency != nsITheme::eOpaque;
+ } else {
+ nativeTheme = false;
+ }
+
+ nsRect frameRect = nativeTheme ?
+ aFrame->GetVisualOverflowRectRelativeToSelf() :
+ nsRect(nsPoint(0, 0), aFrameSize);
+
+ nsRect shadows;
+ int32_t A2D = aFrame->PresContext()->AppUnitsPerDevPixel();
+ for (uint32_t i = 0; i < boxShadows->Length(); ++i) {
+ nsRect tmpRect = frameRect;
+ nsCSSShadowItem* shadow = boxShadows->ShadowAt(i);
+
+ // inset shadows are never painted outside the frame
+ if (shadow->mInset)
+ continue;
+
+ tmpRect.MoveBy(nsPoint(shadow->mXOffset, shadow->mYOffset));
+ tmpRect.Inflate(shadow->mSpread);
+ tmpRect.Inflate(
+ nsContextBoxBlur::GetBlurRadiusMargin(shadow->mRadius, A2D));
+ shadows.UnionRect(shadows, tmpRect);
+ }
+ return shadows;
+}
+
+/* static */ bool
+nsLayoutUtils::GetContentViewerSize(nsPresContext* aPresContext,
+ LayoutDeviceIntSize& aOutSize)
+{
+ nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell();
+ if (!docShell) {
+ return false;
+ }
+
+ nsCOMPtr<nsIContentViewer> cv;
+ docShell->GetContentViewer(getter_AddRefs(cv));
+ if (!cv) {
+ return false;
+ }
+
+ nsIntRect bounds;
+ cv->GetBounds(bounds);
+ aOutSize = LayoutDeviceIntRect::FromUnknownRect(bounds).Size();
+ return true;
+}
+
+static bool
+UpdateCompositionBoundsForRCDRSF(ParentLayerRect& aCompBounds,
+ nsPresContext* aPresContext,
+ bool aScaleContentViewerSize)
+{
+ nsIFrame* rootFrame = aPresContext->PresShell()->GetRootFrame();
+ if (!rootFrame) {
+ return false;
+ }
+
+#if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_UIKIT)
+ nsIWidget* widget = rootFrame->GetNearestWidget();
+#else
+ nsView* view = rootFrame->GetView();
+ nsIWidget* widget = view ? view->GetWidget() : nullptr;
+#endif
+
+ if (widget) {
+ LayoutDeviceIntRect widgetBounds = widget->GetBounds();
+ widgetBounds.MoveTo(0, 0);
+ aCompBounds = ParentLayerRect(
+ ViewAs<ParentLayerPixel>(
+ widgetBounds,
+ PixelCastJustification::LayoutDeviceIsParentLayerForRCDRSF));
+ return true;
+ }
+
+ LayoutDeviceIntSize contentSize;
+ if (nsLayoutUtils::GetContentViewerSize(aPresContext, contentSize)) {
+ LayoutDeviceToParentLayerScale scale;
+ if (aScaleContentViewerSize && aPresContext->GetParentPresContext()) {
+ scale = LayoutDeviceToParentLayerScale(
+ aPresContext->GetParentPresContext()->PresShell()->GetCumulativeResolution());
+ }
+ aCompBounds.SizeTo(contentSize * scale);
+ return true;
+ }
+
+ return false;
+}
+
+/* static */ nsMargin
+nsLayoutUtils::ScrollbarAreaToExcludeFromCompositionBoundsFor(nsIFrame* aScrollFrame)
+{
+ if (!aScrollFrame || !aScrollFrame->GetScrollTargetFrame()) {
+ return nsMargin();
+ }
+ nsPresContext* presContext = aScrollFrame->PresContext();
+ nsIPresShell* presShell = presContext->GetPresShell();
+ if (!presShell) {
+ return nsMargin();
+ }
+ bool isRootScrollFrame = aScrollFrame == presShell->GetRootScrollFrame();
+ bool isRootContentDocRootScrollFrame = isRootScrollFrame
+ && presContext->IsRootContentDocument();
+ if (!isRootContentDocRootScrollFrame) {
+ return nsMargin();
+ }
+ if (LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars)) {
+ return nsMargin();
+ }
+ nsIScrollableFrame* scrollableFrame = aScrollFrame->GetScrollTargetFrame();
+ if (!scrollableFrame) {
+ return nsMargin();
+ }
+ return scrollableFrame->GetActualScrollbarSizes();
+}
+
+/* static */ nsSize
+nsLayoutUtils::CalculateCompositionSizeForFrame(nsIFrame* aFrame, bool aSubtractScrollbars)
+{
+ // If we have a scrollable frame, restrict the composition bounds to its
+ // scroll port. The scroll port excludes the frame borders and the scroll
+ // bars, which we don't want to be part of the composition bounds.
+ nsIScrollableFrame* scrollableFrame = aFrame->GetScrollTargetFrame();
+ nsRect rect = scrollableFrame ? scrollableFrame->GetScrollPortRect() : aFrame->GetRect();
+ nsSize size = rect.Size();
+
+ nsPresContext* presContext = aFrame->PresContext();
+ nsIPresShell* presShell = presContext->PresShell();
+
+ bool isRootContentDocRootScrollFrame = presContext->IsRootContentDocument()
+ && aFrame == presShell->GetRootScrollFrame();
+ if (isRootContentDocRootScrollFrame) {
+ ParentLayerRect compBounds;
+ if (UpdateCompositionBoundsForRCDRSF(compBounds, presContext, false)) {
+ int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
+ size = nsSize(compBounds.width * auPerDevPixel, compBounds.height * auPerDevPixel);
+ }
+ }
+
+ if (aSubtractScrollbars) {
+ nsMargin margins = ScrollbarAreaToExcludeFromCompositionBoundsFor(aFrame);
+ size.width -= margins.LeftRight();
+ size.height -= margins.TopBottom();
+ }
+
+ return size;
+}
+
+/* static */ CSSSize
+nsLayoutUtils::CalculateRootCompositionSize(nsIFrame* aFrame,
+ bool aIsRootContentDocRootScrollFrame,
+ const FrameMetrics& aMetrics)
+{
+
+ if (aIsRootContentDocRootScrollFrame) {
+ return ViewAs<LayerPixel>(aMetrics.GetCompositionBounds().Size(),
+ PixelCastJustification::ParentLayerToLayerForRootComposition)
+ * LayerToScreenScale(1.0f)
+ / aMetrics.DisplayportPixelsPerCSSPixel();
+ }
+ nsPresContext* presContext = aFrame->PresContext();
+ ScreenSize rootCompositionSize;
+ nsPresContext* rootPresContext =
+ presContext->GetToplevelContentDocumentPresContext();
+ if (!rootPresContext) {
+ rootPresContext = presContext->GetRootPresContext();
+ }
+ nsIPresShell* rootPresShell = nullptr;
+ if (rootPresContext) {
+ rootPresShell = rootPresContext->PresShell();
+ if (nsIFrame* rootFrame = rootPresShell->GetRootFrame()) {
+ LayoutDeviceToLayerScale2D cumulativeResolution(
+ rootPresShell->GetCumulativeResolution()
+ * nsLayoutUtils::GetTransformToAncestorScale(rootFrame));
+ ParentLayerRect compBounds;
+ if (UpdateCompositionBoundsForRCDRSF(compBounds, rootPresContext, true)) {
+ rootCompositionSize = ViewAs<ScreenPixel>(compBounds.Size(),
+ PixelCastJustification::ScreenIsParentLayerForRoot);
+ } else {
+ int32_t rootAUPerDevPixel = rootPresContext->AppUnitsPerDevPixel();
+ LayerSize frameSize =
+ (LayoutDeviceRect::FromAppUnits(rootFrame->GetRect(), rootAUPerDevPixel)
+ * cumulativeResolution).Size();
+ rootCompositionSize = frameSize * LayerToScreenScale(1.0f);
+ }
+ }
+ } else {
+ nsIWidget* widget = aFrame->GetNearestWidget();
+ LayoutDeviceIntRect widgetBounds = widget->GetBounds();
+ rootCompositionSize = ScreenSize(
+ ViewAs<ScreenPixel>(widgetBounds.Size(),
+ PixelCastJustification::LayoutDeviceIsScreenForBounds));
+ }
+
+ // Adjust composition size for the size of scroll bars.
+ nsIFrame* rootRootScrollFrame = rootPresShell ? rootPresShell->GetRootScrollFrame() : nullptr;
+ nsMargin scrollbarMargins = ScrollbarAreaToExcludeFromCompositionBoundsFor(rootRootScrollFrame);
+ LayoutDeviceMargin margins = LayoutDeviceMargin::FromAppUnits(scrollbarMargins,
+ rootPresContext->AppUnitsPerDevPixel());
+ // Scrollbars are not subject to resolution scaling, so LD pixels = layer pixels for them.
+ rootCompositionSize.width -= margins.LeftRight();
+ rootCompositionSize.height -= margins.TopBottom();
+
+ return rootCompositionSize / aMetrics.DisplayportPixelsPerCSSPixel();
+}
+
+/* static */ nsRect
+nsLayoutUtils::CalculateScrollableRectForFrame(nsIScrollableFrame* aScrollableFrame, nsIFrame* aRootFrame)
+{
+ nsRect contentBounds;
+ if (aScrollableFrame) {
+ contentBounds = aScrollableFrame->GetScrollRange();
+
+ nsPoint scrollPosition = aScrollableFrame->GetScrollPosition();
+ if (aScrollableFrame->GetScrollbarStyles().mVertical == NS_STYLE_OVERFLOW_HIDDEN) {
+ contentBounds.y = scrollPosition.y;
+ contentBounds.height = 0;
+ }
+ if (aScrollableFrame->GetScrollbarStyles().mHorizontal == NS_STYLE_OVERFLOW_HIDDEN) {
+ contentBounds.x = scrollPosition.x;
+ contentBounds.width = 0;
+ }
+
+ contentBounds.width += aScrollableFrame->GetScrollPortRect().width;
+ contentBounds.height += aScrollableFrame->GetScrollPortRect().height;
+ } else {
+ contentBounds = aRootFrame->GetRect();
+ }
+ return contentBounds;
+}
+
+/* static */ nsRect
+nsLayoutUtils::CalculateExpandedScrollableRect(nsIFrame* aFrame)
+{
+ nsRect scrollableRect =
+ CalculateScrollableRectForFrame(aFrame->GetScrollTargetFrame(),
+ aFrame->PresContext()->PresShell()->GetRootFrame());
+ nsSize compSize = CalculateCompositionSizeForFrame(aFrame);
+
+ if (aFrame == aFrame->PresContext()->PresShell()->GetRootScrollFrame()) {
+ // the composition size for the root scroll frame does not include the
+ // local resolution, so we adjust.
+ float res = aFrame->PresContext()->PresShell()->GetResolution();
+ compSize.width = NSToCoordRound(compSize.width / res);
+ compSize.height = NSToCoordRound(compSize.height / res);
+ }
+
+ if (scrollableRect.width < compSize.width) {
+ scrollableRect.x = std::max(0,
+ scrollableRect.x - (compSize.width - scrollableRect.width));
+ scrollableRect.width = compSize.width;
+ }
+
+ if (scrollableRect.height < compSize.height) {
+ scrollableRect.y = std::max(0,
+ scrollableRect.y - (compSize.height - scrollableRect.height));
+ scrollableRect.height = compSize.height;
+ }
+ return scrollableRect;
+}
+
+/* static */ void
+nsLayoutUtils::DoLogTestDataForPaint(LayerManager* aManager,
+ ViewID aScrollId,
+ const std::string& aKey,
+ const std::string& aValue)
+{
+ if (ClientLayerManager* mgr = aManager->AsClientLayerManager()) {
+ mgr->LogTestDataForCurrentPaint(aScrollId, aKey, aValue);
+ }
+}
+
+/* static */ bool
+nsLayoutUtils::IsAPZTestLoggingEnabled()
+{
+ return gfxPrefs::APZTestLoggingEnabled();
+}
+
+////////////////////////////////////////
+// SurfaceFromElementResult
+
+nsLayoutUtils::SurfaceFromElementResult::SurfaceFromElementResult()
+ // Use safe default values here
+ : mIsWriteOnly(true)
+ , mIsStillLoading(false)
+ , mHasSize(false)
+ , mCORSUsed(false)
+ , mIsPremultiplied(true)
+{
+}
+
+const RefPtr<mozilla::gfx::SourceSurface>&
+nsLayoutUtils::SurfaceFromElementResult::GetSourceSurface()
+{
+ if (!mSourceSurface && mLayersImage) {
+ mSourceSurface = mLayersImage->GetAsSourceSurface();
+ }
+
+ return mSourceSurface;
+}
+
+////////////////////////////////////////
+
+bool
+nsLayoutUtils::IsNonWrapperBlock(nsIFrame* aFrame)
+{
+ return GetAsBlock(aFrame) && !aFrame->IsBlockWrapper();
+}
+
+bool
+nsLayoutUtils::NeedsPrintPreviewBackground(nsPresContext* aPresContext)
+{
+ return aPresContext->IsRootPaginatedDocument() &&
+ (aPresContext->Type() == nsPresContext::eContext_PrintPreview ||
+ aPresContext->Type() == nsPresContext::eContext_PageLayout);
+}
+
+AutoMaybeDisableFontInflation::AutoMaybeDisableFontInflation(nsIFrame *aFrame)
+{
+ // FIXME: Now that inflation calculations are based on the flow
+ // root's NCA's (nearest common ancestor of its inflatable
+ // descendants) width, we could probably disable inflation in
+ // fewer cases than we currently do.
+ // MathML cells need special treatment. See bug 1002526 comment 56.
+ if (aFrame->IsContainerForFontSizeInflation() &&
+ !aFrame->IsFrameOfType(nsIFrame::eMathML)) {
+ mPresContext = aFrame->PresContext();
+ mOldValue = mPresContext->mInflationDisabledForShrinkWrap;
+ mPresContext->mInflationDisabledForShrinkWrap = true;
+ } else {
+ // indicate we have nothing to restore
+ mPresContext = nullptr;
+ }
+}
+
+AutoMaybeDisableFontInflation::~AutoMaybeDisableFontInflation()
+{
+ if (mPresContext) {
+ mPresContext->mInflationDisabledForShrinkWrap = mOldValue;
+ }
+}
+
+namespace mozilla {
+
+Rect NSRectToRect(const nsRect& aRect, double aAppUnitsPerPixel)
+{
+ // Note that by making aAppUnitsPerPixel a double we're doing floating-point
+ // division using a larger type and avoiding rounding error.
+ return Rect(Float(aRect.x / aAppUnitsPerPixel),
+ Float(aRect.y / aAppUnitsPerPixel),
+ Float(aRect.width / aAppUnitsPerPixel),
+ Float(aRect.height / aAppUnitsPerPixel));
+}
+
+Rect NSRectToSnappedRect(const nsRect& aRect, double aAppUnitsPerPixel,
+ const gfx::DrawTarget& aSnapDT)
+{
+ // Note that by making aAppUnitsPerPixel a double we're doing floating-point
+ // division using a larger type and avoiding rounding error.
+ Rect rect(Float(aRect.x / aAppUnitsPerPixel),
+ Float(aRect.y / aAppUnitsPerPixel),
+ Float(aRect.width / aAppUnitsPerPixel),
+ Float(aRect.height / aAppUnitsPerPixel));
+ MaybeSnapToDevicePixels(rect, aSnapDT, true);
+ return rect;
+}
+// Similar to a snapped rect, except an axis is left unsnapped if the snapping
+// process results in a length of 0.
+Rect NSRectToNonEmptySnappedRect(const nsRect& aRect, double aAppUnitsPerPixel,
+ const gfx::DrawTarget& aSnapDT)
+{
+ // Note that by making aAppUnitsPerPixel a double we're doing floating-point
+ // division using a larger type and avoiding rounding error.
+ Rect rect(Float(aRect.x / aAppUnitsPerPixel),
+ Float(aRect.y / aAppUnitsPerPixel),
+ Float(aRect.width / aAppUnitsPerPixel),
+ Float(aRect.height / aAppUnitsPerPixel));
+ MaybeSnapToDevicePixels(rect, aSnapDT, true, false);
+ return rect;
+}
+
+void StrokeLineWithSnapping(const nsPoint& aP1, const nsPoint& aP2,
+ int32_t aAppUnitsPerDevPixel,
+ DrawTarget& aDrawTarget,
+ const Pattern& aPattern,
+ const StrokeOptions& aStrokeOptions,
+ const DrawOptions& aDrawOptions)
+{
+ Point p1 = NSPointToPoint(aP1, aAppUnitsPerDevPixel);
+ Point p2 = NSPointToPoint(aP2, aAppUnitsPerDevPixel);
+ SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget,
+ aStrokeOptions.mLineWidth);
+ aDrawTarget.StrokeLine(p1, p2, aPattern, aStrokeOptions, aDrawOptions);
+}
+
+namespace layout {
+
+
+void
+MaybeSetupTransactionIdAllocator(layers::LayerManager* aManager, nsView* aView)
+{
+ if (aManager->GetBackendType() == layers::LayersBackend::LAYERS_CLIENT) {
+ layers::ClientLayerManager *manager = static_cast<layers::ClientLayerManager*>(aManager);
+ nsRefreshDriver *refresh = aView->GetViewManager()->GetPresShell()->GetPresContext()->RefreshDriver();
+ manager->SetTransactionIdAllocator(refresh);
+ }
+}
+
+} // namespace layout
+} // namespace mozilla
+
+/* static */ bool
+nsLayoutUtils::IsOutlineStyleAutoEnabled()
+{
+ static bool sOutlineStyleAutoEnabled;
+ static bool sOutlineStyleAutoPrefCached = false;
+
+ if (!sOutlineStyleAutoPrefCached) {
+ sOutlineStyleAutoPrefCached = true;
+ Preferences::AddBoolVarCache(&sOutlineStyleAutoEnabled,
+ "layout.css.outline-style-auto.enabled",
+ false);
+ }
+ return sOutlineStyleAutoEnabled;
+}
+
+/* static */ void
+nsLayoutUtils::SetBSizeFromFontMetrics(const nsIFrame* aFrame,
+ ReflowOutput& aMetrics,
+ const LogicalMargin& aFramePadding,
+ WritingMode aLineWM,
+ WritingMode aFrameWM)
+{
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
+
+ if (fm) {
+ // Compute final height of the frame.
+ //
+ // Do things the standard css2 way -- though it's hard to find it
+ // in the css2 spec! It's actually found in the css1 spec section
+ // 4.4 (you will have to read between the lines to really see
+ // it).
+ //
+ // The height of our box is the sum of our font size plus the top
+ // and bottom border and padding. The height of children do not
+ // affect our height.
+ aMetrics.SetBlockStartAscent(aLineWM.IsLineInverted() ? fm->MaxDescent()
+ : fm->MaxAscent());
+ aMetrics.BSize(aLineWM) = fm->MaxHeight();
+ } else {
+ NS_WARNING("Cannot get font metrics - defaulting sizes to 0");
+ aMetrics.SetBlockStartAscent(aMetrics.BSize(aLineWM) = 0);
+ }
+ aMetrics.SetBlockStartAscent(aMetrics.BlockStartAscent() +
+ aFramePadding.BStart(aFrameWM));
+ aMetrics.BSize(aLineWM) += aFramePadding.BStartEnd(aFrameWM);
+}
+
+/* static */ bool
+nsLayoutUtils::HasDocumentLevelListenersForApzAwareEvents(nsIPresShell* aShell)
+{
+ if (nsIDocument* doc = aShell->GetDocument()) {
+ WidgetEvent event(true, eVoidEvent);
+ nsTArray<EventTarget*> targets;
+ nsresult rv = EventDispatcher::Dispatch(doc, nullptr, &event, nullptr,
+ nullptr, nullptr, &targets);
+ NS_ENSURE_SUCCESS(rv, false);
+ for (size_t i = 0; i < targets.Length(); i++) {
+ if (targets[i]->IsApzAware()) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+static void
+MaybeReflowForInflationScreenSizeChange(nsPresContext *aPresContext)
+{
+ if (aPresContext) {
+ nsIPresShell* presShell = aPresContext->GetPresShell();
+ bool fontInflationWasEnabled = presShell->FontSizeInflationEnabled();
+ presShell->NotifyFontSizeInflationEnabledIsDirty();
+ bool changed = false;
+ if (presShell && presShell->FontSizeInflationEnabled() &&
+ presShell->FontSizeInflationMinTwips() != 0) {
+ aPresContext->ScreenSizeInchesForFontInflation(&changed);
+ }
+
+ changed = changed ||
+ (fontInflationWasEnabled != presShell->FontSizeInflationEnabled());
+ if (changed) {
+ nsCOMPtr<nsIDocShell> docShell = aPresContext->GetDocShell();
+ if (docShell) {
+ nsCOMPtr<nsIContentViewer> cv;
+ docShell->GetContentViewer(getter_AddRefs(cv));
+ if (cv) {
+ nsTArray<nsCOMPtr<nsIContentViewer> > array;
+ cv->AppendSubtree(array);
+ for (uint32_t i = 0, iEnd = array.Length(); i < iEnd; ++i) {
+ nsCOMPtr<nsIPresShell> shell;
+ nsCOMPtr<nsIContentViewer> cv = array[i];
+ cv->GetPresShell(getter_AddRefs(shell));
+ if (shell) {
+ nsIFrame *rootFrame = shell->GetRootFrame();
+ if (rootFrame) {
+ shell->FrameNeedsReflow(rootFrame,
+ nsIPresShell::eStyleChange,
+ NS_FRAME_IS_DIRTY);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+}
+
+/* static */ void
+nsLayoutUtils::SetScrollPositionClampingScrollPortSize(nsIPresShell* aPresShell, CSSSize aSize)
+{
+ MOZ_ASSERT(aSize.width >= 0.0 && aSize.height >= 0.0);
+
+ aPresShell->SetScrollPositionClampingScrollPortSize(
+ nsPresContext::CSSPixelsToAppUnits(aSize.width),
+ nsPresContext::CSSPixelsToAppUnits(aSize.height));
+
+ // When the "font.size.inflation.minTwips" preference is set, the
+ // layout depends on the size of the screen. Since when the size
+ // of the screen changes, the scroll position clamping scroll port
+ // size also changes, we hook in the needed updates here rather
+ // than adding a separate notification just for this change.
+ nsPresContext* presContext = aPresShell->GetPresContext();
+ MaybeReflowForInflationScreenSizeChange(presContext);
+}
+
+/* static */ bool
+nsLayoutUtils::CanScrollOriginClobberApz(nsIAtom* aScrollOrigin)
+{
+ return aScrollOrigin != nullptr
+ && aScrollOrigin != nsGkAtoms::apz
+ && aScrollOrigin != nsGkAtoms::restore;
+}
+
+/* static */ ScrollMetadata
+nsLayoutUtils::ComputeScrollMetadata(nsIFrame* aForFrame,
+ nsIFrame* aScrollFrame,
+ nsIContent* aContent,
+ const nsIFrame* aReferenceFrame,
+ Layer* aLayer,
+ ViewID aScrollParentId,
+ const nsRect& aViewport,
+ const Maybe<nsRect>& aClipRect,
+ bool aIsRootContent,
+ const ContainerLayerParameters& aContainerParameters)
+{
+ nsPresContext* presContext = aForFrame->PresContext();
+ int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
+
+ nsIPresShell* presShell = presContext->GetPresShell();
+ ScrollMetadata metadata;
+ FrameMetrics& metrics = metadata.GetMetrics();
+ metrics.SetViewport(CSSRect::FromAppUnits(aViewport));
+
+ ViewID scrollId = FrameMetrics::NULL_SCROLL_ID;
+ if (aContent) {
+ if (void* paintRequestTime = aContent->GetProperty(nsGkAtoms::paintRequestTime)) {
+ metrics.SetPaintRequestTime(*static_cast<TimeStamp*>(paintRequestTime));
+ aContent->DeleteProperty(nsGkAtoms::paintRequestTime);
+ }
+ scrollId = nsLayoutUtils::FindOrCreateIDFor(aContent);
+ nsRect dp;
+ if (nsLayoutUtils::GetDisplayPort(aContent, &dp)) {
+ metrics.SetDisplayPort(CSSRect::FromAppUnits(dp));
+ nsLayoutUtils::LogTestDataForPaint(aLayer->Manager(), scrollId, "displayport",
+ metrics.GetDisplayPort());
+ }
+ if (nsLayoutUtils::GetCriticalDisplayPort(aContent, &dp)) {
+ metrics.SetCriticalDisplayPort(CSSRect::FromAppUnits(dp));
+ nsLayoutUtils::LogTestDataForPaint(aLayer->Manager(), scrollId,
+ "criticalDisplayport", metrics.GetCriticalDisplayPort());
+ }
+ DisplayPortMarginsPropertyData* marginsData =
+ static_cast<DisplayPortMarginsPropertyData*>(aContent->GetProperty(nsGkAtoms::DisplayPortMargins));
+ if (marginsData) {
+ metrics.SetDisplayPortMargins(marginsData->mMargins);
+ }
+ }
+
+ nsIScrollableFrame* scrollableFrame = nullptr;
+ if (aScrollFrame)
+ scrollableFrame = aScrollFrame->GetScrollTargetFrame();
+
+ metrics.SetScrollableRect(CSSRect::FromAppUnits(
+ nsLayoutUtils::CalculateScrollableRectForFrame(scrollableFrame, aForFrame)));
+
+ if (scrollableFrame) {
+ nsPoint scrollPosition = scrollableFrame->GetScrollPosition();
+ metrics.SetScrollOffset(CSSPoint::FromAppUnits(scrollPosition));
+
+ nsPoint smoothScrollPosition = scrollableFrame->LastScrollDestination();
+ metrics.SetSmoothScrollOffset(CSSPoint::FromAppUnits(smoothScrollPosition));
+
+ // If the frame was scrolled since the last layers update, and by something
+ // that is higher priority than APZ, we want to tell the APZ to update
+ // its scroll offset. We want to distinguish the case where the scroll offset
+ // was "restored" because in that case the restored scroll position should
+ // not overwrite a user-driven scroll.
+ if (scrollableFrame->LastScrollOrigin() == nsGkAtoms::restore) {
+ metrics.SetScrollOffsetRestored(scrollableFrame->CurrentScrollGeneration());
+ } else if (CanScrollOriginClobberApz(scrollableFrame->LastScrollOrigin())) {
+ metrics.SetScrollOffsetUpdated(scrollableFrame->CurrentScrollGeneration());
+ }
+ scrollableFrame->AllowScrollOriginDowngrade();
+
+ nsIAtom* lastSmoothScrollOrigin = scrollableFrame->LastSmoothScrollOrigin();
+ if (lastSmoothScrollOrigin) {
+ metrics.SetSmoothScrollOffsetUpdated(scrollableFrame->CurrentScrollGeneration());
+ }
+
+ nsSize lineScrollAmount = scrollableFrame->GetLineScrollAmount();
+ LayoutDeviceIntSize lineScrollAmountInDevPixels =
+ LayoutDeviceIntSize::FromAppUnitsRounded(lineScrollAmount, presContext->AppUnitsPerDevPixel());
+ metadata.SetLineScrollAmount(lineScrollAmountInDevPixels);
+
+ nsSize pageScrollAmount = scrollableFrame->GetPageScrollAmount();
+ LayoutDeviceIntSize pageScrollAmountInDevPixels =
+ LayoutDeviceIntSize::FromAppUnitsRounded(pageScrollAmount, presContext->AppUnitsPerDevPixel());
+ metadata.SetPageScrollAmount(pageScrollAmountInDevPixels);
+
+ if (!aScrollFrame->GetParent() ||
+ EventStateManager::CanVerticallyScrollFrameWithWheel(aScrollFrame->GetParent()))
+ {
+ metadata.SetAllowVerticalScrollWithWheel(true);
+ }
+
+ metadata.SetUsesContainerScrolling(scrollableFrame->UsesContainerScrolling());
+
+ metadata.SetSnapInfo(scrollableFrame->GetScrollSnapInfo());
+ }
+
+ // If we have the scrollparent being the same as the scroll id, the
+ // compositor-side code could get into an infinite loop while building the
+ // overscroll handoff chain.
+ MOZ_ASSERT(aScrollParentId == FrameMetrics::NULL_SCROLL_ID || scrollId != aScrollParentId);
+ metrics.SetScrollId(scrollId);
+ metrics.SetIsRootContent(aIsRootContent);
+ metadata.SetScrollParentId(aScrollParentId);
+
+ if (scrollId != FrameMetrics::NULL_SCROLL_ID && !presContext->GetParentPresContext()) {
+ if ((aScrollFrame && (aScrollFrame == presShell->GetRootScrollFrame())) ||
+ aContent == presShell->GetDocument()->GetDocumentElement()) {
+ metadata.SetIsLayersIdRoot(true);
+ }
+ }
+
+ // Only the root scrollable frame for a given presShell should pick up
+ // the presShell's resolution. All the other frames are 1.0.
+ if (aScrollFrame == presShell->GetRootScrollFrame()) {
+ metrics.SetPresShellResolution(presShell->GetResolution());
+ } else {
+ metrics.SetPresShellResolution(1.0f);
+ }
+ // The cumulative resolution is the resolution at which the scroll frame's
+ // content is actually rendered. It includes the pres shell resolutions of
+ // all the pres shells from here up to the root, as well as any css-driven
+ // resolution. We don't need to compute it as it's already stored in the
+ // container parameters.
+ metrics.SetCumulativeResolution(aContainerParameters.Scale());
+
+ LayoutDeviceToScreenScale2D resolutionToScreen(
+ presShell->GetCumulativeResolution()
+ * nsLayoutUtils::GetTransformToAncestorScale(aScrollFrame ? aScrollFrame : aForFrame));
+ metrics.SetExtraResolution(metrics.GetCumulativeResolution() / resolutionToScreen);
+
+ metrics.SetDevPixelsPerCSSPixel(presContext->CSSToDevPixelScale());
+
+ // Initially, AsyncPanZoomController should render the content to the screen
+ // at the painted resolution.
+ const LayerToParentLayerScale layerToParentLayerScale(1.0f);
+ metrics.SetZoom(metrics.GetCumulativeResolution() * metrics.GetDevPixelsPerCSSPixel()
+ * layerToParentLayerScale);
+
+ // Calculate the composition bounds as the size of the scroll frame and
+ // its origin relative to the reference frame.
+ // If aScrollFrame is null, we are in a document without a root scroll frame,
+ // so it's a xul document. In this case, use the size of the viewport frame.
+ nsIFrame* frameForCompositionBoundsCalculation = aScrollFrame ? aScrollFrame : aForFrame;
+ nsRect compositionBounds(frameForCompositionBoundsCalculation->GetOffsetToCrossDoc(aReferenceFrame),
+ frameForCompositionBoundsCalculation->GetSize());
+ if (scrollableFrame) {
+ // If we have a scrollable frame, restrict the composition bounds to its
+ // scroll port. The scroll port excludes the frame borders and the scroll
+ // bars, which we don't want to be part of the composition bounds.
+ nsRect scrollPort = scrollableFrame->GetScrollPortRect();
+ compositionBounds = nsRect(compositionBounds.TopLeft() + scrollPort.TopLeft(),
+ scrollPort.Size());
+ }
+ ParentLayerRect frameBounds = LayoutDeviceRect::FromAppUnits(compositionBounds, auPerDevPixel)
+ * metrics.GetCumulativeResolution()
+ * layerToParentLayerScale;
+
+ if (aClipRect) {
+ ParentLayerRect rect = LayoutDeviceRect::FromAppUnits(*aClipRect, auPerDevPixel)
+ * metrics.GetCumulativeResolution()
+ * layerToParentLayerScale;
+ metadata.SetScrollClip(Some(LayerClip(RoundedToInt(rect))));
+ }
+
+ // For the root scroll frame of the root content document (RCD-RSF), the above calculation
+ // will yield the size of the viewport frame as the composition bounds, which
+ // doesn't actually correspond to what is visible when
+ // nsIDOMWindowUtils::setCSSViewport has been called to modify the visible area of
+ // the prescontext that the viewport frame is reflowed into. In that case if our
+ // document has a widget then the widget's bounds will correspond to what is
+ // visible. If we don't have a widget the root view's bounds correspond to what
+ // would be visible because they don't get modified by setCSSViewport.
+ bool isRootScrollFrame = aScrollFrame == presShell->GetRootScrollFrame();
+ bool isRootContentDocRootScrollFrame = isRootScrollFrame
+ && presContext->IsRootContentDocument();
+ if (isRootContentDocRootScrollFrame) {
+ UpdateCompositionBoundsForRCDRSF(frameBounds, presContext, true);
+ }
+
+ nsMargin sizes = ScrollbarAreaToExcludeFromCompositionBoundsFor(aScrollFrame);
+ // Scrollbars are not subject to resolution scaling, so LD pixels = layer pixels for them.
+ ParentLayerMargin boundMargins = LayoutDeviceMargin::FromAppUnits(sizes, auPerDevPixel)
+ * LayoutDeviceToParentLayerScale(1.0f);
+ frameBounds.Deflate(boundMargins);
+
+ metrics.SetCompositionBounds(frameBounds);
+
+ metrics.SetRootCompositionSize(
+ nsLayoutUtils::CalculateRootCompositionSize(aScrollFrame ? aScrollFrame : aForFrame,
+ isRootContentDocRootScrollFrame, metrics));
+
+ if (gfxPrefs::APZPrintTree() || gfxPrefs::APZTestLoggingEnabled()) {
+ if (nsIContent* content = frameForCompositionBoundsCalculation->GetContent()) {
+ nsAutoString contentDescription;
+ content->Describe(contentDescription);
+ metadata.SetContentDescription(NS_LossyConvertUTF16toASCII(contentDescription));
+ nsLayoutUtils::LogTestDataForPaint(aLayer->Manager(), scrollId, "contentDescription",
+ metadata.GetContentDescription().get());
+ }
+ }
+
+ metrics.SetPresShellId(presShell->GetPresShellId());
+
+ // If the scroll frame's content is marked 'scrollgrab', record this
+ // in the FrameMetrics so APZ knows to provide the scroll grabbing
+ // behaviour.
+ if (aScrollFrame && nsContentUtils::HasScrollgrab(aScrollFrame->GetContent())) {
+ metadata.SetHasScrollgrab(true);
+ }
+
+ // Also compute and set the background color.
+ // This is needed for APZ overscrolling support.
+ if (aScrollFrame) {
+ if (isRootScrollFrame) {
+ metadata.SetBackgroundColor(Color::FromABGR(
+ presShell->GetCanvasBackground()));
+ } else {
+ nsStyleContext* backgroundStyle;
+ if (nsCSSRendering::FindBackground(aScrollFrame, &backgroundStyle)) {
+ metadata.SetBackgroundColor(Color::FromABGR(
+ backgroundStyle->StyleBackground()->mBackgroundColor));
+ }
+ }
+ }
+
+ if (ShouldDisableApzForElement(aContent)) {
+ metadata.SetForceDisableApz(true);
+ }
+
+ return metadata;
+}
+
+/* static */ bool
+nsLayoutUtils::ContainsMetricsWithId(const Layer* aLayer, const ViewID& aScrollId)
+{
+ for (uint32_t i = aLayer->GetScrollMetadataCount(); i > 0; i--) {
+ if (aLayer->GetFrameMetrics(i-1).GetScrollId() == aScrollId) {
+ return true;
+ }
+ }
+ for (Layer* child = aLayer->GetFirstChild(); child; child = child->GetNextSibling()) {
+ if (ContainsMetricsWithId(child, aScrollId)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* static */ uint32_t
+nsLayoutUtils::GetTouchActionFromFrame(nsIFrame* aFrame)
+{
+ // If aFrame is null then return default value
+ if (!aFrame) {
+ return NS_STYLE_TOUCH_ACTION_AUTO;
+ }
+
+ // The touch-action CSS property applies to: all elements except:
+ // non-replaced inline elements, table rows, row groups, table columns, and column groups
+ bool isNonReplacedInlineElement = aFrame->IsFrameOfType(nsIFrame::eLineParticipant);
+ if (isNonReplacedInlineElement) {
+ return NS_STYLE_TOUCH_ACTION_AUTO;
+ }
+
+ const nsStyleDisplay* disp = aFrame->StyleDisplay();
+ bool isTableElement = disp->IsInnerTableStyle() &&
+ disp->mDisplay != StyleDisplay::TableCell &&
+ disp->mDisplay != StyleDisplay::TableCaption;
+ if (isTableElement) {
+ return NS_STYLE_TOUCH_ACTION_AUTO;
+ }
+
+ return disp->mTouchAction;
+}
+
+/* static */ void
+nsLayoutUtils::TransformToAncestorAndCombineRegions(
+ const nsRegion& aRegion,
+ nsIFrame* aFrame,
+ const nsIFrame* aAncestorFrame,
+ nsRegion* aPreciseTargetDest,
+ nsRegion* aImpreciseTargetDest,
+ Maybe<Matrix4x4>* aMatrixCache)
+{
+ if (aRegion.IsEmpty()) {
+ return;
+ }
+ bool isPrecise;
+ RegionBuilder<nsRegion> transformedRegion;
+ for (nsRegion::RectIterator it = aRegion.RectIter(); !it.Done(); it.Next()) {
+ nsRect transformed = TransformFrameRectToAncestor(
+ aFrame, it.Get(), aAncestorFrame, &isPrecise, aMatrixCache);
+ transformedRegion.OrWith(transformed);
+ }
+ nsRegion* dest = isPrecise ? aPreciseTargetDest : aImpreciseTargetDest;
+ dest->OrWith(transformedRegion.ToRegion());
+}
+
+/* static */ bool
+nsLayoutUtils::ShouldUseNoScriptSheet(nsIDocument* aDocument)
+{
+ // also handle the case where print is done from print preview
+ // see bug #342439 for more details
+ if (aDocument->IsStaticDocument()) {
+ aDocument = aDocument->GetOriginalDocument();
+ }
+ return aDocument->IsScriptEnabled();
+}
+
+/* static */ bool
+nsLayoutUtils::ShouldUseNoFramesSheet(nsIDocument* aDocument)
+{
+ bool allowSubframes = true;
+ nsIDocShell* docShell = aDocument->GetDocShell();
+ if (docShell) {
+ docShell->GetAllowSubframes(&allowSubframes);
+ }
+ return !allowSubframes;
+}
+
+/* static */ void
+nsLayoutUtils::GetFrameTextContent(nsIFrame* aFrame, nsAString& aResult)
+{
+ aResult.Truncate();
+ AppendFrameTextContent(aFrame, aResult);
+}
+
+/* static */ void
+nsLayoutUtils::AppendFrameTextContent(nsIFrame* aFrame, nsAString& aResult)
+{
+ if (aFrame->GetType() == nsGkAtoms::textFrame) {
+ auto textFrame = static_cast<nsTextFrame*>(aFrame);
+ auto offset = textFrame->GetContentOffset();
+ auto length = textFrame->GetContentLength();
+ textFrame->GetContent()->
+ GetText()->AppendTo(aResult, offset, length);
+ } else {
+ for (nsIFrame* child : aFrame->PrincipalChildList()) {
+ AppendFrameTextContent(child, aResult);
+ }
+ }
+}
+
+/* static */
+nsRect
+nsLayoutUtils::GetSelectionBoundingRect(Selection* aSel)
+{
+ nsRect res;
+ // Bounding client rect may be empty after calling GetBoundingClientRect
+ // when range is collapsed. So we get caret's rect when range is
+ // collapsed.
+ if (aSel->IsCollapsed()) {
+ nsIFrame* frame = nsCaret::GetGeometry(aSel, &res);
+ if (frame) {
+ nsIFrame* relativeTo = GetContainingBlockForClientRect(frame);
+ res = TransformFrameRectToAncestor(frame, res, relativeTo);
+ }
+ } else {
+ int32_t rangeCount = aSel->RangeCount();
+ RectAccumulator accumulator;
+ for (int32_t idx = 0; idx < rangeCount; ++idx) {
+ nsRange* range = aSel->GetRangeAt(idx);
+ nsRange::CollectClientRectsAndText(&accumulator, nullptr, range,
+ range->GetStartParent(), range->StartOffset(),
+ range->GetEndParent(), range->EndOffset(),
+ true, false);
+ }
+ res = accumulator.mResultRect.IsEmpty() ? accumulator.mFirstRect :
+ accumulator.mResultRect;
+ }
+
+ return res;
+}
+
+/* static */ nsBlockFrame*
+nsLayoutUtils::GetFloatContainingBlock(nsIFrame* aFrame)
+{
+ nsIFrame* ancestor = aFrame->GetParent();
+ while (ancestor && !ancestor->IsFloatContainingBlock()) {
+ ancestor = ancestor->GetParent();
+ }
+ MOZ_ASSERT(!ancestor || GetAsBlock(ancestor),
+ "Float containing block can only be block frame");
+ return static_cast<nsBlockFrame*>(ancestor);
+}
+
+// The implementation of this calculation is adapted from
+// Element::GetBoundingClientRect().
+/* static */ CSSRect
+nsLayoutUtils::GetBoundingContentRect(const nsIContent* aContent,
+ const nsIScrollableFrame* aRootScrollFrame) {
+ CSSRect result;
+ if (nsIFrame* frame = aContent->GetPrimaryFrame()) {
+ nsIFrame* relativeTo = aRootScrollFrame->GetScrolledFrame();
+ result = CSSRect::FromAppUnits(
+ nsLayoutUtils::GetAllInFlowRectsUnion(
+ frame,
+ relativeTo,
+ nsLayoutUtils::RECTS_ACCOUNT_FOR_TRANSFORMS));
+
+ // If the element is contained in a scrollable frame that is not
+ // the root scroll frame, make sure to clip the result so that it is
+ // not larger than the containing scrollable frame's bounds.
+ nsIScrollableFrame* scrollFrame = nsLayoutUtils::GetNearestScrollableFrame(frame);
+ if (scrollFrame && scrollFrame != aRootScrollFrame) {
+ nsIFrame* subFrame = do_QueryFrame(scrollFrame);
+ MOZ_ASSERT(subFrame);
+ // Get the bounds of the scroll frame in the same coordinate space
+ // as |result|.
+ CSSRect subFrameRect = CSSRect::FromAppUnits(
+ nsLayoutUtils::TransformFrameRectToAncestor(
+ subFrame,
+ subFrame->GetRectRelativeToSelf(),
+ relativeTo));
+
+ result = subFrameRect.Intersect(result);
+ }
+ }
+ return result;
+}
+
+static already_AddRefed<nsIPresShell>
+GetPresShell(const nsIContent* aContent)
+{
+ nsCOMPtr<nsIPresShell> result;
+ if (nsIDocument* doc = aContent->GetComposedDoc()) {
+ result = doc->GetShell();
+ }
+ return result.forget();
+}
+
+static void UpdateDisplayPortMarginsForPendingMetrics(FrameMetrics& aMetrics) {
+ nsIContent* content = nsLayoutUtils::FindContentFor(aMetrics.GetScrollId());
+ if (!content) {
+ return;
+ }
+
+ nsCOMPtr<nsIPresShell> shell = GetPresShell(content);
+ if (!shell) {
+ return;
+ }
+
+ MOZ_ASSERT(aMetrics.GetUseDisplayPortMargins());
+
+ if (gfxPrefs::APZAllowZooming() && aMetrics.IsRootContent()) {
+ // See APZCCallbackHelper::UpdateRootFrame for details.
+ float presShellResolution = shell->GetResolution();
+ if (presShellResolution != aMetrics.GetPresShellResolution()) {
+ return;
+ }
+ }
+
+ nsIScrollableFrame* frame = nsLayoutUtils::FindScrollableFrameFor(aMetrics.GetScrollId());
+
+ if (!frame) {
+ return;
+ }
+
+ if (APZCCallbackHelper::IsScrollInProgress(frame)) {
+ // If these conditions are true, then the UpdateFrame
+ // message may be ignored by the main-thread, so we
+ // shouldn't update the displayport based on it.
+ return;
+ }
+
+ DisplayPortMarginsPropertyData* currentData =
+ static_cast<DisplayPortMarginsPropertyData*>(content->GetProperty(nsGkAtoms::DisplayPortMargins));
+ if (!currentData) {
+ return;
+ }
+
+ CSSPoint frameScrollOffset = CSSPoint::FromAppUnits(frame->GetScrollPosition());
+ APZCCallbackHelper::AdjustDisplayPortForScrollDelta(aMetrics, frameScrollOffset);
+
+ nsLayoutUtils::SetDisplayPortMargins(content, shell,
+ aMetrics.GetDisplayPortMargins(), 0);
+}
+
+/* static */ void
+nsLayoutUtils::UpdateDisplayPortMarginsFromPendingMessages()
+{
+ if (mozilla::dom::ContentChild::GetSingleton() &&
+ mozilla::dom::ContentChild::GetSingleton()->GetIPCChannel()) {
+ CompositorBridgeChild::Get()->GetIPCChannel()->PeekMessages(
+ [](const IPC::Message& aMsg) -> bool {
+ if (aMsg.type() == mozilla::layers::PAPZ::Msg_RequestContentRepaint__ID) {
+ PickleIterator iter(aMsg);
+ FrameMetrics frame;
+ if (!IPC::ReadParam(&aMsg, &iter, &frame)) {
+ MOZ_ASSERT(false);
+ return true;
+ }
+
+ UpdateDisplayPortMarginsForPendingMetrics(frame);
+ }
+ return true;
+ });
+ }
+}
+
+/* static */ bool
+nsLayoutUtils::IsTransformed(nsIFrame* aForFrame, nsIFrame* aTopFrame)
+{
+ for (nsIFrame* f = aForFrame; f != aTopFrame; f = f->GetParent()) {
+ if (f->IsTransformed()) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/*static*/ CSSPoint
+nsLayoutUtils::GetCumulativeApzCallbackTransform(nsIFrame* aFrame)
+{
+ CSSPoint delta;
+ if (!aFrame) {
+ return delta;
+ }
+ nsIFrame* frame = aFrame;
+ nsCOMPtr<nsIContent> content = frame->GetContent();
+ nsCOMPtr<nsIContent> lastContent;
+ while (frame) {
+ if (content && (content != lastContent)) {
+ void* property = content->GetProperty(nsGkAtoms::apzCallbackTransform);
+ if (property) {
+ delta += *static_cast<CSSPoint*>(property);
+ }
+ }
+ frame = GetCrossDocParentFrame(frame);
+ lastContent = content;
+ content = frame ? frame->GetContent() : nullptr;
+ }
+ return delta;
+}
+
+/* static */ bool
+nsLayoutUtils::SupportsServoStyleBackend(nsIDocument* aDocument)
+{
+ return StyloEnabled() &&
+ aDocument->IsHTMLOrXHTML() &&
+ static_cast<nsDocument*>(aDocument)->IsContentDocument();
+}
+
+static
+bool
+LineHasNonEmptyContentWorker(nsIFrame* aFrame)
+{
+ // Look for non-empty frames, but ignore inline and br frames.
+ // For inline frames, descend into the children, if any.
+ if (aFrame->GetType() == nsGkAtoms::inlineFrame) {
+ for (nsIFrame* child : aFrame->PrincipalChildList()) {
+ if (LineHasNonEmptyContentWorker(child)) {
+ return true;
+ }
+ }
+ } else {
+ if (aFrame->GetType() != nsGkAtoms::brFrame &&
+ !aFrame->IsEmpty()) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static
+bool
+LineHasNonEmptyContent(nsLineBox* aLine)
+{
+ int32_t count = aLine->GetChildCount();
+ for (nsIFrame* frame = aLine->mFirstChild; count > 0;
+ --count, frame = frame->GetNextSibling()) {
+ if (LineHasNonEmptyContentWorker(frame)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* static */ bool
+nsLayoutUtils::IsInvisibleBreak(nsINode* aNode, nsIFrame** aNextLineFrame)
+{
+ if (aNextLineFrame) {
+ *aNextLineFrame = nullptr;
+ }
+
+ if (!aNode->IsElement() || !aNode->IsEditable()) {
+ return false;
+ }
+ nsIFrame* frame = aNode->AsElement()->GetPrimaryFrame();
+ if (!frame || frame->GetType() != nsGkAtoms::brFrame) {
+ return false;
+ }
+
+ nsContainerFrame* f = frame->GetParent();
+ while (f && f->IsFrameOfType(nsBox::eLineParticipant)) {
+ f = f->GetParent();
+ }
+ nsBlockFrame* blockAncestor = do_QueryFrame(f);
+ if (!blockAncestor) {
+ // The container frame doesn't support line breaking.
+ return false;
+ }
+
+ bool valid = false;
+ nsBlockInFlowLineIterator iter(blockAncestor, frame, &valid);
+ if (!valid) {
+ return false;
+ }
+
+ bool lineNonEmpty = LineHasNonEmptyContent(iter.GetLine());
+ if (!lineNonEmpty) {
+ return false;
+ }
+
+ while (iter.Next()) {
+ auto currentLine = iter.GetLine();
+ // Completely skip empty lines.
+ if (!currentLine->IsEmpty()) {
+ // If we come across an inline line, the BR has caused a visible line break.
+ if (currentLine->IsInline()) {
+ if (aNextLineFrame) {
+ *aNextLineFrame = currentLine->mFirstChild;
+ }
+ return false;
+ }
+ break;
+ }
+ }
+
+ return lineNonEmpty;
+}