+
−/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+
−/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
−/* This Source Code Form is subject to the terms of the Mozilla Public
+
− * License, v. 2.0. If a copy of the MPL was not distributed with this
+
− * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
−
+
−#include "nsLayoutUtils.h"
+
−
+
−#include <algorithm>
+
−#include <limits>
+
−
+
−#include "ActiveLayerTracker.h"
+
−#include "DisplayItemClip.h"
+
−#include "gfx2DGlue.h"
+
−#include "gfxContext.h"
+
−#include "gfxDrawable.h"
+
−#include "gfxEnv.h"
+
−#include "gfxMatrix.h"
+
−#include "gfxPlatform.h"
+
−#include "gfxRect.h"
+
−#include "gfxTypes.h"
+
−#include "gfxUtils.h"
+
−#include "ImageContainer.h"
+
−#include "ImageOps.h"
+
−#include "ImageRegion.h"
+
−#include "imgIContainer.h"
+
−#include "imgIRequest.h"
+
−#include "Layers.h"
+
−#include "LayoutLogging.h"
+
−#include "MobileViewportManager.h"
+
−#include "mozilla/AccessibleCaretEventHub.h"
+
−#include "mozilla/ArrayUtils.h"
+
−#include "mozilla/BasicEvents.h"
+
−#include "mozilla/ClearOnShutdown.h"
+
−#include "mozilla/DisplayPortUtils.h"
+
−#include "mozilla/GeckoBindings.h"
+
−#include "mozilla/glean/GleanMetrics.h"
+
−#include "mozilla/dom/AnonymousContent.h"
+
−#include "mozilla/dom/BrowserChild.h"
+
−#include "mozilla/dom/CanvasUtils.h"
+
−#include "mozilla/dom/Document.h"
+
−#include "mozilla/dom/DocumentInlines.h"
+
−#include "mozilla/dom/DOMRect.h"
+
−#include "mozilla/dom/DOMStringList.h"
+
−#include "mozilla/dom/Element.h"
+
−#include "mozilla/dom/HTMLBodyElement.h"
+
−#include "mozilla/dom/HTMLCanvasElement.h"
+
−#include "mozilla/dom/HTMLImageElement.h"
+
−#include "mozilla/dom/HTMLMediaElementBinding.h"
+
−#include "mozilla/dom/HTMLVideoElement.h"
+
−#include "mozilla/dom/InspectorFontFace.h"
+
−#include "mozilla/dom/KeyframeEffect.h"
+
−#include "mozilla/dom/SVGViewportElement.h"
+
−#include "mozilla/dom/UIEvent.h"
+
−#include "mozilla/EffectCompositor.h"
+
−#include "mozilla/EffectSet.h"
+
−#include "mozilla/EventDispatcher.h"
+
−#include "mozilla/EventStateManager.h"
+
−#include "mozilla/FloatingPoint.h"
+
−#include "mozilla/gfx/2D.h"
+
−#include "mozilla/gfx/gfxVars.h"
+
−#include "mozilla/gfx/PathHelpers.h"
+
−#include "mozilla/layers/APZCCallbackHelper.h"
+
−#include "mozilla/layers/APZPublicUtils.h"  // for apz::CalculatePendingDisplayPort
+
−#include "mozilla/layers/CompositorBridgeChild.h"
+
−#include "mozilla/layers/PAPZ.h"
+
−#include "mozilla/layers/StackingContextHelper.h"
+
−#include "mozilla/layers/WebRenderLayerManager.h"
+
−#include "mozilla/Likely.h"
+
−#include "mozilla/LookAndFeel.h"
+
−#include "mozilla/Maybe.h"
+
−#include "mozilla/MemoryReporting.h"
+
−#include "mozilla/PerfStats.h"
+
−#include "mozilla/Preferences.h"
+
−#include "mozilla/PresShell.h"
+
−#include "mozilla/ProfilerLabels.h"
+
−#include "mozilla/ProfilerMarkers.h"
+
−#include "mozilla/RestyleManager.h"
+
−#include "mozilla/ScopeExit.h"
+
−#include "mozilla/ScrollOrigin.h"
+
−#include "mozilla/ServoStyleSet.h"
+
−#include "mozilla/ServoStyleSetInlines.h"
+
−#include "mozilla/StaticPrefs_apz.h"
+
−#include "mozilla/StaticPrefs_dom.h"
+
−#include "mozilla/StaticPrefs_font.h"
+
−#include "mozilla/StaticPrefs_gfx.h"
+
−#include "mozilla/StaticPrefs_image.h"
+
−#include "mozilla/StaticPrefs_layers.h"
+
−#include "mozilla/StaticPrefs_layout.h"
+
−#include "mozilla/StyleAnimationValue.h"
+
−#include "mozilla/SVGImageContext.h"
+
−#include "mozilla/SVGIntegrationUtils.h"
+
−#include "mozilla/SVGTextFrame.h"
+
−#include "mozilla/SVGUtils.h"
+
−#include "mozilla/Telemetry.h"
+
−#include "mozilla/ToString.h"
+
−#include "mozilla/Unused.h"
+
−#include "mozilla/ViewportFrame.h"
+
−#include "mozilla/ViewportUtils.h"
+
−#include "mozilla/WheelHandlingHelper.h"  // for WheelHandlingUtils
+
−#include "nsAnimationManager.h"
+
−#include "nsAtom.h"
+
−#include "nsBidiPresUtils.h"
+
−#include "nsBlockFrame.h"
+
−#include "nsCanvasFrame.h"
+
−#include "nsCaret.h"
+
−#include "nsCharTraits.h"
+
−#include "nsCOMPtr.h"
+
−#include "nsComputedDOMStyle.h"
+
−#include "nsCSSAnonBoxes.h"
+
−#include "nsCSSColorUtils.h"
+
−#include "nsCSSFrameConstructor.h"
+
−#include "nsCSSProps.h"
+
−#include "nsCSSPseudoElements.h"
+
−#include "nsCSSRendering.h"
+
−#include "nsTHashMap.h"
+
−#include "nsDeckFrame.h"
+
−#include "nsDisplayList.h"
+
−#include "nsFlexContainerFrame.h"
+
−#include "nsFontInflationData.h"
+
−#include "nsFontMetrics.h"
+
−#include "nsFrameList.h"
+
−#include "nsFrameSelection.h"
+
−#include "nsGenericHTMLElement.h"
+
−#include "nsGkAtoms.h"
+
−#include "nsICanvasRenderingContextInternal.h"
+
−#include "nsIContent.h"
+
−#include "nsIContentViewer.h"
+
−#include "nsIDocShell.h"
+
−#include "nsIFrameInlines.h"
+
−#include "nsIImageLoadingContent.h"
+
−#include "nsIInterfaceRequestorUtils.h"
+
−#include "nsIScrollableFrame.h"
+
−#include "nsIWidget.h"
+
−#include "nsListControlFrame.h"
+
−#include "nsPIDOMWindow.h"
+
−#include "nsPlaceholderFrame.h"
+
−#include "nsPresContext.h"
+
−#include "nsPresContextInlines.h"
+
−#include "nsRefreshDriver.h"
+
−#include "nsRegion.h"
+
−#include "nsStyleConsts.h"
+
−#include "nsStyleStructInlines.h"
+
−#include "nsStyleTransformMatrix.h"
+
−#include "nsSubDocumentFrame.h"
+
−#include "nsTableWrapperFrame.h"
+
−#include "nsTArray.h"
+
−#include "nsTextFragment.h"
+
−#include "nsTextFrame.h"
+
−#include "nsTransitionManager.h"
+
−#include "nsView.h"
+
−#include "nsViewManager.h"
+
−#include "prenv.h"
+
−#include "RegionBuilder.h"
+
−#include "RetainedDisplayListBuilder.h"
+
−#include "TextDrawTarget.h"
+
−#include "UnitTransforms.h"
+
−#include "ViewportFrame.h"
+
−
+
−#ifdef MOZ_XUL
+
−#  include "nsXULPopupManager.h"
+
−#endif
+
−
+
−// 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;
+
−using mozilla::dom::HTMLMediaElement_Binding::HAVE_METADATA;
+
−using mozilla::dom::HTMLMediaElement_Binding::HAVE_NOTHING;
+
−
+
−#ifdef DEBUG
+
−// TODO: remove, see bug 598468.
+
−bool nsLayoutUtils::gPreventAssertInCompareTreePosition = false;
+
−#endif  // DEBUG
+
−
+
−typedef ScrollableLayerGuid::ViewID ViewID;
+
−typedef nsStyleTransformMatrix::TransformReferenceBox TransformReferenceBox;
+
−
+
−static ViewID sScrollIdCounter = ScrollableLayerGuid::START_SCROLL_ID;
+
−
+
−typedef nsTHashMap<nsUint64HashKey, nsIContent*> ContentMap;
+
−static ContentMap* sContentMap = nullptr;
+
−static ContentMap& GetContentMap() {
+
−  if (!sContentMap) {
+
−    sContentMap = new ContentMap();
+
−  }
+
−  return *sContentMap;
+
−}
+
−
+
−template <typename TestType>
+
−static bool HasMatchingAnimations(EffectSet& aEffects, TestType&& aTest) {
+
−  for (KeyframeEffect* effect : aEffects) {
+
−    if (!effect->GetAnimation() || !effect->GetAnimation()->IsRelevant()) {
+
−      continue;
+
−    }
+
−
+
−    if (aTest(*effect, aEffects)) {
+
−      return true;
+
−    }
+
−  }
+
−
+
−  return false;
+
−}
+
−
+
−template <typename TestType>
+
−static bool HasMatchingAnimations(const nsIFrame* aFrame,
+
−                                  const nsCSSPropertyIDSet& aPropertySet,
+
−                                  TestType&& aTest) {
+
−  MOZ_ASSERT(aFrame);
+
−
+
−  if (aPropertySet.IsSubsetOf(nsCSSPropertyIDSet::OpacityProperties()) &&
+
−      !aFrame->MayHaveOpacityAnimation()) {
+
−    return false;
+
−  }
+
−
+
−  if (aPropertySet.IsSubsetOf(nsCSSPropertyIDSet::TransformLikeProperties()) &&
+
−      !aFrame->MayHaveTransformAnimation()) {
+
−    return false;
+
−  }
+
−
+
−  EffectSet* effectSet = EffectSet::GetEffectSetForFrame(aFrame, aPropertySet);
+
−  if (!effectSet) {
+
−    return false;
+
−  }
+
−
+
−  return HasMatchingAnimations(*effectSet, aTest);
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::HasAnimationOfPropertySet(
+
−    const nsIFrame* aFrame, const nsCSSPropertyIDSet& aPropertySet) {
+
−  return HasMatchingAnimations(
+
−      aFrame, aPropertySet,
+
−      [&aPropertySet](KeyframeEffect& aEffect, const EffectSet&) {
+
−        return aEffect.HasAnimationOfPropertySet(aPropertySet);
+
−      });
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::HasAnimationOfPropertySet(
+
−    const nsIFrame* aFrame, const nsCSSPropertyIDSet& aPropertySet,
+
−    EffectSet* aEffectSet) {
+
−  MOZ_ASSERT(
+
−      !aEffectSet ||
+
−          EffectSet::GetEffectSetForFrame(aFrame, aPropertySet) == aEffectSet,
+
−      "The EffectSet, if supplied, should match what we would otherwise fetch");
+
−
+
−  if (!aEffectSet) {
+
−    return nsLayoutUtils::HasAnimationOfPropertySet(aFrame, aPropertySet);
+
−  }
+
−
+
−  if (aPropertySet.IsSubsetOf(nsCSSPropertyIDSet::TransformLikeProperties()) &&
+
−      !aEffectSet->MayHaveTransformAnimation()) {
+
−    return false;
+
−  }
+
−
+
−  if (aPropertySet.IsSubsetOf(nsCSSPropertyIDSet::OpacityProperties()) &&
+
−      !aEffectSet->MayHaveOpacityAnimation()) {
+
−    return false;
+
−  }
+
−
+
−  return HasMatchingAnimations(
+
−      *aEffectSet,
+
−      [&aPropertySet](KeyframeEffect& aEffect, const EffectSet& aEffectSet) {
+
−        return aEffect.HasAnimationOfPropertySet(aPropertySet);
+
−      });
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::HasAnimationOfTransformAndMotionPath(
+
−    const nsIFrame* aFrame) {
+
−  return nsLayoutUtils::HasAnimationOfPropertySet(
+
−             aFrame,
+
−             nsCSSPropertyIDSet{eCSSProperty_transform, eCSSProperty_translate,
+
−                                eCSSProperty_rotate, eCSSProperty_scale,
+
−                                eCSSProperty_offset_path}) ||
+
−         (!aFrame->StyleDisplay()->mOffsetPath.IsNone() &&
+
−          nsLayoutUtils::HasAnimationOfPropertySet(
+
−              aFrame, nsCSSPropertyIDSet::MotionPathProperties()));
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::HasEffectiveAnimation(
+
−    const nsIFrame* aFrame, const nsCSSPropertyIDSet& aPropertySet) {
+
−  return HasMatchingAnimations(
+
−      aFrame, aPropertySet,
+
−      [&aPropertySet](KeyframeEffect& aEffect, const EffectSet& aEffectSet) {
+
−        return aEffect.HasEffectiveAnimationOfPropertySet(aPropertySet,
+
−                                                          aEffectSet);
+
−      });
+
−}
+
−
+
−/* static */
+
−nsCSSPropertyIDSet nsLayoutUtils::GetAnimationPropertiesForCompositor(
+
−    const nsIFrame* aStyleFrame) {
+
−  nsCSSPropertyIDSet properties;
+
−
+
−  // We fetch the effects for the style frame here since this method is called
+
−  // by RestyleManager::AddLayerChangesForAnimation which takes care to apply
+
−  // the relevant hints to the primary frame as needed.
+
−  EffectSet* effects = EffectSet::GetEffectSetForStyleFrame(aStyleFrame);
+
−  if (!effects) {
+
−    return properties;
+
−  }
+
−
+
−  AnimationPerformanceWarning::Type warning;
+
−  if (!EffectCompositor::AllowCompositorAnimationsOnFrame(aStyleFrame,
+
−                                                          warning)) {
+
−    return properties;
+
−  }
+
−
+
−  for (const KeyframeEffect* effect : *effects) {
+
−    properties |= effect->GetPropertiesForCompositor(*effects, aStyleFrame);
+
−  }
+
−
+
−  // If properties only have motion-path properties, we have to make sure they
+
−  // have effects. i.e. offset-path is not none or we have offset-path
+
−  // animations.
+
−  if (properties.IsSubsetOf(nsCSSPropertyIDSet::MotionPathProperties()) &&
+
−      !properties.HasProperty(eCSSProperty_offset_path) &&
+
−      aStyleFrame->StyleDisplay()->mOffsetPath.IsNone()) {
+
−    properties.Empty();
+
−  }
+
−
+
−  return properties;
+
−}
+
−
+
−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);
+
−}
+
−
+
−// The first value in this pair is the min scale, and the second one is the max
+
−// scale.
+
−using MinAndMaxScale = std::pair<Size, Size>;
+
−
+
−static inline void UpdateMinMaxScale(const nsIFrame* aFrame,
+
−                                     const AnimationValue& aValue,
+
−                                     MinAndMaxScale& aMinAndMaxScale) {
+
−  Size size = aValue.GetScaleValue(aFrame);
+
−  Size& minScale = aMinAndMaxScale.first;
+
−  Size& maxScale = aMinAndMaxScale.second;
+
−
+
−  minScale = Min(minScale, size);
+
−  maxScale = Max(maxScale, size);
+
−}
+
−
+
−// The final transform matrix is calculated by merging the final results of each
+
−// transform-like properties, so do the scale factors. In other words, the
+
−// potential min/max scales could be gotten by multiplying the max/min scales of
+
−// each properties.
+
−//
+
−// For example, there is an animation:
+
−//   from { "transform: scale(1, 1)", "scale: 3, 3" };
+
−//   to   { "transform: scale(2, 2)", "scale: 1, 1" };
+
−//
+
−// the min scale is (1, 1) * (1, 1) = (1, 1), and
+
−// The max scale is (2, 2) * (3, 3) = (6, 6).
+
−// This means we multiply the min/max scale factor of transform property and the
+
−// min/max scale factor of scale property to get the final max/min scale factor.
+
−static Array<MinAndMaxScale, 2> GetMinAndMaxScaleForAnimationProperty(
+
−    const nsIFrame* aFrame,
+
−    const nsTArray<RefPtr<dom::Animation>>& aAnimations) {
+
−  // We use a fixed array to store the min/max scales for each property.
+
−  // The first element in the array is for eCSSProperty_transform, and the
+
−  // second one is for eCSSProperty_scale.
+
−  const MinAndMaxScale defaultValue =
+
−      std::make_pair(Size(std::numeric_limits<float>::max(),
+
−                          std::numeric_limits<float>::max()),
+
−                     Size(std::numeric_limits<float>::min(),
+
−                          std::numeric_limits<float>::min()));
+
−  Array<MinAndMaxScale, 2> minAndMaxScales(defaultValue, defaultValue);
+
−
+
−  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());
+
−
+
−    const dom::KeyframeEffect* effect =
+
−        anim->GetEffect() ? anim->GetEffect()->AsKeyframeEffect() : nullptr;
+
−    MOZ_ASSERT(effect, "A playing animation should have a keyframe effect");
+
−    for (const AnimationProperty& prop : effect->Properties()) {
+
−      if (prop.mProperty != eCSSProperty_transform &&
+
−          prop.mProperty != eCSSProperty_scale) {
+
−        continue;
+
−      }
+
−
+
−      // 0: eCSSProperty_transform.
+
−      // 1: eCSSProperty_scale.
+
−      MinAndMaxScale& scales =
+
−          minAndMaxScales[prop.mProperty == eCSSProperty_transform ? 0 : 1];
+
−
+
−      // We need to factor in the scale of the base style if the base style
+
−      // will be used on the compositor.
+
−      const AnimationValue& baseStyle = effect->BaseStyle(prop.mProperty);
+
−      if (!baseStyle.IsNull()) {
+
−        UpdateMinMaxScale(aFrame, baseStyle, scales);
+
−      }
+
−
+
−      for (const AnimationPropertySegment& segment : prop.mSegments) {
+
−        // In case of add or accumulate composite, StyleAnimationValue does
+
−        // not have a valid value.
+
−        if (segment.HasReplaceableFromValue()) {
+
−          UpdateMinMaxScale(aFrame, segment.mFromValue, scales);
+
−        }
+
−
+
−        if (segment.HasReplaceableToValue()) {
+
−          UpdateMinMaxScale(aFrame, segment.mToValue, scales);
+
−        }
+
−      }
+
−    }
+
−  }
+
−
+
−  return minAndMaxScales;
+
−}
+
−
+
−Size nsLayoutUtils::ComputeSuitableScaleForAnimation(
+
−    const nsIFrame* aFrame, const nsSize& aVisibleSize,
+
−    const nsSize& aDisplaySize) {
+
−  const nsTArray<RefPtr<dom::Animation>> compositorAnimations =
+
−      EffectCompositor::GetAnimationsForCompositor(
+
−          aFrame,
+
−          nsCSSPropertyIDSet{eCSSProperty_transform, eCSSProperty_scale});
+
−
+
−  if (compositorAnimations.IsEmpty()) {
+
−    return Size(1.0, 1.0);
+
−  }
+
−
+
−  const Array<MinAndMaxScale, 2> minAndMaxScales =
+
−      GetMinAndMaxScaleForAnimationProperty(aFrame, compositorAnimations);
+
−
+
−  // This might cause an issue if users use std::numeric_limits<float>::min()
+
−  // (or max()) as the scale value. However, in this case, we may render an
+
−  // extreme small (or large) element, so this may not be a problem. If so,
+
−  // please fix this.
+
−  Size maxScale(std::numeric_limits<float>::min(),
+
−                std::numeric_limits<float>::min());
+
−  Size minScale(std::numeric_limits<float>::max(),
+
−                std::numeric_limits<float>::max());
+
−
+
−  auto isUnset = [](const Size& aMax, const Size& aMin) {
+
−    return aMax.width == std::numeric_limits<float>::min() &&
+
−           aMax.height == std::numeric_limits<float>::min() &&
+
−           aMin.width == std::numeric_limits<float>::max() &&
+
−           aMin.height == std::numeric_limits<float>::max();
+
−  };
+
−
+
−  // Iterate the slots to get the final scale value.
+
−  for (const auto& pair : minAndMaxScales) {
+
−    const Size& currMinScale = pair.first;
+
−    const Size& currMaxScale = pair.second;
+
−
+
−    if (isUnset(currMaxScale, currMinScale)) {
+
−      // We don't have this animation property, so skip.
+
−      continue;
+
−    }
+
−
+
−    if (isUnset(maxScale, minScale)) {
+
−      // Initialize maxScale and minScale.
+
−      maxScale = currMaxScale;
+
−      minScale = currMinScale;
+
−    } else {
+
−      // The scale factors of each transform-like property should be multiplied
+
−      // by others because we merge their sampled values as a final matrix by
+
−      // matrix multiplication, so here we multiply the scale factors by the
+
−      // previous one to get the possible max and min scale factors.
+
−      maxScale = maxScale * currMaxScale;
+
−      minScale = minScale * currMinScale;
+
−    }
+
−  }
+
−
+
−  if (isUnset(maxScale, minScale)) {
+
−    // We didn't encounter any transform-like property.
+
−    return Size(1.0, 1.0);
+
−  }
+
−
+
−  return Size(GetSuitableScale(maxScale.width, minScale.width,
+
−                               aVisibleSize.width, aDisplaySize.width),
+
−              GetSuitableScale(maxScale.height, minScale.height,
+
−                               aVisibleSize.height, aDisplaySize.height));
+
−}
+
−
+
−bool nsLayoutUtils::AreAsyncAnimationsEnabled() {
+
−  return StaticPrefs::layers_offmainthreadcomposition_async_animations() &&
+
−         gfxPlatform::OffMainThreadCompositingEnabled();
+
−}
+
−
+
−bool nsLayoutUtils::AreRetainedDisplayListsEnabled() {
+
−#ifdef MOZ_WIDGET_ANDROID
+
−  return StaticPrefs::layout_display_list_retain();
+
−#else
+
−  if (XRE_IsContentProcess()) {
+
−    return StaticPrefs::layout_display_list_retain();
+
−  }
+
−
+
−  if (XRE_IsE10sParentProcess()) {
+
−    return StaticPrefs::layout_display_list_retain_chrome();
+
−  }
+
−
+
−  // Retained display lists require e10s.
+
−  return false;
+
−#endif
+
−}
+
−
+
−bool nsLayoutUtils::DisplayRootHasRetainedDisplayListBuilder(nsIFrame* aFrame) {
+
−  const nsIFrame* displayRoot = nsLayoutUtils::GetDisplayRootFrame(aFrame);
+
−  MOZ_ASSERT(displayRoot);
+
−  return displayRoot->HasProperty(RetainedDisplayListBuilder::Cached());
+
−}
+
−
+
−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;
+
−}
+
−
+
−void nsLayoutUtils::UnionChildOverflow(nsIFrame* aFrame,
+
−                                       OverflowAreas& aOverflowAreas,
+
−                                       FrameChildListIDs aSkipChildLists) {
+
−  // Iterate over all children except pop-ups.
+
−  FrameChildListIDs skip(aSkipChildLists);
+
−  skip += {nsIFrame::kSelectPopupList, nsIFrame::kPopupList};
+
−
+
−  for (const auto& [list, listID] : aFrame->ChildLists()) {
+
−    if (skip.contains(listID)) {
+
−      continue;
+
−    }
+
−    for (nsIFrame* child : list) {
+
−      aOverflowAreas.UnionWith(child->GetOverflowAreasRelativeToParent());
+
−    }
+
−  }
+
−}
+
−
+
−static void DestroyViewID(void* aObject, nsAtom* 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().InsertOrUpdate(scrollId, aContent);
+
−  }
+
−
+
−  return scrollId;
+
−}
+
−
+
−nsIContent* nsLayoutUtils::FindContentFor(ViewID aId) {
+
−  MOZ_ASSERT(aId != ScrollableLayerGuid::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* nsLayoutUtils::GetScrollFrameFromContent(nsIContent* aContent) {
+
−  nsIFrame* frame = aContent->GetPrimaryFrame();
+
−  if (aContent->OwnerDoc()->GetRootElement() == aContent) {
+
−    PresShell* presShell = frame ? frame->PresShell() : nullptr;
+
−    if (!presShell) {
+
−      presShell = aContent->OwnerDoc()->GetPresShell();
+
−    }
+
−    // 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(
+
−    nsIContent* aContent) {
+
−  nsIFrame* scrollFrame = GetScrollFrameFromContent(aContent);
+
−  return scrollFrame ? scrollFrame->GetScrollTargetFrame() : nullptr;
+
−}
+
−
+
−nsIScrollableFrame* nsLayoutUtils::FindScrollableFrameFor(ViewID aId) {
+
−  nsIContent* content = FindContentFor(aId);
+
−  if (!content) {
+
−    return nullptr;
+
−  }
+
−
+
−  return FindScrollableFrameFor(content);
+
−}
+
−
+
−ViewID nsLayoutUtils::FindIDForScrollableFrame(
+
−    nsIScrollableFrame* aScrollable) {
+
−  if (!aScrollable) {
+
−    return ScrollableLayerGuid::NULL_SCROLL_ID;
+
−  }
+
−
+
−  nsIFrame* scrollFrame = do_QueryFrame(aScrollable);
+
−  nsIContent* scrollContent = scrollFrame->GetContent();
+
−
+
−  ScrollableLayerGuid::ViewID scrollId;
+
−  if (scrollContent && nsLayoutUtils::FindIDFor(scrollContent, &scrollId)) {
+
−    return scrollId;
+
−  }
+
−
+
−  return ScrollableLayerGuid::NULL_SCROLL_ID;
+
−}
+
−
+
−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(const 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;
+
−  }
+
−
+
−  const nsIFrame* frame = nsLayoutUtils::GetDisplayRootFrame(aFrame);
+
−  nsIWidget* widget = frame->GetNearestWidget();
+
−  if (!widget) {
+
−    return false;
+
−  }
+
−  return widget->AsyncPanZoomEnabled();
+
−}
+
−
+
−bool nsLayoutUtils::AllowZoomingForDocument(
+
−    const mozilla::dom::Document* aDocument) {
+
−  if (aDocument->GetPresShell() &&
+
−      !aDocument->GetPresShell()->AsyncPanZoomEnabled()) {
+
−    return false;
+
−  }
+
−  // True if we allow zooming for all documents on this platform, or if we are
+
−  // in RDM and handling meta viewports, which force zoom under some
+
−  // circumstances.
+
−  BrowsingContext* bc = aDocument ? aDocument->GetBrowsingContext() : nullptr;
+
−  return StaticPrefs::apz_allow_zooming() ||
+
−         (bc && bc->InRDMPane() &&
+
−          nsLayoutUtils::ShouldHandleMetaViewport(aDocument));
+
−}
+
−
+
−float nsLayoutUtils::GetCurrentAPZResolutionScale(PresShell* aPresShell) {
+
−  return aPresShell ? aPresShell->GetCumulativeResolution() : 1.0;
+
−}
+
−
+
−static bool HasVisibleAnonymousContents(Document* aDoc) {
+
−  for (RefPtr<AnonymousContent>& ac : aDoc->GetAnonymousContents()) {
+
−    // We check to see if the anonymous content node has a frame. If it doesn't,
+
−    // that means that's not visible to the user because e.g. it's display:none.
+
−    // For now we assume that if it has a frame, it is visible. We might be able
+
−    // to refine this further by adding complexity if it turns out this
+
−    // condition results in a lot of false positives.
+
−    if (ac->ContentNode().GetPrimaryFrame()) {
+
−      return true;
+
−    }
+
−  }
+
−  return false;
+
−}
+
−
+
−bool nsLayoutUtils::ShouldDisableApzForElement(nsIContent* aContent) {
+
−  if (!aContent) {
+
−    return false;
+
−  }
+
−
+
−  if (aContent->GetProperty(nsGkAtoms::apzDisabled)) {
+
−    return true;
+
−  }
+
−
+
−  Document* doc = aContent->GetComposedDoc();
+
−  if (PresShell* rootPresShell =
+
−          APZCCallbackHelper::GetRootContentDocumentPresShellForContent(
+
−              aContent)) {
+
−    if (Document* rootDoc = rootPresShell->GetDocument()) {
+
−      nsIContent* rootContent =
+
−          rootPresShell->GetRootScrollFrame()
+
−              ? rootPresShell->GetRootScrollFrame()->GetContent()
+
−              : rootDoc->GetDocumentElement();
+
−      // For the AccessibleCaret and other anonymous contents: disable APZ on
+
−      // any scrollable subframes that are not the root scrollframe of a
+
−      // document, if the document has any visible anonymous contents.
+
−      //
+
−      // If we find this is triggering in too many scenarios then we might
+
−      // want to tighten this check further. The main use cases for which we
+
−      // want to disable APZ as of this writing are listed in bug 1316318.
+
−      if (aContent != rootContent && HasVisibleAnonymousContents(rootDoc)) {
+
−        return true;
+
−      }
+
−    }
+
−  }
+
−
+
−  if (!doc) {
+
−    return false;
+
−  }
+
−
+
−  if (PresShell* presShell = doc->GetPresShell()) {
+
−    if (RefPtr<AccessibleCaretEventHub> eventHub =
+
−            presShell->GetAccessibleCaretEventHub()) {
+
−      // Disable APZ for all elements if AccessibleCaret tells us to do so.
+
−      if (eventHub->ShouldDisableApz()) {
+
−        return true;
+
−      }
+
−    }
+
−  }
+
−
+
−  return StaticPrefs::apz_disable_for_scroll_linked_effects() &&
+
−         doc->HasScrollLinkedEffect();
+
−}
+
−
+
−void nsLayoutUtils::NotifyPaintSkipTransaction(ViewID aScrollId) {
+
−  if (nsIScrollableFrame* scrollFrame =
+
−          nsLayoutUtils::FindScrollableFrameFor(aScrollId)) {
+
−#ifdef DEBUG
+
−    nsIFrame* f = do_QueryFrame(scrollFrame);
+
−    MOZ_ASSERT(f && f->PresShell() && !f->PresShell()->IsResolutionUpdated());
+
−#endif
+
−    scrollFrame->NotifyApzTransaction();
+
−  }
+
−}
+
−
+
−nsContainerFrame* nsLayoutUtils::LastContinuationWithChild(
+
−    nsContainerFrame* aFrame) {
+
−  MOZ_ASSERT(aFrame, "NULL frame pointer");
+
−  for (auto f = aFrame->LastContinuation(); f; f = f->GetPrevContinuation()) {
+
−    for (const auto& childList : f->ChildLists()) {
+
−      if (MOZ_LIKELY(!childList.mList.IsEmpty())) {
+
−        return static_cast<nsContainerFrame*>(f);
+
−      }
+
−    }
+
−  }
+
−  return aFrame;
+
−}
+
−
+
−// static
+
−FrameChildListID nsLayoutUtils::GetChildListNameFor(nsIFrame* aChildFrame) {
+
−  nsIFrame::ChildListID id = nsIFrame::kPrincipalList;
+
−
+
−  MOZ_DIAGNOSTIC_ASSERT(!aChildFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW));
+
−
+
−  if (aChildFrame->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+
−    nsIFrame* pif = aChildFrame->GetPrevInFlow();
+
−    if (pif->GetParent() == aChildFrame->GetParent()) {
+
−      id = nsIFrame::kExcessOverflowContainersList;
+
−    } else {
+
−      id = nsIFrame::kOverflowContainersList;
+
−    }
+
−  } else {
+
−    LayoutFrameType childType = aChildFrame->Type();
+
−    if (LayoutFrameType::MenuPopup == childType) {
+
−      nsIFrame* parent = aChildFrame->GetParent();
+
−      MOZ_ASSERT(parent, "nsMenuPopupFrame can't be the root frame");
+
−      if (parent) {
+
−        if (parent->IsPopupSetFrame()) {
+
−          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 (LayoutFrameType::TableColGroup == 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) {
+
−    found = parent->GetChildList(nsIFrame::kOverflowList)
+
−                .ContainsFrame(aChildFrame);
+
−    MOZ_ASSERT(found, "not in child list");
+
−  }
+
−#endif
+
−
+
−  return id;
+
−}
+
−
+
−static Element* GetPseudo(const nsIContent* aContent, nsAtom* aPseudoProperty) {
+
−  MOZ_ASSERT(aPseudoProperty == nsGkAtoms::beforePseudoProperty ||
+
−             aPseudoProperty == nsGkAtoms::afterPseudoProperty ||
+
−             aPseudoProperty == nsGkAtoms::markerPseudoProperty);
+
−  if (!aContent->MayHaveAnonymousChildren()) {
+
−    return nullptr;
+
−  }
+
−  return static_cast<Element*>(aContent->GetProperty(aPseudoProperty));
+
−}
+
−
+
−/*static*/
+
−Element* nsLayoutUtils::GetBeforePseudo(const nsIContent* aContent) {
+
−  return GetPseudo(aContent, nsGkAtoms::beforePseudoProperty);
+
−}
+
−
+
−/*static*/
+
−nsIFrame* nsLayoutUtils::GetBeforeFrame(const nsIContent* aContent) {
+
−  Element* pseudo = GetBeforePseudo(aContent);
+
−  return pseudo ? pseudo->GetPrimaryFrame() : nullptr;
+
−}
+
−
+
−/*static*/
+
−Element* nsLayoutUtils::GetAfterPseudo(const nsIContent* aContent) {
+
−  return GetPseudo(aContent, nsGkAtoms::afterPseudoProperty);
+
−}
+
−
+
−/*static*/
+
−nsIFrame* nsLayoutUtils::GetAfterFrame(const nsIContent* aContent) {
+
−  Element* pseudo = GetAfterPseudo(aContent);
+
−  return pseudo ? pseudo->GetPrimaryFrame() : nullptr;
+
−}
+
−
+
−/*static*/
+
−Element* nsLayoutUtils::GetMarkerPseudo(const nsIContent* aContent) {
+
−  return GetPseudo(aContent, nsGkAtoms::markerPseudoProperty);
+
−}
+
−
+
−/*static*/
+
−nsIFrame* nsLayoutUtils::GetMarkerFrame(const nsIContent* aContent) {
+
−  Element* pseudo = GetMarkerPseudo(aContent);
+
−  return pseudo ? pseudo->GetPrimaryFrame() : nullptr;
+
−}
+
−
+
−#ifdef ACCESSIBILITY
+
−void nsLayoutUtils::GetMarkerSpokenText(const nsIContent* aContent,
+
−                                        nsAString& aText) {
+
−  MOZ_ASSERT(aContent && aContent->IsGeneratedContentContainerForMarker());
+
−
+
−  aText.Truncate();
+
−
+
−  nsIFrame* frame = aContent->GetPrimaryFrame();
+
−  if (!frame) {
+
−    return;
+
−  }
+
−
+
−  if (frame->StyleContent()->ContentCount() > 0) {
+
−    for (nsIFrame* child : frame->PrincipalChildList()) {
+
−      nsIFrame::RenderedText text = child->GetRenderedText();
+
−      aText += text.mString;
+
−    }
+
−    return;
+
−  }
+
−
+
−  if (!frame->StyleList()->mListStyleImage.IsNone()) {
+
−    // ::marker is an image, so use default bullet character.
+
−    static const char16_t kDiscMarkerString[] = {0x2022, ' ', 0};
+
−    aText.AssignLiteral(kDiscMarkerString);
+
−    return;
+
−  }
+
−
+
−  frame->PresContext()
+
−      ->FrameConstructor()
+
−      ->CounterManager()
+
−      ->GetSpokenCounterText(frame, aText);
+
−}
+
−#endif
+
−
+
−// static
+
−nsIFrame* nsLayoutUtils::GetClosestFrameOfType(nsIFrame* aFrame,
+
−                                               LayoutFrameType aFrameType,
+
−                                               nsIFrame* aStopAt) {
+
−  for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent()) {
+
−    if (frame->Type() == aFrameType) {
+
−      return frame;
+
−    }
+
−    if (frame == aStopAt) {
+
−      break;
+
−    }
+
−  }
+
−  return nullptr;
+
−}
+
−
+
−/* static */
+
−nsIFrame* nsLayoutUtils::GetPageFrame(nsIFrame* aFrame) {
+
−  return GetClosestFrameOfType(aFrame, LayoutFrameType::Page);
+
−}
+
−
+
−/* static */
+
−nsIFrame* nsLayoutUtils::GetStyleFrame(nsIFrame* aPrimaryFrame) {
+
−  MOZ_ASSERT(aPrimaryFrame);
+
−  if (aPrimaryFrame->IsTableWrapperFrame()) {
+
−    nsIFrame* inner = aPrimaryFrame->PrincipalChildList().FirstChild();
+
−    // inner may be null, if aPrimaryFrame is mid-destruction
+
−    return inner;
+
−  }
+
−
+
−  return aPrimaryFrame;
+
−}
+
−
+
−const nsIFrame* nsLayoutUtils::GetStyleFrame(const nsIFrame* aPrimaryFrame) {
+
−  return nsLayoutUtils::GetStyleFrame(const_cast<nsIFrame*>(aPrimaryFrame));
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::GetStyleFrame(const nsIContent* aContent) {
+
−  nsIFrame* frame = aContent->GetPrimaryFrame();
+
−  if (!frame) {
+
−    return nullptr;
+
−  }
+
−
+
−  return nsLayoutUtils::GetStyleFrame(frame);
+
−}
+
−
+
−CSSIntCoord nsLayoutUtils::UnthemedScrollbarSize(StyleScrollbarWidth aWidth) {
+
−  switch (aWidth) {
+
−    case StyleScrollbarWidth::Auto:
+
−      return 12;
+
−    case StyleScrollbarWidth::Thin:
+
−      return 6;
+
−    case StyleScrollbarWidth::None:
+
−      return 0;
+
−  }
+
−  return 0;
+
−}
+
−
+
−/* static */
+
−nsIFrame* nsLayoutUtils::GetPrimaryFrameFromStyleFrame(nsIFrame* aStyleFrame) {
+
−  nsIFrame* parent = aStyleFrame->GetParent();
+
−  return parent && parent->IsTableWrapperFrame() ? parent : aStyleFrame;
+
−}
+
−
+
−/* static */
+
−const nsIFrame* nsLayoutUtils::GetPrimaryFrameFromStyleFrame(
+
−    const nsIFrame* aStyleFrame) {
+
−  return nsLayoutUtils::GetPrimaryFrameFromStyleFrame(
+
−      const_cast<nsIFrame*>(aStyleFrame));
+
−}
+
−
+
−/*static*/
+
−bool nsLayoutUtils::IsPrimaryStyleFrame(const nsIFrame* aFrame) {
+
−  if (aFrame->IsTableWrapperFrame()) {
+
−    return false;
+
−  }
+
−
+
−  const nsIFrame* parent = aFrame->GetParent();
+
−  if (parent && parent->IsTableWrapperFrame()) {
+
−    return parent->PrincipalChildList().FirstChild() == aFrame;
+
−  }
+
−
+
−  return aFrame->IsPrimaryFrame();
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::GetFloatFromPlaceholder(nsIFrame* aFrame) {
+
−  NS_ASSERTION(aFrame->IsPlaceholderFrame(), "Must have a placeholder here");
+
−  if (aFrame->HasAnyStateBits(PLACEHOLDER_FOR_FLOAT)) {
+
−    nsIFrame* outOfFlowFrame =
+
−        nsPlaceholderFrame::GetRealFrameForPlaceholder(aFrame);
+
−    NS_ASSERTION(outOfFlowFrame && outOfFlowFrame->IsFloating(),
+
−                 "How did that happen?");
+
−    return outOfFlowFrame;
+
−  }
+
−
+
−  return nullptr;
+
−}
+
−
+
−// static
+
−nsIFrame* nsLayoutUtils::GetCrossDocParentFrameInProcess(
+
−    const nsIFrame* aFrame, nsPoint* aCrossDocOffset) {
+
−  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;
+
−  }
+
−  v = v->GetParent();  // subdocumentframe's view
+
−  if (!v) {
+
−    return nullptr;
+
−  }
+
−
+
−  p = v->GetFrame();
+
−  if (p && aCrossDocOffset) {
+
−    nsSubDocumentFrame* subdocumentFrame = do_QueryFrame(p);
+
−    MOZ_ASSERT(subdocumentFrame);
+
−    *aCrossDocOffset += subdocumentFrame->GetExtraOffset();
+
−  }
+
−
+
−  return p;
+
−}
+
−
+
−// static
+
−nsIFrame* nsLayoutUtils::GetCrossDocParentFrame(const nsIFrame* aFrame,
+
−                                                nsPoint* aCrossDocOffset) {
+
−  return GetCrossDocParentFrameInProcess(aFrame, aCrossDocOffset);
+
−}
+
−
+
−// static
+
−bool nsLayoutUtils::IsProperAncestorFrameCrossDoc(
+
−    const nsIFrame* aAncestorFrame, const nsIFrame* aFrame,
+
−    const nsIFrame* aCommonAncestor) {
+
−  if (aFrame == aAncestorFrame) return false;
+
−  return IsAncestorFrameCrossDoc(aAncestorFrame, aFrame, aCommonAncestor);
+
−}
+
−
+
−// static
+
−bool nsLayoutUtils::IsProperAncestorFrameCrossDocInProcess(
+
−    const nsIFrame* aAncestorFrame, const nsIFrame* aFrame,
+
−    const nsIFrame* aCommonAncestor) {
+
−  if (aFrame == aAncestorFrame) return false;
+
−  return IsAncestorFrameCrossDocInProcess(aAncestorFrame, aFrame,
+
−                                          aCommonAncestor);
+
−}
+
−
+
−// static
+
−bool nsLayoutUtils::IsAncestorFrameCrossDoc(const nsIFrame* aAncestorFrame,
+
−                                            const nsIFrame* aFrame,
+
−                                            const nsIFrame* aCommonAncestor) {
+
−  for (const nsIFrame* f = aFrame; f != aCommonAncestor;
+
−       f = GetCrossDocParentFrameInProcess(f)) {
+
−    if (f == aAncestorFrame) return true;
+
−  }
+
−  return aCommonAncestor == aAncestorFrame;
+
−}
+
−
+
−// static
+
−bool nsLayoutUtils::IsAncestorFrameCrossDocInProcess(
+
−    const nsIFrame* aAncestorFrame, const nsIFrame* aFrame,
+
−    const nsIFrame* aCommonAncestor) {
+
−  for (const nsIFrame* f = aFrame; f != aCommonAncestor;
+
−       f = GetCrossDocParentFrameInProcess(f)) {
+
−    if (f == aAncestorFrame) return true;
+
−  }
+
−  return aCommonAncestor == aAncestorFrame;
+
−}
+
−
+
−// static
+
−bool nsLayoutUtils::IsProperAncestorFrame(const nsIFrame* aAncestorFrame,
+
−                                          const nsIFrame* aFrame,
+
−                                          const nsIFrame* aCommonAncestor) {
+
−  if (aFrame == aAncestorFrame) return false;
+
−  for (const 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) {
+
−  MOZ_ASSERT(aIf1Ancestor == -1 || aIf1Ancestor == 0 || aIf1Ancestor == 1);
+
−  MOZ_ASSERT(aIf2Ancestor == -1 || aIf2Ancestor == 0 || aIf2Ancestor == 1);
+
−  MOZ_ASSERT(aContent1, "aContent1 must not be null");
+
−  MOZ_ASSERT(aContent2, "aContent2 must not be null");
+
−
+
−  AutoTArray<nsINode*, 32> content1Ancestors;
+
−  nsINode* c1;
+
−  for (c1 = aContent1; c1 && c1 != aCommonAncestor;
+
−       c1 = c1->GetParentOrShadowHostNode()) {
+
−    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->GetParentOrShadowHostNode()) {
+
−    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->GetParentOrShadowHostNode();
+
−#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->ComputeIndexOf(content1Ancestor);
+
−  int32_t index2 = parent->ComputeIndexOf(content2Ancestor);
+
−
+
−  // None of the nodes are anonymous, just do a regular comparison.
+
−  if (index1 >= 0 && index2 >= 0) {
+
−    return index1 - index2;
+
−  }
+
−
+
−  // Otherwise handle pseudo-element and anonymous content ordering.
+
−  //
+
−  // ::marker -> ::before -> anon siblings -> regular siblings -> ::after
+
−  auto PseudoIndex = [](const nsINode* aNode, int32_t aNodeIndex) -> int32_t {
+
−    if (aNodeIndex >= 0) {
+
−      return 1;  // Not a pseudo.
+
−    }
+
−    if (aNode->IsContent()) {
+
−      if (aNode->AsContent()->IsGeneratedContentContainerForMarker()) {
+
−        return -2;
+
−      }
+
−      if (aNode->AsContent()->IsGeneratedContentContainerForBefore()) {
+
−        return -1;
+
−      }
+
−      if (aNode->AsContent()->IsGeneratedContentContainerForAfter()) {
+
−        return 2;
+
−      }
+
−    }
+
−    return 0;
+
−  };
+
−
+
−  return PseudoIndex(content1Ancestor, index1) -
+
−         PseudoIndex(content2Ancestor, 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) {
+
−  MOZ_ASSERT(aIf1Ancestor == -1 || aIf1Ancestor == 0 || aIf1Ancestor == 1);
+
−  MOZ_ASSERT(aIf2Ancestor == -1 || aIf2Ancestor == 0 || aIf2Ancestor == 1);
+
−  MOZ_ASSERT(aFrame1, "aFrame1 must not be null");
+
−  MOZ_ASSERT(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) {
+
−  MOZ_ASSERT(aIf1Ancestor == -1 || aIf1Ancestor == 0 || aIf1Ancestor == 1);
+
−  MOZ_ASSERT(aIf2Ancestor == -1 || aIf2Ancestor == 0 || aIf2Ancestor == 1);
+
−  MOZ_ASSERT(aFrame1, "aFrame1 must not be null");
+
−  MOZ_ASSERT(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 */
+
−SideBits nsLayoutUtils::GetSideBitsForFixedPositionContent(
+
−    const nsIFrame* aFixedPosFrame) {
+
−  return GetSideBitsAndAdjustAnchorForFixedPositionContent(
+
−      nullptr, aFixedPosFrame, nullptr, nullptr);
+
−}
+
−
+
−/* static */
+
−SideBits nsLayoutUtils::GetSideBitsAndAdjustAnchorForFixedPositionContent(
+
−    const nsIFrame* aViewportFrame, const nsIFrame* aFixedPosFrame,
+
−    LayerPoint* aAnchor, const Rect* aAnchorRect) {
+
−  SideBits sides = SideBits::eNone;
+
−  if (aFixedPosFrame != aViewportFrame) {
+
−    const nsStylePosition* position = aFixedPosFrame->StylePosition();
+
−    if (!position->mOffset.Get(eSideRight).IsAuto()) {
+
−      sides |= SideBits::eRight;
+
−      if (!position->mOffset.Get(eSideLeft).IsAuto()) {
+
−        sides |= SideBits::eLeft;
+
−        if (aAnchor) {
+
−          aAnchor->x = aAnchorRect->x + aAnchorRect->width / 2.f;
+
−        }
+
−      } else {
+
−        if (aAnchor) {
+
−          aAnchor->x = aAnchorRect->XMost();
+
−        }
+
−      }
+
−    } else if (!position->mOffset.Get(eSideLeft).IsAuto()) {
+
−      sides |= SideBits::eLeft;
+
−    }
+
−    if (!position->mOffset.Get(eSideBottom).IsAuto()) {
+
−      sides |= SideBits::eBottom;
+
−      if (!position->mOffset.Get(eSideTop).IsAuto()) {
+
−        sides |= SideBits::eTop;
+
−        if (aAnchor) {
+
−          aAnchor->y = aAnchorRect->y + aAnchorRect->height / 2.f;
+
−        }
+
−      } else {
+
−        if (aAnchor) {
+
−          aAnchor->y = aAnchorRect->YMost();
+
−        }
+
−      }
+
−    } else if (!position->mOffset.Get(eSideTop).IsAuto()) {
+
−      sides |= SideBits::eTop;
+
−    }
+
−  }
+
−  return sides;
+
−}
+
−
+
−ScrollableLayerGuid::ViewID nsLayoutUtils::ScrollIdForRootScrollFrame(
+
−    nsPresContext* aPresContext) {
+
−  ViewID id = ScrollableLayerGuid::NULL_SCROLL_ID;
+
−  if (nsIFrame* rootScrollFrame =
+
−          aPresContext->PresShell()->GetRootScrollFrame()) {
+
−    if (nsIContent* content = rootScrollFrame->GetContent()) {
+
−      id = FindOrCreateIDFor(content);
+
−    }
+
−  }
+
−  return id;
+
−}
+
−
+
−// static
+
−nsIScrollableFrame* nsLayoutUtils::GetNearestScrollableFrameForDirection(
+
−    nsIFrame* aFrame, ScrollDirections aDirections) {
+
−  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) {
+
−      ScrollDirections directions =
+
−          scrollableFrame->GetAvailableScrollingDirectionsForUserInputEvents();
+
−      if (aDirections.contains(ScrollDirection::eVertical)) {
+
−        if (directions.contains(ScrollDirection::eVertical)) {
+
−          return scrollableFrame;
+
−        }
+
−      }
+
−      if (aDirections.contains(ScrollDirection::eHorizontal)) {
+
−        if (directions.contains(ScrollDirection::eHorizontal)) {
+
−          return scrollableFrame;
+
−        }
+
−      }
+
−    }
+
−  }
+
−  return nullptr;
+
−}
+
−
+
−static nsIFrame* GetNearestScrollableOrOverflowClipFrame(
+
−    nsIFrame* aFrame, uint32_t aFlags,
+
−    const std::function<bool(const nsIFrame* aCurrentFrame)>& aClipFrameCheck =
+
−        nullptr) {
+
−  MOZ_ASSERT(
+
−      aFrame,
+
−      "GetNearestScrollableOrOverflowClipFrame expects a non-null frame");
+
−
+
−  auto GetNextFrame = [aFlags](const nsIFrame* aFrame) -> nsIFrame* {
+
−    if (aFlags & nsLayoutUtils::SCROLLABLE_FOLLOW_OOF_TO_PLACEHOLDER) {
+
−      return (aFlags & nsLayoutUtils::SCROLLABLE_SAME_DOC)
+
−                 ? nsLayoutUtils::GetParentOrPlaceholderFor(aFrame)
+
−                 : nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(aFrame);
+
−    }
+
−    return (aFlags & nsLayoutUtils::SCROLLABLE_SAME_DOC)
+
−               ? aFrame->GetParent()
+
−               : nsLayoutUtils::GetCrossDocParentFrameInProcess(aFrame);
+
−  };
+
−
+
−  for (nsIFrame* f = aFrame; f; f = GetNextFrame(f)) {
+
−    if (aClipFrameCheck && aClipFrameCheck(f)) {
+
−      return f;
+
−    }
+
−
+
−    if ((aFlags & nsLayoutUtils::SCROLLABLE_STOP_AT_PAGE) && f->IsPageFrame()) {
+
−      break;
+
−    }
+
−    if (nsIScrollableFrame* scrollableFrame = do_QueryFrame(f)) {
+
−      if (aFlags & nsLayoutUtils::SCROLLABLE_ONLY_ASYNC_SCROLLABLE) {
+
−        if (scrollableFrame->WantAsyncScroll()) {
+
−          return f;
+
−        }
+
−      } else {
+
−        ScrollStyles ss = scrollableFrame->GetScrollStyles();
+
−        if ((aFlags & nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN) ||
+
−            ss.mVertical != StyleOverflow::Hidden ||
+
−            ss.mHorizontal != StyleOverflow::Hidden) {
+
−          return f;
+
−        }
+
−      }
+
−      if (aFlags & nsLayoutUtils::SCROLLABLE_ALWAYS_MATCH_ROOT) {
+
−        PresShell* presShell = f->PresShell();
+
−        if (presShell->GetRootScrollFrame() == f && presShell->GetDocument() &&
+
−            presShell->GetDocument()->IsRootDisplayDocument()) {
+
−          return f;
+
−        }
+
−      }
+
−    }
+
−    if ((aFlags & nsLayoutUtils::SCROLLABLE_FIXEDPOS_FINDS_ROOT) &&
+
−        f->StyleDisplay()->mPosition == StylePositionProperty::Fixed &&
+
−        nsLayoutUtils::IsReallyFixedPos(f)) {
+
−      return f->PresShell()->GetRootScrollFrame();
+
−    }
+
−  }
+
−  return nullptr;
+
−}
+
−
+
−// static
+
−nsIScrollableFrame* nsLayoutUtils::GetNearestScrollableFrame(nsIFrame* aFrame,
+
−                                                             uint32_t aFlags) {
+
−  nsIFrame* found = GetNearestScrollableOrOverflowClipFrame(aFrame, aFlags);
+
−  if (!found) {
+
−    return nullptr;
+
−  }
+
−
+
−  return do_QueryFrame(found);
+
−}
+
−
+
−// static
+
−nsIFrame* nsLayoutUtils::GetNearestOverflowClipFrame(nsIFrame* aFrame) {
+
−  return GetNearestScrollableOrOverflowClipFrame(
+
−      aFrame, SCROLLABLE_SAME_DOC | SCROLLABLE_INCLUDE_HIDDEN,
+
−      [](const nsIFrame* currentFrame) -> bool {
+
−        // In cases of SVG Inner/Outer frames it basically clips descendants
+
−        // unless overflow: visible is explicitly specified.
+
−        LayoutFrameType type = currentFrame->Type();
+
−        return ((type == LayoutFrameType::SVGOuterSVG ||
+
−                 type == LayoutFrameType::SVGInnerSVG) &&
+
−                (currentFrame->StyleDisplay()->mOverflowX !=
+
−                     StyleOverflow::Visible &&
+
−                 currentFrame->StyleDisplay()->mOverflowY !=
+
−                     StyleOverflow::Visible));
+
−      });
+
−}
+
−
+
−// static
+
−nsRect nsLayoutUtils::GetScrolledRect(nsIFrame* aScrolledFrame,
+
−                                      const nsRect& aScrolledFrameOverflowArea,
+
−                                      const nsSize& aScrollPortSize,
+
−                                      StyleDirection aDirection) {
+
−  WritingMode wm = aScrolledFrame->GetWritingMode();
+
−  // Potentially override the frame's direction to use the direction found
+
−  // by ScrollFrameHelper::GetScrolledFrameDir()
+
−  wm.SetDirectionFromBidiLevel(aDirection == StyleDirection::Rtl ? 1 : 0);
+
−
+
−  nscoord x1 = aScrolledFrameOverflowArea.x,
+
−          x2 = aScrolledFrameOverflowArea.XMost(),
+
−          y1 = aScrolledFrameOverflowArea.y,
+
−          y2 = aScrolledFrameOverflowArea.YMost();
+
−
+
−  const bool isHorizontalWM = !wm.IsVertical();
+
−  const bool isVerticalWM = wm.IsVertical();
+
−  bool isInlineFlowFromTopOrLeft = !wm.IsInlineReversed();
+
−  bool isBlockFlowFromTopOrLeft = isHorizontalWM || wm.IsVerticalLR();
+
−
+
−  if (aScrolledFrame->IsFlexContainerFrame()) {
+
−    // In a flex container, the children flow (and overflow) along the flex
+
−    // container's main axis and cross axis. These are analogous to the
+
−    // inline/block axes, and by default they correspond exactly to those axes;
+
−    // but the flex container's CSS (e.g. flex-direction: column-reverse) may
+
−    // have swapped and/or reversed them, and we need to account for that here.
+
−    FlexboxAxisInfo info(aScrolledFrame);
+
−    if (info.mIsRowOriented) {
+
−      // The flex container's inline axis is the main axis.
+
−      isInlineFlowFromTopOrLeft =
+
−          isInlineFlowFromTopOrLeft == !info.mIsMainAxisReversed;
+
−      isBlockFlowFromTopOrLeft =
+
−          isBlockFlowFromTopOrLeft == !info.mIsCrossAxisReversed;
+
−    } else {
+
−      // The flex container's block axis is the main axis.
+
−      isBlockFlowFromTopOrLeft =
+
−          isBlockFlowFromTopOrLeft == !info.mIsMainAxisReversed;
+
−      isInlineFlowFromTopOrLeft =
+
−          isInlineFlowFromTopOrLeft == !info.mIsCrossAxisReversed;
+
−    }
+
−  }
+
−
+
−  // Clamp the horizontal start-edge (x1 or x2, depending whether the logical
+
−  // axis that corresponds to horizontal progresses from left-to-right or
+
−  // right-to-left).
+
−  if ((isHorizontalWM && isInlineFlowFromTopOrLeft) ||
+
−      (isVerticalWM && isBlockFlowFromTopOrLeft)) {
+
−    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 (y1 or y2, depending whether the
+
−  // logical axis that corresponds to vertical progresses from top-to-bottom or
+
−  // buttom-to-top).
+
−  if ((isHorizontalWM && isBlockFlowFromTopOrLeft) ||
+
−      (isVerticalWM && isInlineFlowFromTopOrLeft)) {
+
−    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,
+
−                                   ComputedStyle* aComputedStyle,
+
−                                   PseudoStyleType aPseudoElement,
+
−                                   nsPresContext* aPresContext) {
+
−  MOZ_ASSERT(aPresContext, "Must have a prescontext");
+
−
+
−  RefPtr<ComputedStyle> pseudoContext;
+
−  if (aContent) {
+
−    pseudoContext = aPresContext->StyleSet()->ProbePseudoElementStyle(
+
−        *aContent->AsElement(), aPseudoElement, aComputedStyle);
+
−  }
+
−  return pseudoContext != nullptr;
+
−}
+
−
+
−nsPoint nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(Event* 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, RelativeTo{aFrame});
+
−}
+
−
+
−nsPoint nsLayoutUtils::GetEventCoordinatesRelativeTo(const WidgetEvent* aEvent,
+
−                                                     RelativeTo 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,
+
−    RelativeTo aFrame) {
+
−  if (!aFrame.mFrame) {
+
−    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 GetEventCoordinatesRelativeTo(nsIWidget* aWidget,
+
−                                      const LayoutDeviceIntPoint& aPoint,
+
−                                      RelativeTo aFrame) {
+
−  const nsIFrame* frame = aFrame.mFrame;
+
−  if (!frame || !aWidget) {
+
−    return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+
−  }
+
−
+
−  nsView* view = frame->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 = frame->PresContext();
+
−      nsPoint pt(presContext->DevPixelsToAppUnits(aPoint.x),
+
−                 presContext->DevPixelsToAppUnits(aPoint.y));
+
−      return pt - view->ViewToWidgetOffset();
+
−    }
+
−  }
+
−
+
−  /* 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.
+
−   */
+
−  const nsIFrame* rootFrame = frame;
+
−  bool transformFound = false;
+
−  for (const nsIFrame* f = frame; f;
+
−       f = nsLayoutUtils::GetCrossDocParentFrameInProcess(f)) {
+
−    if (f->IsTransformed() || ViewportUtils::IsZoomedContentRoot(f)) {
+
−      transformFound = true;
+
−    }
+
−
+
−    rootFrame = f;
+
−  }
+
−
+
−  nsView* rootView = rootFrame->GetView();
+
−  if (!rootView) {
+
−    return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+
−  }
+
−
+
−  nsPoint widgetToView = nsLayoutUtils::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 = frame->PresContext()->AppUnitsPerDevPixel();
+
−  widgetToView = widgetToView.ScaleToOtherAppUnits(rootAPD, localAPD);
+
−
+
−  /* 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 || SVGUtils::IsInSVGTextSubtree(frame)) {
+
−    return nsLayoutUtils::TransformRootPointToFrame(ViewportType::Visual,
+
−                                                    aFrame, widgetToView);
+
−  }
+
−
+
−  /* Otherwise, all coordinate systems are translations of one another,
+
−   * so we can just subtract out the difference.
+
−   */
+
−  return widgetToView - frame->GetOffsetToCrossDoc(rootFrame);
+
−}
+
−
+
−nsPoint nsLayoutUtils::GetEventCoordinatesRelativeTo(
+
−    nsIWidget* aWidget, const LayoutDeviceIntPoint& aPoint, RelativeTo aFrame) {
+
−  nsPoint result = ::GetEventCoordinatesRelativeTo(aWidget, aPoint, aFrame);
+
−  if (aFrame.mViewportType == ViewportType::Layout && aFrame.mFrame &&
+
−      aFrame.mFrame->Type() == LayoutFrameType::Viewport &&
+
−      aFrame.mFrame->PresContext()->IsRootContentDocumentCrossProcess()) {
+
−    result = ViewportUtils::VisualToLayout(result, aFrame.mFrame->PresShell());
+
−  }
+
−  return result;
+
−}
+
−
+
−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->ScrollableOverflowRect().Contains(
+
−            GetEventCoordinatesRelativeTo(aEvent, RelativeTo{popup}))) {
+
−      return popup;
+
−    }
+
−  }
+
−#endif
+
−  return nullptr;
+
−}
+
−
+
−void nsLayoutUtils::GetContainerAndOffsetAtEvent(PresShell* aPresShell,
+
−                                                 const WidgetEvent* aEvent,
+
−                                                 nsIContent** aContainer,
+
−                                                 int32_t* aOffset) {
+
−  MOZ_ASSERT(aContainer || aOffset);
+
−
+
−  if (aContainer) {
+
−    *aContainer = nullptr;
+
−  }
+
−  if (aOffset) {
+
−    *aOffset = 0;
+
−  }
+
−
+
−  if (!aPresShell) {
+
−    return;
+
−  }
+
−
+
−  aPresShell->FlushPendingNotifications(FlushType::Layout);
+
−
+
−  RefPtr<nsPresContext> presContext = aPresShell->GetPresContext();
+
−  if (!presContext) {
+
−    return;
+
−  }
+
−
+
−  nsIFrame* targetFrame = presContext->EventStateManager()->GetEventTarget();
+
−  if (!targetFrame) {
+
−    return;
+
−  }
+
−
+
−  WidgetEvent* openingEvent = nullptr;
+
−  // For popupshowing events, redirect via the original mouse event
+
−  // that triggered the popup to open.
+
−  if (aEvent->mMessage == eXULPopupShowing) {
+
−    if (auto* pm = nsXULPopupManager::GetInstance()) {
+
−      if (Event* openingPopupEvent = pm->GetOpeningPopupEvent()) {
+
−        openingEvent = openingPopupEvent->WidgetEventPtr();
+
−      }
+
−    }
+
−  }
+
−
+
−  nsPoint point = nsLayoutUtils::GetEventCoordinatesRelativeTo(
+
−      openingEvent ? openingEvent : aEvent, RelativeTo{targetFrame});
+
−
+
−  if (aContainer) {
+
−    // TODO: This result may be useful to change to Selection.  However, this
+
−    //       may return improper node (e.g., native anonymous node) for the
+
−    //       Selection.  Perhaps, this should take Selection optionally and
+
−    //       if it's specified, needs to check if it's proper for the
+
−    //       Selection.
+
−    nsCOMPtr<nsIContent> container =
+
−        targetFrame->GetContentOffsetsFromPoint(point).content;
+
−    if (container && (!container->ChromeOnlyAccess() ||
+
−                      nsContentUtils::CanAccessNativeAnon())) {
+
−      container.forget(aContainer);
+
−    }
+
−  }
+
−  if (aOffset) {
+
−    *aOffset = targetFrame->GetContentOffsetsFromPoint(point).offset;
+
−  }
+
−}
+
−
+
−void nsLayoutUtils::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 > float(nscoord_MAX)) {
+
−    float excess = aSize - float(nscoord_MAX);
+
−    excess /= 2;
+
−    aStart += excess;
+
−    aSize = (float)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;
+
−}
+
−
+
−void nsLayoutUtils::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;
+
−  }
+
−}
+
−
+
−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[eCornerTopLeftX], aRadii[eCornerBottomLeftX]);
+
−  rectFullHeight.x += xDiff;
+
−  rectFullHeight.width -=
+
−      std::max(aRadii[eCornerTopRightX], aRadii[eCornerBottomRightX]) + xDiff;
+
−  nsRect r1;
+
−  r1.IntersectRect(rectFullHeight, aContainedRect);
+
−
+
−  nsRect rectFullWidth = aRoundedRect;
+
−  nscoord yDiff = std::max(aRadii[eCornerTopLeftY], aRadii[eCornerTopRightY]);
+
−  rectFullWidth.y += yDiff;
+
−  rectFullWidth.height -=
+
−      std::max(aRadii[eCornerBottomLeftY], aRadii[eCornerBottomRightY]) + 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[eCornerTopLeftX],
+
−                     aRadii[eCornerTopLeftY]) &&
+
−         CheckCorner(insets.right, insets.top, aRadii[eCornerTopRightX],
+
−                     aRadii[eCornerTopRightY]) &&
+
−         CheckCorner(insets.right, insets.bottom, aRadii[eCornerBottomRightX],
+
−                     aRadii[eCornerBottomRightY]) &&
+
−         CheckCorner(insets.left, insets.bottom, aRadii[eCornerBottomLeftX],
+
−                     aRadii[eCornerBottomLeftY]);
+
−}
+
−
+
−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);
+
−}
+
−
+
−nsRect nsLayoutUtils::MatrixTransformRect(const nsRect& aBounds,
+
−                                          const Matrix4x4Flagged& 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 = aMatrix.TransformPoint(image);
+
−  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);
+
−}
+
−
+
−bool nsLayoutUtils::ShouldSnapToGrid(const nsIFrame* aFrame) {
+
−  return !aFrame || !aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT) ||
+
−         aFrame->IsSVGOuterSVGAnonChildFrame();
+
−}
+
−
+
−Matrix4x4Flagged nsLayoutUtils::GetTransformToAncestor(
+
−    RelativeTo aFrame, RelativeTo aAncestor, uint32_t aFlags,
+
−    nsIFrame** aOutAncestor) {
+
−  nsIFrame* parent;
+
−  Matrix4x4Flagged ctm;
+
−  // Make sure we don't get an invalid combination of source and destination
+
−  // RelativeTo values.
+
−  MOZ_ASSERT(!(aFrame.mViewportType == ViewportType::Visual &&
+
−               aAncestor.mViewportType == ViewportType::Layout));
+
−  if (aFrame == aAncestor) {
+
−    return ctm;
+
−  }
+
−  ctm = aFrame.mFrame->GetTransformMatrix(aFrame.mViewportType, aAncestor,
+
−                                          &parent, aFlags);
+
−  if (!aFrame.mFrame->Combines3DTransformWithAncestors()) {
+
−    ctm.ProjectTo2D();
+
−  }
+
−  while (parent && parent != aAncestor.mFrame &&
+
−         (!(aFlags & nsIFrame::STOP_AT_STACKING_CONTEXT_AND_DISPLAY_PORT) ||
+
−          (!parent->IsStackingContext() &&
+
−           !DisplayPortUtils::FrameHasDisplayPort(parent)))) {
+
−    nsIFrame* cur = parent;
+
−    ctm = ctm * cur->GetTransformMatrix(aFrame.mViewportType, aAncestor,
+
−                                        &parent, aFlags);
+
−    if (!cur->Combines3DTransformWithAncestors()) {
+
−      ctm.ProjectTo2D();
+
−    }
+
−  }
+
−  if (aOutAncestor) {
+
−    *aOutAncestor = parent;
+
−  }
+
−  return ctm;
+
−}
+
−
+
−gfxSize nsLayoutUtils::GetTransformToAncestorScale(const nsIFrame* aFrame) {
+
−  Matrix4x4Flagged transform = GetTransformToAncestor(
+
−      RelativeTo{aFrame},
+
−      RelativeTo{nsLayoutUtils::GetDisplayRootFrame(aFrame)});
+
−  Matrix transform2D;
+
−  if (transform.Is2D(&transform2D)) {
+
−    return ThebesMatrix(transform2D).ScaleFactors();
+
−  }
+
−  return gfxSize(1, 1);
+
−}
+
−
+
−static Matrix4x4Flagged GetTransformToAncestorExcludingAnimated(
+
−    nsIFrame* aFrame, const nsIFrame* aAncestor) {
+
−  nsIFrame* parent;
+
−  Matrix4x4Flagged ctm;
+
−  if (aFrame == aAncestor) {
+
−    return ctm;
+
−  }
+
−  if (ActiveLayerTracker::IsScaleSubjectToAnimation(aFrame)) {
+
−    return ctm;
+
−  }
+
−  ctm = aFrame->GetTransformMatrix(ViewportType::Layout, RelativeTo{aAncestor},
+
−                                   &parent);
+
−  while (parent && parent != aAncestor) {
+
−    if (ActiveLayerTracker::IsScaleSubjectToAnimation(parent)) {
+
−      return Matrix4x4Flagged();
+
−    }
+
−    if (!parent->Extend3DContext()) {
+
−      ctm.ProjectTo2D();
+
−    }
+
−    ctm = ctm * parent->GetTransformMatrix(ViewportType::Layout,
+
−                                           RelativeTo{aAncestor}, &parent);
+
−  }
+
−  return ctm;
+
−}
+
−
+
−gfxSize nsLayoutUtils::GetTransformToAncestorScaleExcludingAnimated(
+
−    nsIFrame* aFrame) {
+
−  Matrix4x4Flagged transform = GetTransformToAncestorExcludingAnimated(
+
−      aFrame, nsLayoutUtils::GetDisplayRootFrame(aFrame));
+
−  Matrix transform2D;
+
−  if (transform.Is2D(&transform2D)) {
+
−    return ThebesMatrix(transform2D).ScaleFactors();
+
−  }
+
−  return gfxSize(1, 1);
+
−}
+
−
+
−const nsIFrame* nsLayoutUtils::FindNearestCommonAncestorFrame(
+
−    const nsIFrame* aFrame1, const nsIFrame* aFrame2) {
+
−  AutoTArray<const nsIFrame*, 100> ancestors1;
+
−  AutoTArray<const nsIFrame*, 100> ancestors2;
+
−  const nsIFrame* commonAncestor = nullptr;
+
−  if (aFrame1->PresContext() == aFrame2->PresContext()) {
+
−    commonAncestor = aFrame1->PresShell()->GetRootFrame();
+
−  }
+
−  for (const nsIFrame* f = aFrame1; f != commonAncestor;
+
−       f = nsLayoutUtils::GetCrossDocParentFrameInProcess(f)) {
+
−    ancestors1.AppendElement(f);
+
−  }
+
−  for (const nsIFrame* f = aFrame2; f != commonAncestor;
+
−       f = nsLayoutUtils::GetCrossDocParentFrameInProcess(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;
+
−}
+
−
+
−const nsIFrame* nsLayoutUtils::FindNearestCommonAncestorFrameWithinBlock(
+
−    const nsTextFrame* aFrame1, const nsTextFrame* aFrame2) {
+
−  MOZ_ASSERT(aFrame1);
+
−  MOZ_ASSERT(aFrame2);
+
−
+
−  const nsIFrame* f1 = aFrame1;
+
−  const nsIFrame* f2 = aFrame2;
+
−
+
−  int n1 = 1;
+
−  int n2 = 1;
+
−
+
−  for (auto f = f1->GetParent();;) {
+
−    NS_ASSERTION(f, "All text frames should have a block ancestor");
+
−    if (!f) {
+
−      return nullptr;
+
−    }
+
−    if (f->IsBlockFrameOrSubclass()) {
+
−      break;
+
−    }
+
−    ++n1;
+
−    f = f->GetParent();
+
−  }
+
−
+
−  for (auto f = f2->GetParent();;) {
+
−    NS_ASSERTION(f, "All text frames should have a block ancestor");
+
−    if (!f) {
+
−      return nullptr;
+
−    }
+
−    if (f->IsBlockFrameOrSubclass()) {
+
−      break;
+
−    }
+
−    ++n2;
+
−    f = f->GetParent();
+
−  }
+
−
+
−  if (n1 > n2) {
+
−    std::swap(n1, n2);
+
−    std::swap(f1, f2);
+
−  }
+
−
+
−  while (n2 > n1) {
+
−    f2 = f2->GetParent();
+
−    --n2;
+
−  }
+
−
+
−  while (n2 >= 0) {
+
−    if (f1 == f2) {
+
−      return f1;
+
−    }
+
−    f1 = f1->GetParent();
+
−    f2 = f2->GetParent();
+
−    --n2;
+
−  }
+
−
+
−  return nullptr;
+
−}
+
−
+
−bool nsLayoutUtils::AuthorSpecifiedBorderBackgroundDisablesTheming(
+
−    StyleAppearance aAppearance) {
+
−  return aAppearance == StyleAppearance::NumberInput ||
+
−         aAppearance == StyleAppearance::Button ||
+
−         aAppearance == StyleAppearance::Textfield ||
+
−         aAppearance == StyleAppearance::Textarea ||
+
−         aAppearance == StyleAppearance::Listbox ||
+
−         aAppearance == StyleAppearance::Menulist ||
+
−         aAppearance == StyleAppearance::MenulistButton;
+
−}
+
−
+
−nsLayoutUtils::TransformResult nsLayoutUtils::TransformPoints(
+
−    nsIFrame* aFromFrame, nsIFrame* aToFrame, uint32_t aPointCount,
+
−    CSSPoint* aPoints) {
+
−  const nsIFrame* nearestCommonAncestor =
+
−      FindNearestCommonAncestorFrame(aFromFrame, aToFrame);
+
−  if (!nearestCommonAncestor) {
+
−    return NO_COMMON_ANCESTOR;
+
−  }
+
−  Matrix4x4Flagged downToDest = GetTransformToAncestor(
+
−      RelativeTo{aToFrame}, RelativeTo{nearestCommonAncestor});
+
−  if (downToDest.IsSingular()) {
+
−    return NONINVERTIBLE_TRANSFORM;
+
−  }
+
−  downToDest.Invert();
+
−  Matrix4x4Flagged upToAncestor = GetTransformToAncestor(
+
−      RelativeTo{aFromFrame}, RelativeTo{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(
+
−    RelativeTo aFromFrame, RelativeTo aToFrame, nsPoint& aPoint) {
+
−  // Conceptually, {ViewportFrame, Visual} is an ancestor of
+
−  // {ViewportFrame, Layout}, so factor that into the nearest ancestor
+
−  // computation.
+
−  RelativeTo nearestCommonAncestor{
+
−      FindNearestCommonAncestorFrame(aFromFrame.mFrame, aToFrame.mFrame),
+
−      aFromFrame.mViewportType == ViewportType::Visual ||
+
−              aToFrame.mViewportType == ViewportType::Visual
+
−          ? ViewportType::Visual
+
−          : ViewportType::Layout};
+
−  if (!nearestCommonAncestor.mFrame) {
+
−    return NO_COMMON_ANCESTOR;
+
−  }
+
−  Matrix4x4Flagged downToDest =
+
−      GetTransformToAncestor(aToFrame, nearestCommonAncestor);
+
−  if (downToDest.IsSingular()) {
+
−    return NONINVERTIBLE_TRANSFORM;
+
−  }
+
−  downToDest.Invert();
+
−  Matrix4x4Flagged upToAncestor =
+
−      GetTransformToAncestor(aFromFrame, nearestCommonAncestor);
+
−
+
−  float devPixelsPerAppUnitFromFrame =
+
−      1.0f / aFromFrame.mFrame->PresContext()->AppUnitsPerDevPixel();
+
−  float devPixelsPerAppUnitToFrame =
+
−      1.0f / aToFrame.mFrame->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(
+
−    const nsIFrame* aFromFrame, const nsIFrame* aToFrame, nsRect& aRect) {
+
−  const nsIFrame* nearestCommonAncestor =
+
−      FindNearestCommonAncestorFrame(aFromFrame, aToFrame);
+
−  if (!nearestCommonAncestor) {
+
−    return NO_COMMON_ANCESTOR;
+
−  }
+
−  Matrix4x4Flagged downToDest = GetTransformToAncestor(
+
−      RelativeTo{aToFrame}, RelativeTo{nearestCommonAncestor});
+
−  if (downToDest.IsSingular()) {
+
−    return NONINVERTIBLE_TRANSFORM;
+
−  }
+
−  downToDest.Invert();
+
−  Matrix4x4Flagged upToAncestor = GetTransformToAncestor(
+
−      RelativeTo{aFromFrame}, RelativeTo{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 = NSToCoordRound(toDevPixels.x / devPixelsPerAppUnitToFrame);
+
−  aRect.y = NSToCoordRound(toDevPixels.y / devPixelsPerAppUnitToFrame);
+
−  aRect.width = NSToCoordRound(toDevPixels.width / devPixelsPerAppUnitToFrame);
+
−  aRect.height =
+
−      NSToCoordRound(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, LayoutFrameType::Scroll);
+
−
+
−  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(), LayoutFrameType::Scroll);
+
−  }
+
−
+
−  return resultRect;
+
−}
+
−
+
−bool nsLayoutUtils::GetLayerTransformForFrame(nsIFrame* aFrame,
+
−                                              Matrix4x4Flagged* 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->GetTransformGetter()) {
+
−    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::TransformComputation,
+
−                               false /*don't build caret*/);
+
−  builder.BeginFrame();
+
−  nsDisplayList list;
+
−  nsDisplayTransform* item =
+
−      MakeDisplayItem<nsDisplayTransform>(&builder, aFrame, &list, nsRect());
+
−  MOZ_ASSERT(item);
+
−
+
−  *aTransform = item->GetTransform();
+
−  item->Destroy(&builder);
+
−
+
−  builder.EndFrame();
+
−
+
−  return true;
+
−}
+
−
+
−static bool TransformGfxPointFromAncestor(RelativeTo aFrame,
+
−                                          const Point& aPoint,
+
−                                          RelativeTo aAncestor, Point* aOut) {
+
−  Matrix4x4Flagged 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(
+
−    RelativeTo aFrame, const Rect& aRect, RelativeTo aAncestor,
+
−    bool* aPreservesAxisAlignedRectangles = nullptr,
+
−    Maybe<Matrix4x4Flagged>* aMatrixCache = nullptr,
+
−    bool aStopAtStackingContextAndDisplayPortAndOOFFrame = false,
+
−    nsIFrame** aOutAncestor = nullptr) {
+
−  Matrix4x4Flagged ctm;
+
−  if (aMatrixCache && *aMatrixCache) {
+
−    // We are given a matrix to use, so use it
+
−    ctm = aMatrixCache->value();
+
−  } else {
+
−    // Else, compute it
+
−    uint32_t flags = 0;
+
−    if (aStopAtStackingContextAndDisplayPortAndOOFFrame) {
+
−      flags |= nsIFrame::STOP_AT_STACKING_CONTEXT_AND_DISPLAY_PORT;
+
−    }
+
−    ctm = nsLayoutUtils::GetTransformToAncestor(aFrame, aAncestor, flags,
+
−                                                aOutAncestor);
+
−    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();
+
−  }
+
−  const nsIFrame* ancestor = aOutAncestor ? *aOutAncestor : aAncestor.mFrame;
+
−  float factor = ancestor->PresContext()->AppUnitsPerDevPixel();
+
−  Rect maxBounds =
+
−      Rect(float(nscoord_MIN) / factor * 0.5, float(nscoord_MIN) / factor * 0.5,
+
−           float(nscoord_MAX) / factor, float(nscoord_MAX) / factor);
+
−  return ctm.TransformAndClipBounds(aRect, maxBounds);
+
−}
+
−
+
−static SVGTextFrame* GetContainingSVGTextFrame(const nsIFrame* aFrame) {
+
−  if (!SVGUtils::IsInSVGTextSubtree(aFrame)) {
+
−    return nullptr;
+
−  }
+
−
+
−  return static_cast<SVGTextFrame*>(nsLayoutUtils::GetClosestFrameOfType(
+
−      aFrame->GetParent(), LayoutFrameType::SVGText));
+
−}
+
−
+
−nsPoint nsLayoutUtils::TransformAncestorPointToFrame(RelativeTo aFrame,
+
−                                                     const nsPoint& aPoint,
+
−                                                     RelativeTo aAncestor) {
+
−  SVGTextFrame* text = GetContainingSVGTextFrame(aFrame.mFrame);
+
−
+
−  float factor = aFrame.mFrame->PresContext()->AppUnitsPerDevPixel();
+
−  Point result(NSAppUnitsToFloatPixels(aPoint.x, factor),
+
−               NSAppUnitsToFloatPixels(aPoint.y, factor));
+
−
+
−  if (!TransformGfxPointFromAncestor(
+
−          text ? RelativeTo{text, aFrame.mViewportType} : aFrame, result,
+
−          aAncestor, &result)) {
+
−    return nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+
−  }
+
−
+
−  if (text) {
+
−    result = text->TransformFramePointToTextChild(result, aFrame.mFrame);
+
−  }
+
−
+
−  return nsPoint(NSFloatPixelsToAppUnits(float(result.x), factor),
+
−                 NSFloatPixelsToAppUnits(float(result.y), factor));
+
−}
+
−
+
−nsRect nsLayoutUtils::TransformFrameRectToAncestor(
+
−    const nsIFrame* aFrame, const nsRect& aRect, RelativeTo aAncestor,
+
−    bool* aPreservesAxisAlignedRectangles /* = nullptr */,
+
−    Maybe<Matrix4x4Flagged>* aMatrixCache /* = nullptr */,
+
−    bool aStopAtStackingContextAndDisplayPortAndOOFFrame /* = false */,
+
−    nsIFrame** aOutAncestor /* = nullptr */) {
+
−  MOZ_ASSERT(IsAncestorFrameCrossDocInProcess(aAncestor.mFrame, aFrame),
+
−             "Fix the caller");
+
−
+
−  SVGTextFrame* text = GetContainingSVGTextFrame(aFrame);
+
−
+
−  float srcAppUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
+
−  Rect result;
+
−
+
−  if (text) {
+
−    result = ToRect(text->TransformFrameRectFromTextChild(aRect, aFrame));
+
−
+
−    // |result| from TransformFrameRectFromTextChild() is in user space (css
+
−    // pixel), should convert to device pixel
+
−    float devPixelPerCSSPixel =
+
−        float(AppUnitsPerCSSPixel()) / srcAppUnitsPerDevPixel;
+
−    result.Scale(devPixelPerCSSPixel);
+
−
+
−    result = TransformGfxRectToAncestor(
+
−        RelativeTo{text}, result, aAncestor, nullptr, aMatrixCache,
+
−        aStopAtStackingContextAndDisplayPortAndOOFFrame, aOutAncestor);
+
−    // 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(
+
−        RelativeTo{aFrame}, result, aAncestor, aPreservesAxisAlignedRectangles,
+
−        aMatrixCache, aStopAtStackingContextAndDisplayPortAndOOFFrame,
+
−        aOutAncestor);
+
−  }
+
−
+
−  float destAppUnitsPerDevPixel =
+
−      aAncestor.mFrame->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) {
+
−    nsIWidget* parent = aWidget->GetParent();
+
−    if (!parent) {
+
−      break;
+
−    }
+
−    LayoutDeviceIntRect bounds = aWidget->GetBounds();
+
−    offset += bounds.TopLeft();
+
−    aWidget = parent;
+
−  }
+
−  aRootWidget = aWidget;
+
−  return offset;
+
−}
+
−
+
−LayoutDeviceIntPoint nsLayoutUtils::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,
+
−    ViewportType aViewportType, nsIWidget* aWidget) {
+
−  nsPoint viewOffset;
+
−  nsIWidget* viewWidget = aView->GetNearestWidget(&viewOffset);
+
−  if (!viewWidget) {
+
−    return LayoutDeviceIntPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+
−  }
+
−
+
−  nsPoint pt = (aPt + viewOffset);
+
−  // The target coordinates are visual, so perform a layout-to-visual
+
−  // conversion if the incoming coordinates are layout.
+
−  if (aViewportType == ViewportType::Layout && aPresContext->GetPresShell()) {
+
−    pt = ViewportUtils::LayoutToVisual(pt, aPresContext->GetPresShell());
+
−  }
+
−  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->RemoveLastElement(); }
+
−};
+
−
+
−#endif
+
−
+
−nsIFrame* nsLayoutUtils::GetFrameForPoint(
+
−    RelativeTo aRelativeTo, nsPoint aPt, const FrameForPointOptions& aOptions) {
+
−  AUTO_PROFILER_LABEL("nsLayoutUtils::GetFrameForPoint", LAYOUT);
+
−
+
−  nsresult rv;
+
−  AutoTArray<nsIFrame*, 8> outFrames;
+
−  rv = GetFramesForArea(aRelativeTo, nsRect(aPt, nsSize(1, 1)), outFrames,
+
−                        aOptions);
+
−  NS_ENSURE_SUCCESS(rv, nullptr);
+
−  return outFrames.Length() ? outFrames.ElementAt(0) : nullptr;
+
−}
+
−
+
−nsresult nsLayoutUtils::GetFramesForArea(RelativeTo aRelativeTo,
+
−                                         const nsRect& aRect,
+
−                                         nsTArray<nsIFrame*>& aOutFrames,
+
−                                         const FrameForPointOptions& aOptions) {
+
−  AUTO_PROFILER_LABEL("nsLayoutUtils::GetFramesForArea", LAYOUT);
+
−
+
−  nsIFrame* frame = const_cast<nsIFrame*>(aRelativeTo.mFrame);
+
−
+
−  nsDisplayListBuilder builder(frame, nsDisplayListBuilderMode::EventDelivery,
+
−                               false);
+
−  builder.BeginFrame();
+
−  nsDisplayList list;
+
−
+
−  if (aOptions.mBits.contains(FrameForPointOption::IgnorePaintSuppression)) {
+
−    builder.IgnorePaintSuppression();
+
−  }
+
−  if (aOptions.mBits.contains(FrameForPointOption::IgnoreRootScrollFrame)) {
+
−    nsIFrame* rootScrollFrame = frame->PresShell()->GetRootScrollFrame();
+
−    if (rootScrollFrame) {
+
−      builder.SetIgnoreScrollFrame(rootScrollFrame);
+
−    }
+
−  }
+
−  if (aRelativeTo.mViewportType == ViewportType::Layout) {
+
−    builder.SetIsRelativeToLayoutViewport();
+
−  }
+
−  if (aOptions.mBits.contains(FrameForPointOption::IgnoreCrossDoc)) {
+
−    builder.SetDescendIntoSubdocuments(false);
+
−  }
+
−
+
−  if (aOptions.mBits.contains(FrameForPointOption::OnlyVisible)) {
+
−    builder.SetHitTestIsForVisibility(aOptions.mVisibleThreshold);
+
−  }
+
−
+
−  builder.EnterPresShell(frame);
+
−
+
−  builder.SetVisibleRect(aRect);
+
−  builder.SetDirtyRect(aRect);
+
−
+
−  frame->BuildDisplayListForStackingContext(&builder, &list);
+
−  builder.LeavePresShell(frame, nullptr);
+
−
+
−#ifdef MOZ_DUMP_PAINTING
+
−  if (gDumpEventList) {
+
−    fprintf_stderr(stderr, "Event handling --- (%d,%d):\n", aRect.x, aRect.y);
+
−
+
−    std::stringstream ss;
+
−    nsIFrame::PrintDisplayList(&builder, list, ss);
+
−    print_stderr(ss);
+
−  }
+
−#endif
+
−
+
−  nsDisplayItem::HitTestState hitTestState;
+
−  list.HitTest(&builder, aRect, &hitTestState, &aOutFrames);
+
−  list.DeleteAll(&builder);
+
−  builder.EndFrame();
+
−  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();
+
−  PresShell* presShell = presContext->PresShell();
+
−  CSSToLayoutDeviceScale deviceScale = presContext->CSSToDevPixelScale();
+
−  float resolution = 1.0f;
+
−  bool isRcdRsf = aScrollFrame->IsRootScrollFrameOfDocument() &&
+
−                  presContext->IsRootContentDocumentCrossProcess();
+
−  metrics.SetIsRootContent(isRcdRsf);
+
−  if (isRcdRsf) {
+
−    // Only the root content document's root scrollable frame 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->IsRootContentDocumentCrossProcess()) {
+
−    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.SetBoundingCompositionSize(
+
−      nsLayoutUtils::CalculateBoundingCompositionSize(frame, false, metrics));
+
−
+
−  metrics.SetLayoutViewport(
+
−      CSSRect::FromAppUnits(nsRect(aScrollFrame->GetScrollPosition(),
+
−                                   aScrollFrame->GetScrollPortRect().Size())));
+
−  metrics.SetVisualScrollOffset(
+
−      isRcdRsf ? CSSPoint::FromAppUnits(presShell->GetVisualViewportOffset())
+
−               : metrics.GetLayoutViewport().TopLeft());
+
−
+
−  metrics.SetScrollableRect(CSSRect::FromAppUnits(
+
−      nsLayoutUtils::CalculateScrollableRectForFrame(aScrollFrame, nullptr)));
+
−
+
−  return metrics;
+
−}
+
−
+
−nsIScrollableFrame* nsLayoutUtils::GetAsyncScrollableAncestorFrame(
+
−    nsIFrame* aTarget) {
+
−  uint32_t flags = nsLayoutUtils::SCROLLABLE_ALWAYS_MATCH_ROOT |
+
−                   nsLayoutUtils::SCROLLABLE_ONLY_ASYNC_SCROLLABLE |
+
−                   nsLayoutUtils::SCROLLABLE_FIXEDPOS_FINDS_ROOT |
+
−                   nsLayoutUtils::SCROLLABLE_FOLLOW_OOF_TO_PLACEHOLDER;
+
−  return nsLayoutUtils::GetNearestScrollableFrame(aTarget, flags);
+
−}
+
−
+
−void nsLayoutUtils::AddExtraBackgroundItems(nsDisplayListBuilder* aBuilder,
+
−                                            nsDisplayList* aList,
+
−                                            nsIFrame* aFrame,
+
−                                            const nsRect& aCanvasArea,
+
−                                            const nsRegion& aVisibleRegion,
+
−                                            nscolor aBackstop) {
+
−  LayoutFrameType frameType = aFrame->Type();
+
−  nsPresContext* presContext = aFrame->PresContext();
+
−  PresShell* presShell = presContext->PresShell();
+
−
+
−  // 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 == LayoutFrameType::Viewport &&
+
−      nsLayoutUtils::NeedsPrintPreviewBackground(presContext)) {
+
−    nsRect bounds =
+
−        nsRect(aBuilder->ToReferenceFrame(aFrame), aFrame->GetSize());
+
−    nsDisplayListBuilder::AutoBuildingDisplayList buildingDisplayList(
+
−        aBuilder, aFrame, bounds, bounds);
+
−    presShell->AddPrintPreviewBackgroundItem(aBuilder, aList, aFrame, bounds);
+
−  } else if (frameType != LayoutFrameType::Page) {
+
−    // 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.
+
−    nsRect canvasArea = aVisibleRegion.GetBounds();
+
−    canvasArea.IntersectRect(aCanvasArea, canvasArea);
+
−    nsDisplayListBuilder::AutoBuildingDisplayList buildingDisplayList(
+
−        aBuilder, aFrame, canvasArea, canvasArea);
+
−    presShell->AddCanvasBackgroundColorItem(aBuilder, aList, aFrame, canvasArea,
+
−                                            aBackstop);
+
−  }
+
−}
+
−
+
−/**
+
− * Returns a retained display list builder for frame |aFrame|. If there is no
+
− * retained display list builder property set for the frame, and if the flag
+
− * |aRetainingEnabled| is true, a new retained display list builder is created,
+
− * stored as a property for the frame, and returned.
+
− */
+
−static RetainedDisplayListBuilder* GetOrCreateRetainedDisplayListBuilder(
+
−    nsIFrame* aFrame, bool aRetainingEnabled, bool aBuildCaret) {
+
−  RetainedDisplayListBuilder* retainedBuilder =
+
−      aFrame->GetProperty(RetainedDisplayListBuilder::Cached());
+
−
+
−  if (retainedBuilder) {
+
−    return retainedBuilder;
+
−  }
+
−
+
−  if (aRetainingEnabled) {
+
−    retainedBuilder = new RetainedDisplayListBuilder(
+
−        aFrame, nsDisplayListBuilderMode::Painting, aBuildCaret);
+
−    aFrame->SetProperty(RetainedDisplayListBuilder::Cached(), retainedBuilder);
+
−  }
+
−
+
−  return retainedBuilder;
+
−}
+
−
+
−// #define PRINT_HITTESTINFO_STATS
+
−#ifdef PRINT_HITTESTINFO_STATS
+
−void PrintHitTestInfoStatsInternal(nsDisplayList* aList, int& aTotal,
+
−                                   int& aHitTest, int& aVisible,
+
−                                   int& aSpecial) {
+
−  for (nsDisplayItem* i : *aList) {
+
−    aTotal++;
+
−
+
−    if (i->GetChildren()) {
+
−      PrintHitTestInfoStatsInternal(i->GetChildren(), aTotal, aHitTest,
+
−                                    aVisible, aSpecial);
+
−    }
+
−
+
−    if (i->GetType() == DisplayItemType::TYPE_COMPOSITOR_HITTEST_INFO) {
+
−      aHitTest++;
+
−
+
−      const auto& hitTestInfo =
+
−          static_cast<nsDisplayHitTestInfoBase*>(i)->HitTestFlags();
+
−
+
−      if (hitTestInfo.size() > 1) {
+
−        aSpecial++;
+
−        continue;
+
−      }
+
−
+
−      if (hitTestInfo == CompositorHitTestVisibleToHit) {
+
−        aVisible++;
+
−        continue;
+
−      }
+
−
+
−      aSpecial++;
+
−    }
+
−  }
+
−}
+
−
+
−void PrintHitTestInfoStats(nsDisplayList* aList) {
+
−  int total = 0;
+
−  int hitTest = 0;
+
−  int visible = 0;
+
−  int special = 0;
+
−
+
−  PrintHitTestInfoStatsInternal(aList, total, hitTest, visible, special);
+
−
+
−  double ratio = (double)hitTest / (double)total;
+
−
+
−  printf(
+
−      "List %p: total items: %d, hit test items: %d, ratio: %f, visible: %d, "
+
−      "special: %d\n",
+
−      aList, total, hitTest, ratio, visible, special);
+
−}
+
−#endif
+
−
+
−// Apply a batch of effects updates generated during a paint to their
+
−// respective remote browsers.
+
−static void ApplyEffectsUpdates(
+
−    const nsTHashMap<nsPtrHashKey<RemoteBrowser>, EffectsInfo>& aUpdates) {
+
−  for (const auto& entry : aUpdates) {
+
−    auto* browser = entry.GetKey();
+
−    const auto& update = entry.GetData();
+
−    browser->UpdateEffects(update);
+
−  }
+
−}
+
−
+
−static void DumpBeforePaintDisplayList(UniquePtr<std::stringstream>& aStream,
+
−                                       nsDisplayListBuilder* aBuilder,
+
−                                       nsDisplayList* aList,
+
−                                       const nsRect& aVisibleRect) {
+
−#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()) {
+
−    *aStream << "<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
+
−  *aStream << nsPrintfCString(
+
−                  "Painting --- before optimization (dirty %d,%d,%d,%d):\n",
+
−                  aVisibleRect.x, aVisibleRect.y, aVisibleRect.width,
+
−                  aVisibleRect.height)
+
−                  .get();
+
−  nsIFrame::PrintDisplayList(aBuilder, *aList, *aStream,
+
−                             gfxEnv::DumpPaintToFile());
+
−
+
−  if (gfxEnv::DumpPaint() || gfxEnv::DumpPaintItems()) {
+
−    // Flush stream now to avoid reordering dump output relative to
+
−    // messages dumped by PaintRoot below.
+
−    fprint_stderr(gfxUtils::sDumpPaintFile, *aStream);
+
−    aStream = MakeUnique<std::stringstream>();
+
−  }
+
−}
+
−
+
−static void DumpAfterPaintDisplayList(UniquePtr<std::stringstream>& aStream,
+
−                                      nsDisplayListBuilder* aBuilder,
+
−                                      nsDisplayList* aList) {
+
−  *aStream << "Painting --- after optimization:\n";
+
−  nsIFrame::PrintDisplayList(aBuilder, *aList, *aStream,
+
−                             gfxEnv::DumpPaintToFile());
+
−
+
−  fprint_stderr(gfxUtils::sDumpPaintFile, *aStream);
+
−
+
−#ifdef MOZ_DUMP_PAINTING
+
−  if (gfxEnv::DumpPaintToFile()) {
+
−    *aStream << "</body></html>";
+
−  }
+
−  if (gfxEnv::DumpPaintToFile()) {
+
−    fclose(gfxUtils::sDumpPaintFile);
+
−  }
+
−#endif
+
−
+
−  std::stringstream lsStream;
+
−  nsIFrame::PrintDisplayList(aBuilder, *aList, lsStream);
+
−}
+
−
+
−struct TemporaryDisplayListBuilder {
+
−  TemporaryDisplayListBuilder(nsIFrame* aFrame,
+
−                              nsDisplayListBuilderMode aBuilderMode,
+
−                              const bool aBuildCaret)
+
−      : mBuilder(aFrame, aBuilderMode, aBuildCaret) {}
+
−
+
−  ~TemporaryDisplayListBuilder() { mList.DeleteAll(&mBuilder); }
+
−
+
−  nsDisplayListBuilder mBuilder;
+
−  nsDisplayList mList;
+
−  RetainedDisplayListMetrics mMetrics;
+
−};
+
−
+
−void nsLayoutUtils::PaintFrame(gfxContext* aRenderingContext, nsIFrame* aFrame,
+
−                               const nsRegion& aDirtyRegion, nscolor aBackstop,
+
−                               nsDisplayListBuilderMode aBuilderMode,
+
−                               PaintFrameFlags aFlags) {
+
−  AUTO_PROFILER_LABEL("nsLayoutUtils::PaintFrame", GRAPHICS);
+
−
+
−#ifdef MOZ_DUMP_PAINTING
+
−  if (!gPaintCountStack) {
+
−    gPaintCountStack = new nsTArray<int>();
+
−    ClearOnShutdown(&gPaintCountStack);
+
−
+
−    gPaintCountStack->AppendElement(0);
+
−  }
+
−  ++gPaintCountStack->LastElement();
+
−  AutoNestedPaintCount nestedPaintCount;
+
−#endif
+
−
+
−  if (aFlags & PaintFrameFlags::WidgetLayers) {
+
−    nsView* view = aFrame->GetView();
+
−    if (!(view && view->GetWidget() && GetDisplayRootFrame(aFrame) == aFrame)) {
+
−      aFlags &= ~PaintFrameFlags::WidgetLayers;
+
−      NS_ASSERTION(aRenderingContext, "need a rendering context");
+
−    }
+
−  }
+
−
+
−  nsPresContext* presContext = aFrame->PresContext();
+
−  PresShell* presShell = presContext->PresShell();
+
−
+
−  TimeStamp startBuildDisplayList = TimeStamp::Now();
+
−  auto dlTimerId = mozilla::glean::paint::build_displaylist_time.Start();
+
−
+
−  const bool buildCaret = !(aFlags & PaintFrameFlags::HideCaret);
+
−
+
−  // Note that isForPainting here does not include the PaintForPrinting builder
+
−  // mode; that's OK because there is no point in using retained display lists
+
−  // for a print destination.
+
−  const bool isForPainting = (aFlags & PaintFrameFlags::WidgetLayers) &&
+
−                             aBuilderMode == nsDisplayListBuilderMode::Painting;
+
−
+
−  // Only allow retaining for painting when preffed on, and for root frames
+
−  // (since the modified frame tracking is per-root-frame).
+
−  const bool retainingEnabled =
+
−      isForPainting && AreRetainedDisplayListsEnabled() && !aFrame->GetParent();
+
−
+
−  RetainedDisplayListBuilder* retainedBuilder =
+
−      GetOrCreateRetainedDisplayListBuilder(aFrame, retainingEnabled,
+
−                                            buildCaret);
+
−
+
−  // Only use the retained display list builder if the retaining is currently
+
−  // enabled. This check is needed because it is possible that the pref has been
+
−  // disabled after creating the retained display list builder.
+
−  const bool useRetainedBuilder = retainedBuilder && retainingEnabled;
+
−
+
−  Maybe<TemporaryDisplayListBuilder> temporaryBuilder;
+
−  nsDisplayListBuilder* builder = nullptr;
+
−  nsDisplayList* list = nullptr;
+
−  RetainedDisplayListMetrics* metrics = nullptr;
+
−
+
−  if (useRetainedBuilder) {
+
−    builder = retainedBuilder->Builder();
+
−    list = retainedBuilder->List();
+
−    metrics = retainedBuilder->Metrics();
+
−  } else {
+
−    temporaryBuilder.emplace(aFrame, aBuilderMode, buildCaret);
+
−    builder = &temporaryBuilder->mBuilder;
+
−    list = &temporaryBuilder->mList;
+
−    metrics = &temporaryBuilder->mMetrics;
+
−  }
+
−
+
−  MOZ_ASSERT(builder && list && metrics);
+
−
+
−  // Retained builder exists, but display list retaining is disabled.
+
−  if (!useRetainedBuilder && retainedBuilder) {
+
−    // Clear the modified frames lists and frame properties.
+
−    retainedBuilder->ClearFramesWithProps();
+
−
+
−    // Clear the retained display list.
+
−    retainedBuilder->List()->DeleteAll(retainedBuilder->Builder());
+
−  }
+
−
+
−  metrics->Reset();
+
−  metrics->StartBuild();
+
−
+
−  builder->BeginFrame();
+
−
+
−  if (aFlags & PaintFrameFlags::InTransform) {
+
−    builder->SetInTransform(true);
+
−  }
+
−  if (aFlags & PaintFrameFlags::SyncDecodeImages) {
+
−    builder->SetSyncDecodeImages(true);
+
−  }
+
−  if (aFlags & (PaintFrameFlags::WidgetLayers | PaintFrameFlags::ToWindow)) {
+
−    builder->SetPaintingToWindow(true);
+
−  }
+
−  if (aFlags & PaintFrameFlags::UseHighQualityScaling) {
+
−    builder->SetUseHighQualityScaling(true);
+
−  }
+
−  if (aFlags & PaintFrameFlags::ForWebRender) {
+
−    builder->SetPaintingForWebRender(true);
+
−  }
+
−  if (aFlags & PaintFrameFlags::IgnoreSuppression) {
+
−    builder->IgnorePaintSuppression();
+
−  }
+
−
+
−  if (BrowsingContext* bc = presContext->Document()->GetBrowsingContext()) {
+
−    builder->SetInActiveDocShell(bc->IsActive());
+
−  }
+
−
+
−  nsRect rootInkOverflow = aFrame->InkOverflowRectRelativeToSelf();
+
−
+
−  // If we are in a remote browser, then apply clipping from ancestor browsers
+
−  if (BrowserChild* browserChild = BrowserChild::GetFrom(presShell)) {
+
−    if (!browserChild->IsTopLevel()) {
+
−      Maybe<nsRect> unscaledVisibleRect = browserChild->GetVisibleRect();
+
−
+
−      if (!unscaledVisibleRect) {
+
−        unscaledVisibleRect = Some(nsRect());
+
−      }
+
−
+
−      rootInkOverflow.IntersectRect(rootInkOverflow, *unscaledVisibleRect);
+
−    }
+
−  }
+
−
+
−  builder->ClearHaveScrollableDisplayPort();
+
−  if (builder->IsPaintingToWindow()) {
+
−    DisplayPortUtils::MaybeCreateDisplayPortInFirstScrollFrameEncountered(
+
−        aFrame, builder);
+
−  }
+
−
+
−  nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
+
−  if (rootScrollFrame && !aFrame->GetParent()) {
+
−    nsIScrollableFrame* rootScrollableFrame =
+
−        presShell->GetRootScrollFrameAsScrollable();
+
−    MOZ_ASSERT(rootScrollableFrame);
+
−    nsRect displayPortBase = rootInkOverflow;
+
−    nsRect temp = displayPortBase;
+
−    Unused << rootScrollableFrame->DecideScrollableLayer(
+
−        builder, &displayPortBase, &temp,
+
−        /* aSetBase = */ true);
+
−  }
+
−
+
−  nsRegion visibleRegion;
+
−  if (aFlags & PaintFrameFlags::WidgetLayers) {
+
−    // 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 = rootInkOverflow;
+
−  } else {
+
−    visibleRegion = aDirtyRegion;
+
−  }
+
−
+
−  Maybe<nsPoint> originalScrollPosition;
+
−  auto maybeResetScrollPosition = MakeScopeExit([&]() {
+
−    if (originalScrollPosition && rootScrollFrame) {
+
−      nsIScrollableFrame* rootScrollableFrame =
+
−          presShell->GetRootScrollFrameAsScrollable();
+
−      MOZ_ASSERT(rootScrollableFrame->GetScrolledFrame()->GetPosition() ==
+
−                 nsPoint());
+
−      rootScrollableFrame->GetScrolledFrame()->SetPosition(
+
−          *originalScrollPosition);
+
−    }
+
−  });
+
−
+
−  nsRect canvasArea(nsPoint(0, 0), aFrame->GetSize());
+
−  bool ignoreViewportScrolling =
+
−      !aFrame->GetParent() && presShell->IgnoringViewportScrolling();
+
−  if (ignoreViewportScrolling && rootScrollFrame) {
+
−    nsIScrollableFrame* rootScrollableFrame =
+
−        presShell->GetRootScrollFrameAsScrollable();
+
−    if (aFlags & PaintFrameFlags::ResetViewportScrolling) {
+
−      // Temporarily scroll the root scroll frame to 0,0 so that position:fixed
+
−      // elements will appear fixed to the top-left of the document. We manually
+
−      // set the position of the scrolled frame instead of using ScrollTo, since
+
−      // the latter fires scroll listeners, which we don't want.
+
−      originalScrollPosition.emplace(
+
−          rootScrollableFrame->GetScrolledFrame()->GetPosition());
+
−      rootScrollableFrame->GetScrolledFrame()->SetPosition(nsPoint());
+
−    }
+
−    if (aFlags & PaintFrameFlags::DocumentRelative) {
+
−      // 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->SetMatrixDouble(
+
−            aRenderingContext->CurrentMatrixDouble().PreTranslate(
+
−                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));
+
−    }
+
−  }
+
−
+
−  nsRect visibleRect = visibleRegion.GetBounds();
+
−  PartialUpdateResult updateState = PartialUpdateResult::Failed;
+
−
+
−  {
+
−    AUTO_PROFILER_LABEL_CATEGORY_PAIR(GRAPHICS_DisplayListBuilding);
+
−    AUTO_PROFILER_TRACING_MARKER("Paint", "DisplayList", GRAPHICS);
+
−    PerfStats::AutoMetricRecording<PerfStats::Metric::DisplayListBuilding>
+
−        autoRecording;
+
−    {
+
−      ViewID id = ScrollableLayerGuid::NULL_SCROLL_ID;
+
−      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);
+
−        }
+
−        // In some cases we get a root document here on an APZ-enabled window
+
−        // that doesn't have the root displayport initialized yet, even though
+
−        // the ChromeProcessController is supposed to do it when the widget is
+
−        // created. This can happen simply because the ChromeProcessController
+
−        // does it on the next spin of the event loop, and we can trigger a
+
−        // paint synchronously after window creation but before that runs. In
+
−        // that case we should initialize the root displayport here before we do
+
−        // the paint.
+
−      } else if (XRE_IsParentProcess() && presContext->IsRoot() &&
+
−                 presShell->GetDocument() != nullptr &&
+
−                 presShell->GetRootScrollFrame() != nullptr &&
+
−                 nsLayoutUtils::UsesAsyncScrolling(
+
−                     presShell->GetRootScrollFrame())) {
+
−        if (dom::Element* element =
+
−                presShell->GetDocument()->GetDocumentElement()) {
+
−          if (!DisplayPortUtils::HasNonMinimalDisplayPort(element)) {
+
−            APZCCallbackHelper::InitializeRootDisplayport(presShell);
+
−          }
+
−        }
+
−      }
+
−
+
−      nsDisplayListBuilder::AutoCurrentScrollParentIdSetter idSetter(builder,
+
−                                                                     id);
+
−
+
−      builder->SetVisibleRect(visibleRect);
+
−      builder->SetIsBuilding(true);
+
−      builder->SetAncestorHasApzAwareEventHandler(
+
−          gfxPlatform::AsyncPanZoomEnabled() &&
+
−          nsLayoutUtils::HasDocumentLevelListenersForApzAwareEvents(presShell));
+
−
+
−      // If a pref is toggled that adds or removes display list items,
+
−      // we need to rebuild the display list. The pref may be toggled
+
−      // manually by the user, or during test setup.
+
−      bool shouldAttemptPartialUpdate = useRetainedBuilder;
+
−      if (builder->ShouldRebuildDisplayListDueToPrefChange()) {
+
−        shouldAttemptPartialUpdate = false;
+
−      }
+
−
+
−      // Attempt to do a partial build and merge into the existing list.
+
−      // This calls BuildDisplayListForStacking context on a subset of the
+
−      // viewport.
+
−      if (shouldAttemptPartialUpdate) {
+
−        updateState = retainedBuilder->AttemptPartialUpdate(aBackstop);
+
−        metrics->EndPartialBuild(updateState);
+
−      } else {
+
−        // Partial updates are disabled.
+
−        metrics->mPartialUpdateResult = PartialUpdateResult::Failed;
+
−        metrics->mPartialUpdateFailReason = PartialUpdateFailReason::Disabled;
+
−      }
+
−
+
−      // Rebuild the full display list if the partial display list build failed.
+
−      bool doFullRebuild = updateState == PartialUpdateResult::Failed;
+
−
+
−      if (StaticPrefs::layout_display_list_build_twice()) {
+
−        // Build display list twice to compare partial and full display list
+
−        // build times.
+
−        metrics->StartBuild();
+
−        doFullRebuild = true;
+
−      }
+
−
+
−      if (doFullRebuild) {
+
−        list->DeleteAll(builder);
+
−        list->RestoreState();
+
−
+
−        builder->ClearRetainedWindowRegions();
+
−        builder->ClearWillChangeBudgets();
+
−
+
−        builder->EnterPresShell(aFrame);
+
−        builder->SetDirtyRect(visibleRect);
+
−        aFrame->BuildDisplayListForStackingContext(builder, list);
+
−        AddExtraBackgroundItems(builder, list, aFrame, canvasArea,
+
−                                visibleRegion, aBackstop);
+
−
+
−        builder->LeavePresShell(aFrame, list);
+
−        metrics->EndFullBuild();
+
−
+
−        updateState = PartialUpdateResult::Updated;
+
−      }
+
−    }
+
−
+
−    builder->SetIsBuilding(false);
+
−    builder->IncrementPresShellPaintCount(presShell);
+
−  }
+
−
+
−  MOZ_ASSERT(updateState != PartialUpdateResult::Failed);
+
−  builder->Check();
+
−
+
−  const double geckoDLBuildTime =
+
−      (TimeStamp::Now() - startBuildDisplayList).ToMilliseconds();
+
−  mozilla::glean::paint::build_displaylist_time.StopAndAccumulate(
+
−      std::move(dlTimerId));
+
−
+
−  bool consoleNeedsDisplayList =
+
−      (gfxUtils::DumpDisplayList() || gfxEnv::DumpPaint()) &&
+
−      builder->IsInActiveDocShell();
+
−#ifdef MOZ_DUMP_PAINTING
+
−  FILE* savedDumpFile = gfxUtils::sDumpPaintFile;
+
−#endif
+
−
+
−  UniquePtr<std::stringstream> ss;
+
−  if (consoleNeedsDisplayList) {
+
−    ss = MakeUnique<std::stringstream>();
+
−    Document* doc = presContext->Document();
+
−    nsAutoString uri;
+
−    if (doc && doc->GetDocumentURI(uri) == NS_OK) {
+
−      *ss << "Display list for " << uri << "\n";
+
−    }
+
−    DumpBeforePaintDisplayList(ss, builder, list, visibleRect);
+
−  }
+
−
+
−  uint32_t flags = nsDisplayList::PAINT_DEFAULT;
+
−  if (aFlags & PaintFrameFlags::WidgetLayers) {
+
−    flags |= nsDisplayList::PAINT_USE_WIDGET_LAYERS;
+
−    if (!(aFlags & PaintFrameFlags::DocumentRelative)) {
+
−      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::ExistingTransaction) {
+
−    flags |= nsDisplayList::PAINT_EXISTING_TRANSACTION;
+
−  }
+
−  if (aFlags & PaintFrameFlags::NoComposite) {
+
−    flags |= nsDisplayList::PAINT_NO_COMPOSITE;
+
−  }
+
−  if (aFlags & PaintFrameFlags::Compressed) {
+
−    flags |= nsDisplayList::PAINT_COMPRESSED;
+
−  }
+
−  if (updateState == PartialUpdateResult::NoChange && !aRenderingContext) {
+
−    flags |= nsDisplayList::PAINT_IDENTICAL_DISPLAY_LIST;
+
−  }
+
−
+
−#ifdef PRINT_HITTESTINFO_STATS
+
−  if (XRE_IsContentProcess()) {
+
−    PrintHitTestInfoStats(list);
+
−  }
+
−#endif
+
−
+
−  TimeStamp paintStart = TimeStamp::Now();
+
−  list->PaintRoot(builder, aRenderingContext, flags, Some(geckoDLBuildTime));
+
−  Telemetry::AccumulateTimeDelta(Telemetry::PAINT_RASTERIZE_TIME, paintStart);
+
−
+
−  if (builder->IsPaintingToWindow()) {
+
−    presShell->EndPaint();
+
−  }
+
−  builder->Check();
+
−
+
−  if (consoleNeedsDisplayList) {
+
−    DumpAfterPaintDisplayList(ss, builder, list);
+
−  }
+
−
+
−#ifdef MOZ_DUMP_PAINTING
+
−  gfxUtils::sDumpPaintFile = savedDumpFile;
+
−#endif
+
−
+
−  // Update the widget's opaque region information. This sets
+
−  // glass boundaries on Windows. Also set up the window dragging region.
+
−  if ((aFlags & PaintFrameFlags::WidgetLayers) &&
+
−      !(aFlags & PaintFrameFlags::DocumentRelative)) {
+
−    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());
+
−    }
+
−  }
+
−
+
−  // Apply effects updates if we were actually painting
+
−  if (isForPainting) {
+
−    ApplyEffectsUpdates(builder->GetEffectUpdates());
+
−  }
+
−
+
−  builder->Check();
+
−
+
−  {
+
−    AUTO_PROFILER_TRACING_MARKER("Paint", "DisplayListResources", GRAPHICS);
+
−
+
−    builder->EndFrame();
+
−
+
−    if (!useRetainedBuilder) {
+
−      temporaryBuilder.reset();
+
−    }
+
−  }
+
−
+
−#if 0
+
−  if (XRE_IsParentProcess()) {
+
−    if (metrics->mPartialUpdateResult == PartialUpdateResult::Failed) {
+
−      printf("DL partial update failed: %s, Frame: %p\n",
+
−             metrics->FailReasonString(), aFrame);
+
−    } else {
+
−      printf(
+
−          "DL partial build success!"
+
−          " new: %d, reused: %d, rebuilt: %d, removed: %d, total: %d\n",
+
−          metrics->mNewItems, metrics->mReusedItems, metrics->mRebuiltItems,
+
−          metrics->mRemovedItems, metrics->mTotalItems);
+
−    }
+
−  }
+
−#endif
+
−}
+
−
+
−/**
+
− * 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;
+
−}
+
−
+
−void nsLayoutUtils::AddBoxesForFrame(nsIFrame* aFrame,
+
−                                     nsLayoutUtils::BoxCallback* aCallback) {
+
−  auto pseudoType = aFrame->Style()->GetPseudoType();
+
−
+
−  if (pseudoType == PseudoStyleType::tableWrapper) {
+
−    AddBoxesForFrame(aFrame->PrincipalChildList().FirstChild(), aCallback);
+
−    if (aCallback->mIncludeCaptionBoxForTable) {
+
−      nsIFrame* kid = aFrame->GetChildList(nsIFrame::kCaptionList).FirstChild();
+
−      if (kid) {
+
−        AddBoxesForFrame(kid, aCallback);
+
−      }
+
−    }
+
−  } else if (pseudoType == PseudoStyleType::mozBlockInsideInlineWrapper ||
+
−             pseudoType == PseudoStyleType::mozMathMLAnonymousBlock ||
+
−             pseudoType == PseudoStyleType::mozXULAnonymousBlock) {
+
−    for (nsIFrame* kid : aFrame->PrincipalChildList()) {
+
−      AddBoxesForFrame(kid, aCallback);
+
−    }
+
−  } else {
+
−    aCallback->AddBox(aFrame);
+
−  }
+
−}
+
−
+
−void nsLayoutUtils::GetAllInFlowBoxes(nsIFrame* aFrame,
+
−                                      BoxCallback* aCallback) {
+
−  aCallback->mInTargetContinuation = false;
+
−  while (aFrame) {
+
−    AddBoxesForFrame(aFrame, aCallback);
+
−    aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame);
+
−    aCallback->mInTargetContinuation = true;
+
−  }
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::GetFirstNonAnonymousFrame(nsIFrame* aFrame) {
+
−  while (aFrame) {
+
−    auto pseudoType = aFrame->Style()->GetPseudoType();
+
−
+
−    if (pseudoType == PseudoStyleType::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 == PseudoStyleType::mozBlockInsideInlineWrapper ||
+
−               pseudoType == PseudoStyleType::mozMathMLAnonymousBlock ||
+
−               pseudoType == PseudoStyleType::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 {
+
−  const nsIFrame* mRelativeTo;
+
−  RectCallback* mCallback;
+
−  uint32_t mFlags;
+
−  // If the frame we're measuring relative to is the root, we know all frames
+
−  // are descendants of it, so we don't need to compute the common ancestor
+
−  // between a frame and mRelativeTo.
+
−  bool mRelativeToIsRoot;
+
−  // For the same reason, if the frame we're measuring relative to is the target
+
−  // (this is useful for IntersectionObserver), we know all frames are
+
−  // descendants of it except if we're in a continuation or ib-split-sibling of
+
−  // it.
+
−  bool mRelativeToIsTarget;
+
−
+
−  BoxToRect(const nsIFrame* aTargetFrame, const nsIFrame* aRelativeTo,
+
−            RectCallback* aCallback, uint32_t aFlags)
+
−      : mRelativeTo(aRelativeTo),
+
−        mCallback(aCallback),
+
−        mFlags(aFlags),
+
−        mRelativeToIsRoot(!aRelativeTo->GetParent()),
+
−        mRelativeToIsTarget(aRelativeTo == aTargetFrame) {}
+
−
+
−  void AddBox(nsIFrame* aFrame) override {
+
−    nsRect r;
+
−    nsIFrame* outer = SVGUtils::GetOuterSVGFrameAndCoveredRegion(aFrame, &r);
+
−    const bool usingSVGOuterFrame = !!outer;
+
−    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) {
+
−      const bool isAncestorKnown = [&] {
+
−        if (mRelativeToIsRoot) {
+
−          return true;
+
−        }
+
−        if (mRelativeToIsTarget && !mInTargetContinuation) {
+
−          return !usingSVGOuterFrame;
+
−        }
+
−        return false;
+
−      }();
+
−      if (isAncestorKnown) {
+
−        r = nsLayoutUtils::TransformFrameRectToAncestor(outer, r, mRelativeTo);
+
−      } else {
+
−        nsLayoutUtils::TransformRect(outer, mRelativeTo, r);
+
−      }
+
−    } else {
+
−      r += outer->GetOffsetTo(mRelativeTo);
+
−    }
+
−    mCallback->AddRect(r);
+
−  }
+
−};
+
−
+
−struct MOZ_RAII BoxToRectAndText : public BoxToRect {
+
−  Sequence<nsString>* mTextList;
+
−
+
−  BoxToRectAndText(const nsIFrame* aTargetFrame, const nsIFrame* aRelativeTo,
+
−                   RectCallback* aCallback, Sequence<nsString>* aTextList,
+
−                   uint32_t aFlags)
+
−      : BoxToRect(aTargetFrame, aRelativeTo, aCallback, aFlags),
+
−        mTextList(aTextList) {}
+
−
+
−  static void AccumulateText(nsIFrame* aFrame, nsAString& aResult) {
+
−    MOZ_ASSERT(aFrame);
+
−
+
−    // Get all the text in aFrame and child frames, while respecting
+
−    // the content offsets in each of the nsTextFrames.
+
−    if (aFrame->IsTextFrame()) {
+
−      nsTextFrame* textFrame = static_cast<nsTextFrame*>(aFrame);
+
−
+
−      nsIFrame::RenderedText renderedText = textFrame->GetRenderedText(
+
−          textFrame->GetContentOffset(),
+
−          textFrame->GetContentOffset() + textFrame->GetContentLength(),
+
−          nsIFrame::TextOffsetType::OffsetsInContentText,
+
−          nsIFrame::TrailingWhitespace::DontTrim);
+
−
+
−      aResult.Append(renderedText.mString);
+
−    }
+
−
+
−    for (nsIFrame* child = aFrame->PrincipalChildList().FirstChild(); child;
+
−         child = child->GetNextSibling()) {
+
−      AccumulateText(child, aResult);
+
−    }
+
−  }
+
−
+
−  void AddBox(nsIFrame* aFrame) override {
+
−    BoxToRect::AddBox(aFrame);
+
−    if (mTextList) {
+
−      nsString* textForFrame = mTextList->AppendElement(fallible);
+
−      if (textForFrame) {
+
−        AccumulateText(aFrame, *textForFrame);
+
−      }
+
−    }
+
−  }
+
−};
+
−
+
−void nsLayoutUtils::GetAllInFlowRects(nsIFrame* aFrame,
+
−                                      const nsIFrame* aRelativeTo,
+
−                                      RectCallback* aCallback,
+
−                                      uint32_t aFlags) {
+
−  BoxToRect converter(aFrame, aRelativeTo, aCallback, aFlags);
+
−  GetAllInFlowBoxes(aFrame, &converter);
+
−}
+
−
+
−void nsLayoutUtils::GetAllInFlowRectsAndTexts(nsIFrame* aFrame,
+
−                                              const nsIFrame* aRelativeTo,
+
−                                              RectCallback* aCallback,
+
−                                              Sequence<nsString>* aTextList,
+
−                                              uint32_t aFlags) {
+
−  BoxToRectAndText converter(aFrame, 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->PresShell()->GetRootFrame();
+
−}
+
−
+
−nsRect nsLayoutUtils::GetAllInFlowRectsUnion(nsIFrame* aFrame,
+
−                                             const 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();
+
−  auto shadows = textStyle->mTextShadow.AsSpan();
+
−  if (shadows.IsEmpty()) {
+
−    return aTextAndDecorationsRect;
+
−  }
+
−
+
−  nsRect resultRect = aTextAndDecorationsRect;
+
−  int32_t A2D = aFrame->PresContext()->AppUnitsPerDevPixel();
+
−  for (auto& shadow : shadows) {
+
−    nsMargin blur =
+
−        nsContextBoxBlur::GetBlurRadiusMargin(shadow.blur.ToAppUnits(), A2D);
+
−    if ((aFlags & EXCLUDE_BLUR_SHADOWS) && blur != nsMargin(0, 0, 0, 0))
+
−      continue;
+
−
+
−    nsRect tmpRect(aTextAndDecorationsRect);
+
−
+
−    tmpRect.MoveBy(
+
−        nsPoint(shadow.horizontal.ToAppUnits(), shadow.vertical.ToAppUnits()));
+
−    tmpRect.Inflate(blur);
+
−
+
−    resultRect.UnionRect(resultRect, tmpRect);
+
−  }
+
−  return resultRect;
+
−}
+
−
+
−enum ObjectDimensionType { eWidth, eHeight };
+
−static nscoord ComputeMissingDimension(
+
−    const nsSize& aDefaultObjectSize, const AspectRatio& 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) {
+
−    // Fill in the missing dimension using the intrinsic aspect ratio.
+
−    if (aDimensionToCompute == eWidth) {
+
−      return aIntrinsicRatio.ApplyTo(*aSpecifiedHeight);
+
−    }
+
−    return aIntrinsicRatio.Inverted().ApplyTo(*aSpecifiedWidth);
+
−  }
+
−
+
−  // 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 AspectRatio& 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:
+
−  const Maybe<nscoord>& specifiedWidth = aIntrinsicSize.width;
+
−  const Maybe<nscoord>& specifiedHeight = aIntrinsicSize.height;
+
−
+
−  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 AspectRatio& aIntrinsicRatio,
+
−                                        StyleObjectFit 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 == StyleObjectFit::Fill) || !aIntrinsicRatio) {
+
−    return aConstraintSize;
+
−  }
+
−
+
−  // The type of constraint to compute (cover/contain), if needed:
+
−  Maybe<nsImageRenderer::FitType> fitType;
+
−
+
−  Maybe<nsSize> noneSize;
+
−  if (aObjectFit == StyleObjectFit::None ||
+
−      aObjectFit == StyleObjectFit::ScaleDown) {
+
−    noneSize = MaybeComputeObjectFitNoneSize(aConstraintSize, aIntrinsicSize,
+
−                                             aIntrinsicRatio);
+
−    if (!noneSize || aObjectFit == StyleObjectFit::ScaleDown) {
+
−      // 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 == StyleObjectFit::Cover) {
+
−    fitType.emplace(nsImageRenderer::COVER);
+
−  } else if (aObjectFit == StyleObjectFit::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 StyleObjectFit::Fill; we handled it w/ early-return.
+
−    case StyleObjectFit::Contain:
+
−    case StyleObjectFit::Cover:
+
−      MOZ_ASSERT(constrainedSize);
+
−      return *constrainedSize;
+
−
+
−    case StyleObjectFit::None:
+
−      if (noneSize) {
+
−        return *noneSize;
+
−      }
+
−      MOZ_ASSERT(constrainedSize);
+
−      return *constrainedSize;
+
−
+
−    case StyleObjectFit::ScaleDown:
+
−      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 LengthPercentage& aCoord) {
+
−  return aCoord.ConvertsToPercentage() && aCoord.ToPercentage() == 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 Position& objectPos = aStylePos->mObjectPosition;
+
−
+
−  return aStylePos->mObjectFit == StyleObjectFit::Fill &&
+
−         IsCoord50Pct(objectPos.horizontal) && IsCoord50Pct(objectPos.vertical);
+
−}
+
−
+
−/* static */
+
−nsRect nsLayoutUtils::ComputeObjectDestRect(const nsRect& aConstraintRect,
+
−                                            const IntrinsicSize& aIntrinsicSize,
+
−                                            const AspectRatio& 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) {
+
−  ComputedStyle* computedStyle = aFrame->Style();
+
−  uint8_t variantWidth = NS_FONT_VARIANT_WIDTH_NORMAL;
+
−  if (computedStyle->IsTextCombined()) {
+
−    MOZ_ASSERT(aFrame->IsTextFrame());
+
−    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 GetFontMetricsForComputedStyle(computedStyle, aFrame->PresContext(),
+
−                                        aInflation, variantWidth);
+
−}
+
−
+
−already_AddRefed<nsFontMetrics> nsLayoutUtils::GetFontMetricsForComputedStyle(
+
−    ComputedStyle* aComputedStyle, nsPresContext* aPresContext,
+
−    float aInflation, uint8_t aVariantWidth) {
+
−  WritingMode wm(aComputedStyle);
+
−  const nsStyleFont* styleFont = aComputedStyle->StyleFont();
+
−  nsFontMetrics::Params params;
+
−  params.language = styleFont->mLanguage;
+
−  params.explicitLanguage = styleFont->mExplicitLanguage;
+
−  params.orientation = wm.IsVertical() && !wm.IsSideways()
+
−                           ? nsFontMetrics::eVertical
+
−                           : nsFontMetrics::eHorizontal;
+
−  // pass the user font set object into the device context to
+
−  // pass along to CreateFontGroup
+
−  params.userFontSet = aPresContext->GetUserFontSet();
+
−  params.textPerf = aPresContext->GetTextPerfMetrics();
+
−  params.featureValueLookup = aPresContext->GetFontFeatureValuesLookup();
+
−
+
−  // 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 aPresContext->GetMetricsFor(styleFont->mFont, params);
+
−  }
+
−
+
−  nsFont font = styleFont->mFont;
+
−  MOZ_ASSERT(!IsNaN(float(font.size.ToCSSPixels())),
+
−             "Style font should never be NaN");
+
−  font.size.ScaleBy(aInflation);
+
−  if (MOZ_UNLIKELY(IsNaN(float(font.size.ToCSSPixels())))) {
+
−    font.size = {0};
+
−  }
+
−  font.variantWidth = aVariantWidth;
+
−  return aPresContext->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::FindNearestBlockAncestor(nsIFrame* aFrame) {
+
−  nsIFrame* nextAncestor;
+
−  for (nextAncestor = aFrame->GetParent(); nextAncestor;
+
−       nextAncestor = nextAncestor->GetParent()) {
+
−    nsBlockFrame* block = do_QueryFrame(nextAncestor);
+
−    if (block) return block;
+
−  }
+
−  return nullptr;
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::GetNonGeneratedAncestor(nsIFrame* aFrame) {
+
−  if (!aFrame->HasAnyStateBits(NS_FRAME_GENERATED_CONTENT)) return aFrame;
+
−
+
−  nsIFrame* f = aFrame;
+
−  do {
+
−    f = GetParentOrPlaceholderFor(f);
+
−  } while (f->HasAnyStateBits(NS_FRAME_GENERATED_CONTENT));
+
−  return f;
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::GetParentOrPlaceholderFor(const nsIFrame* aFrame) {
+
−  if (aFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) &&
+
−      !aFrame->GetPrevInFlow()) {
+
−    return aFrame->GetProperty(nsIFrame::PlaceholderFrameProperty());
+
−  }
+
−  return aFrame->GetParent();
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(
+
−    const nsIFrame* aFrame) {
+
−  nsIFrame* f = GetParentOrPlaceholderFor(aFrame);
+
−  if (f) return f;
+
−  return GetCrossDocParentFrameInProcess(aFrame);
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::GetDisplayListParent(nsIFrame* aFrame) {
+
−  if (aFrame->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT)) {
+
−    return aFrame->GetParent();
+
−  }
+
−  return nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(aFrame);
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::GetPrevContinuationOrIBSplitSibling(
+
−    const nsIFrame* aFrame) {
+
−  if (nsIFrame* result = aFrame->GetPrevContinuation()) {
+
−    return result;
+
−  }
+
−
+
−  if (aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) {
+
−    // We are the first frame in the continuation chain. Get the ib-split prev
+
−    // sibling property stored in us.
+
−    return aFrame->GetProperty(nsIFrame::IBSplitPrevSibling());
+
−  }
+
−
+
−  return nullptr;
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::GetNextContinuationOrIBSplitSibling(
+
−    const nsIFrame* aFrame) {
+
−  if (nsIFrame* result = aFrame->GetNextContinuation()) {
+
−    return result;
+
−  }
+
−
+
−  if (aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) {
+
−    // We only store the ib-split sibling annotation with the first frame in the
+
−    // continuation chain.
+
−    return aFrame->FirstContinuation()->GetProperty(nsIFrame::IBSplitSibling());
+
−  }
+
−
+
−  return nullptr;
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::FirstContinuationOrIBSplitSibling(
+
−    const nsIFrame* aFrame) {
+
−  nsIFrame* result = aFrame->FirstContinuation();
+
−
+
−  if (result->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) {
+
−    while (auto* f = result->GetProperty(nsIFrame::IBSplitPrevSibling())) {
+
−      result = f;
+
−    }
+
−  }
+
−
+
−  return result;
+
−}
+
−
+
−nsIFrame* nsLayoutUtils::LastContinuationOrIBSplitSibling(
+
−    const nsIFrame* aFrame) {
+
−  nsIFrame* result = aFrame->FirstContinuation();
+
−
+
−  if (result->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) {
+
−    while (auto* f = result->GetProperty(nsIFrame::IBSplitSibling())) {
+
−      result = f;
+
−    }
+
−  }
+
−
+
−  return result->LastContinuation();
+
−}
+
−
+
−bool nsLayoutUtils::IsFirstContinuationOrIBSplitSibling(
+
−    const nsIFrame* aFrame) {
+
−  if (aFrame->GetPrevContinuation()) {
+
−    return false;
+
−  }
+
−  if (aFrame->HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT) &&
+
−      aFrame->GetProperty(nsIFrame::IBSplitPrevSibling())) {
+
−    return false;
+
−  }
+
−
+
−  return true;
+
−}
+
−
+
−bool nsLayoutUtils::IsViewportScrollbarFrame(nsIFrame* aFrame) {
+
−  if (!aFrame) return false;
+
−
+
−  nsIFrame* rootScrollFrame = aFrame->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 paddings / widths / heights, since it clamps negative calc() to
+
− * 0.
+
− */
+
−template <typename LengthPercentageLike>
+
−static bool GetAbsoluteCoord(const LengthPercentageLike& aStyle,
+
−                             nscoord& aResult) {
+
−  if (!aStyle.ConvertsToLength()) {
+
−    return false;
+
−  }
+
−  aResult = std::max(0, aStyle.ToLength());
+
−  return true;
+
−}
+
−
+
−static nscoord GetBSizePercentBasisAdjustment(StyleBoxSizing aBoxSizing,
+
−                                              nsIFrame* aFrame,
+
−                                              bool aHorizontalAxis,
+
−                                              bool aResolvesAgainstPaddingBox);
+
−
+
−static bool GetPercentBSize(const LengthPercentage& aStyle, nsIFrame* aFrame,
+
−                            bool aHorizontalAxis, nscoord& aResult);
+
−
+
−// Only call on style coords for which GetAbsoluteCoord returned false.
+
−template <typename SizeOrMaxSize>
+
−static bool GetPercentBSize(const SizeOrMaxSize& aStyle, nsIFrame* aFrame,
+
−                            bool aHorizontalAxis, nscoord& aResult) {
+
−  if (!aStyle.IsLengthPercentage()) {
+
−    return false;
+
−  }
+
−  return GetPercentBSize(aStyle.AsLengthPercentage(), aFrame, aHorizontalAxis,
+
−                         aResult);
+
−}
+
−
+
−static bool GetPercentBSize(const LengthPercentage& aStyle, nsIFrame* aFrame,
+
−                            bool aHorizontalAxis, nscoord& aResult) {
+
−  if (!aStyle.HasPercent()) {
+
−    return false;
+
−  }
+
−
+
−  MOZ_ASSERT(!aStyle.ConvertsToLength(),
+
−             "GetAbsoluteCoord should have handled this");
+
−
+
−  // During reflow, nsHTMLScrollFrame::ReflowScrolledFrame uses
+
−  // SetComputedHeight on the reflow input 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) {
+
−    MOZ_ASSERT_UNREACHABLE("top of frame tree not a containing block");
+
−    return false;
+
−  }
+
−
+
−  WritingMode wm = f->GetWritingMode();
+
−
+
−  const nsStylePosition* pos = f->StylePosition();
+
−  const auto& bSizeCoord = pos->BSize(wm);
+
−  nscoord h;
+
−  if (!GetAbsoluteCoord(bSizeCoord, h) &&
+
−      !GetPercentBSize(bSizeCoord, f, aHorizontalAxis, h)) {
+
−    LayoutFrameType fType = f->Type();
+
−    if (fType != LayoutFrameType::Viewport &&
+
−        fType != LayoutFrameType::Canvas &&
+
−        fType != LayoutFrameType::PageContent) {
+
−      // 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;
+
−    }
+
−    // 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 auto& maxBSizeCoord = pos->MaxBSize(wm);
+
−
+
−  nscoord maxh;
+
−  if (GetAbsoluteCoord(maxBSizeCoord, maxh) ||
+
−      GetPercentBSize(maxBSizeCoord, f, aHorizontalAxis, maxh)) {
+
−    if (maxh < h) h = maxh;
+
−  }
+
−
+
−  const auto& minBSizeCoord = pos->MinBSize(wm);
+
−
+
−  nscoord minh;
+
−  if (GetAbsoluteCoord(minBSizeCoord, minh) ||
+
−      GetPercentBSize(minBSizeCoord, f, aHorizontalAxis, minh)) {
+
−    if (minh > h) {
+
−      h = minh;
+
−    }
+
−  }
+
−
+
−  // If we're an abspos box, percentages in that case resolve against the
+
−  // padding box.
+
−  //
+
−  // TODO: This could conceivably cause some problems with fieldsets (which are
+
−  // the other 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.
+
−  const bool resolvesAgainstPaddingBox = aFrame->IsAbsolutelyPositioned();
+
−  h += GetBSizePercentBasisAdjustment(pos->mBoxSizing, f, aHorizontalAxis,
+
−                                      resolvesAgainstPaddingBox);
+
−
+
−  aResult = std::max(aStyle.Resolve(std::max(h, 0)), 0);
+
−  return true;
+
−}
+
−
+
−// Return true if aStyle can be resolved to a definite value and if so
+
−// return that value in aResult.
+
−static bool GetDefiniteSize(const LengthPercentage& aStyle, nsIFrame* aFrame,
+
−                            bool aIsInlineAxis,
+
−                            const Maybe<LogicalSize>& aPercentageBasis,
+
−                            nscoord* aResult) {
+
−  if (aStyle.ConvertsToLength()) {
+
−    *aResult = aStyle.ToLength();
+
−    return true;
+
−  }
+
−
+
−  if (!aPercentageBasis) {
+
−    return false;
+
−  }
+
−
+
−  auto wm = aFrame->GetWritingMode();
+
−  nscoord pb = aIsInlineAxis ? aPercentageBasis.value().ISize(wm)
+
−                             : aPercentageBasis.value().BSize(wm);
+
−  if (pb == NS_UNCONSTRAINEDSIZE) {
+
−    return false;
+
−  }
+
−  *aResult = std::max(0, aStyle.Resolve(pb));
+
−  return true;
+
−}
+
−
+
−// Return true if aStyle can be resolved to a definite value and if so
+
−// return that value in aResult.
+
−template <typename SizeOrMaxSize>
+
−static bool GetDefiniteSize(const SizeOrMaxSize& aStyle, nsIFrame* aFrame,
+
−                            bool aIsInlineAxis,
+
−                            const Maybe<LogicalSize>& aPercentageBasis,
+
−                            nscoord* aResult) {
+
−  if (!aStyle.IsLengthPercentage()) {
+
−    return false;
+
−  }
+
−  return GetDefiniteSize(aStyle.AsLengthPercentage(), aFrame, aIsInlineAxis,
+
−                         aPercentageBasis, aResult);
+
−}
+
−
+
−// NOTE: this function will be replaced by GetDefiniteSizeTakenByBoxSizing (bug
+
−// 1363918). Please do not add new uses of this function.
+
−//
+
−// Get the amount of space to add or subtract out of aFrame's 'block-size' or
+
−// property value due its borders and paddings, given the box-sizing value in
+
−// aBoxSizing.
+
−//
+
−// aHorizontalAxis is true if our inline direction is horizontal and our block
+
−// direction is vertical. aResolvesAgainstPaddingBox is true if padding should
+
−// be added or not removed.
+
−static nscoord GetBSizePercentBasisAdjustment(StyleBoxSizing aBoxSizing,
+
−                                              nsIFrame* aFrame,
+
−                                              bool aHorizontalAxis,
+
−                                              bool aResolvesAgainstPaddingBox) {
+
−  nscoord adjustment = 0;
+
−  if (aBoxSizing == StyleBoxSizing::Border) {
+
−    const auto& border = aFrame->StyleBorder()->GetComputedBorder();
+
−    adjustment -= aHorizontalAxis ? border.TopBottom() : border.LeftRight();
+
−  }
+
−  if ((aBoxSizing == StyleBoxSizing::Border) == !aResolvesAgainstPaddingBox) {
+
−    const auto& stylePadding = aFrame->StylePadding()->mPadding;
+
−    const LengthPercentage& paddingStart =
+
−        stylePadding.Get(aHorizontalAxis ? eSideTop : eSideLeft);
+
−    const LengthPercentage& paddingEnd =
+
−        stylePadding.Get(aHorizontalAxis ? eSideBottom : eSideRight);
+
−    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)) {
+
−      adjustment += aResolvesAgainstPaddingBox ? pad : -pad;
+
−    }
+
−    if (GetAbsoluteCoord(paddingEnd, pad) ||
+
−        GetPercentBSize(paddingEnd, aFrame, aHorizontalAxis, pad)) {
+
−      adjustment += aResolvesAgainstPaddingBox ? pad : -pad;
+
−    }
+
−  }
+
−  return adjustment;
+
−}
+
−
+
−// Get the amount of 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.
+
−// aIsInlineAxis is true if we're computing for aFrame's inline axis.
+
−// aIgnorePadding is true if padding should be ignored.
+
−static nscoord GetDefiniteSizeTakenByBoxSizing(
+
−    StyleBoxSizing aBoxSizing, nsIFrame* aFrame, bool aIsInlineAxis,
+
−    bool aIgnorePadding, const Maybe<LogicalSize>& aPercentageBasis) {
+
−  nscoord sizeTakenByBoxSizing = 0;
+
−  if (MOZ_UNLIKELY(aBoxSizing == StyleBoxSizing::Border)) {
+
−    const bool isHorizontalAxis =
+
−        aIsInlineAxis == !aFrame->GetWritingMode().IsVertical();
+
−    const nsStyleBorder* styleBorder = aFrame->StyleBorder();
+
−    sizeTakenByBoxSizing = isHorizontalAxis
+
−                               ? styleBorder->GetComputedBorder().LeftRight()
+
−                               : styleBorder->GetComputedBorder().TopBottom();
+
−    if (!aIgnorePadding) {
+
−      const auto& stylePadding = aFrame->StylePadding()->mPadding;
+
−      const LengthPercentage& pStart =
+
−          stylePadding.Get(isHorizontalAxis ? eSideLeft : eSideTop);
+
−      const LengthPercentage& pEnd =
+
−          stylePadding.Get(isHorizontalAxis ? eSideRight : eSideBottom);
+
−      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 (GetDefiniteSize(pStart, aFrame, aIsInlineAxis, aPercentageBasis,
+
−                          &pad) ||
+
−          (aPercentageBasis.isNothing() &&
+
−           GetPercentBSize(pStart, aFrame, isHorizontalAxis, pad))) {
+
−        sizeTakenByBoxSizing += pad;
+
−      }
+
−      if (GetDefiniteSize(pEnd, aFrame, aIsInlineAxis, aPercentageBasis,
+
−                          &pad) ||
+
−          (aPercentageBasis.isNothing() &&
+
−           GetPercentBSize(pEnd, aFrame, isHorizontalAxis, pad))) {
+
−        sizeTakenByBoxSizing += pad;
+
−      }
+
−    }
+
−  }
+
−  return sizeTakenByBoxSizing;
+
−}
+
−
+
−// Handles only max-content and 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.
+
−static bool GetIntrinsicCoord(nsIFrame::ExtremumLength aStyle,
+
−                              gfxContext* aRenderingContext, nsIFrame* aFrame,
+
−                              Maybe<nscoord> aInlineSizeFromAspectRatio,
+
−                              nsIFrame::SizeProperty aProperty,
+
−                              nscoord& aResult) {
+
−  if (aStyle == nsIFrame::ExtremumLength::MozAvailable) {
+
−    return false;
+
−  }
+
−
+
−  if (aStyle == nsIFrame::ExtremumLength::FitContentFunction) {
+
−    // fit-content() should be handled by the caller.
+
−    return false;
+
−  }
+
−
+
−  if (aStyle == nsIFrame::ExtremumLength::MozFitContent) {
+
−    switch (aProperty) {
+
−      case nsIFrame::SizeProperty::Size:
+
−        // handle like 'width: auto'
+
−        return false;
+
−      case nsIFrame::SizeProperty::MaxSize:
+
−        // constrain large 'width' values down to max-content
+
−        aStyle = nsIFrame::ExtremumLength::MaxContent;
+
−        break;
+
−      case nsIFrame::SizeProperty::MinSize:
+
−        // constrain small 'width' or 'max-width' values up to min-content
+
−        aStyle = nsIFrame::ExtremumLength::MinContent;
+
−        break;
+
−    }
+
−  }
+
−
+
−  NS_ASSERTION(aStyle == nsIFrame::ExtremumLength::MinContent ||
+
−                   aStyle == nsIFrame::ExtremumLength::MaxContent,
+
−               "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 (aInlineSizeFromAspectRatio) {
+
−    aResult = *aInlineSizeFromAspectRatio;
+
−  } else if (aStyle == nsIFrame::ExtremumLength::MaxContent) {
+
−    aResult = aFrame->GetPrefISize(aRenderingContext);
+
−  } else {
+
−    aResult = aFrame->GetMinISize(aRenderingContext);
+
−  }
+
−  return true;
+
−}
+
−
+
−template <typename SizeOrMaxSize>
+
−static bool GetIntrinsicCoord(const SizeOrMaxSize& aStyle,
+
−                              gfxContext* aRenderingContext, nsIFrame* aFrame,
+
−                              Maybe<nscoord> aInlineSizeFromAspectRatio,
+
−                              nsIFrame::SizeProperty aProperty,
+
−                              nscoord& aResult) {
+
−  auto length = nsIFrame::ToExtremumLength(aStyle);
+
−  if (!length) {
+
−    return false;
+
−  }
+
−  return GetIntrinsicCoord(*length, aRenderingContext, aFrame,
+
−                           aInlineSizeFromAspectRatio, aProperty, aResult);
+
−}
+
−
+
−#undef DEBUG_INTRINSIC_WIDTH
+
−
+
−#ifdef DEBUG_INTRINSIC_WIDTH
+
−static int32_t gNoiseIndent = 0;
+
−#endif
+
−
+
−static nscoord GetFitContentSizeForMaxOrPreferredSize(
+
−    const IntrinsicISizeType aType, const nsIFrame::SizeProperty aProperty,
+
−    const nsIFrame* aFrame, const LengthPercentage& aStyleSize,
+
−    const nscoord aInitialValue, const nscoord aMinContentSize,
+
−    const nscoord aMaxContentSize) {
+
−  MOZ_ASSERT(aProperty != nsIFrame::SizeProperty::MinSize);
+
−
+
−  nscoord size = NS_UNCONSTRAINEDSIZE;
+
−  // 1. Treat fit-content()'s arg as a plain LengthPercentage
+
−  // However, we have to handle the cyclic percentage contribution first.
+
−  //
+
−  // https://drafts.csswg.org/css-sizing-3/#cyclic-percentage-contribution
+
−  if (aType == IntrinsicISizeType::MinISize &&
+
−      aFrame->IsPercentageResolvedAgainstZero(aStyleSize, aProperty)) {
+
−    // Case (c) in the spec.
+
−    // FIXME: This doesn't follow the spec for calc(). We should fix this in
+
−    // Bug 1463700.
+
−    size = 0;
+
−  } else if (!GetAbsoluteCoord(aStyleSize, size)) {
+
−    // As initial value. Case (a) and (b) in the spec.
+
−    size = aInitialValue;
+
−  }
+
−
+
−  // 2. Clamp size by min-content and max-content.
+
−  return std::max(aMinContentSize, std::min(aMaxContentSize, size));
+
−}
+
−
+
−/**
+
− * 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 aInlineSizeFromAspectRatio the content-box inline size computed from
+
− *                                   aspect-ratio and the definite block size.
+
− *                                   We use this value to resolve
+
− *                                   {min|max}-content.
+
− * @param aFlags same as for IntrinsicForContainer
+
− * @param aContainerWM the container's WM
+
− */
+
−static nscoord AddIntrinsicSizeOffset(
+
−    gfxContext* aRenderingContext, nsIFrame* aFrame,
+
−    const nsIFrame::IntrinsicSizeOffsetData& aOffsets, IntrinsicISizeType aType,
+
−    StyleBoxSizing aBoxSizing, nscoord aContentSize, nscoord aContentMinSize,
+
−    const StyleSize& aStyleSize, const nscoord* aFixedMinSize,
+
−    const StyleSize& aStyleMinSize, const nscoord* aFixedMaxSize,
+
−    const StyleMaxSize& aStyleMaxSize,
+
−    Maybe<nscoord> aInlineSizeFromAspectRatio, uint32_t aFlags,
+
−    PhysicalAxis aAxis) {
+
−  nscoord result = aContentSize;
+
−  nscoord min = aContentMinSize;
+
−  nscoord coordOutsideSize = 0;
+
−
+
−  if (!(aFlags & nsLayoutUtils::IGNORE_PADDING)) {
+
−    coordOutsideSize += aOffsets.padding;
+
−  }
+
−
+
−  coordOutsideSize += aOffsets.border;
+
−
+
−  if (aBoxSizing == StyleBoxSizing::Border) {
+
−    min += coordOutsideSize;
+
−    result = NSCoordSaturatingAdd(result, coordOutsideSize);
+
−
+
−    coordOutsideSize = 0;
+
−  }
+
−
+
−  coordOutsideSize += aOffsets.margin;
+
−
+
−  min += coordOutsideSize;
+
−
+
−  // Compute min-content/max-content for fit-content().
+
−  nscoord minContent = 0;
+
−  nscoord maxContent = NS_UNCONSTRAINEDSIZE;
+
−  if (aStyleSize.IsFitContentFunction() ||
+
−      aStyleMaxSize.IsFitContentFunction() ||
+
−      aStyleMinSize.IsFitContentFunction()) {
+
−    if (aInlineSizeFromAspectRatio) {
+
−      minContent = maxContent = *aInlineSizeFromAspectRatio;
+
−    } else {
+
−      minContent = aFrame->GetMinISize(aRenderingContext);
+
−      maxContent = aFrame->GetPrefISize(aRenderingContext);
+
−    }
+
−  }
+
−
+
−  // Compute size.
+
−  nscoord size = NS_UNCONSTRAINEDSIZE;
+
−  if (aType == IntrinsicISizeType::MinISize &&
+
−      aFrame->IsPercentageResolvedAgainstZero(aStyleSize, aStyleMaxSize)) {
+
−    // XXX bug 1463700: this doesn't handle calc() according to spec
+
−    result = 0;  // let |min| handle padding/border/margin
+
−  } else if (GetAbsoluteCoord(aStyleSize, size) ||
+
−             GetIntrinsicCoord(aStyleSize, aRenderingContext, aFrame,
+
−                               aInlineSizeFromAspectRatio,
+
−                               nsIFrame::SizeProperty::Size, size)) {
+
−    result = size + coordOutsideSize;
+
−  } else if (aStyleSize.IsFitContentFunction()) {
+
−    // |result| here is the content size or border size, depends on
+
−    // StyleBoxSizing. We use it as the initial value when handling the cyclic
+
−    // percentage.
+
−    nscoord initial = result;
+
−    nscoord fitContentFuncSize = GetFitContentSizeForMaxOrPreferredSize(
+
−        aType, nsIFrame::SizeProperty::Size, aFrame,
+
−        aStyleSize.AsFitContentFunction(), initial, minContent, maxContent);
+
−    // Add border and padding.
+
−    result = NSCoordSaturatingAdd(fitContentFuncSize, coordOutsideSize);
+
−  } else {
+
−    result = NSCoordSaturatingAdd(result, coordOutsideSize);
+
−  }
+
−
+
−  // Compute max-size.
+
−  nscoord maxSize = aFixedMaxSize ? *aFixedMaxSize : 0;
+
−  if (aFixedMaxSize ||
+
−      GetIntrinsicCoord(aStyleMaxSize, aRenderingContext, aFrame,
+
−                        aInlineSizeFromAspectRatio,
+
−                        nsIFrame::SizeProperty::MaxSize, maxSize)) {
+
−    maxSize += coordOutsideSize;
+
−    if (result > maxSize) {
+
−      result = maxSize;
+
−    }
+
−  } else if (aStyleMaxSize.IsFitContentFunction()) {
+
−    nscoord fitContentFuncSize = GetFitContentSizeForMaxOrPreferredSize(
+
−        aType, nsIFrame::SizeProperty::MaxSize, aFrame,
+
−        aStyleMaxSize.AsFitContentFunction(), NS_UNCONSTRAINEDSIZE, minContent,
+
−        maxContent);
+
−    maxSize = NSCoordSaturatingAdd(fitContentFuncSize, coordOutsideSize);
+
−    if (result > maxSize) {
+
−      result = maxSize;
+
−    }
+
−  }
+
−
+
−  // Compute min-size.
+
−  nscoord minSize = aFixedMinSize ? *aFixedMinSize : 0;
+
−  if (aFixedMinSize ||
+
−      GetIntrinsicCoord(aStyleMinSize, aRenderingContext, aFrame,
+
−                        aInlineSizeFromAspectRatio,
+
−                        nsIFrame::SizeProperty::MinSize, minSize)) {
+
−    minSize += coordOutsideSize;
+
−    if (result < minSize) {
+
−      result = minSize;
+
−    }
+
−  } else if (aStyleMinSize.IsFitContentFunction()) {
+
−    if (!GetAbsoluteCoord(aStyleMinSize.AsFitContentFunction(), minSize)) {
+
−      // FIXME: Bug 1463700, we should resolve only the percentage part to 0
+
−      // such as min-width: fit-content(calc(50% + 50px)).
+
−      minSize = 0;
+
−    }
+
−    nscoord fitContentFuncSize =
+
−        std::max(minContent, std::min(maxContent, minSize));
+
−    minSize = NSCoordSaturatingAdd(fitContentFuncSize, coordOutsideSize);
+
−    if (result < minSize) {
+
−      result = minSize;
+
−    }
+
−  }
+
−
+
−  if (result < min) {
+
−    result = min;
+
−  }
+
−
+
−  const nsStyleDisplay* disp = aFrame->StyleDisplay();
+
−  if (aFrame->IsThemed(disp)) {
+
−    LayoutDeviceIntSize devSize;
+
−    bool canOverride = true;
+
−    nsPresContext* pc = aFrame->PresContext();
+
−    pc->Theme()->GetMinimumWidgetSize(pc, aFrame, disp->EffectiveAppearance(),
+
−                                      &devSize, &canOverride);
+
−    nscoord themeSize = pc->DevPixelsToAppUnits(
+
−        aAxis == eAxisVertical ? devSize.height : devSize.width);
+
−    // GetMinimumWidgetSize() returns a border-box width.
+
−    themeSize += aOffsets.margin;
+
−    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, gfxContext* aRenderingContext, nsIFrame* aFrame,
+
−    IntrinsicISizeType aType, const Maybe<LogicalSize>& aPercentageBasis,
+
−    uint32_t aFlags, nscoord aMarginBoxMinSizeClamp) {
+
−  MOZ_ASSERT(aFrame, "null frame");
+
−  MOZ_ASSERT(aFrame->GetParent(),
+
−             "IntrinsicForAxis called on frame not in tree");
+
−  MOZ_ASSERT(aFrame->GetParent()->Type() != LayoutFrameType::GridContainer ||
+
−                 aPercentageBasis.isSome(),
+
−             "grid layout should always pass a percentage basis");
+
−
+
−  const bool horizontalAxis = MOZ_LIKELY(aAxis == eAxisHorizontal);
+
−#ifdef DEBUG_INTRINSIC_WIDTH
+
−  nsIFrame::IndentBy(stderr, gNoiseIndent);
+
−  aFrame->ListTag(stderr);
+
−  printf_stderr(" %s %s intrinsic size for container:\n",
+
−                aType == IntrinsicISizeType::MinISize ? "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;
+
−
+
−  StyleSize styleMinISize =
+
−      horizontalAxis ? stylePos->mMinWidth : stylePos->mMinHeight;
+
−  StyleSize styleISize =
+
−      (aFlags & MIN_INTRINSIC_ISIZE)
+
−          ? styleMinISize
+
−          : (horizontalAxis ? stylePos->mWidth : stylePos->mHeight);
+
−  MOZ_ASSERT(!(aFlags & MIN_INTRINSIC_ISIZE) || styleISize.IsAuto() ||
+
−                 nsIFrame::ToExtremumLength(styleISize),
+
−             "should only use MIN_INTRINSIC_ISIZE for intrinsic values");
+
−  StyleMaxSize styleMaxISize =
+
−      horizontalAxis ? stylePos->mMaxWidth : stylePos->mMaxHeight;
+
−
+
−  PhysicalAxis ourInlineAxis =
+
−      aFrame->GetWritingMode().PhysicalAxis(eLogicalAxisInline);
+
−  const bool isInlineAxis = aAxis == ourInlineAxis;
+
−
+
−  auto resetIfKeywords = [](StyleSize& aSize, StyleSize& aMinSize,
+
−                            StyleMaxSize& aMaxSize) {
+
−    if (!aSize.IsLengthPercentage()) {
+
−      aSize = StyleSize::Auto();
+
−    }
+
−    if (!aMinSize.IsLengthPercentage()) {
+
−      aMinSize = StyleSize::Auto();
+
−    }
+
−    if (!aMaxSize.IsLengthPercentage()) {
+
−      aMaxSize = StyleMaxSize::None();
+
−    }
+
−  };
+
−  // According to the spec, max-content and min-content should behave as the
+
−  // property's initial values in block axis.
+
−  // It also make senses to use the initial values for -moz-fit-content and
+
−  // -moz-available for intrinsic size in block axis. Therefore, we reset them
+
−  // if needed.
+
−  if (!isInlineAxis) {
+
−    resetIfKeywords(styleISize, styleMinISize, styleMaxISize);
+
−  }
+
−
+
−  // 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 (styleMinISize.IsAuto()) {
+
−    // 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);
+
−  }
+
−
+
−  auto childWM = aFrame->GetWritingMode();
+
−  nscoord pmPercentageBasis = NS_UNCONSTRAINEDSIZE;
+
−  if (aPercentageBasis.isSome()) {
+
−    // The padding/margin percentage basis is the inline-size in the parent's
+
−    // writing-mode.
+
−    pmPercentageBasis =
+
−        aFrame->GetParent()->GetWritingMode().IsOrthogonalTo(childWM)
+
−            ? aPercentageBasis->BSize(childWM)
+
−            : aPercentageBasis->ISize(childWM);
+
−  }
+
−  nsIFrame::IntrinsicSizeOffsetData offsets =
+
−      MOZ_LIKELY(isInlineAxis)
+
−          ? aFrame->IntrinsicISizeOffsets(pmPercentageBasis)
+
−          : aFrame->IntrinsicBSizeOffsets(pmPercentageBasis);
+
−
+
−  auto getContentBoxSizeToBoxSizingAdjust =
+
−      [childWM, &offsets, &aFrame, isInlineAxis,
+
−       pmPercentageBasis](const StyleBoxSizing aBoxSizing) {
+
−        return aBoxSizing == StyleBoxSizing::Border
+
−                   ? LogicalSize(childWM,
+
−                                 (isInlineAxis ? offsets
+
−                                               : aFrame->IntrinsicISizeOffsets(
+
−                                                     pmPercentageBasis))
+
−                                     .BorderPadding(),
+
−                                 (!isInlineAxis ? offsets
+
−                                                : aFrame->IntrinsicBSizeOffsets(
+
−                                                      pmPercentageBasis))
+
−                                     .BorderPadding())
+
−                   : LogicalSize(childWM);
+
−      };
+
−
+
−  Maybe<nscoord> inlineSizeFromAspectRatio;
+
−  Maybe<LogicalSize> contentBoxSizeToBoxSizingAdjust;
+
−
+
−  const bool ignorePadding =
+
−      (aFlags & IGNORE_PADDING) || aFrame->IsAbsolutelyPositioned();
+
−
+
−  // 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.IsMaxContent() || styleISize.IsMinContent()) {
+
−    MOZ_ASSERT(isInlineAxis);
+
−    // -moz-fit-content and -moz-available enumerated widths compute intrinsic
+
−    // widths just like auto.
+
−    // For max-content and min-content, we handle them like
+
−    // specified widths, but ignore box-sizing.
+
−    boxSizing = StyleBoxSizing::Content;
+
−  } else if (!styleISize.ConvertsToLength() &&
+
−             !(styleISize.IsFitContentFunction() &&
+
−               styleISize.AsFitContentFunction().ConvertsToLength()) &&
+
−             !(haveFixedMinISize && haveFixedMaxISize &&
+
−               maxISize <= minISize)) {
+
−#ifdef DEBUG_INTRINSIC_WIDTH
+
−    ++gNoiseIndent;
+
−#endif
+
−    if (MOZ_UNLIKELY(!isInlineAxis)) {
+
−      IntrinsicSize intrinsicSize = aFrame->GetIntrinsicSize();
+
−      const auto& intrinsicBSize =
+
−          horizontalAxis ? intrinsicSize.width : intrinsicSize.height;
+
−      if (intrinsicBSize) {
+
−        result = *intrinsicBSize;
+
−      } 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_ISIZE_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 == IntrinsicISizeType::MinISize
+
−                   ? aFrame->GetMinISize(aRenderingContext)
+
−                   : aFrame->GetPrefISize(aRenderingContext);
+
−    }
+
−#ifdef DEBUG_INTRINSIC_WIDTH
+
−    --gNoiseIndent;
+
−    nsIFrame::IndentBy(stderr, gNoiseIndent);
+
−    aFrame->ListTag(stderr);
+
−    printf_stderr(" %s %s intrinsic size from frame is %d.\n",
+
−                  aType == IntrinsicISizeType::MinISize ? "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:
+
−    // 1. 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.
+
−    // 2. The 'B' in |styleBSize|, |styleMinBSize|, and |styleMaxBSize|
+
−    // represents the ratio-determining axis of |aFrame|. It could be the inline
+
−    // axis or the block axis of |aFrame|. (So we are calculating the size
+
−    // along the ratio-dependent axis in this if-branch.)
+
−    StyleSize styleBSize =
+
−        horizontalAxis ? stylePos->mHeight : stylePos->mWidth;
+
−    StyleSize styleMinBSize =
+
−        horizontalAxis ? stylePos->mMinHeight : stylePos->mMinWidth;
+
−    StyleMaxSize styleMaxBSize =
+
−        horizontalAxis ? stylePos->mMaxHeight : stylePos->mMaxWidth;
+
−
+
−    // According to the spec, max-content and min-content should behave as the
+
−    // property's initial values in block axis.
+
−    // It also make senses to use the initial values for -moz-fit-content and
+
−    // -moz-available for intrinsic size in block axis. Therefore, we reset them
+
−    // if needed.
+
−    if (isInlineAxis) {
+
−      resetIfKeywords(styleBSize, styleMinBSize, styleMaxBSize);
+
−    }
+
−
+
−    // FIXME(emilio): Why the minBsize == 0 special-case? Also, shouldn't this
+
−    // use BehavesLikeInitialValueOnBlockAxis instead?
+
−    if (!styleBSize.IsAuto() ||
+
−        !(styleMinBSize.IsAuto() || (styleMinBSize.ConvertsToLength() &&
+
−                                     styleMinBSize.ToLength() == 0)) ||
+
−        !styleMaxBSize.IsNone()) {
+
−      if (AspectRatio ratio = aFrame->GetAspectRatio()) {
+
−        AddStateBitToAncestors(
+
−            aFrame, NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE);
+
−
+
−        nscoord bSizeTakenByBoxSizing = GetDefiniteSizeTakenByBoxSizing(
+
−            boxSizing, aFrame, !isInlineAxis, ignorePadding, aPercentageBasis);
+
−        contentBoxSizeToBoxSizingAdjust.emplace(
+
−            getContentBoxSizeToBoxSizingAdjust(boxSizing));
+
−        // 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 (GetDefiniteSize(styleBSize, aFrame, !isInlineAxis, aPercentageBasis,
+
−                            &h) ||
+
−            (aPercentageBasis.isNothing() &&
+
−             GetPercentBSize(styleBSize, aFrame, horizontalAxis, h))) {
+
−          h = std::max(0, h - bSizeTakenByBoxSizing);
+
−          // We are computing the size of |aFrame|, so we use the inline & block
+
−          // dimensions of |aFrame|.
+
−          result = ratio.ComputeRatioDependentSize(
+
−              isInlineAxis ? eLogicalAxisInline : eLogicalAxisBlock, childWM, h,
+
−              *contentBoxSizeToBoxSizingAdjust);
+
−          // We have get the inlineSizeForAspectRatio value, so we don't have to
+
−          // recompute this again below.
+
−          inlineSizeFromAspectRatio.emplace(result);
+
−        }
+
−
+
−        if (GetDefiniteSize(styleMaxBSize, aFrame, !isInlineAxis,
+
−                            aPercentageBasis, &h) ||
+
−            (aPercentageBasis.isNothing() &&
+
−             GetPercentBSize(styleMaxBSize, aFrame, horizontalAxis, h))) {
+
−          h = std::max(0, h - bSizeTakenByBoxSizing);
+
−          nscoord maxISize = ratio.ComputeRatioDependentSize(
+
−              isInlineAxis ? eLogicalAxisInline : eLogicalAxisBlock, childWM, h,
+
−              *contentBoxSizeToBoxSizingAdjust);
+
−          if (maxISize < result) {
+
−            result = maxISize;
+
−          }
+
−          if (maxISize < minContentSize) {
+
−            minContentSize = maxISize;
+
−          }
+
−        }
+
−
+
−        if (GetDefiniteSize(styleMinBSize, aFrame, !isInlineAxis,
+
−                            aPercentageBasis, &h) ||
+
−            (aPercentageBasis.isNothing() &&
+
−             GetPercentBSize(styleMinBSize, aFrame, horizontalAxis, h))) {
+
−          h = std::max(0, h - bSizeTakenByBoxSizing);
+
−          nscoord minISize = ratio.ComputeRatioDependentSize(
+
−              isInlineAxis ? eLogicalAxisInline : eLogicalAxisBlock, childWM, h,
+
−              *contentBoxSizeToBoxSizingAdjust);
+
−          if (minISize > result) {
+
−            result = minISize;
+
−          }
+
−          if (minISize > minContentSize) {
+
−            minContentSize = minISize;
+
−          }
+
−        }
+
−
+
−        if (MOZ_UNLIKELY(aFlags & nsLayoutUtils::MIN_INTRINSIC_ISIZE) &&
+
−            // FIXME: Bug 1715681. Should we use eReplacedSizing instead
+
−            // because eReplaced is set on some other frames which are
+
−            // non-replaced elements, e.g. <select>?
+
−            aFrame->IsFrameOfType(nsIFrame::eReplaced)) {
+
−          // This is the 'min-width/height:auto' "transferred size" piece of:
+
−          // https://drafts.csswg.org/css-flexbox-1/#min-size-auto
+
−          // https://drafts.csswg.org/css-grid/#min-size-auto
+
−          // Per spec, we handle it only for replaced elements.
+
−          result = std::min(result, minContentSize);
+
−        }
+
−      }
+
−    }
+
−  }
+
−
+
−  if (aFrame->IsTableFrame()) {
+
−    // Tables can't shrink smaller than their intrinsic minimum width,
+
−    // no matter what.
+
−    min = aFrame->GetMinISize(aRenderingContext);
+
−  }
+
−
+
−  // If we have an aspect-ratio and a definite block size of |aFrame|, we
+
−  // resolve the {min|max}-content size by the aspect-ratio and the block size.
+
−  // If |aAxis| is not the inline axis of |aFrame|, {min|max}-content should
+
−  // behaves as auto, so we don't need this.
+
−  //
+
−  // FIXME(emilio): For -moz-available it seems we shouldn't need this.
+
−  //
+
−  // https://github.com/w3c/csswg-drafts/issues/5032
+
−  // FIXME: Bug 1670151: Use GetAspectRatio() to cover replaced elements (and
+
−  // then we can drop the check of eSupportsAspectRatio).
+
−  const AspectRatio ar = stylePos->mAspectRatio.ToLayoutRatio();
+
−  if (isInlineAxis && ar && nsIFrame::ToExtremumLength(styleISize) &&
+
−      aFrame->IsFrameOfType(nsIFrame::eSupportsAspectRatio) &&
+
−      !inlineSizeFromAspectRatio) {
+
−    // This 'B' in |styleBSize| means the block size of |aFrame|. We go into
+
−    // this branch only if |aAxis| is the inline axis of |aFrame|.
+
−    const StyleSize& styleBSize =
+
−        horizontalAxis ? stylePos->mHeight : stylePos->mWidth;
+
−    nscoord bSize;
+
−    if (GetDefiniteSize(styleBSize, aFrame, !isInlineAxis, aPercentageBasis,
+
−                        &bSize) ||
+
−        (aPercentageBasis.isNothing() &&
+
−         GetPercentBSize(styleBSize, aFrame, horizontalAxis, bSize))) {
+
−      // We cannot reuse |boxSizing| because it may be updated to content-box
+
−      // in the above if-branch.
+
−      const StyleBoxSizing boxSizingForAR = stylePos->mBoxSizing;
+
−      if (!contentBoxSizeToBoxSizingAdjust) {
+
−        contentBoxSizeToBoxSizingAdjust.emplace(
+
−            getContentBoxSizeToBoxSizingAdjust(boxSizingForAR));
+
−      }
+
−      nscoord bSizeTakenByBoxSizing =
+
−          GetDefiniteSizeTakenByBoxSizing(boxSizingForAR, aFrame, !isInlineAxis,
+
−                                          ignorePadding, aPercentageBasis);
+
−      bSize -= bSizeTakenByBoxSizing;
+
−      inlineSizeFromAspectRatio.emplace(ar.ComputeRatioDependentSize(
+
−          LogicalAxis::eLogicalAxisInline, childWM, bSize,
+
−          *contentBoxSizeToBoxSizingAdjust));
+
−    }
+
−  }
+
−
+
−  nscoord contentBoxSize = result;
+
−  result = AddIntrinsicSizeOffset(
+
−      aRenderingContext, aFrame, offsets, aType, boxSizing, result, min,
+
−      styleISize, haveFixedMinISize ? &minISize : nullptr, styleMinISize,
+
−      haveFixedMaxISize ? &maxISize : nullptr, styleMaxISize,
+
−      inlineSizeFromAspectRatio, 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
+
−  nsIFrame::IndentBy(stderr, gNoiseIndent);
+
−  aFrame->ListTag(stderr);
+
−  printf_stderr(" %s %s intrinsic size for container is %d twips.\n",
+
−                aType == IntrinsicISizeType::MinISize ? "min" : "pref",
+
−                horizontalAxis ? "horizontal" : "vertical", result);
+
−#endif
+
−
+
−  return result;
+
−}
+
−
+
−/* static */
+
−nscoord nsLayoutUtils::IntrinsicForContainer(gfxContext* 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, Nothing(),
+
−                          aFlags);
+
−}
+
−
+
−/* static */
+
−nscoord nsLayoutUtils::MinSizeContributionForAxis(
+
−    PhysicalAxis aAxis, gfxContext* aRC, nsIFrame* aFrame,
+
−    IntrinsicISizeType aType, const LogicalSize& aPercentageBasis,
+
−    uint32_t aFlags) {
+
−  MOZ_ASSERT(aFrame);
+
−  MOZ_ASSERT(aFrame->IsFlexOrGridItem(),
+
−             "only grid/flex items have this behavior currently");
+
−
+
−#ifdef DEBUG_INTRINSIC_WIDTH
+
−  nsIFrame::IndentBy(stderr, gNoiseIndent);
+
−  aFrame->ListTag(stderr);
+
−  printf_stderr(" %s min-isize for %s WM:\n",
+
−                aType == IntrinsicISizeType::MinISize ? "min" : "pref",
+
−                aAxis == eAxisVertical ? "vertical" : "horizontal");
+
−#endif
+
−
+
−  // Note: this method is only meant for grid/flex items.
+
−  const nsStylePosition* const stylePos = aFrame->StylePosition();
+
−  StyleSize size =
+
−      aAxis == eAxisHorizontal ? stylePos->mMinWidth : stylePos->mMinHeight;
+
−  StyleMaxSize maxSize =
+
−      aAxis == eAxisHorizontal ? stylePos->mMaxWidth : stylePos->mMaxHeight;
+
−  auto childWM = aFrame->GetWritingMode();
+
−  PhysicalAxis ourInlineAxis = childWM.PhysicalAxis(eLogicalAxisInline);
+
−  // According to the spec, max-content and min-content should behave as the
+
−  // property's initial values in block axis.
+
−  // It also make senses to use the initial values for -moz-fit-content and
+
−  // -moz-available for intrinsic size in block axis. Therefore, we reset them
+
−  // if needed.
+
−  if (aAxis != ourInlineAxis) {
+
−    if (size.BehavesLikeInitialValueOnBlockAxis()) {
+
−      size = StyleSize::Auto();
+
−    }
+
−    if (maxSize.BehavesLikeInitialValueOnBlockAxis()) {
+
−      maxSize = StyleMaxSize::None();
+
−    }
+
−  }
+
−
+
−  nscoord minSize;
+
−  nscoord* fixedMinSize = nullptr;
+
−  if (size.IsAuto()) {
+
−    if (aFrame->StyleDisplay()->mOverflowX == StyleOverflow::Visible) {
+
−      size = aAxis == eAxisHorizontal ? stylePos->mWidth : stylePos->mHeight;
+
−      // This is same as above: keywords should behaves as property's initial
+
−      // values in block axis.
+
−      if (aAxis != ourInlineAxis && size.BehavesLikeInitialValueOnBlockAxis()) {
+
−        size = StyleSize::Auto();
+
−      }
+
−
+
−      if (GetAbsoluteCoord(size, minSize)) {
+
−        // We have a definite width/height.  This is the "specified size" in:
+
−        // https://drafts.csswg.org/css-grid/#min-size-auto
+
−        fixedMinSize = &minSize;
+
−      } else if (aFrame->IsPercentageResolvedAgainstZero(size, maxSize)) {
+
−        // XXX bug 1463700: this doesn't handle calc() according to spec
+
−        minSize = 0;
+
−        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(size, minSize)) {
+
−    fixedMinSize = &minSize;
+
−  } else if (size.IsLengthPercentage()) {
+
−    MOZ_ASSERT(size.HasPercent());
+
−    minSize = 0;
+
−    fixedMinSize = &minSize;
+
−  }
+
−
+
−  if (!fixedMinSize) {
+
−    // Let the caller deal with the "content size" cases.
+
−#ifdef DEBUG_INTRINSIC_WIDTH
+
−    nsIFrame::IndentBy(stderr, gNoiseIndent);
+
−    aFrame->ListTag(stderr);
+
−    printf_stderr(" %s min-isize is indefinite.\n",
+
−                  aType == IntrinsicISizeType::MinISize ? "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);
+
−
+
−  // The padding/margin percentage basis is the inline-size in the parent's
+
−  // writing-mode.
+
−  nscoord pmPercentageBasis =
+
−      aFrame->GetParent()->GetWritingMode().IsOrthogonalTo(childWM)
+
−          ? aPercentageBasis.BSize(childWM)
+
−          : aPercentageBasis.ISize(childWM);
+
−  nsIFrame::IntrinsicSizeOffsetData offsets =
+
−      ourInlineAxis == aAxis ? aFrame->IntrinsicISizeOffsets(pmPercentageBasis)
+
−                             : aFrame->IntrinsicBSizeOffsets(pmPercentageBasis);
+
−  nscoord result = 0;
+
−  nscoord min = 0;
+
−  // Note: aInlineSizeFromAspectRatio is Nothing() here because we don't handle
+
−  // "content size" cases here (i.e. |fixedMinSize| is false here).
+
−  result = AddIntrinsicSizeOffset(
+
−      aRC, aFrame, offsets, aType, stylePos->mBoxSizing, result, min, size,
+
−      fixedMinSize, size, nullptr, maxSize, Nothing(), aFlags, aAxis);
+
−
+
−#ifdef DEBUG_INTRINSIC_WIDTH
+
−  nsIFrame::IndentBy(stderr, gNoiseIndent);
+
−  aFrame->ListTag(stderr);
+
−  printf_stderr(" %s min-isize is %d twips.\n",
+
−                aType == IntrinsicISizeType::MinISize ? "min" : "pref", result);
+
−#endif
+
−
+
−  return result;
+
−}
+
−
+
−/* static */
+
−nscoord nsLayoutUtils::ComputeBSizeDependentValue(
+
−    nscoord aContainingBlockBSize, const LengthPercentageOrAuto& aCoord) {
+
−  // XXXldb Some callers explicitly check aContainingBlockBSize
+
−  // against NS_UNCONSTRAINEDSIZE *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'.
+
−  MOZ_ASSERT(
+
−      NS_UNCONSTRAINEDSIZE != aContainingBlockBSize || !aCoord.HasPercent(),
+
−      "unexpected containing block block-size");
+
−
+
−  if (aCoord.IsAuto()) {
+
−    return 0;
+
−  }
+
−
+
−  return aCoord.AsLengthPercentage().Resolve(aContainingBlockBSize);
+
−}
+
−
+
−/* 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.PopLastElement();
+
−
+
−    // 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.PopLastElement();
+
−
+
−      f->MarkIntrinsicISizesDirty();
+
−
+
−      if (f->IsPlaceholderFrame()) {
+
−        nsIFrame* oof = nsPlaceholderFrame::GetRealFrameForPlaceholder(f);
+
−        if (!nsLayoutUtils::IsProperAncestorFrame(subtreeRoot, oof)) {
+
−          // We have another distinct subtree we need to mark.
+
−          subtrees.AppendElement(oof);
+
−        }
+
−      }
+
−
+
−      for (const auto& childList : f->ChildLists()) {
+
−        for (nsIFrame* kid : childList.mList) {
+
−          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.PopLastElement();
+
−
+
−    if (!f->HasAnyStateBits(
+
−            NS_FRAME_DESCENDANT_INTRINSIC_ISIZE_DEPENDS_ON_BSIZE)) {
+
−      continue;
+
−    }
+
−    f->MarkIntrinsicISizesDirty();
+
−
+
−    for (const auto& childList : f->ChildLists()) {
+
−      for (nsIFrame* kid : childList.mList) {
+
−        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,
+
−                                          gfxContext* aRenderingContext) {
+
−  NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
+
−               "should not be container for font size inflation");
+
−
+
−  nsIFrame::InlineMinISizeData data;
+
−  DISPLAY_MIN_INLINE_SIZE(aFrame, data.mPrevLines);
+
−  aFrame->AddInlineMinISize(aRenderingContext, &data);
+
−  data.ForceBreak();
+
−  return data.mPrevLines;
+
−}
+
−
+
−/* static */
+
−nscoord nsLayoutUtils::PrefISizeFromInline(nsIFrame* aFrame,
+
−                                           gfxContext* aRenderingContext) {
+
−  NS_ASSERTION(!aFrame->IsContainerForFontSizeInflation(),
+
−               "should not be container for font size inflation");
+
−
+
−  nsIFrame::InlinePrefISizeData data;
+
−  DISPLAY_PREF_INLINE_SIZE(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(nsIFrame* aFrame) {
+
−  nsPresContext* pc = aFrame->PresContext();
+
−  if (pc->GetBackgroundColorDraw() || pc->GetBackgroundImageDraw()) {
+
−    return false;
+
−  }
+
−  return aFrame->StyleVisibility()->mColorAdjust != StyleColorAdjust::Exact;
+
−}
+
−
+
−nscolor nsLayoutUtils::DarkenColorIfNeeded(nsIFrame* aFrame, nscolor aColor) {
+
−  return ShouldDarkenColors(aFrame) ? DarkenColor(aColor) : aColor;
+
−}
+
−
+
−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, gfxContext::SnapOption::IgnoreScale)) {
+
−    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, gfxContext::SnapOption::IgnoreScale)) {
+
−    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,
+
−                                                gfxContext& aContext) {
+
−  nsPresContext* presContext = aFrame->PresContext();
+
−  if (presContext->BidiEnabled()) {
+
−    nsBidiLevel level = nsBidiPresUtils::BidiLevelFromStyle(aFrame->Style());
+
−    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,
+
−                               gfxContext* aContext, const char16_t* aString,
+
−                               int32_t aLength, nsPoint aPoint,
+
−                               ComputedStyle* aComputedStyle,
+
−                               DrawStringFlags aFlags) {
+
−  nsresult rv = NS_ERROR_FAILURE;
+
−
+
−  // If caller didn't pass a style, use the frame's.
+
−  if (!aComputedStyle) {
+
−    aComputedStyle = aFrame->Style();
+
−  }
+
−
+
−  if (aFlags & DrawStringFlags::ForceHorizontal) {
+
−    aFontMetrics.SetVertical(false);
+
−  } else {
+
−    aFontMetrics.SetVertical(WritingMode(aComputedStyle).IsVertical());
+
−  }
+
−
+
−  aFontMetrics.SetTextOrientation(
+
−      aComputedStyle->StyleVisibility()->mTextOrientation);
+
−
+
−  nsPresContext* presContext = aFrame->PresContext();
+
−  if (presContext->BidiEnabled()) {
+
−    nsBidiLevel level = nsBidiPresUtils::BidiLevelFromStyle(aComputedStyle);
+
−    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,
+
−                                     const nsPoint& aPoint,
+
−                                     nsFontMetrics& aFontMetrics,
+
−                                     gfxContext& 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, gfxContext* aContext, const nsRect& aTextRect,
+
−    const nsRect& aDirtyRect, const nscolor& aForegroundColor,
+
−    TextShadowCallback aCallback, void* aCallbackData) {
+
−  const nsStyleText* textStyle = aFrame->StyleText();
+
−  auto shadows = textStyle->mTextShadow.AsSpan();
+
−  if (shadows.IsEmpty()) {
+
−    return;
+
−  }
+
−
+
−  // Text shadow happens with the last value being painted at the back,
+
−  // ie. it is painted first.
+
−  gfxContext* aDestCtx = aContext;
+
−  for (auto& shadow : Reversed(shadows)) {
+
−    nsPoint shadowOffset(shadow.horizontal.ToAppUnits(),
+
−                         shadow.vertical.ToAppUnits());
+
−    nscoord blurRadius = std::max(shadow.blur.ToAppUnits(), 0);
+
−
+
−    nsRect shadowRect(aTextRect);
+
−    shadowRect.MoveBy(shadowOffset);
+
−
+
−    nsPresContext* presCtx = aFrame->PresContext();
+
−    nsContextBoxBlur contextBoxBlur;
+
−
+
−    nscolor shadowColor = shadow.color.CalcColor(aForegroundColor);
+
−
+
−    // Webrender just needs the shadow details
+
−    if (auto* textDrawer = aContext->GetTextDrawer()) {
+
−      wr::Shadow wrShadow;
+
−
+
−      wrShadow.offset = {
+
−          presCtx->AppUnitsToFloatDevPixels(shadow.horizontal.ToAppUnits()),
+
−          presCtx->AppUnitsToFloatDevPixels(shadow.vertical.ToAppUnits())};
+
−
+
−      wrShadow.blur_radius = presCtx->AppUnitsToFloatDevPixels(blurRadius);
+
−      wrShadow.color = wr::ToColorF(ToDeviceColor(shadowColor));
+
−
+
−      // Gecko already inflates the bounding rect of text shadows,
+
−      // so tell WR not to inflate again.
+
−      bool inflate = false;
+
−      textDrawer->AppendShadow(wrShadow, inflate);
+
−      continue;
+
−    }
+
−
+
−    gfxContext* shadowContext = contextBoxBlur.Init(
+
−        shadowRect, 0, blurRadius, presCtx->AppUnitsPerDevPixel(), aDestCtx,
+
−        aDirtyRect, nullptr,
+
−        nsContextBoxBlur::DISABLE_HARDWARE_ACCELERATION_BLUR);
+
−    if (!shadowContext) continue;
+
−
+
−    aDestCtx->Save();
+
−    aDestCtx->NewPath();
+
−    aDestCtx->SetColor(sRGBColor::FromABGR(shadowColor));
+
−
+
−    // The callback will draw whatever we want to blur as a shadow.
+
−    aCallback(shadowContext, 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) {
+
−  if (aFrame->StyleDisplay()->IsContainLayout()) {
+
−    return false;
+
−  }
+
−  const nsBlockFrame* block = do_QueryFrame(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.
+
−    LayoutFrameType fType = aFrame->Type();
+
−    if (fType == LayoutFrameType::TableWrapper ||
+
−        fType == LayoutFrameType::FlexContainer ||
+
−        fType == LayoutFrameType::GridContainer) {
+
−      if ((fType == LayoutFrameType::GridContainer &&
+
−           aFrame->HasAnyStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE)) ||
+
−          (fType == LayoutFrameType::FlexContainer &&
+
−           aFrame->HasAnyStateBits(NS_STATE_FLEX_SYNTHESIZE_BASELINE)) ||
+
−          (fType == LayoutFrameType::TableWrapper &&
+
−           static_cast<const nsTableWrapperFrame*>(aFrame)->GetRowCount() ==
+
−               0)) {
+
−        // empty grid/flex/table container
+
−        aResult->mBStart = 0;
+
−        aResult->mBaseline = aFrame->SynthesizeBaselineBOffsetFromBorderBox(
+
−            aWM, BaselineSharingGroup::First);
+
−        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 == LayoutFrameType::Scroll) {
+
−      nsIScrollableFrame* sFrame = do_QueryFrame(const_cast<nsIFrame*>(aFrame));
+
−      if (!sFrame) {
+
−        MOZ_ASSERT_UNREACHABLE("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 == LayoutFrameType::FieldSet ||
+
−        fType == LayoutFrameType::ColumnSet) {
+
−      LinePosition kidPosition;
+
−      nsIFrame* kid = aFrame->PrincipalChildList().FirstChild();
+
−      // If aFrame is fieldset, kid might be a legend frame here, but that's ok.
+
−      if (kid && GetFirstLinePosition(aWM, kid, &kidPosition)) {
+
−        *aResult = kidPosition +
+
−                   kid->GetLogicalNormalPosition(aWM, aFrame->GetSize()).B(aWM);
+
−        return true;
+
−      }
+
−      return false;
+
−    }
+
−
+
−    // No baseline.
+
−    return false;
+
−  }
+
−
+
−  for (const auto& line : block->Lines()) {
+
−    if (line.IsBlock()) {
+
−      const 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 auto& 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 (0 != line.BSize() || !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) {
+
−  if (aFrame->StyleDisplay()->IsContainLayout()) {
+
−    return false;
+
−  }
+
−
+
−  const nsBlockFrame* block = do_QueryFrame(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->IsScrollFrame()) {
+
−        // Defer to nsIFrame::GetLogicalBaseline (which synthesizes a baseline
+
−        // from the margin-box).
+
−        kidBaseline = kid->GetLogicalBaseline(aWM);
+
−        *aResult = kidBaseline +
+
−                   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()) {
+
−        *aResult = line->BStart() + line->GetLogicalAscent();
+
−        return true;
+
−      }
+
−    }
+
−  }
+
−  return false;
+
−}
+
−
+
−static nscoord CalculateBlockContentBEnd(WritingMode aWM,
+
−                                         nsBlockFrame* aFrame) {
+
−  MOZ_ASSERT(aFrame, "null ptr");
+
−
+
−  nscoord contentBEnd = 0;
+
−
+
−  for (const auto& line : aFrame->Lines()) {
+
−    if (line.IsBlock()) {
+
−      nsIFrame* child = line.mFirstChild;
+
−      const auto& 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) {
+
−  MOZ_ASSERT(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->ScrollableOverflowRect().Size());
+
−  if (overflowSize.BSize(aWM) > contentBEnd) {
+
−    nsIFrame::ChildListIDs skip = {nsIFrame::kOverflowList,
+
−                                   nsIFrame::kExcessOverflowContainersList,
+
−                                   nsIFrame::kOverflowOutOfFlowList};
+
−    nsBlockFrame* blockFrame = do_QueryFrame(aFrame);
+
−    if (blockFrame) {
+
−      contentBEnd =
+
−          std::max(contentBEnd, CalculateBlockContentBEnd(aWM, blockFrame));
+
−      skip += nsIFrame::kPrincipalList;
+
−    }
+
−    for (const auto& [list, listID] : aFrame->ChildLists()) {
+
−      if (!skip.contains(listID)) {
+
−        for (nsIFrame* child : list) {
+
−          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()->IsScrollFrame()))
+
−      break;
+
−  }
+
−  if (layer) return layer;
+
−  return aFrame->PresShell()->GetRootFrame();
+
−}
+
−
+
−SamplingFilter nsLayoutUtils::GetSamplingFilterForFrame(nsIFrame* aForFrame) {
+
−  switch (aForFrame->UsedImageRendering()) {
+
−    case StyleImageRendering::Smooth:
+
−    case StyleImageRendering::Optimizequality:
+
−      return SamplingFilter::LINEAR;
+
−    case StyleImageRendering::CrispEdges:
+
−    case StyleImageRendering::Optimizespeed:
+
−    case StyleImageRendering::Pixelated:
+
−      return SamplingFilter::POINT;
+
−    case StyleImageRendering::Auto:
+
−      return SamplingFilter::GOOD;
+
−  }
+
−  MOZ_ASSERT_UNREACHABLE("Unknown image-rendering value");
+
−  return SamplingFilter::GOOD;
+
−}
+
−
+
−/**
+
− * 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->CurrentMatrixDouble();
+
−  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,
+
−                                     gfxContext::SnapOption::IgnoreScale) &&
+
−      aCtx->UserToDevicePixelSnapped(dest,
+
−                                     gfxContext::SnapOption::IgnoreScale)) {
+
−    // 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();
+
−  gfxSize scaleFactors = currentMatrix.ScaleFactors();
+
−  if (!didSnap) {
+
−    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()) {
+
−    return SnappedImageDrawingParameters();
+
−  }
+
−
+
−  nsIntSize intImageSize = aImage->OptimalImageSizeForDest(
+
−      snappedDestSize, imgIContainer::FRAME_CURRENT, aSamplingFilter,
+
−      aImageFlags);
+
−
+
−  nsIntSize svgViewportSize;
+
−  if (scaleFactors.width == 1.0 && scaleFactors.height == 1.0) {
+
−    // intImageSize is scaled by currentMatrix. But since there are no scale
+
−    // factors in currentMatrix, it is safe to assign intImageSize to
+
−    // svgViewportSize directly.
+
−    svgViewportSize = intImageSize;
+
−  } else {
+
−    // We should not take into account any transformation of currentMatrix
+
−    // when computing svg viewport size. Since currentMatrix contains scale
+
−    // factors, we need to recompute SVG viewport by unscaled devPixelDest.
+
−    svgViewportSize = aImage->OptimalImageSizeForDest(
+
−        devPixelDest.Size(), imgIContainer::FRAME_CURRENT, aSamplingFilter,
+
−        aImageFlags);
+
−  }
+
−
+
−  gfxSize imageSize(intImageSize.width, intImageSize.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.TransformPoint(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()
+
−                : 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.TransformRect(devPixelDirty);
+
−    devPixelDirty.RoundOut();
+
−    fill = fill.Intersect(devPixelDirty);
+
−  }
+
−  if (fill.IsEmpty()) return SnappedImageDrawingParameters();
+
−
+
−  gfxRect imageSpaceFill(didSnap ? invTransform.TransformRect(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,
+
−      CSSIntSize(svgViewportSize.width, svgViewportSize.height));
+
−}
+
−
+
−static ImgDrawResult DrawImageInternal(
+
−    gfxContext& aContext, nsPresContext* aPresContext, imgIContainer* aImage,
+
−    const SamplingFilter aSamplingFilter, const nsRect& aDest,
+
−    const nsRect& aFill, const nsPoint& aAnchor, const nsRect& aDirty,
+
−    const Maybe<SVGImageContext>& aSVGContext, uint32_t aImageFlags,
+
−    ExtendMode aExtendMode = ExtendMode::CLAMP, float aOpacity = 1.0) {
+
−  ImgDrawResult result = ImgDrawResult::SUCCESS;
+
−
+
−  aImageFlags |= imgIContainer::FLAG_ASYNC_NOTIFY;
+
−
+
−  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);
+
−
+
−    aContext.SetMatrixDouble(params.imageSpaceToDeviceSpace);
+
−
+
−    Maybe<SVGImageContext> fallbackContext;
+
−    if (!aSVGContext) {
+
−      // Use the default viewport.
+
−      fallbackContext.emplace(Some(params.svgViewportSize));
+
−    }
+
−
+
−    result = aImage->Draw(&aContext, params.size, params.region,
+
−                          imgIContainer::FRAME_CURRENT, aSamplingFilter,
+
−                          aSVGContext ? aSVGContext : fallbackContext,
+
−                          aImageFlags, aOpacity);
+
−  }
+
−
+
−  return result;
+
−}
+
−
+
−/* static */
+
−ImgDrawResult nsLayoutUtils::DrawSingleUnscaledImage(
+
−    gfxContext& aContext, nsPresContext* aPresContext, imgIContainer* aImage,
+
−    const SamplingFilter aSamplingFilter, const nsPoint& aDest,
+
−    const nsRect* aDirty, const Maybe<SVGImageContext>& aSVGContext,
+
−    uint32_t aImageFlags, const nsRect* aSourceArea) {
+
−  CSSIntSize imageSize;
+
−  aImage->GetWidth(&imageSize.width);
+
−  aImage->GetHeight(&imageSize.height);
+
−  aImage->GetResolution().ApplyTo(imageSize.width, imageSize.height);
+
−
+
−  if (imageSize.width < 1 || imageSize.height < 1) {
+
−    NS_WARNING("Image width or height is non-positive");
+
−    return ImgDrawResult::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,
+
−                           aSVGContext, aImageFlags);
+
−}
+
−
+
−/* static */
+
−ImgDrawResult nsLayoutUtils::DrawSingleImage(
+
−    gfxContext& aContext, nsPresContext* aPresContext, imgIContainer* aImage,
+
−    SamplingFilter aSamplingFilter, const nsRect& aDest, const nsRect& aDirty,
+
−    const Maybe<SVGImageContext>& aSVGContext, uint32_t aImageFlags,
+
−    const nsPoint* aAnchorPoint, const nsRect* aSourceArea) {
+
−  nscoord appUnitsPerCSSPixel = AppUnitsPerCSSPixel();
+
−  // NOTE(emilio): We can hardcode resolution to 1 here, since we're interested
+
−  // in the actual image pixels, for snapping purposes, not on the adjusted
+
−  // size.
+
−  CSSIntSize pixelImageSize(ComputeSizeForDrawingWithFallback(
+
−      aImage, ImageResolution(), aDest.Size()));
+
−  if (pixelImageSize.width < 1 || pixelImageSize.height < 1) {
+
−    NS_ASSERTION(pixelImageSize.width >= 0 && pixelImageSize.height >= 0,
+
−                 "Image width or height is negative");
+
−    return ImgDrawResult::SUCCESS;  // no point in drawing a zero size image
+
−  }
+
−
+
−  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, const ImageResolution& aResolution,
+
−    /* outparam */ CSSIntSize& aImageSize,
+
−    /* outparam */ AspectRatio& aIntrinsicRatio,
+
−    /* outparam */ bool& aGotWidth,
+
−    /* outparam */ bool& aGotHeight) {
+
−  aGotWidth = NS_SUCCEEDED(aImage->GetWidth(&aImageSize.width));
+
−  aGotHeight = NS_SUCCEEDED(aImage->GetHeight(&aImageSize.height));
+
−  Maybe<AspectRatio> intrinsicRatio = aImage->GetIntrinsicRatio();
+
−  aIntrinsicRatio = intrinsicRatio.valueOr(AspectRatio());
+
−
+
−  if (aGotWidth) {
+
−    aResolution.ApplyXTo(aImageSize.width);
+
−  }
+
−  if (aGotHeight) {
+
−    aResolution.ApplyYTo(aImageSize.height);
+
−  }
+
−
+
−  if (!(aGotWidth && aGotHeight) && intrinsicRatio.isNothing()) {
+
−    // 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);
+
−  }
+
−}
+
−
+
−/* static */
+
−CSSIntSize nsLayoutUtils::ComputeSizeForDrawingWithFallback(
+
−    imgIContainer* aImage, const ImageResolution& aResolution,
+
−    const nsSize& aFallbackSize) {
+
−  CSSIntSize imageSize;
+
−  AspectRatio imageRatio;
+
−  bool gotHeight, gotWidth;
+
−  ComputeSizeForDrawing(aImage, aResolution, 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) {
+
−        imageSize.width = imageRatio.ApplyTo(imageSize.height);
+
−        gotWidth = true;
+
−      }
+
−    } else {
+
−      if (imageRatio) {
+
−        imageSize.height = imageRatio.Inverted().ApplyTo(imageSize.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 */ LayerIntRect SnapRectForImage(const gfx::Matrix& aTransform,
+
−                                           const gfx::Size& aScaleFactors,
+
−                                           const LayoutDeviceRect& aRect) {
+
−  // Attempt to snap pixels, the same as ComputeSnappedImageDrawingParameters.
+
−  // Any changes to the algorithm here will need to be reflected there.
+
−  bool snapped = false;
+
−  LayerIntRect snapRect;
+
−  if (!aTransform.HasNonAxisAlignedTransform() && aTransform._11 > 0.0 &&
+
−      aTransform._22 > 0.0) {
+
−    gfxRect rect(gfxPoint(aRect.X(), aRect.Y()),
+
−                 gfxSize(aRect.Width(), aRect.Height()));
+
−
+
−    gfxPoint p1 =
+
−        ThebesPoint(aTransform.TransformPoint(ToPoint(rect.TopLeft())));
+
−    gfxPoint p2 =
+
−        ThebesPoint(aTransform.TransformPoint(ToPoint(rect.TopRight())));
+
−    gfxPoint p3 =
+
−        ThebesPoint(aTransform.TransformPoint(ToPoint(rect.BottomRight())));
+
−
+
−    if (p2 == gfxPoint(p1.x, p3.y) || p2 == gfxPoint(p3.x, p1.y)) {
+
−      p1.Round();
+
−      p3.Round();
+
−
+
−      IntPoint p1i(int32_t(p1.x), int32_t(p1.y));
+
−      IntPoint p3i(int32_t(p3.x), int32_t(p3.y));
+
−
+
−      snapRect.MoveTo(std::min(p1i.x, p3i.x), std::min(p1i.y, p3i.y));
+
−      snapRect.SizeTo(std::max(p1i.x, p3i.x) - snapRect.X(),
+
−                      std::max(p1i.y, p3i.y) - snapRect.Y());
+
−      snapped = true;
+
−    }
+
−  }
+
−
+
−  if (!snapped) {
+
−    // If we couldn't snap directly with the transform, we need to go best
+
−    // effort in layer pixels.
+
−    snapRect = RoundedToInt(LayerRect(aRect.X() * aScaleFactors.width,
+
−                                      aRect.Y() * aScaleFactors.height,
+
−                                      aRect.Width() * aScaleFactors.width,
+
−                                      aRect.Height() * aScaleFactors.height));
+
−  }
+
−
+
−  // An empty size is unacceptable so we ensure our suggested size is at least
+
−  // 1 pixel wide/tall.
+
−  if (snapRect.Width() < 1) {
+
−    snapRect.SetWidth(1);
+
−  }
+
−  if (snapRect.Height() < 1) {
+
−    snapRect.SetHeight(1);
+
−  }
+
−  return snapRect;
+
−}
+
−
+
−/* static */
+
−IntSize nsLayoutUtils::ComputeImageContainerDrawingParameters(
+
−    imgIContainer* aImage, nsIFrame* aForFrame,
+
−    const LayoutDeviceRect& aDestRect, const LayoutDeviceRect& aFillRect,
+
−    const StackingContextHelper& aSc, uint32_t aFlags,
+
−    Maybe<SVGImageContext>& aSVGContext, Maybe<ImageIntRegion>& aRegion) {
+
−  MOZ_ASSERT(aImage);
+
−  MOZ_ASSERT(aForFrame);
+
−
+
−  gfx::Size scaleFactors = aSc.GetInheritedScale();
+
−  SamplingFilter samplingFilter =
+
−      nsLayoutUtils::GetSamplingFilterForFrame(aForFrame);
+
−
+
−  // Compute our SVG context parameters, if any. Don't replace the viewport
+
−  // size if it was already set, prefer what the caller gave.
+
−  SVGImageContext::MaybeStoreContextPaint(aSVGContext, aForFrame, aImage);
+
−  if ((scaleFactors.width != 1.0 || scaleFactors.height != 1.0) &&
+
−      aImage->GetType() == imgIContainer::TYPE_VECTOR &&
+
−      (!aSVGContext || !aSVGContext->GetViewportSize())) {
+
−    gfxSize gfxDestSize(aDestRect.Width(), aDestRect.Height());
+
−    IntSize viewportSize = aImage->OptimalImageSizeForDest(
+
−        gfxDestSize, imgIContainer::FRAME_CURRENT, samplingFilter, aFlags);
+
−
+
−    CSSIntSize cssViewportSize(viewportSize.width, viewportSize.height);
+
−    if (!aSVGContext) {
+
−      aSVGContext.emplace(Some(cssViewportSize));
+
−    } else {
+
−      aSVGContext->SetViewportSize(Some(cssViewportSize));
+
−    }
+
−  }
+
−
+
−  const gfx::Matrix& itm = aSc.GetInheritedTransform();
+
−  LayerIntRect destRect = SnapRectForImage(itm, scaleFactors, aDestRect);
+
−
+
−  // Since we always decode entire raster images, we only care about the
+
−  // ImageIntRegion for vector images, for which we may only draw part of in
+
−  // some cases.
+
−  if (aImage->GetType() != imgIContainer::TYPE_VECTOR) {
+
−    return aImage->OptimalImageSizeForDest(
+
−        gfxSize(destRect.Width(), destRect.Height()),
+
−        imgIContainer::FRAME_CURRENT, samplingFilter, aFlags);
+
−  }
+
−
+
−  // If the dest rect contains the fill rect, then we are only displaying part
+
−  // of the vector image. We need to calculate the restriction region to avoid
+
−  // drawing more than we need, and sampling outside the desired bounds.
+
−  LayerIntRect clipRect = SnapRectForImage(itm, scaleFactors, aFillRect);
+
−  if (destRect.Contains(clipRect)) {
+
−    LayerIntRect restrictRect = destRect.Intersect(clipRect);
+
−    restrictRect.MoveBy(-destRect.TopLeft());
+
−
+
−    if (restrictRect.Width() < 1) {
+
−      restrictRect.SetWidth(1);
+
−    }
+
−    if (restrictRect.Height() < 1) {
+
−      restrictRect.SetHeight(1);
+
−    }
+
−
+
−    if (restrictRect.X() != 0 || restrictRect.Y() != 0 ||
+
−        restrictRect.Size() != destRect.Size()) {
+
−      IntRect sampleRect = restrictRect.ToUnknownRect();
+
−      aRegion = Some(ImageIntRegion::CreateWithSamplingRestriction(
+
−          sampleRect, sampleRect, ExtendMode::CLAMP));
+
−    }
+
−  }
+
−
+
−  // VectorImage::OptimalImageSizeForDest will just round up, but we already
+
−  // have an integer size.
+
−  return destRect.Size().ToUnknownSize();
+
−}
+
−
+
−/* static */
+
−nsPoint nsLayoutUtils::GetBackgroundFirstTilePos(const nsPoint& aDest,
+
−                                                 const nsPoint& aFill,
+
−                                                 const nsSize& aRepeatSize) {
+
−  return nsPoint(NSToIntFloor(float(aFill.x - aDest.x) / aRepeatSize.width) *
+
−                     aRepeatSize.width,
+
−                 NSToIntFloor(float(aFill.y - aDest.y) / aRepeatSize.height) *
+
−                     aRepeatSize.height) +
+
−         aDest;
+
−}
+
−
+
−/* static */
+
−ImgDrawResult nsLayoutUtils::DrawBackgroundImage(
+
−    gfxContext& aContext, nsIFrame* aForFrame, nsPresContext* aPresContext,
+
−    imgIContainer* aImage, SamplingFilter aSamplingFilter, const nsRect& aDest,
+
−    const nsRect& aFill, const nsSize& aRepeatSize, const nsPoint& aAnchor,
+
−    const nsRect& aDirty, uint32_t aImageFlags, ExtendMode aExtendMode,
+
−    float aOpacity) {
+
−  AUTO_PROFILER_LABEL("nsLayoutUtils::DrawBackgroundImage",
+
−                      GRAPHICS_Rasterization);
+
−
+
−  CSSIntSize destCSSSize{nsPresContext::AppUnitsToIntCSSPixels(aDest.width),
+
−                         nsPresContext::AppUnitsToIntCSSPixels(aDest.height)};
+
−
+
−  Maybe<SVGImageContext> svgContext(Some(SVGImageContext(Some(destCSSSize))));
+
−  SVGImageContext::MaybeStoreContextPaint(svgContext, aForFrame, aImage);
+
−
+
−  /* 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, aOpacity);
+
−  }
+
−
+
−  const nsPoint firstTilePos =
+
−      GetBackgroundFirstTilePos(aDest.TopLeft(), aFill.TopLeft(), aRepeatSize);
+
−  const nscoord xMost = aFill.XMost();
+
−  const nscoord repeatWidth = aRepeatSize.width;
+
−  const nscoord yMost = aFill.YMost();
+
−  const nscoord repeatHeight = aRepeatSize.height;
+
−  nsRect dest(0, 0, aDest.width, aDest.height);
+
−  nsPoint anchor = aAnchor;
+
−  for (nscoord x = firstTilePos.x; x < xMost; x += repeatWidth) {
+
−    for (nscoord y = firstTilePos.y; y < yMost; y += repeatHeight) {
+
−      dest.x = x;
+
−      dest.y = y;
+
−      ImgDrawResult result = DrawImageInternal(
+
−          aContext, aPresContext, aImage, aSamplingFilter, dest, dest, anchor,
+
−          aDirty, svgContext, aImageFlags, ExtendMode::CLAMP, aOpacity);
+
−      anchor.y += repeatHeight;
+
−      if (result != ImgDrawResult::SUCCESS) {
+
−        return result;
+
−      }
+
−    }
+
−    anchor.x += repeatWidth;
+
−    anchor.y = aAnchor.y;
+
−  }
+
−
+
−  return ImgDrawResult::SUCCESS;
+
−}
+
−
+
−/* static */
+
−ImgDrawResult nsLayoutUtils::DrawImage(
+
−    gfxContext& aContext, ComputedStyle* aComputedStyle,
+
−    nsPresContext* aPresContext, imgIContainer* aImage,
+
−    const SamplingFilter aSamplingFilter, const nsRect& aDest,
+
−    const nsRect& aFill, const nsPoint& aAnchor, const nsRect& aDirty,
+
−    uint32_t aImageFlags, float aOpacity) {
+
−  Maybe<SVGImageContext> svgContext;
+
−  SVGImageContext::MaybeStoreContextPaint(svgContext, aComputedStyle, aImage);
+
−
+
−  return DrawImageInternal(aContext, aPresContext, aImage, aSamplingFilter,
+
−                           aDest, aFill, aAnchor, aDirty, svgContext,
+
−                           aImageFlags, ExtendMode::CLAMP, aOpacity);
+
−}
+
−
+
−/* 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 StyleImageOrientation& aOrientation) {
+
−  MOZ_ASSERT(aContainer, "Should have an image container");
+
−  nsCOMPtr<imgIContainer> img(aContainer);
+
−
+
−  switch (aOrientation) {
+
−    case StyleImageOrientation::FromImage:
+
−      break;
+
−    case StyleImageOrientation::None:
+
−      img = ImageOps::Unorient(img);
+
−      break;
+
−  }
+
−
+
−  return img.forget();
+
−}
+
−
+
−static bool NonZeroCorner(const LengthPercentage& aLength) {
+
−  // Since negative results are clamped to 0, check > 0.
+
−  return aLength.Resolve(nscoord_MAX) > 0 || aLength.Resolve(0) > 0;
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::HasNonZeroCorner(const BorderRadius& aCorners) {
+
−  for (const auto corner : mozilla::AllPhysicalHalfCorners()) {
+
−    if (NonZeroCorner(aCorners.Get(corner))) return true;
+
−  }
+
−  return false;
+
−}
+
−
+
−// aCorner is a "full corner" value, i.e. eCornerTopLeft etc.
+
−static bool IsCornerAdjacentToSide(uint8_t aCorner, Side aSide) {
+
−  static_assert((int)eSideTop == eCornerTopLeft, "Check for Full Corner");
+
−  static_assert((int)eSideRight == eCornerTopRight, "Check for Full Corner");
+
−  static_assert((int)eSideBottom == eCornerBottomRight,
+
−                "Check for Full Corner");
+
−  static_assert((int)eSideLeft == eCornerBottomLeft, "Check for Full Corner");
+
−  static_assert((int)eSideTop == ((eCornerTopRight - 1) & 3),
+
−                "Check for Full Corner");
+
−  static_assert((int)eSideRight == ((eCornerBottomRight - 1) & 3),
+
−                "Check for Full Corner");
+
−  static_assert((int)eSideBottom == ((eCornerBottomLeft - 1) & 3),
+
−                "Check for Full Corner");
+
−  static_assert((int)eSideLeft == ((eCornerTopLeft - 1) & 3),
+
−                "Check for Full Corner");
+
−
+
−  return aSide == aCorner || aSide == ((aCorner - 1) & 3);
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::HasNonZeroCornerOnSide(const BorderRadius& aCorners,
+
−                                           Side aSide) {
+
−  static_assert(eCornerTopLeftX / 2 == eCornerTopLeft,
+
−                "Check for Non Zero on side");
+
−  static_assert(eCornerTopLeftY / 2 == eCornerTopLeft,
+
−                "Check for Non Zero on side");
+
−  static_assert(eCornerTopRightX / 2 == eCornerTopRight,
+
−                "Check for Non Zero on side");
+
−  static_assert(eCornerTopRightY / 2 == eCornerTopRight,
+
−                "Check for Non Zero on side");
+
−  static_assert(eCornerBottomRightX / 2 == eCornerBottomRight,
+
−                "Check for Non Zero on side");
+
−  static_assert(eCornerBottomRightY / 2 == eCornerBottomRight,
+
−                "Check for Non Zero on side");
+
−  static_assert(eCornerBottomLeftX / 2 == eCornerBottomLeft,
+
−                "Check for Non Zero on side");
+
−  static_assert(eCornerBottomLeftY / 2 == eCornerBottomLeft,
+
−                "Check for Non Zero on side");
+
−
+
−  for (const auto corner : mozilla::AllPhysicalHalfCorners()) {
+
−    // corner is a "half corner" value, so dividing by two gives us a
+
−    // "full corner" value.
+
−    if (NonZeroCorner(aCorners.Get(corner)) &&
+
−        IsCornerAdjacentToSide(corner / 2, aSide))
+
−      return true;
+
−  }
+
−  return false;
+
−}
+
−
+
−/* static */
+
−LayoutDeviceIntSize nsLayoutUtils::GetBorderRadiusForMenuDropShadow(
+
−    const nsIFrame* aFrame) {
+
−  if (aFrame->StyleUIReset()->mWindowShadow == StyleWindowShadow::Cliprounded) {
+
−    const auto& corners = aFrame->StyleBorder()->mBorderRadius;
+
−
+
−    // Get the width and height of the top-left corner.
+
−    const LengthPercentage& cornerX = corners.Get(eCornerTopLeftX);
+
−    const LengthPercentage& cornerY = corners.Get(eCornerTopLeftY);
+
−    nscoord lengthX = (cornerX.IsLength() ? cornerX.ToLength() : 0);
+
−    nscoord lengthY = (cornerY.IsLength() ? cornerY.ToLength() : 0);
+
−    if (lengthX || lengthY) {
+
−      const nsPresContext* presContext = aFrame->PresContext();
+
−      return LayoutDeviceIntSize(presContext->AppUnitsToDevPixels(lengthX),
+
−                                 presContext->AppUnitsToDevPixels(lengthY));
+
−    }
+
−  }
+
−
+
−  return LayoutDeviceIntSize();
+
−}
+
−
+
−/* static */
+
−nsTransparencyMode nsLayoutUtils::GetFrameTransparency(
+
−    nsIFrame* aBackgroundFrame, nsIFrame* aCSSRootFrame) {
+
−  if (aCSSRootFrame->StyleEffects()->mOpacity < 1.0f)
+
−    return eTransparencyTransparent;
+
−
+
−  if (HasNonZeroCorner(aCSSRootFrame->StyleBorder()->mBorderRadius))
+
−    return eTransparencyTransparent;
+
−
+
−  StyleAppearance appearance =
+
−      aCSSRootFrame->StyleDisplay()->EffectiveAppearance();
+
−
+
−  if (appearance == StyleAppearance::MozWinGlass) return eTransparencyGlass;
+
−
+
−  if (appearance == StyleAppearance::MozWinBorderlessGlass)
+
−    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->IsViewportFrame() &&
+
−      !aBackgroundFrame->PrincipalChildList().FirstChild()) {
+
−    return eTransparencyOpaque;
+
−  }
+
−
+
−  ComputedStyle* bgSC;
+
−  if (!nsCSSRendering::FindBackground(aBackgroundFrame, &bgSC)) {
+
−    return eTransparencyTransparent;
+
−  }
+
−  const nsStyleBackground* bg = bgSC->StyleBackground();
+
−  if (NS_GET_A(bg->BackgroundColor(bgSC)) < 255 ||
+
−      // bottom layer's clip is used for the color
+
−      bg->BottomLayer().mClip != StyleGeometryBox::BorderBox)
+
−    return eTransparencyTransparent;
+
−  return eTransparencyOpaque;
+
−}
+
−
+
−static bool IsPopupFrame(const nsIFrame* aFrame) {
+
−  // aFrame is a popup it's the list control frame dropdown for a combobox.
+
−  LayoutFrameType frameType = aFrame->Type();
+
−  if (frameType == LayoutFrameType::ListControl) {
+
−    const nsListControlFrame* lcf =
+
−        static_cast<const nsListControlFrame*>(aFrame);
+
−    return lcf->IsInDropDownMode();
+
−  }
+
−
+
−  // ... or if it's a XUL menupopup frame.
+
−  return frameType == LayoutFrameType::MenuPopup;
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::IsPopup(const 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) {
+
−  return const_cast<nsIFrame*>(
+
−      nsLayoutUtils::GetDisplayRootFrame(const_cast<const nsIFrame*>(aFrame)));
+
−}
+
−
+
−/* static */
+
−const nsIFrame* nsLayoutUtils::GetDisplayRootFrame(const nsIFrame* aFrame) {
+
−  // We could use GetRootPresContext() here if the
+
−  // NS_FRAME_IN_POPUP frame bit is set.
+
−  const nsIFrame* f = aFrame;
+
−  for (;;) {
+
−    if (!f->HasAnyStateBits(NS_FRAME_IN_POPUP)) {
+
−      f = f->PresShell()->GetRootFrame();
+
−      if (!f) {
+
−        return aFrame;
+
−      }
+
−    } else if (IsPopup(f)) {
+
−      return f;
+
−    }
+
−    nsIFrame* parent = GetCrossDocParentFrameInProcess(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 = GetCrossDocParentFrameInProcess(f);
+
−    if (!parent) {
+
−      return f;
+
−    }
+
−    f = parent;
+
−  }
+
−}
+
−
+
−/* static */ gfx::ShapedTextFlags nsLayoutUtils::GetTextRunFlagsForStyle(
+
−    ComputedStyle* aComputedStyle, nsPresContext* aPresContext,
+
−    const nsStyleFont* aStyleFont, const nsStyleText* aStyleText,
+
−    nscoord aLetterSpacing) {
+
−  gfx::ShapedTextFlags result = gfx::ShapedTextFlags();
+
−  if (aLetterSpacing != 0 ||
+
−      aStyleText->mTextJustify == StyleTextJustify::InterCharacter) {
+
−    result |= gfx::ShapedTextFlags::TEXT_DISABLE_OPTIONAL_LIGATURES;
+
−  }
+
−  if (aStyleText->mMozControlCharacterVisibility ==
+
−      StyleMozControlCharacterVisibility::Hidden) {
+
−    result |= gfx::ShapedTextFlags::TEXT_HIDE_CONTROL_CHARACTERS;
+
−  }
+
−  switch (aComputedStyle->StyleText()->mTextRendering) {
+
−    case StyleTextRendering::Optimizespeed:
+
−      result |= gfx::ShapedTextFlags::TEXT_OPTIMIZE_SPEED;
+
−      break;
+
−    case StyleTextRendering::Auto:
+
−      if (aStyleFont->mFont.size.ToCSSPixels() <
+
−          aPresContext->GetAutoQualityMinFontSize()) {
+
−        result |= gfx::ShapedTextFlags::TEXT_OPTIMIZE_SPEED;
+
−      }
+
−      break;
+
−    default:
+
−      break;
+
−  }
+
−  return result | GetTextRunOrientFlagsForStyle(aComputedStyle);
+
−}
+
−
+
−/* static */ gfx::ShapedTextFlags nsLayoutUtils::GetTextRunOrientFlagsForStyle(
+
−    ComputedStyle* aComputedStyle) {
+
−  auto writingMode = aComputedStyle->StyleVisibility()->mWritingMode;
+
−  switch (writingMode) {
+
−    case StyleWritingModeProperty::HorizontalTb:
+
−      return gfx::ShapedTextFlags::TEXT_ORIENT_HORIZONTAL;
+
−
+
−    case StyleWritingModeProperty::VerticalLr:
+
−    case StyleWritingModeProperty::VerticalRl:
+
−      switch (aComputedStyle->StyleVisibility()->mTextOrientation) {
+
−        case StyleTextOrientation::Mixed:
+
−          return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_MIXED;
+
−        case StyleTextOrientation::Upright:
+
−          return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_UPRIGHT;
+
−        case StyleTextOrientation::Sideways:
+
−          return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
+
−        default:
+
−          MOZ_ASSERT_UNREACHABLE("unknown text-orientation");
+
−          return gfx::ShapedTextFlags();
+
−      }
+
−
+
−    case StyleWritingModeProperty::SidewaysLr:
+
−      return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_LEFT;
+
−
+
−    case StyleWritingModeProperty::SidewaysRl:
+
−      return gfx::ShapedTextFlags::TEXT_ORIENT_VERTICAL_SIDEWAYS_RIGHT;
+
−
+
−    default:
+
−      MOZ_ASSERT_UNREACHABLE("unknown writing-mode");
+
−      return gfx::ShapedTextFlags();
+
−  }
+
−}
+
−
+
−/* 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->EnsureSizeAndPositionUpToDate();
+
−
+
−    RefPtr<nsPresContext> presContext = docShell->GetPresContext();
+
−    if (presContext) {
+
−      nsDeviceContext* context = presContext->DeviceContext();
+
−      if (context) {
+
−        return context;
+
−      }
+
−    }
+
−
+
−    nsCOMPtr<nsIDocShellTreeItem> parentItem;
+
−    docShell->GetInProcessParent(getter_AddRefs(parentItem));
+
−    docShell = do_QueryInterface(parentItem);
+
−  }
+
−
+
−  return nullptr;
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::IsReallyFixedPos(const nsIFrame* aFrame) {
+
−  MOZ_ASSERT(aFrame->StyleDisplay()->mPosition == StylePositionProperty::Fixed,
+
−             "IsReallyFixedPos called on non-'position:fixed' frame");
+
−  return MayBeReallyFixedPos(aFrame);
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::MayBeReallyFixedPos(const nsIFrame* aFrame) {
+
−  MOZ_ASSERT(aFrame->GetParent(),
+
−             "MayBeReallyFixedPos called on frame not in tree");
+
−  LayoutFrameType parentType = aFrame->GetParent()->Type();
+
−  return parentType == LayoutFrameType::Viewport ||
+
−         parentType == LayoutFrameType::PageContent;
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::IsInPositionFixedSubtree(const nsIFrame* aFrame) {
+
−  for (const nsIFrame* f = aFrame; f; f = f->GetParent()) {
+
−    if (f->StyleDisplay()->mPosition == StylePositionProperty::Fixed &&
+
−        nsLayoutUtils::IsReallyFixedPos(f)) {
+
−      return true;
+
−    }
+
−  }
+
−  return false;
+
−}
+
−
+
−SurfaceFromElementResult nsLayoutUtils::SurfaceFromOffscreenCanvas(
+
−    OffscreenCanvas* aOffscreenCanvas, uint32_t aSurfaceFlags,
+
−    RefPtr<DrawTarget>& aTarget) {
+
−  SurfaceFromElementResult result;
+
−
+
−  IntSize size = aOffscreenCanvas->GetWidthHeight();
+
−
+
−  result.mSourceSurface =
+
−      aOffscreenCanvas->GetSurfaceSnapshot(&result.mAlphaType);
+
−  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.
+
−    result.mAlphaType = gfxAlphaType::Opaque;
+
−    RefPtr<DrawTarget> ref =
+
−        aTarget ? aTarget
+
−                : gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
+
−    if (ref->CanCreateSimilarDrawTarget(size, SurfaceFormat::B8G8R8A8)) {
+
−      RefPtr<DrawTarget> dt =
+
−          ref->CreateSimilarDrawTarget(size, 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.mIntrinsicSize = size;
+
−  result.mIsWriteOnly = aOffscreenCanvas->IsWriteOnly();
+
−
+
−  return result;
+
−}
+
−
+
−static RefPtr<SourceSurface> ScaleSourceSurface(SourceSurface& aSurface,
+
−                                                const IntSize& aTargetSize) {
+
−  const IntSize surfaceSize = aSurface.GetSize();
+
−
+
−  MOZ_ASSERT(surfaceSize != aTargetSize);
+
−  MOZ_ASSERT(!surfaceSize.IsEmpty());
+
−  MOZ_ASSERT(!aTargetSize.IsEmpty());
+
−
+
−  RefPtr<DrawTarget> dt = Factory::CreateDrawTarget(
+
−      gfxVars::ContentBackend(), aTargetSize, aSurface.GetFormat());
+
−
+
−  if (!dt || !dt->IsValid()) {
+
−    return nullptr;
+
−  }
+
−
+
−  RefPtr<gfxContext> context = gfxContext::CreateOrNull(dt);
+
−  MOZ_ASSERT(context);
+
−
+
−  dt->DrawSurface(&aSurface, Rect(Point(), Size(aTargetSize)),
+
−                  Rect(Point(), Size(surfaceSize)));
+
−  return dt->GetBackingSurface();
+
−}
+
−
+
−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
+
−    // HTMLImageElement, 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;
+
−  }
+
−
+
−  nsCOMPtr<nsIContent> content = do_QueryInterface(aElement);
+
−
+
−  // Ensure that the image is oriented the same way as it's displayed.
+
−  auto orientation = StyleImageOrientation::FromImage;
+
−  if (nsIFrame* f = content->GetPrimaryFrame()) {
+
−    orientation = f->StyleVisibility()->mImageOrientation;
+
−  }
+
−  imgContainer = OrientImage(imgContainer, orientation);
+
−
+
−  const bool noRasterize = aSurfaceFlags & SFE_NO_RASTERIZING_VECTORS;
+
−
+
−  uint32_t whichFrame = aSurfaceFlags & SFE_WANT_FIRST_FRAME_IF_IMAGE
+
−                            ? (uint32_t)imgIContainer::FRAME_FIRST
+
−                            : (uint32_t)imgIContainer::FRAME_CURRENT;
+
−  const bool exactSize = aSurfaceFlags & SFE_EXACT_SIZE_SURFACE;
+
−
+
−  uint32_t frameFlags =
+
−      imgIContainer::FLAG_SYNC_DECODE | imgIContainer::FLAG_ASYNC_NOTIFY;
+
−  if (aSurfaceFlags & SFE_NO_COLORSPACE_CONVERSION)
+
−    frameFlags |= imgIContainer::FLAG_DECODE_NO_COLORSPACE_CONVERSION;
+
−  if (aSurfaceFlags & SFE_ALLOW_NON_PREMULT) {
+
−    frameFlags |= imgIContainer::FLAG_DECODE_NO_PREMULTIPLY_ALPHA;
+
−  }
+
−
+
−  int32_t imgWidth, imgHeight;
+
−  HTMLImageElement* element = HTMLImageElement::FromNodeOrNull(content);
+
−  if (aSurfaceFlags & SFE_USE_ELEMENT_SIZE_IF_VECTOR && element &&
+
−      imgContainer->GetType() == imgIContainer::TYPE_VECTOR) {
+
−    // We're holding a strong ref to "element" via "content".
+
−    imgWidth = MOZ_KnownLive(element)->Width();
+
−    imgHeight = MOZ_KnownLive(element)->Height();
+
−  } else {
+
−    rv = imgContainer->GetWidth(&imgWidth);
+
−    nsresult rv2 = imgContainer->GetHeight(&imgHeight);
+
−    if (NS_FAILED(rv) || NS_FAILED(rv2)) return result;
+
−    imgContainer->GetResolution().ApplyTo(imgWidth, imgHeight);
+
−  }
+
−  result.mSize = result.mIntrinsicSize = IntSize(imgWidth, imgHeight);
+
−
+
−  if (!noRasterize || imgContainer->GetType() == imgIContainer::TYPE_RASTER) {
+
−    result.mSourceSurface =
+
−        imgContainer->GetFrameAtSize(result.mSize, whichFrame, frameFlags);
+
−    if (!result.mSourceSurface) {
+
−      return result;
+
−    }
+
−    if (exactSize && result.mSourceSurface->GetSize() != result.mSize) {
+
−      result.mSourceSurface =
+
−          ScaleSourceSurface(*result.mSourceSurface, result.mSize);
+
−      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;
+
−      }
+
−    }
+
−
+
−    const auto& format = result.mSourceSurface->GetFormat();
+
−    if (IsOpaque(format)) {
+
−      result.mAlphaType = gfxAlphaType::Opaque;
+
−    } else if (frameFlags & imgIContainer::FLAG_DECODE_NO_PREMULTIPLY_ALPHA) {
+
−      result.mAlphaType = gfxAlphaType::NonPremult;
+
−    } else {
+
−      result.mAlphaType = gfxAlphaType::Premult;
+
−    }
+
−  } 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 != CORS_NONE;
+
−  }
+
−
+
−  bool hadCrossOriginRedirects = true;
+
−  imgRequest->GetHadCrossOriginRedirects(&hadCrossOriginRedirects);
+
−
+
−  result.mPrincipal = std::move(principal);
+
−  result.mHadCrossOriginRedirects = hadCrossOriginRedirects;
+
−  result.mImageRequest = std::move(imgRequest);
+
−  result.mIsWriteOnly = CanvasUtils::CheckWriteOnlySecurity(
+
−      result.mCORSUsed, result.mPrincipal, result.mHadCrossOriginRedirects);
+
−
+
−  return result;
+
−}
+
−
+
−SurfaceFromElementResult nsLayoutUtils::SurfaceFromElement(
+
−    HTMLImageElement* aElement, uint32_t aSurfaceFlags,
+
−    RefPtr<DrawTarget>& aTarget) {
+
−  return SurfaceFromElement(static_cast<nsIImageLoadingContent*>(aElement),
+
−                            aSurfaceFlags, aTarget);
+
−}
+
−
+
−SurfaceFromElementResult nsLayoutUtils::SurfaceFromElement(
+
−    HTMLCanvasElement* aElement, uint32_t aSurfaceFlags,
+
−    RefPtr<DrawTarget>& aTarget) {
+
−  SurfaceFromElementResult result;
+
−
+
−  IntSize size = aElement->GetSize();
+
−
+
−  auto pAlphaType = &result.mAlphaType;
+
−  if (!(aSurfaceFlags & SFE_ALLOW_NON_PREMULT)) {
+
−    pAlphaType =
+
−        nullptr;  // Coersce GetSurfaceSnapshot to give us Opaque/Premult only.
+
−  }
+
−  result.mSourceSurface = aElement->GetSurfaceSnapshot(pAlphaType);
+
−  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.
+
−    result.mAlphaType = gfxAlphaType::Opaque;
+
−    RefPtr<DrawTarget> ref =
+
−        aTarget ? aTarget
+
−                : gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget();
+
−    if (ref->CanCreateSimilarDrawTarget(size, SurfaceFormat::B8G8R8A8)) {
+
−      RefPtr<DrawTarget> dt =
+
−          ref->CreateSimilarDrawTarget(size, 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.mIntrinsicSize = size;
+
−  result.mPrincipal = aElement->NodePrincipal();
+
−  result.mHadCrossOriginRedirects = false;
+
−  result.mIsWriteOnly = aElement->IsWriteOnly();
+
−
+
−  return result;
+
−}
+
−
+
−SurfaceFromElementResult nsLayoutUtils::SurfaceFromElement(
+
−    HTMLVideoElement* aElement, uint32_t aSurfaceFlags,
+
−    RefPtr<DrawTarget>& aTarget) {
+
−  SurfaceFromElementResult result;
+
−  result.mAlphaType = gfxAlphaType::Opaque;  // Assume opaque.
+
−
+
−  if (aElement->ContainsRestrictedContent()) {
+
−    return result;
+
−  }
+
−
+
−  uint16_t readyState = aElement->ReadyState();
+
−  if (readyState == HAVE_NOTHING || readyState == 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;
+
−  }
+
−
+
−  result.mLayersImage = aElement->GetCurrentImage();
+
−  if (!result.mLayersImage) {
+
−    return result;
+
−  }
+
−
+
−  result.mCORSUsed = aElement->GetCORSMode() != CORS_NONE;
+
−  result.mHasSize = true;
+
−  result.mSize = result.mLayersImage->GetSize();
+
−  result.mIntrinsicSize =
+
−      gfx::IntSize(aElement->VideoWidth(), aElement->VideoHeight());
+
−  result.mPrincipal = std::move(principal);
+
−  result.mHadCrossOriginRedirects = aElement->HadCrossOriginRedirects();
+
−  result.mIsWriteOnly = CanvasUtils::CheckWriteOnlySecurity(
+
−      result.mCORSUsed, result.mPrincipal, result.mHadCrossOriginRedirects);
+
−
+
−  if (aTarget) {
+
−    // They gave us a DrawTarget to optimize for, so even though we have a
+
−    // layers::Image, we should unconditionally try to grab a SourceSurface and
+
−    // try to optimize it.
+
−    if ((result.mSourceSurface = result.mLayersImage->GetAsSourceSurface())) {
+
−      RefPtr<SourceSurface> opt =
+
−          aTarget->OptimizeSourceSurface(result.mSourceSurface);
+
−      if (opt) {
+
−        result.mSourceSurface = opt;
+
−      }
+
−    }
+
−  }
+
−
+
−  return result;
+
−}
+
−
+
−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::FromNodeOrNull(aElement)) {
+
−    return SurfaceFromElement(canvas, aSurfaceFlags, aTarget);
+
−  }
+
−
+
−  // Maybe it's <video>?
+
−  if (HTMLVideoElement* video = HTMLVideoElement::FromNodeOrNull(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 */
+
−Element* nsLayoutUtils::GetEditableRootContentByContentEditable(
+
−    Document* 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.
+
−  // XXXbz should this test IsHTMLOrXHTML(), or just IsHTML()?
+
−  if (!aDocument->IsHTMLOrXHTML()) {
+
−    return nullptr;
+
−  }
+
−
+
−  Element* rootElement = aDocument->GetRootElement();
+
−  if (rootElement && rootElement->IsEditable()) {
+
−    return rootElement;
+
−  }
+
−
+
−  // If there is no editable root element, check its <body> element.
+
−  // Note that the body element could be <frameset> element.
+
−  Element* bodyElement = aDocument->GetBody();
+
−  if (bodyElement && bodyElement->IsEditable()) {
+
−    return bodyElement;
+
−  }
+
−  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->IsLetterFrame()) {
+
−      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.
+
−  auto [start, end] = aSubtreeRoot->GetOffsets();
+
−  // 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");
+
−
+
−  for (const auto& childList : aSubtreeRoot->ChildLists()) {
+
−    for (nsIFrame* child : childList.mList) {
+
−      nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(child);
+
−    }
+
−  }
+
−}
+
−#endif
+
−
+
−static void GetFontFacesForFramesInner(
+
−    nsIFrame* aFrame, nsLayoutUtils::UsedFontFaceList& aResult,
+
−    nsLayoutUtils::UsedFontFaceTable& aFontFaces, uint32_t aMaxRanges,
+
−    bool aSkipCollapsedWhitespace) {
+
−  MOZ_ASSERT(aFrame, "NULL frame pointer");
+
−
+
−  if (aFrame->IsTextFrame()) {
+
−    if (!aFrame->GetPrevContinuation()) {
+
−      nsLayoutUtils::GetFontFacesForText(aFrame, 0, INT32_MAX, true, aResult,
+
−                                         aFontFaces, aMaxRanges,
+
−                                         aSkipCollapsedWhitespace);
+
−    }
+
−    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, aResult, aFontFaces, aMaxRanges,
+
−                                 aSkipCollapsedWhitespace);
+
−    }
+
−  }
+
−}
+
−
+
−/* static */
+
−nsresult nsLayoutUtils::GetFontFacesForFrames(nsIFrame* aFrame,
+
−                                              UsedFontFaceList& aResult,
+
−                                              UsedFontFaceTable& aFontFaces,
+
−                                              uint32_t aMaxRanges,
+
−                                              bool aSkipCollapsedWhitespace) {
+
−  MOZ_ASSERT(aFrame, "NULL frame pointer");
+
−
+
−  while (aFrame) {
+
−    GetFontFacesForFramesInner(aFrame, aResult, aFontFaces, aMaxRanges,
+
−                               aSkipCollapsedWhitespace);
+
−    aFrame = GetNextContinuationOrIBSplitSibling(aFrame);
+
−  }
+
−
+
−  return NS_OK;
+
−}
+
−
+
−static void AddFontsFromTextRun(gfxTextRun* aTextRun, nsTextFrame* aFrame,
+
−                                gfxSkipCharsIterator& aSkipIter,
+
−                                const gfxTextRun::Range& aRange,
+
−                                nsLayoutUtils::UsedFontFaceList& aResult,
+
−                                nsLayoutUtils::UsedFontFaceTable& aFontFaces,
+
−                                uint32_t aMaxRanges) {
+
−  gfxTextRun::GlyphRunIterator glyphRuns(aTextRun, aRange);
+
−  nsIContent* content = aFrame->GetContent();
+
−  int32_t contentLimit =
+
−      aFrame->GetContentOffset() + aFrame->GetInFlowContentLength();
+
−  while (glyphRuns.NextRun()) {
+
−    gfxFontEntry* fe = glyphRuns.GetGlyphRun()->mFont->GetFontEntry();
+
−    // if we have already listed this face, just make sure the match type is
+
−    // recorded
+
−    InspectorFontFace* fontFace = aFontFaces.Get(fe);
+
−    if (fontFace) {
+
−      fontFace->AddMatchType(glyphRuns.GetGlyphRun()->mMatchType);
+
−    } else {
+
−      // A new font entry we haven't seen before
+
−      fontFace = new InspectorFontFace(fe, aTextRun->GetFontGroup(),
+
−                                       glyphRuns.GetGlyphRun()->mMatchType);
+
−      aFontFaces.InsertOrUpdate(fe, fontFace);
+
−      aResult.AppendElement(fontFace);
+
−    }
+
−
+
−    // Add this glyph run to the fontFace's list of ranges, unless we have
+
−    // already collected as many as wanted.
+
−    if (fontFace->RangeCount() < aMaxRanges) {
+
−      int32_t start =
+
−          aSkipIter.ConvertSkippedToOriginal(glyphRuns.GetStringStart());
+
−      int32_t end =
+
−          aSkipIter.ConvertSkippedToOriginal(glyphRuns.GetStringEnd());
+
−
+
−      // Mapping back from textrun offsets ("skipped" offsets that reflect the
+
−      // text after whitespace collapsing, etc) to DOM content offsets in the
+
−      // original text is ambiguous, because many original characters can
+
−      // map to a single skipped offset. aSkipIter.ConvertSkippedToOriginal()
+
−      // will return an "original" offset that corresponds to the *end* of
+
−      // a collapsed run of characters in this case; but that might extend
+
−      // beyond the current content node if the textrun mapped multiple nodes.
+
−      // So we clamp the end offset to keep it valid for the content node
+
−      // that corresponds to the current textframe.
+
−      end = std::min(end, contentLimit);
+
−
+
−      if (end > start) {
+
−        RefPtr<nsRange> range =
+
−            nsRange::Create(content, start, content, end, IgnoreErrors());
+
−        NS_WARNING_ASSERTION(range,
+
−                             "nsRange::Create() failed to create valid range");
+
−        if (range) {
+
−          fontFace->AddRange(range);
+
−        }
+
−      }
+
−    }
+
−  }
+
−}
+
−
+
−/* static */
+
−void nsLayoutUtils::GetFontFacesForText(nsIFrame* aFrame, int32_t aStartOffset,
+
−                                        int32_t aEndOffset,
+
−                                        bool aFollowContinuations,
+
−                                        UsedFontFaceList& aResult,
+
−                                        UsedFontFaceTable& aFontFaces,
+
−                                        uint32_t aMaxRanges,
+
−                                        bool aSkipCollapsedWhitespace) {
+
−  MOZ_ASSERT(aFrame, "NULL frame pointer");
+
−
+
−  if (!aFrame->IsTextFrame()) {
+
−    return;
+
−  }
+
−
+
−  if (!aFrame->StyleVisibility()->IsVisible()) {
+
−    return;
+
−  }
+
−
+
−  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);
+
−    if (!textRun) {
+
−      NS_WARNING("failed to get textRun, low memory?");
+
−      return;
+
−    }
+
−
+
−    // 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;
+
−      }
+
−    }
+
−
+
−    if (!aSkipCollapsedWhitespace || (curr->HasAnyNoncollapsedCharacters() &&
+
−                                      curr->HasNonSuppressedText())) {
+
−      gfxTextRun::Range range(iter.ConvertOriginalToSkipped(fstart),
+
−                              iter.ConvertOriginalToSkipped(fend));
+
−      AddFontsFromTextRun(textRun, curr, iter, range, aResult, aFontFaces,
+
−                          aMaxRanges);
+
−    }
+
−
+
−    curr = next;
+
−  } while (aFollowContinuations && curr);
+
−}
+
−
+
−/* static */
+
−size_t nsLayoutUtils::SizeOfTextRunsForFrames(nsIFrame* aFrame,
+
−                                              MallocSizeOf aMallocSizeOf,
+
−                                              bool clear) {
+
−  MOZ_ASSERT(aFrame, "NULL frame pointer");
+
−
+
−  size_t total = 0;
+
−
+
−  if (aFrame->IsTextFrame()) {
+
−    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;
+
−  }
+
−
+
−  for (const auto& childList : aFrame->ChildLists()) {
+
−    for (nsIFrame* f : childList.mList) {
+
−      total += SizeOfTextRunsForFrames(f, aMallocSizeOf, clear);
+
−    }
+
−  }
+
−  return total;
+
−}
+
−
+
−/* static */
+
−void nsLayoutUtils::Initialize() {
+
−  nsComputedDOMStyle::RegisterPrefChangeCallbacks();
+
−}
+
−
+
−/* static */
+
−void nsLayoutUtils::Shutdown() {
+
−  if (sContentMap) {
+
−    delete sContentMap;
+
−    sContentMap = nullptr;
+
−  }
+
−
+
−  nsComputedDOMStyle::UnregisterPrefChangeCallbacks();
+
−}
+
−
+
−/* 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,
+
−                                     RestyleHint aRestyleHint,
+
−                                     nsChangeHint aMinChangeHint) {
+
−  if (Document* doc = aElement->GetComposedDoc()) {
+
−    if (nsPresContext* presContext = doc->GetPresContext()) {
+
−      presContext->RestyleManager()->PostRestyleEvent(aElement, aRestyleHint,
+
−                                                      aMinChangeHint);
+
−    }
+
−  }
+
−}
+
−
+
−nsSetAttrRunnable::nsSetAttrRunnable(Element* aElement, nsAtom* aAttrName,
+
−                                     const nsAString& aValue)
+
−    : mozilla::Runnable("nsSetAttrRunnable"),
+
−      mElement(aElement),
+
−      mAttrName(aAttrName),
+
−      mValue(aValue) {
+
−  NS_ASSERTION(aElement && aAttrName, "Missing stuff, prepare to crash");
+
−}
+
−
+
−nsSetAttrRunnable::nsSetAttrRunnable(Element* aElement, nsAtom* aAttrName,
+
−                                     int32_t aValue)
+
−    : mozilla::Runnable("nsSetAttrRunnable"),
+
−      mElement(aElement),
+
−      mAttrName(aAttrName) {
+
−  NS_ASSERTION(aElement && aAttrName, "Missing stuff, prepare to crash");
+
−  mValue.AppendInt(aValue);
+
−}
+
−
+
−NS_IMETHODIMP
+
−nsSetAttrRunnable::Run() {
+
−  return mElement->SetAttr(kNameSpaceID_None, mAttrName, mValue, true);
+
−}
+
−
+
−nsUnsetAttrRunnable::nsUnsetAttrRunnable(Element* aElement, nsAtom* aAttrName)
+
−    : mozilla::Runnable("nsUnsetAttrRunnable"),
+
−      mElement(aElement),
+
−      mAttrName(aAttrName) {
+
−  NS_ASSERTION(aElement && aAttrName, "Missing stuff, prepare to crash");
+
−}
+
−
+
−NS_IMETHODIMP
+
−nsUnsetAttrRunnable::Run() {
+
−  return mElement->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) {
+
−  PresShell* presShell = aPresContext->PresShell();
+
−
+
−  uint32_t emPerLine = presShell->FontSizeInflationEmPerLine();
+
−  uint32_t minTwips = presShell->FontSizeInflationMinTwips();
+
−  if (emPerLine == 0 && minTwips == 0) {
+
−    return 0;
+
−  }
+
−
+
−  nscoord byLine = 0, byInch = 0;
+
−  if (emPerLine != 0) {
+
−    byLine = aContainerISize / 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(aContainerISize / (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.ToAppUnits();
+
−  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();
+
−    LayoutFrameType fType = f->Type();
+
−    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 != LayoutFrameType::Inline &&
+
−        // ignore width on radios and checkboxes since we enlarge them and
+
−        // they have width/height in ua.css
+
−        fType != LayoutFrameType::CheckboxRadio) {
+
−      // ruby annotations should have the same inflation as its
+
−      // grandparent, which is the ruby frame contains the annotation.
+
−      if (fType == LayoutFrameType::RubyText) {
+
−        MOZ_ASSERT(parent && parent->IsRubyTextContainerFrame());
+
−        nsIFrame* grandparent = parent->GetParent();
+
−        MOZ_ASSERT(grandparent && grandparent->IsRubyFrame());
+
−        return FontSizeInflationFor(grandparent);
+
−      }
+
−      WritingMode wm = f->GetWritingMode();
+
−      const auto& stylePosISize = f->StylePosition()->ISize(wm);
+
−      const auto& stylePosBSize = f->StylePosition()->BSize(wm);
+
−      if (!stylePosISize.IsAuto() ||
+
−          !stylePosBSize.BehavesLikeInitialValueOnBlockAxis()) {
+
−        return 1.0;
+
−      }
+
−    }
+
−  }
+
−
+
−  int32_t interceptParam = StaticPrefs::font_size_inflation_mappingIntercept();
+
−  float maxRatio = (float)StaticPrefs::font_size_inflation_maxRatio() / 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 != StyleTextSizeAdjust::None &&
+
−         !aFrame->HasAnyStateBits(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->UsableISize());
+
−    }
+
−  }
+
−
+
−  MOZ_ASSERT(false, "root should always be container");
+
−
+
−  return 0;
+
−}
+
−
+
−float nsLayoutUtils::FontSizeInflationFor(const nsIFrame* aFrame) {
+
−  if (SVGUtils::IsInSVGTextSubtree(aFrame)) {
+
−    const nsIFrame* container = aFrame;
+
−    while (!container->IsSVGTextFrame()) {
+
−      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) {
+
−  PresShell* presShell = aPresContext->GetPresShell();
+
−  if (!presShell) {
+
−    return false;
+
−  }
+
−  return presShell->FontSizeInflationEnabled();
+
−}
+
−
+
−/* static */
+
−nsRect nsLayoutUtils::GetBoxShadowRectForFrame(nsIFrame* aFrame,
+
−                                               const nsSize& aFrameSize) {
+
−  auto boxShadows = aFrame->StyleEffects()->mBoxShadow.AsSpan();
+
−  if (boxShadows.IsEmpty()) {
+
−    return nsRect();
+
−  }
+
−
+
−  nsRect inputRect(nsPoint(0, 0), aFrameSize);
+
−
+
−  // According to the CSS spec, box-shadow should be based on the border box.
+
−  // However, that looks broken when the background extends outside the border
+
−  // box, as can be the case with native theming.  To fix that we expand the
+
−  // area that we shadow to include the bounds of any native theme drawing.
+
−  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.
+
−    if (transparency != nsITheme::eOpaque) {
+
−      nsPresContext* presContext = aFrame->PresContext();
+
−      presContext->Theme()->GetWidgetOverflow(
+
−          presContext->DeviceContext(), aFrame,
+
−          styleDisplay->EffectiveAppearance(), &inputRect);
+
−    }
+
−  }
+
−
+
−  nsRect shadows;
+
−  int32_t A2D = aFrame->PresContext()->AppUnitsPerDevPixel();
+
−  for (auto& shadow : boxShadows) {
+
−    nsRect tmpRect = inputRect;
+
−
+
−    // inset shadows are never painted outside the frame
+
−    if (shadow.inset) {
+
−      continue;
+
−    }
+
−
+
−    tmpRect.MoveBy(nsPoint(shadow.base.horizontal.ToAppUnits(),
+
−                           shadow.base.vertical.ToAppUnits()));
+
−    tmpRect.Inflate(shadow.spread.ToAppUnits());
+
−    tmpRect.Inflate(nsContextBoxBlur::GetBlurRadiusMargin(
+
−        shadow.base.blur.ToAppUnits(), A2D));
+
−    shadows.UnionRect(shadows, tmpRect);
+
−  }
+
−  return shadows;
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::GetContentViewerSize(
+
−    const nsPresContext* aPresContext, LayoutDeviceIntSize& aOutSize,
+
−    SubtractDynamicToolbar aSubtractDynamicToolbar) {
+
−  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);
+
−
+
−  if (aPresContext->IsRootContentDocumentCrossProcess() &&
+
−      aSubtractDynamicToolbar == SubtractDynamicToolbar::Yes &&
+
−      aPresContext->HasDynamicToolbar() && !bounds.IsEmpty()) {
+
−    MOZ_ASSERT(aPresContext->IsRootContentDocumentCrossProcess());
+
−    bounds.height -= aPresContext->GetDynamicToolbarMaxHeight();
+
−    // Collapse the size in the case the dynamic toolbar max height is greater
+
−    // than the content bound height so that hopefully embedders of GeckoView
+
−    // may notice they set wrong dynamic toolbar max height.
+
−    if (bounds.height < 0) {
+
−      bounds.height = 0;
+
−    }
+
−  }
+
−
+
−  aOutSize = LayoutDeviceIntRect::FromUnknownRect(bounds).Size();
+
−  return true;
+
−}
+
−
+
−bool nsLayoutUtils::UpdateCompositionBoundsForRCDRSF(
+
−    ParentLayerRect& aCompBounds, const nsPresContext* aPresContext) {
+
−  SubtractDynamicToolbar shouldSubtractDynamicToolbar =
+
−      SubtractDynamicToolbar::Yes;
+
−
+
−  if (RefPtr<MobileViewportManager> MVM =
+
−          aPresContext->PresShell()->GetMobileViewportManager()) {
+
−    CSSSize intrinsicCompositionSize = MVM->GetIntrinsicCompositionSize();
+
−
+
−    if (nsIScrollableFrame* rootScrollableFrame =
+
−            aPresContext->PresShell()->GetRootScrollFrameAsScrollable()) {
+
−      // Expand the composition size to include the area initially covered by
+
−      // the dynamic toolbar only if the content is taller than the intrinsic
+
−      // composition size (i.e. the dynamic toolbar should be able to move only
+
−      // if the content is vertically scrollable).
+
−      if (intrinsicCompositionSize.height <
+
−          CSSPixel::FromAppUnits(
+
−              CalculateScrollableRectForFrame(rootScrollableFrame, nullptr)
+
−                  .Height())) {
+
−        shouldSubtractDynamicToolbar = SubtractDynamicToolbar::No;
+
−      }
+
−    }
+
−  }
+
−
+
−  LayoutDeviceIntSize contentSize;
+
−  if (!GetContentViewerSize(aPresContext, contentSize,
+
−                            shouldSubtractDynamicToolbar)) {
+
−    return false;
+
−  }
+
−  aCompBounds.SizeTo(ViewAs<ParentLayerPixel>(
+
−      LayoutDeviceSize(contentSize),
+
−      PixelCastJustification::LayoutDeviceIsParentLayerForRCDRSF));
+
−  return true;
+
−}
+
−
+
−/* static */
+
−nsMargin nsLayoutUtils::ScrollbarAreaToExcludeFromCompositionBoundsFor(
+
−    const nsIFrame* aScrollFrame) {
+
−  if (!aScrollFrame || !aScrollFrame->GetScrollTargetFrame()) {
+
−    return nsMargin();
+
−  }
+
−  nsPresContext* presContext = aScrollFrame->PresContext();
+
−  PresShell* presShell = presContext->GetPresShell();
+
−  if (!presShell) {
+
−    return nsMargin();
+
−  }
+
−  bool isRootScrollFrame = aScrollFrame == presShell->GetRootScrollFrame();
+
−  bool isRootContentDocRootScrollFrame =
+
−      isRootScrollFrame && presContext->IsRootContentDocumentCrossProcess();
+
−  if (!isRootContentDocRootScrollFrame) {
+
−    return nsMargin();
+
−  }
+
−  if (LookAndFeel::GetInt(LookAndFeel::IntID::UseOverlayScrollbars)) {
+
−    return nsMargin();
+
−  }
+
−  nsIScrollableFrame* scrollableFrame = aScrollFrame->GetScrollTargetFrame();
+
−  if (!scrollableFrame) {
+
−    return nsMargin();
+
−  }
+
−  return scrollableFrame->GetActualScrollbarSizes(
+
−      nsIScrollableFrame::ScrollbarSizesOptions::
+
−          INCLUDE_VISUAL_VIEWPORT_SCROLLBARS);
+
−}
+
−
+
−/* static */
+
−nsSize nsLayoutUtils::CalculateCompositionSizeForFrame(
+
−    nsIFrame* aFrame, bool aSubtractScrollbars,
+
−    const nsSize* aOverrideScrollPortSize) {
+
−  // 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 =
+
−      aOverrideScrollPortSize ? *aOverrideScrollPortSize : rect.Size();
+
−
+
−  nsPresContext* presContext = aFrame->PresContext();
+
−  PresShell* presShell = presContext->PresShell();
+
−
+
−  bool isRootContentDocRootScrollFrame =
+
−      presContext->IsRootContentDocumentCrossProcess() &&
+
−      aFrame == presShell->GetRootScrollFrame();
+
−  if (isRootContentDocRootScrollFrame) {
+
−    ParentLayerRect compBounds;
+
−    if (UpdateCompositionBoundsForRCDRSF(compBounds, presContext)) {
+
−      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::CalculateBoundingCompositionSize(
+
−    const 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->GetInProcessRootContentDocumentPresContext();
+
−  if (!rootPresContext) {
+
−    rootPresContext = presContext->GetRootPresContext();
+
−  }
+
−  PresShell* 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)) {
+
−        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();
+
−
+
−  CSSSize result =
+
−      rootCompositionSize / aMetrics.DisplayportPixelsPerCSSPixel();
+
−
+
−  // If this is a nested content process, the in-process root content document's
+
−  // composition size may still be arbitrarily large, so bound it further by
+
−  // how much of the in-process RCD is visible in the top-level (cross-process
+
−  // RCD) viewport.
+
−  if (rootPresShell) {
+
−    if (BrowserChild* bc = BrowserChild::GetFrom(rootPresShell)) {
+
−      if (const auto& visibleRect =
+
−              bc->GetTopLevelViewportVisibleRectInSelfCoords()) {
+
−        CSSSize cssVisibleRect =
+
−            visibleRect->Size() / rootPresContext->CSSToDevPixelScale();
+
−        result = Min(result, cssVisibleRect);
+
−      }
+
−    }
+
−  }
+
−
+
−  return result;
+
−}
+
−
+
−/* static */
+
−nsRect nsLayoutUtils::CalculateScrollableRectForFrame(
+
−    const nsIScrollableFrame* aScrollableFrame, const nsIFrame* aRootFrame) {
+
−  nsRect contentBounds;
+
−  if (aScrollableFrame) {
+
−    contentBounds = aScrollableFrame->GetScrollRange();
+
−
+
−    nsPoint scrollPosition = aScrollableFrame->GetScrollPosition();
+
−    if (aScrollableFrame->GetScrollStyles().mVertical ==
+
−        StyleOverflow::Hidden) {
+
−      contentBounds.y = scrollPosition.y;
+
−      contentBounds.height = 0;
+
−    }
+
−    if (aScrollableFrame->GetScrollStyles().mHorizontal ==
+
−        StyleOverflow::Hidden) {
+
−      contentBounds.x = scrollPosition.x;
+
−      contentBounds.width = 0;
+
−    }
+
−
+
−    contentBounds.width += aScrollableFrame->GetScrollPortRect().width;
+
−    contentBounds.height += aScrollableFrame->GetScrollPortRect().height;
+
−  } else {
+
−    contentBounds = aRootFrame->GetRect();
+
−    // Clamp to (0, 0) if there is no corresponding scrollable frame for the
+
−    // given |aRootFrame|.
+
−    contentBounds.MoveTo(0, 0);
+
−  }
+
−  return contentBounds;
+
−}
+
−
+
−/* static */
+
−nsRect nsLayoutUtils::CalculateExpandedScrollableRect(nsIFrame* aFrame) {
+
−  nsRect scrollableRect = CalculateScrollableRectForFrame(
+
−      aFrame->GetScrollTargetFrame(), aFrame->PresShell()->GetRootFrame());
+
−  nsSize compSize = CalculateCompositionSizeForFrame(aFrame);
+
−
+
−  if (aFrame == aFrame->PresShell()->GetRootScrollFrame()) {
+
−    // the composition size for the root scroll frame does not include the
+
−    // local resolution, so we adjust.
+
−    float res = aFrame->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(WebRenderLayerManager* aManager,
+
−                                          ViewID aScrollId,
+
−                                          const std::string& aKey,
+
−                                          const std::string& aValue) {
+
−  MOZ_ASSERT(nsLayoutUtils::IsAPZTestLoggingEnabled(), "don't call me");
+
−  aManager->LogTestDataForCurrentPaint(aScrollId, aKey, aValue);
+
−}
+
−
+
−void nsLayoutUtils::LogAdditionalTestData(nsDisplayListBuilder* aBuilder,
+
−                                          const std::string& aKey,
+
−                                          const std::string& aValue) {
+
−  WebRenderLayerManager* manager = aBuilder->GetWidgetLayerManager(nullptr);
+
−  if (!manager) {
+
−    return;
+
−  }
+
−  manager->LogAdditionalTestData(aKey, aValue);
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::IsAPZTestLoggingEnabled() {
+
−  return StaticPrefs::apz_test_logging_enabled();
+
−}
+
−
+
−////////////////////////////////////////
+
−// SurfaceFromElementResult
+
−
+
−SurfaceFromElementResult::SurfaceFromElementResult()
+
−    // Use safe default values here
+
−    : mHadCrossOriginRedirects(false),
+
−      mIsWriteOnly(true),
+
−      mIsStillLoading(false),
+
−      mHasSize(false),
+
−      mCORSUsed(false),
+
−      mAlphaType(gfxAlphaType::Opaque) {}
+
−
+
−const RefPtr<mozilla::gfx::SourceSurface>&
+
−SurfaceFromElementResult::GetSourceSurface() {
+
−  if (!mSourceSurface && mLayersImage) {
+
−    mSourceSurface = mLayersImage->GetAsSourceSurface();
+
−  }
+
−
+
−  return mSourceSurface;
+
−}
+
−
+
−////////////////////////////////////////
+
−
+
−bool nsLayoutUtils::IsNonWrapperBlock(nsIFrame* aFrame) {
+
−  MOZ_ASSERT(aFrame);
+
−  return aFrame->IsBlockFrameOrSubclass() && !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;
+
−    mOldValue = false;
+
−  }
+
−}
+
−
+
−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 mozilla
+
−
+
−/* 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(
+
−    PresShell* aPresShell) {
+
−  if (Document* doc = aPresShell->GetDocument()) {
+
−    WidgetEvent event(true, eVoidEvent);
+
−    nsTArray<EventTarget*> targets;
+
−    nsresult rv = EventDispatcher::Dispatch(
+
−        ToSupports(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 */
+
−bool nsLayoutUtils::CanScrollOriginClobberApz(ScrollOrigin aScrollOrigin) {
+
−  switch (aScrollOrigin) {
+
−    case ScrollOrigin::None:
+
−    case ScrollOrigin::NotSpecified:
+
−    case ScrollOrigin::Apz:
+
−    case ScrollOrigin::Restore:
+
−      return false;
+
−    default:
+
−      return true;
+
−  }
+
−}
+
−
+
−/* static */
+
−ScrollMetadata nsLayoutUtils::ComputeScrollMetadata(
+
−    const nsIFrame* aForFrame, const nsIFrame* aScrollFrame,
+
−    nsIContent* aContent, const nsIFrame* aReferenceFrame,
+
−    WebRenderLayerManager* aLayerManager, ViewID aScrollParentId,
+
−    const nsSize& aScrollPortSize, const Maybe<nsRect>& aClipRect,
+
−    bool aIsRootContent) {
+
−  const nsPresContext* presContext = aForFrame->PresContext();
+
−  int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();
+
−
+
−  PresShell* presShell = presContext->GetPresShell();
+
−  ScrollMetadata metadata;
+
−  FrameMetrics& metrics = metadata.GetMetrics();
+
−  metrics.SetLayoutViewport(
+
−      CSSRect(CSSPoint(), CSSSize::FromAppUnits(aScrollPortSize)));
+
−
+
−  nsIDocShell* docShell = presContext->GetDocShell();
+
−  const BrowsingContext* bc =
+
−      docShell ? docShell->GetBrowsingContext() : nullptr;
+
−  bool isTouchEventsEnabled =
+
−      bc &&
+
−      bc->TouchEventsOverride() == mozilla::dom::TouchEventsOverride::Enabled;
+
−
+
−  if (bc && bc->InRDMPane() && isTouchEventsEnabled) {
+
−    metadata.SetIsRDMTouchSimulationActive(true);
+
−  }
+
−
+
−  ViewID scrollId = ScrollableLayerGuid::NULL_SCROLL_ID;
+
−  if (aContent) {
+
−    if (void* paintRequestTime =
+
−            aContent->GetProperty(nsGkAtoms::paintRequestTime)) {
+
−      metrics.SetPaintRequestTime(*static_cast<TimeStamp*>(paintRequestTime));
+
−      aContent->RemoveProperty(nsGkAtoms::paintRequestTime);
+
−    }
+
−    scrollId = nsLayoutUtils::FindOrCreateIDFor(aContent);
+
−    nsRect dp;
+
−    if (DisplayPortUtils::GetDisplayPort(aContent, &dp)) {
+
−      metrics.SetDisplayPort(CSSRect::FromAppUnits(dp));
+
−      DisplayPortUtils::MarkDisplayPortAsPainted(aContent);
+
−    }
+
−    if (DisplayPortUtils::GetCriticalDisplayPort(aContent, &dp)) {
+
−      metrics.SetCriticalDisplayPort(CSSRect::FromAppUnits(dp));
+
−    }
+
−
+
−    metrics.SetHasNonZeroDisplayPortMargins(false);
+
−    if (DisplayPortMarginsPropertyData* currentData =
+
−            static_cast<DisplayPortMarginsPropertyData*>(
+
−                aContent->GetProperty(nsGkAtoms::DisplayPortMargins))) {
+
−      if (currentData->mMargins.mMargins != ScreenMargin()) {
+
−        metrics.SetHasNonZeroDisplayPortMargins(true);
+
−      }
+
−    }
+
−
+
−    // Log the high-resolution display port (which is either the displayport
+
−    // or the critical displayport) for test purposes.
+
−    if (IsAPZTestLoggingEnabled()) {
+
−      LogTestDataForPaint(aLayerManager, scrollId, "displayport",
+
−                          StaticPrefs::layers_low_precision_buffer()
+
−                              ? metrics.GetCriticalDisplayPort()
+
−                              : metrics.GetDisplayPort());
+
−    }
+
−
+
−    metrics.SetMinimalDisplayPort(
+
−        aContent->GetProperty(nsGkAtoms::MinimalDisplayPort));
+
−  }
+
−
+
−  const nsIScrollableFrame* scrollableFrame = nullptr;
+
−  if (aScrollFrame) scrollableFrame = aScrollFrame->GetScrollTargetFrame();
+
−
+
−  metrics.SetScrollableRect(
+
−      CSSRect::FromAppUnits(nsLayoutUtils::CalculateScrollableRectForFrame(
+
−          scrollableFrame, aForFrame)));
+
−
+
−  if (scrollableFrame) {
+
−    CSSPoint layoutScrollOffset =
+
−        CSSPoint::FromAppUnits(scrollableFrame->GetScrollPosition());
+
−    CSSPoint visualScrollOffset =
+
−        aIsRootContent && presShell->IsVisualViewportOffsetSet()
+
−            ? CSSPoint::FromAppUnits(presShell->GetVisualViewportOffset())
+
−            : layoutScrollOffset;
+
−    metrics.SetVisualScrollOffset(visualScrollOffset);
+
−    // APZ sometimes reads this even if we haven't set a visual scroll
+
−    // update type (specifically, in the isFirstPaint case), so always
+
−    // set it.
+
−    metrics.SetVisualDestination(visualScrollOffset);
+
−
+
−    if (aIsRootContent) {
+
−      if (aLayerManager->GetIsFirstPaint() &&
+
−          presShell->IsVisualViewportOffsetSet()) {
+
−        // Restore the visual viewport offset to the copy stored on the
+
−        // main thread.
+
−        presShell->ScrollToVisual(presShell->GetVisualViewportOffset(),
+
−                                  FrameMetrics::eRestore, ScrollMode::Instant);
+
−      }
+
−    }
+
−
+
−    if (scrollableFrame->IsRootScrollFrameOfDocument()) {
+
−      if (const Maybe<PresShell::VisualScrollUpdate>& visualUpdate =
+
−              presShell->GetPendingVisualScrollUpdate()) {
+
−        metrics.SetVisualDestination(
+
−            CSSPoint::FromAppUnits(visualUpdate->mVisualScrollOffset));
+
−        metrics.SetVisualScrollUpdateType(visualUpdate->mUpdateType);
+
−        presShell->AcknowledgePendingVisualScrollUpdate();
+
−      }
+
−    }
+
−
+
−    if (aIsRootContent) {
+
−      // Expand the layout viewport to the size including the area covered by
+
−      // the dynamic toolbar in the case where the dynamic toolbar is being
+
−      // used, otherwise when the dynamic toolbar transitions on the compositor,
+
−      // the layout viewport will be smaller than the visual viewport on the
+
−      // compositor, thus the layout viewport offset will be forced to be moved
+
−      // in FrameMetrics::KeepLayoutViewportEnclosingVisualViewport.
+
−      if (presContext->HasDynamicToolbar()) {
+
−        CSSRect viewport = metrics.GetLayoutViewport();
+
−        viewport.SizeTo(nsLayoutUtils::ExpandHeightForDynamicToolbar(
+
−            presContext, viewport.Size()));
+
−        metrics.SetLayoutViewport(viewport);
+
−
+
−        // We need to set 'fixed margins' to adjust 'fixed margins' value on the
+
−        // composiutor in the case where the dynamic toolbar is completely
+
−        // hidden because the margin value on the compositor is offset from the
+
−        // position where the dynamic toolbar is completely VISIBLE but now the
+
−        // toolbar is completely HIDDEN we need to adjust the difference on the
+
−        // compositor.
+
−        if (presContext->GetDynamicToolbarState() ==
+
−            DynamicToolbarState::Collapsed) {
+
−          metrics.SetFixedLayerMargins(
+
−              ScreenMargin(0, 0,
+
−                           presContext->GetDynamicToolbarHeight() -
+
−                               presContext->GetDynamicToolbarMaxHeight(),
+
−                           0));
+
−        }
+
−      }
+
−    }
+
−
+
−    metrics.SetScrollGeneration(scrollableFrame->CurrentScrollGeneration());
+
−
+
−    CSSRect viewport = metrics.GetLayoutViewport();
+
−    viewport.MoveTo(layoutScrollOffset);
+
−    metrics.SetLayoutViewport(viewport);
+
−
+
−    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()) {
+
−      metadata.SetDisregardedDirection(
+
−          WheelHandlingUtils::GetDisregardedWheelScrollDirection(
+
−              aScrollFrame->GetParent()));
+
−    }
+
−
+
−    metadata.SetSnapInfo(scrollableFrame->GetScrollSnapInfo());
+
−    metadata.SetOverscrollBehavior(
+
−        scrollableFrame->GetOverscrollBehaviorInfo());
+
−    metadata.SetScrollUpdates(scrollableFrame->GetScrollUpdates());
+
−  }
+
−
+
−  // 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 == ScrollableLayerGuid::NULL_SCROLL_ID ||
+
−             scrollId != aScrollParentId);
+
−  metrics.SetScrollId(scrollId);
+
−  metrics.SetIsRootContent(aIsRootContent);
+
−  metadata.SetScrollParentId(aScrollParentId);
+
−
+
−  const nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
+
−  bool isRootScrollFrame = aScrollFrame == rootScrollFrame;
+
−  Document* document = presShell->GetDocument();
+
−
+
−  if (scrollId != ScrollableLayerGuid::NULL_SCROLL_ID &&
+
−      !presContext->GetParentPresContext()) {
+
−    if ((aScrollFrame && isRootScrollFrame)) {
+
−      metadata.SetIsLayersIdRoot(true);
+
−    } else {
+
−      MOZ_ASSERT(document, "A non-root-scroll frame must be in a document");
+
−      if (aContent == document->GetDocumentElement()) {
+
−        metadata.SetIsLayersIdRoot(true);
+
−      }
+
−    }
+
−  }
+
−
+
−  // Get whether the root content is RTL(E.g. it's true either if
+
−  // "writing-mode: vertical-rl", or if
+
−  // "writing-mode: horizontal-tb; direction: rtl;" in CSS).
+
−  // For the concept of this and the reason why we need to get this kind of
+
−  // information, see the definition of |mIsAutoDirRootContentRTL| in struct
+
−  // |ScrollMetadata|.
+
−  const Element* bodyElement = document ? document->GetBodyElement() : nullptr;
+
−  const nsIFrame* primaryFrame =
+
−      bodyElement ? bodyElement->GetPrimaryFrame() : rootScrollFrame;
+
−  if (!primaryFrame) {
+
−    primaryFrame = rootScrollFrame;
+
−  }
+
−  if (primaryFrame) {
+
−    WritingMode writingModeOfRootScrollFrame = primaryFrame->GetWritingMode();
+
−    WritingMode::BlockDir blockDirOfRootScrollFrame =
+
−        writingModeOfRootScrollFrame.GetBlockDir();
+
−    WritingMode::InlineDir inlineDirOfRootScrollFrame =
+
−        writingModeOfRootScrollFrame.GetInlineDir();
+
−    if (blockDirOfRootScrollFrame == WritingMode::BlockDir::eBlockRL ||
+
−        (blockDirOfRootScrollFrame == WritingMode::BlockDir::eBlockTB &&
+
−         inlineDirOfRootScrollFrame == WritingMode::InlineDir::eInlineRTL)) {
+
−      metadata.SetIsAutoDirRootContentRTL(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 (isRootScrollFrame) {
+
−    metrics.SetPresShellResolution(presShell->GetResolution());
+
−  } else {
+
−    metrics.SetPresShellResolution(1.0f);
+
−  }
+
−
+
−  if (presShell->IsResolutionUpdated()) {
+
−    metadata.SetResolutionUpdated(true);
+
−  }
+
−
+
−  // 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... except if we're in WebRender in which case we
+
−  // don't have a aContainerParameters. In that case we're also not rasterizing
+
−  // in Gecko anyway, so the only resolution we care about here is the presShell
+
−  // resolution which we need to propagate to WebRender.
+
−  metrics.SetCumulativeResolution(LayoutDeviceToLayerScale2D(
+
−      LayoutDeviceToLayerScale(presShell->GetCumulativeResolution())));
+
−
+
−  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.
+
−  const 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 isRootContentDocRootScrollFrame =
+
−      isRootScrollFrame && presContext->IsRootContentDocumentCrossProcess();
+
−  if (isRootContentDocRootScrollFrame) {
+
−    UpdateCompositionBoundsForRCDRSF(frameBounds, presContext);
+
−    if (RefPtr<MobileViewportManager> MVM =
+
−            presContext->PresShell()->GetMobileViewportManager()) {
+
−      metrics.SetCompositionSizeWithoutDynamicToolbar(
+
−          MVM->GetCompositionSizeWithoutDynamicToolbar());
+
−    }
+
−  }
+
−
+
−  metrics.SetCompositionBoundsWidthIgnoringScrollbars(frameBounds.width);
+
−
+
−  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.SetBoundingCompositionSize(
+
−      nsLayoutUtils::CalculateBoundingCompositionSize(
+
−          aScrollFrame ? aScrollFrame : aForFrame,
+
−          isRootContentDocRootScrollFrame, metrics));
+
−
+
−  if (StaticPrefs::apz_printtree() || StaticPrefs::apz_test_logging_enabled()) {
+
−    if (const nsIContent* content =
+
−            frameForCompositionBoundsCalculation->GetContent()) {
+
−      nsAutoString contentDescription;
+
−      if (content->IsElement()) {
+
−        content->AsElement()->Describe(contentDescription);
+
−      } else {
+
−        contentDescription.AssignLiteral("(not an element)");
+
−      }
+
−      metadata.SetContentDescription(
+
−          NS_LossyConvertUTF16toASCII(contentDescription));
+
−      if (IsAPZTestLoggingEnabled()) {
+
−        LogTestDataForPaint(aLayerManager, 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(
+
−          sRGBColor::FromABGR(presShell->GetCanvasBackground()));
+
−    } else {
+
−      ComputedStyle* backgroundStyle;
+
−      if (nsCSSRendering::FindBackground(aScrollFrame, &backgroundStyle)) {
+
−        nscolor backgroundColor =
+
−            backgroundStyle->StyleBackground()->BackgroundColor(
+
−                backgroundStyle);
+
−        metadata.SetBackgroundColor(sRGBColor::FromABGR(backgroundColor));
+
−      }
+
−    }
+
−  }
+
−
+
−  if (ShouldDisableApzForElement(aContent)) {
+
−    metadata.SetForceDisableApz(true);
+
−  }
+
−
+
−  metadata.SetPrefersReducedMotion(
+
−      Gecko_MediaFeatures_PrefersReducedMotion(document));
+
−
+
−  return metadata;
+
−}
+
−
+
−/*static*/
+
−Maybe<ScrollMetadata> nsLayoutUtils::GetRootMetadata(
+
−    nsDisplayListBuilder* aBuilder, WebRenderLayerManager* aLayerManager,
+
−    const std::function<bool(ViewID& aScrollId)>& aCallback) {
+
−  nsIFrame* frame = aBuilder->RootReferenceFrame();
+
−  nsPresContext* presContext = frame->PresContext();
+
−  PresShell* presShell = presContext->PresShell();
+
−  Document* document = presShell->GetDocument();
+
−
+
−  // There is one case where we want the root container layer to have metrics.
+
−  // If the parent process is using XUL windows, there is no root scrollframe,
+
−  // and without explicitly creating metrics there will be no guaranteed
+
−  // top-level APZC.
+
−  bool addMetrics = XRE_IsParentProcess() && !presShell->GetRootScrollFrame();
+
−
+
−  // Add metrics if there are none in the layer tree with the id (create an id
+
−  // if there isn't one already) of the root scroll frame/root content.
+
−  bool ensureMetricsForRootId = nsLayoutUtils::AsyncPanZoomEnabled(frame) &&
+
−                                aBuilder->IsPaintingToWindow() &&
+
−                                !presContext->GetParentPresContext();
+
−
+
−  nsIContent* content = nullptr;
+
−  nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
+
−  if (rootScrollFrame) {
+
−    content = rootScrollFrame->GetContent();
+
−  } else {
+
−    // If there is no root scroll frame, pick the document element instead.
+
−    // The only case we don't want to do this is in non-APZ fennec, where
+
−    // we want the root xul document to get a null scroll id so that the root
+
−    // content document gets the first non-null scroll id.
+
−    content = document->GetDocumentElement();
+
−  }
+
−
+
−  if (ensureMetricsForRootId && content) {
+
−    ViewID scrollId = nsLayoutUtils::FindOrCreateIDFor(content);
+
−    if (aCallback(scrollId)) {
+
−      ensureMetricsForRootId = false;
+
−    }
+
−  }
+
−
+
−  if (addMetrics || ensureMetricsForRootId) {
+
−    bool isRootContent = presContext->IsRootContentDocumentCrossProcess();
+
−
+
−    nsSize scrollPortSize = frame->GetSize();
+
−    if (isRootContent && rootScrollFrame) {
+
−      nsIScrollableFrame* scrollableFrame =
+
−          rootScrollFrame->GetScrollTargetFrame();
+
−      scrollPortSize = scrollableFrame->GetScrollPortRect().Size();
+
−    }
+
−    return Some(nsLayoutUtils::ComputeScrollMetadata(
+
−        frame, rootScrollFrame, content, aBuilder->FindReferenceFrameFor(frame),
+
−        aLayerManager, ScrollableLayerGuid::NULL_SCROLL_ID, scrollPortSize,
+
−        Nothing(), isRootContent));
+
−  }
+
−
+
−  return Nothing();
+
−}
+
−
+
−/* 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 */
+
−StyleTouchAction nsLayoutUtils::GetTouchActionFromFrame(nsIFrame* aFrame) {
+
−  if (!aFrame) {
+
−    return StyleTouchAction::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 StyleTouchAction::AUTO;
+
−  }
+
−
+
−  const nsStyleDisplay* disp = aFrame->StyleDisplay();
+
−  bool isTableElement = disp->IsInternalTableStyleExceptCell();
+
−  if (isTableElement) {
+
−    return StyleTouchAction::AUTO;
+
−  }
+
−
+
−  return disp->mTouchAction;
+
−}
+
−
+
−/* static */
+
−void nsLayoutUtils::TransformToAncestorAndCombineRegions(
+
−    const nsRegion& aRegion, nsIFrame* aFrame, const nsIFrame* aAncestorFrame,
+
−    nsRegion* aPreciseTargetDest, nsRegion* aImpreciseTargetDest,
+
−    Maybe<Matrix4x4Flagged>* aMatrixCache, const DisplayItemClip* aClip) {
+
−  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);
+
−    if (aClip) {
+
−      transformed = aClip->ApplyNonRoundedIntersection(transformed);
+
−      if (aClip->GetRoundedRectCount() > 0) {
+
−        isPrecise = false;
+
−      }
+
−    }
+
−    transformedRegion.OrWith(transformed);
+
−  }
+
−  nsRegion* dest = isPrecise ? aPreciseTargetDest : aImpreciseTargetDest;
+
−  dest->OrWith(transformedRegion.ToRegion());
+
−  // If the region becomes too complex this has a large performance impact.
+
−  // We limit its complexity here.
+
−  if (dest->GetNumRects() > 12) {
+
−    dest->SimplifyOutward(6);
+
−    if (isPrecise) {
+
−      aPreciseTargetDest->OrWith(*aImpreciseTargetDest);
+
−      *aImpreciseTargetDest = std::move(*aPreciseTargetDest);
+
−      aImpreciseTargetDest->SimplifyOutward(6);
+
−      *aPreciseTargetDest = nsRegion();
+
−    }
+
−  }
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::ShouldUseNoScriptSheet(Document* 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(Document* 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->IsTextFrame()) {
+
−    auto textFrame = static_cast<nsTextFrame*>(aFrame);
+
−    auto offset = textFrame->GetContentOffset();
+
−    auto length = textFrame->GetContentLength();
+
−    textFrame->TextFragment()->AppendTo(aResult, offset, length);
+
−  } else {
+
−    for (nsIFrame* child : aFrame->PrincipalChildList()) {
+
−      AppendFrameTextContent(child, aResult);
+
−    }
+
−  }
+
−}
+
−
+
−/* static */
+
−nsRect nsLayoutUtils::GetSelectionBoundingRect(const 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->GetStartContainer(),
+
−          range->StartOffset(), range->GetEndContainer(), 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 || ancestor->IsBlockFrameOrSubclass(),
+
−             "Float containing block can only be block frame");
+
−  return static_cast<nsBlockFrame*>(ancestor);
+
−}
+
−
+
−// The implementations of this calculation are adapted from
+
−// Element::GetBoundingClientRect().
+
−/* static */
+
−CSSRect nsLayoutUtils::GetBoundingContentRect(
+
−    const nsIContent* aContent, const nsIScrollableFrame* aRootScrollFrame,
+
−    Maybe<CSSRect>* aOutNearestScrollClip) {
+
−  if (nsIFrame* frame = aContent->GetPrimaryFrame()) {
+
−    return GetBoundingFrameRect(frame, aRootScrollFrame, aOutNearestScrollClip);
+
−  }
+
−  return CSSRect();
+
−}
+
−
+
−/* static */
+
−CSSRect nsLayoutUtils::GetBoundingFrameRect(
+
−    nsIFrame* aFrame, const nsIScrollableFrame* aRootScrollFrame,
+
−    Maybe<CSSRect>* aOutNearestScrollClip) {
+
−  CSSRect result;
+
−  nsIFrame* relativeTo = aRootScrollFrame->GetScrolledFrame();
+
−  result = CSSRect::FromAppUnits(nsLayoutUtils::GetAllInFlowRectsUnion(
+
−      aFrame, 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(
+
−      aFrame, SCROLLABLE_INCLUDE_HIDDEN | SCROLLABLE_FIXEDPOS_FINDS_ROOT);
+
−  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|.
+
−    nsRect subFrameRect = subFrame->GetRectRelativeToSelf();
+
−    TransformResult res =
+
−        nsLayoutUtils::TransformRect(subFrame, relativeTo, subFrameRect);
+
−    MOZ_ASSERT(res == TRANSFORM_SUCCEEDED || res == NONINVERTIBLE_TRANSFORM);
+
−    if (res == TRANSFORM_SUCCEEDED) {
+
−      CSSRect subFrameRectCSS = CSSRect::FromAppUnits(subFrameRect);
+
−      if (aOutNearestScrollClip) {
+
−        *aOutNearestScrollClip = Some(subFrameRectCSS);
+
−      }
+
−
+
−      result = subFrameRectCSS.Intersect(result);
+
−    }
+
−  }
+
−  return result;
+
−}
+
−
+
−/* 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> lastContent;
+
−  bool seenRcdRsf = false;
+
−
+
−  // Helper lambda to apply the callback transform for a single frame.
+
−  auto applyCallbackTransformForFrame = [&](nsIFrame* frame) {
+
−    if (frame) {
+
−      nsCOMPtr<nsIContent> content = frame->GetContent();
+
−      if (content && (content != lastContent)) {
+
−        void* property = content->GetProperty(nsGkAtoms::apzCallbackTransform);
+
−        if (property) {
+
−          delta += *static_cast<CSSPoint*>(property);
+
−        }
+
−      }
+
−      lastContent = content;
+
−    }
+
−  };
+
−
+
−  while (frame) {
+
−    // Apply the callback transform for the current frame.
+
−    applyCallbackTransformForFrame(frame);
+
−
+
−    // Keep track of whether we've encountered the RCD-RSF's content element.
+
−    nsPresContext* pc = frame->PresContext();
+
−    if (pc->IsRootContentDocumentCrossProcess()) {
+
−      if (PresShell* shell = pc->GetPresShell()) {
+
−        if (nsIFrame* rsf = shell->GetRootScrollFrame()) {
+
−          if (frame->GetContent() == rsf->GetContent()) {
+
−            seenRcdRsf = true;
+
−          }
+
−        }
+
−      }
+
−    }
+
−
+
−    // If we reach the RCD's viewport frame, but have not encountered
+
−    // the RCD-RSF, we were inside fixed content in the RCD.
+
−    // We still want to apply the RCD-RSF's callback transform because
+
−    // it contains the offset between the visual and layout viewports
+
−    // which applies to fixed content as well.
+
−    ViewportFrame* viewportFrame = do_QueryFrame(frame);
+
−    if (viewportFrame) {
+
−      if (pc->IsRootContentDocumentCrossProcess() && !seenRcdRsf) {
+
−        applyCallbackTransformForFrame(pc->PresShell()->GetRootScrollFrame());
+
−      }
+
−    }
+
−
+
−    // Proceed to the parent frame.
+
−    frame = GetCrossDocParentFrameInProcess(frame);
+
−  }
+
−  return delta;
+
−}
+
−
+
−static nsSize ComputeMaxSizeForPartialPrerender(nsIFrame* aFrame,
+
−                                                nsSize aMaxSize) {
+
−  Matrix4x4Flagged transform = nsLayoutUtils::GetTransformToAncestor(
+
−      RelativeTo{aFrame},
+
−      RelativeTo{nsLayoutUtils::GetDisplayRootFrame(aFrame)});
+
−
+
−  Matrix transform2D;
+
−  if (!transform.Is2D(&transform2D)) {
+
−    return aMaxSize;
+
−  }
+
−
+
−  gfx::Rect result(0, 0, aMaxSize.width, aMaxSize.height);
+
−  gfx::Size scale = transform2D.ScaleFactors();
+
−  if (scale.width != 0 && scale.height != 0) {
+
−    result.width /= scale.width;
+
−    result.height /= scale.height;
+
−  }
+
−
+
−  // Don't apply translate.
+
−  transform2D._31 = 0.0f;
+
−  transform2D._32 = 0.0f;
+
−
+
−  // Don't apply scale.
+
−  if (scale.width != 0 && scale.height != 0) {
+
−    transform2D._11 /= scale.width;
+
−    transform2D._12 /= scale.width;
+
−    transform2D._21 /= scale.height;
+
−    transform2D._22 /= scale.height;
+
−  }
+
−
+
−  // Theoretically we should use transform2D.Inverse() here but in this case
+
−  // |transform2D| is a pure rotation matrix, no scaling, no translate at all,
+
−  // so that the result bound's width and height would be pretty much same
+
−  // as the one rotated by the inverse matrix.
+
−  result = transform2D.TransformBounds(result);
+
−  return nsSize(result.width, result.height);
+
−}
+
−
+
−/* static */
+
−nsRect nsLayoutUtils::ComputePartialPrerenderArea(
+
−    nsIFrame* aFrame, const nsRect& aDirtyRect, const nsRect& aOverflow,
+
−    const nsSize& aPrerenderSize) {
+
−  nsSize maxSizeForPartialPrerender =
+
−      ComputeMaxSizeForPartialPrerender(aFrame, aPrerenderSize);
+
−  // Simple calculation for now: center the pre-render area on the dirty rect,
+
−  // and clamp to the overflow area. Later we can do more advanced things like
+
−  // redistributing from one axis to another, or from one side to another.
+
−  nscoord xExcess =
+
−      std::max(maxSizeForPartialPrerender.width - aDirtyRect.width, 0);
+
−  nscoord yExcess =
+
−      std::max(maxSizeForPartialPrerender.height - aDirtyRect.height, 0);
+
−  nsRect result = aDirtyRect;
+
−  result.Inflate(xExcess / 2, yExcess / 2);
+
−  return result.MoveInsideAndClamp(aOverflow);
+
−}
+
−
+
−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->IsInlineFrame()) {
+
−    for (nsIFrame* child : aFrame->PrincipalChildList()) {
+
−      if (LineHasNonEmptyContentWorker(child)) {
+
−        return true;
+
−      }
+
−    }
+
−  } else {
+
−    if (!aFrame->IsBrFrame() && !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->IsBrFrame()) {
+
−    return false;
+
−  }
+
−
+
−  nsContainerFrame* f = frame->GetParent();
+
−  while (f && f->IsFrameOfType(nsIFrame::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;
+
−}
+
−
+
−static nsRect ComputeSVGReferenceRect(nsIFrame* aFrame,
+
−                                      StyleGeometryBox aGeometryBox) {
+
−  MOZ_ASSERT(aFrame->GetContent()->IsSVGElement());
+
−  nsRect r;
+
−
+
−  // For SVG elements without associated CSS layout box, the used value for
+
−  // content-box, padding-box, border-box and margin-box is fill-box.
+
−  switch (aGeometryBox) {
+
−    case StyleGeometryBox::StrokeBox: {
+
−      // XXX Bug 1299876
+
−      // The size of stroke-box is not correct if this graphic element has
+
−      // specific stroke-linejoin or stroke-linecap.
+
−      gfxRect bbox =
+
−          SVGUtils::GetBBox(aFrame, SVGUtils::eBBoxIncludeFillGeometry |
+
−                                        SVGUtils::eBBoxIncludeStroke);
+
−      r = nsLayoutUtils::RoundGfxRectToAppRect(bbox, AppUnitsPerCSSPixel());
+
−      break;
+
−    }
+
−    case StyleGeometryBox::ViewBox: {
+
−      nsIContent* content = aFrame->GetContent();
+
−      SVGElement* element = static_cast<SVGElement*>(content);
+
−      SVGViewportElement* svgElement = element->GetCtx();
+
−      MOZ_ASSERT(svgElement);
+
−
+
−      if (svgElement && svgElement->HasViewBox()) {
+
−        // If a `viewBox` attribute is specified for the SVG viewport creating
+
−        // element:
+
−        // 1. The reference box is positioned at the origin of the coordinate
+
−        //    system established by the `viewBox` attribute.
+
−        // 2. The dimension of the reference box is set to the width and height
+
−        //    values of the `viewBox` attribute.
+
−        const SVGViewBox& value =
+
−            svgElement->GetAnimatedViewBox()->GetAnimValue();
+
−        r = nsRect(nsPresContext::CSSPixelsToAppUnits(value.x),
+
−                   nsPresContext::CSSPixelsToAppUnits(value.y),
+
−                   nsPresContext::CSSPixelsToAppUnits(value.width),
+
−                   nsPresContext::CSSPixelsToAppUnits(value.height));
+
−      } else {
+
−        // No viewBox is specified, uses the nearest SVG viewport as reference
+
−        // box.
+
−        svgFloatSize viewportSize = svgElement->GetViewportSize();
+
−        r = nsRect(0, 0, nsPresContext::CSSPixelsToAppUnits(viewportSize.width),
+
−                   nsPresContext::CSSPixelsToAppUnits(viewportSize.height));
+
−      }
+
−
+
−      break;
+
−    }
+
−    case StyleGeometryBox::NoBox:
+
−    case StyleGeometryBox::BorderBox:
+
−    case StyleGeometryBox::ContentBox:
+
−    case StyleGeometryBox::PaddingBox:
+
−    case StyleGeometryBox::MarginBox:
+
−    case StyleGeometryBox::FillBox: {
+
−      gfxRect bbox =
+
−          SVGUtils::GetBBox(aFrame, SVGUtils::eBBoxIncludeFillGeometry);
+
−      r = nsLayoutUtils::RoundGfxRectToAppRect(bbox, AppUnitsPerCSSPixel());
+
−      break;
+
−    }
+
−    default: {
+
−      MOZ_ASSERT_UNREACHABLE("unknown StyleGeometryBox type");
+
−      gfxRect bbox =
+
−          SVGUtils::GetBBox(aFrame, SVGUtils::eBBoxIncludeFillGeometry);
+
−      r = nsLayoutUtils::RoundGfxRectToAppRect(bbox, AppUnitsPerCSSPixel());
+
−      break;
+
−    }
+
−  }
+
−
+
−  return r;
+
−}
+
−
+
−static nsRect ComputeHTMLReferenceRect(nsIFrame* aFrame,
+
−                                       StyleGeometryBox aGeometryBox) {
+
−  nsRect r;
+
−
+
−  // For elements with associated CSS layout box, the used value for fill-box,
+
−  // stroke-box and view-box is border-box.
+
−  switch (aGeometryBox) {
+
−    case StyleGeometryBox::ContentBox:
+
−      r = aFrame->GetContentRectRelativeToSelf();
+
−      break;
+
−    case StyleGeometryBox::PaddingBox:
+
−      r = aFrame->GetPaddingRectRelativeToSelf();
+
−      break;
+
−    case StyleGeometryBox::MarginBox:
+
−      r = aFrame->GetMarginRectRelativeToSelf();
+
−      break;
+
−    case StyleGeometryBox::NoBox:
+
−    case StyleGeometryBox::BorderBox:
+
−    case StyleGeometryBox::FillBox:
+
−    case StyleGeometryBox::StrokeBox:
+
−    case StyleGeometryBox::ViewBox:
+
−      r = aFrame->GetRectRelativeToSelf();
+
−      break;
+
−    default:
+
−      MOZ_ASSERT_UNREACHABLE("unknown StyleGeometryBox type");
+
−      r = aFrame->GetRectRelativeToSelf();
+
−      break;
+
−  }
+
−
+
−  return r;
+
−}
+
−
+
−static StyleGeometryBox ShapeBoxToGeometryBox(const StyleShapeBox& aBox) {
+
−  switch (aBox) {
+
−    case StyleShapeBox::BorderBox:
+
−      return StyleGeometryBox::BorderBox;
+
−    case StyleShapeBox::ContentBox:
+
−      return StyleGeometryBox::ContentBox;
+
−    case StyleShapeBox::MarginBox:
+
−      return StyleGeometryBox::MarginBox;
+
−    case StyleShapeBox::PaddingBox:
+
−      return StyleGeometryBox::PaddingBox;
+
−  }
+
−  MOZ_ASSERT_UNREACHABLE("Unknown shape box type");
+
−  return StyleGeometryBox::MarginBox;
+
−}
+
−
+
−static StyleGeometryBox ClipPathBoxToGeometryBox(
+
−    const StyleShapeGeometryBox& aBox) {
+
−  using Tag = StyleShapeGeometryBox::Tag;
+
−  switch (aBox.tag) {
+
−    case Tag::ShapeBox:
+
−      return ShapeBoxToGeometryBox(aBox.AsShapeBox());
+
−    case Tag::ElementDependent:
+
−      return StyleGeometryBox::NoBox;
+
−    case Tag::FillBox:
+
−      return StyleGeometryBox::FillBox;
+
−    case Tag::StrokeBox:
+
−      return StyleGeometryBox::StrokeBox;
+
−    case Tag::ViewBox:
+
−      return StyleGeometryBox::ViewBox;
+
−  }
+
−  MOZ_ASSERT_UNREACHABLE("Unknown shape box type");
+
−  return StyleGeometryBox::NoBox;
+
−}
+
−
+
−/* static */
+
−nsRect nsLayoutUtils::ComputeGeometryBox(nsIFrame* aFrame,
+
−                                         StyleGeometryBox aGeometryBox) {
+
−  // We use ComputeSVGReferenceRect for all SVG elements, except <svg>
+
−  // element, which does have an associated CSS layout box. In this case we
+
−  // should still use ComputeHTMLReferenceRect for region computing.
+
−  return aFrame->HasAnyStateBits(NS_FRAME_SVG_LAYOUT)
+
−             ? ComputeSVGReferenceRect(aFrame, aGeometryBox)
+
−             : ComputeHTMLReferenceRect(aFrame, aGeometryBox);
+
−}
+
−
+
−nsRect nsLayoutUtils::ComputeGeometryBox(nsIFrame* aFrame,
+
−                                         const StyleShapeBox& aBox) {
+
−  return ComputeGeometryBox(aFrame, ShapeBoxToGeometryBox(aBox));
+
−}
+
−
+
−nsRect nsLayoutUtils::ComputeGeometryBox(nsIFrame* aFrame,
+
−                                         const StyleShapeGeometryBox& aBox) {
+
−  return ComputeGeometryBox(aFrame, ClipPathBoxToGeometryBox(aBox));
+
−}
+
−
+
−/* static */
+
−nsPoint nsLayoutUtils::ComputeOffsetToUserSpace(nsDisplayListBuilder* aBuilder,
+
−                                                nsIFrame* aFrame) {
+
−  nsPoint offsetToBoundingBox =
+
−      aBuilder->ToReferenceFrame(aFrame) -
+
−      SVGIntegrationUtils::GetOffsetToBoundingBox(aFrame);
+
−  if (!aFrame->IsFrameOfType(nsIFrame::eSVG)) {
+
−    // Snap the offset if the reference frame is not a SVG frame, since other
+
−    // frames will be snapped to pixel when rendering.
+
−    offsetToBoundingBox =
+
−        nsPoint(aFrame->PresContext()->RoundAppUnitsToNearestDevPixels(
+
−                    offsetToBoundingBox.x),
+
−                aFrame->PresContext()->RoundAppUnitsToNearestDevPixels(
+
−                    offsetToBoundingBox.y));
+
−  }
+
−
+
−  // During SVG painting, the offset computed here is applied to the gfxContext
+
−  // "ctx" used to paint the mask. After applying only "offsetToBoundingBox",
+
−  // "ctx" would have its origin at the top left corner of frame's bounding box
+
−  // (over all continuations).
+
−  // However, SVG painting needs the origin to be located at the origin of the
+
−  // SVG frame's "user space", i.e. the space in which, for example, the
+
−  // frame's BBox lives.
+
−  // SVG geometry frames and foreignObject frames apply their own offsets, so
+
−  // their position is relative to their user space. So for these frame types,
+
−  // if we want "ctx" to be in user space, we first need to subtract the
+
−  // frame's position so that SVG painting can later add it again and the
+
−  // frame is painted in the right place.
+
−  gfxPoint toUserSpaceGfx =
+
−      SVGUtils::FrameSpaceInCSSPxToUserSpaceOffset(aFrame);
+
−  nsPoint toUserSpace =
+
−      nsPoint(nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.x)),
+
−              nsPresContext::CSSPixelsToAppUnits(float(toUserSpaceGfx.y)));
+
−
+
−  return (offsetToBoundingBox - toUserSpace);
+
−}
+
−
+
−/* static */
+
−already_AddRefed<nsFontMetrics> nsLayoutUtils::GetMetricsFor(
+
−    nsPresContext* aPresContext, bool aIsVertical,
+
−    const nsStyleFont* aStyleFont, Length aFontSize, bool aUseUserFontSet) {
+
−  nsFont font = aStyleFont->mFont;
+
−  font.size = aFontSize;
+
−  gfxFont::Orientation orientation =
+
−      aIsVertical ? nsFontMetrics::eVertical : nsFontMetrics::eHorizontal;
+
−  nsFontMetrics::Params params;
+
−  params.language = aStyleFont->mLanguage;
+
−  params.explicitLanguage = aStyleFont->mExplicitLanguage;
+
−  params.orientation = orientation;
+
−  params.userFontSet =
+
−      aUseUserFontSet ? aPresContext->GetUserFontSet() : nullptr;
+
−  params.textPerf = aPresContext->GetTextPerfMetrics();
+
−  params.featureValueLookup = aPresContext->GetFontFeatureValuesLookup();
+
−  return aPresContext->GetMetricsFor(font, params);
+
−}
+
−
+
−/* static */
+
−void nsLayoutUtils::ComputeSystemFont(nsFont* aSystemFont,
+
−                                      LookAndFeel::FontID aFontID,
+
−                                      const nsFont* aDefaultVariableFont,
+
−                                      const Document* aDocument) {
+
−  gfxFontStyle fontStyle;
+
−  nsAutoString systemFontName;
+
−  if (!LookAndFeel::GetFont(aFontID, systemFontName, fontStyle)) {
+
−    return;
+
−  }
+
−  systemFontName.Trim("\"'");
+
−  NS_ConvertUTF16toUTF8 nameu8(systemFontName);
+
−  Servo_FontFamily_ForSystemFont(&nameu8, &aSystemFont->family);
+
−  aSystemFont->style = fontStyle.style;
+
−  aSystemFont->family.is_system_font = fontStyle.systemFont;
+
−  aSystemFont->weight = fontStyle.weight;
+
−  aSystemFont->stretch = fontStyle.stretch;
+
−  aSystemFont->size = Length::FromPixels(fontStyle.size);
+
−
+
−  // aSystemFont->langGroup = fontStyle.langGroup;
+
−  switch (StyleFontSizeAdjust::Tag(fontStyle.sizeAdjustBasis)) {
+
−    case StyleFontSizeAdjust::Tag::None:
+
−      aSystemFont->sizeAdjust = StyleFontSizeAdjust::None();
+
−      break;
+
−    case StyleFontSizeAdjust::Tag::ExHeight:
+
−      aSystemFont->sizeAdjust =
+
−          StyleFontSizeAdjust::ExHeight(fontStyle.sizeAdjust);
+
−      break;
+
−    case StyleFontSizeAdjust::Tag::CapHeight:
+
−      aSystemFont->sizeAdjust =
+
−          StyleFontSizeAdjust::CapHeight(fontStyle.sizeAdjust);
+
−      break;
+
−    case StyleFontSizeAdjust::Tag::ChWidth:
+
−      aSystemFont->sizeAdjust =
+
−          StyleFontSizeAdjust::ChWidth(fontStyle.sizeAdjust);
+
−      break;
+
−    case StyleFontSizeAdjust::Tag::IcWidth:
+
−      aSystemFont->sizeAdjust =
+
−          StyleFontSizeAdjust::IcWidth(fontStyle.sizeAdjust);
+
−      break;
+
−    case StyleFontSizeAdjust::Tag::IcHeight:
+
−      aSystemFont->sizeAdjust =
+
−          StyleFontSizeAdjust::IcHeight(fontStyle.sizeAdjust);
+
−      break;
+
−  }
+
−
+
−  if (aFontID == LookAndFeel::FontID::MozField ||
+
−      aFontID == LookAndFeel::FontID::MozButton ||
+
−      aFontID == LookAndFeel::FontID::MozList) {
+
−    const bool isWindowsOrNonNativeTheme =
+
−#ifdef XP_WIN
+
−        true ||
+
−#endif
+
−        aDocument->ShouldAvoidNativeTheme();
+
−
+
−    if (isWindowsOrNonNativeTheme) {
+
−      // For textfields, buttons and selects, we use whatever font is defined by
+
−      // the system. Which it appears (and the assumption is) it is always a
+
−      // proportional font. Then we always use 2 points smaller than what the
+
−      // browser has defined as the default proportional font.
+
−      //
+
−      // This matches historical Windows behavior and other browsers.
+
−      auto newSize =
+
−          aDefaultVariableFont->size.ToCSSPixels() - CSSPixel::FromPoints(2.0f);
+
−      aSystemFont->size = Length::FromPixels(std::max(float(newSize), 0.0f));
+
−    }
+
−  }
+
−}
+
−
+
−/* static */
+
−bool nsLayoutUtils::ShouldHandleMetaViewport(const Document* aDocument) {
+
−  auto metaViewportOverride = nsIDocShell::META_VIEWPORT_OVERRIDE_NONE;
+
−  if (aDocument) {
+
−    if (nsIDocShell* docShell = aDocument->GetDocShell()) {
+
−      metaViewportOverride = docShell->GetMetaViewportOverride();
+
−    }
+
−  }
+
−  switch (metaViewportOverride) {
+
−    case nsIDocShell::META_VIEWPORT_OVERRIDE_ENABLED:
+
−      return true;
+
−    case nsIDocShell::META_VIEWPORT_OVERRIDE_DISABLED:
+
−      return false;
+
−    default:
+
−      MOZ_ASSERT(metaViewportOverride ==
+
−                 nsIDocShell::META_VIEWPORT_OVERRIDE_NONE);
+
−      // The META_VIEWPORT_OVERRIDE_NONE case means that there is no override
+
−      // and we rely solely on the StaticPrefs.
+
−      return StaticPrefs::dom_meta_viewport_enabled();
+
−  }
+
−}
+
−
+
−/* static */
+
−ComputedStyle* nsLayoutUtils::StyleForScrollbar(nsIFrame* aScrollbarPart) {
+
−  // Get the closest content node which is not an anonymous scrollbar
+
−  // part. It should be the originating element of the scrollbar part.
+
−  nsIContent* content = aScrollbarPart->GetContent();
+
−  // Note that the content may be a normal element with scrollbar part
+
−  // value specified for its -moz-appearance, so don't rely on it being
+
−  // a native anonymous. Also note that we have to check the node name
+
−  // because anonymous element like generated content may originate a
+
−  // scrollbar.
+
−  MOZ_ASSERT(content, "No content for the scrollbar part?");
+
−  while (content && content->IsInNativeAnonymousSubtree() &&
+
−         content->IsAnyOfXULElements(
+
−             nsGkAtoms::scrollbar, nsGkAtoms::scrollbarbutton,
+
−             nsGkAtoms::scrollcorner, nsGkAtoms::slider, nsGkAtoms::thumb)) {
+
−    content = content->GetParent();
+
−  }
+
−  MOZ_ASSERT(content, "Native anonymous element with no originating node?");
+
−  // Use the style from the primary frame of the content.
+
−  // Note: it is important to use the primary frame rather than an
+
−  // ancestor frame of the scrollbar part for the correct handling of
+
−  // viewport scrollbar. The content of the scroll frame of the viewport
+
−  // is the root element, but its style inherits from the viewport.
+
−  // Since we need to use the style of root element for the viewport
+
−  // scrollbar, we have to get the style from the primary frame.
+
−  if (nsIFrame* primaryFrame = content->GetPrimaryFrame()) {
+
−    return primaryFrame->Style();
+
−  }
+
−  // If the element doesn't have primary frame, get the computed style
+
−  // from the element directly. This can happen on viewport, because
+
−  // the scrollbar of viewport may be shown when the root element has
+
−  // > display: none; overflow: scroll;
+
−  MOZ_ASSERT(
+
−      content == aScrollbarPart->PresContext()->Document()->GetRootElement(),
+
−      "Root element is the only case for this fallback "
+
−      "path to be triggered");
+
−  RefPtr<ComputedStyle> style =
+
−      ServoStyleSet::ResolveServoStyle(*content->AsElement());
+
−  // Dropping the strong reference is fine because the style should be
+
−  // held strongly by the element.
+
−  return style.get();
+
−}
+
−
+
−// NOTE: Returns Nothing() if |aFrame| is not in out-of-process or if we haven't
+
−// received enough information from APZ.
+
−static Maybe<ScreenRect> GetFrameVisibleRectOnScreen(const nsIFrame* aFrame) {
+
−  // We actually want the in-process top prescontext here.
+
−  nsPresContext* topContextInProcess =
+
−      aFrame->PresContext()->GetInProcessRootContentDocumentPresContext();
+
−  if (!topContextInProcess) {
+
−    // We are in chrome process.
+
−    return Nothing();
+
−  }
+
−
+
−  if (topContextInProcess->Document()->IsTopLevelContentDocument()) {
+
−    // We are in the top of content document.
+
−    return Nothing();
+
−  }
+
−
+
−  nsIDocShell* docShell = topContextInProcess->GetDocShell();
+
−  BrowserChild* browserChild = BrowserChild::GetFrom(docShell);
+
−  if (!browserChild) {
+
−    // We are not in out-of-process iframe.
+
−    return Nothing();
+
−  }
+
−
+
−  if (!browserChild->GetEffectsInfo().IsVisible()) {
+
−    // There is no visible rect on this iframe at all.
+
−    return Some(ScreenRect());
+
−  }
+
−
+
−  Maybe<ScreenRect> visibleRect =
+
−      browserChild->GetTopLevelViewportVisibleRectInBrowserCoords();
+
−  if (!visibleRect) {
+
−    // We are unsure if we haven't received the transformed rectangle of the
+
−    // iframe's visible area.
+
−    return Nothing();
+
−  }
+
−
+
−  nsIFrame* rootFrame = topContextInProcess->PresShell()->GetRootFrame();
+
−  nsRect transformedToIFrame = nsLayoutUtils::TransformFrameRectToAncestor(
+
−      aFrame, aFrame->GetRectRelativeToSelf(), rootFrame);
+
−
+
−  LayoutDeviceRect rectInLayoutDevicePixel = LayoutDeviceRect::FromAppUnits(
+
−      transformedToIFrame, topContextInProcess->AppUnitsPerDevPixel());
+
−
+
−  ScreenRect transformedToRoot = ViewAs<ScreenPixel>(
+
−      browserChild->GetChildToParentConversionMatrix().TransformBounds(
+
−          rectInLayoutDevicePixel),
+
−      PixelCastJustification::ContentProcessIsLayerInUiProcess);
+
−
+
−  return Some(visibleRect->Intersect(transformedToRoot));
+
−}
+
−
+
−// static
+
−bool nsLayoutUtils::FrameIsScrolledOutOfViewInCrossProcess(
+
−    const nsIFrame* aFrame) {
+
−  Maybe<ScreenRect> visibleRect = GetFrameVisibleRectOnScreen(aFrame);
+
−  if (visibleRect.isNothing()) {
+
−    return false;
+
−  }
+
−
+
−  return visibleRect->IsEmpty();
+
−}
+
−
+
−// static
+
−bool nsLayoutUtils::FrameIsMostlyScrolledOutOfViewInCrossProcess(
+
−    const nsIFrame* aFrame, nscoord aMargin) {
+
−  Maybe<ScreenRect> visibleRect = GetFrameVisibleRectOnScreen(aFrame);
+
−  if (visibleRect.isNothing()) {
+
−    return false;
+
−  }
+
−
+
−  nsPresContext* topContextInProcess =
+
−      aFrame->PresContext()->GetInProcessRootContentDocumentPresContext();
+
−  MOZ_ASSERT(topContextInProcess);
+
−
+
−  nsIDocShell* docShell = topContextInProcess->GetDocShell();
+
−  BrowserChild* browserChild = BrowserChild::GetFrom(docShell);
+
−  MOZ_ASSERT(browserChild);
+
−
+
−  Size scale =
+
−      browserChild->GetChildToParentConversionMatrix().As2D().ScaleFactors();
+
−  ScreenSize margin(scale.width * CSSPixel::FromAppUnits(aMargin),
+
−                    scale.height * CSSPixel::FromAppUnits(aMargin));
+
−
+
−  return visibleRect->width < margin.width ||
+
−         visibleRect->height < margin.height;
+
−}
+
−
+
−// static
+
−nsSize nsLayoutUtils::ExpandHeightForViewportUnits(nsPresContext* aPresContext,
+
−                                                   const nsSize& aSize) {
+
−  nsSize sizeForViewportUnits = aPresContext->GetSizeForViewportUnits();
+
−
+
−  // |aSize| might be the size expanded to the minimum-scale size whereas the
+
−  // size for viewport units is not scaled so that we need to expand the |aSize|
+
−  // height by multiplying by the ratio of the viewport units height to the
+
−  // visible area height.
+
−  float vhExpansionRatio = (float)sizeForViewportUnits.height /
+
−                           aPresContext->GetVisibleArea().height;
+
−
+
−  MOZ_ASSERT(aSize.height <= NSCoordSaturatingNonnegativeMultiply(
+
−                                 aSize.height, vhExpansionRatio));
+
−  return nsSize(aSize.width, NSCoordSaturatingNonnegativeMultiply(
+
−                                 aSize.height, vhExpansionRatio));
+
−}
+
−
+
−template <typename SizeType>
+
−/* static */ SizeType ExpandHeightForDynamicToolbarImpl(
+
−    const nsPresContext* aPresContext, const SizeType& aSize) {
+
−  MOZ_ASSERT(aPresContext);
+
−
+
−  LayoutDeviceIntSize displaySize;
+
−  if (RefPtr<MobileViewportManager> MVM =
+
−          aPresContext->PresShell()->GetMobileViewportManager()) {
+
−    displaySize = MVM->DisplaySize();
+
−  } else if (!nsLayoutUtils::GetContentViewerSize(aPresContext, displaySize)) {
+
−    return aSize;
+
−  }
+
−
+
−  float toolbarHeightRatio =
+
−      mozilla::ScreenCoord(aPresContext->GetDynamicToolbarMaxHeight()) /
+
−      mozilla::ViewAs<mozilla::ScreenPixel>(
+
−          displaySize,
+
−          mozilla::PixelCastJustification::LayoutDeviceIsScreenForBounds)
+
−          .height;
+
−
+
−  return SizeType(
+
−      aSize.width,
+
−      NSCoordSaturatingAdd(aSize.height, aSize.height * toolbarHeightRatio));
+
−}
+
−
+
−CSSSize nsLayoutUtils::ExpandHeightForDynamicToolbar(
+
−    const nsPresContext* aPresContext, const CSSSize& aSize) {
+
−  return ExpandHeightForDynamicToolbarImpl(aPresContext, aSize);
+
−}
+
−nsSize nsLayoutUtils::ExpandHeightForDynamicToolbar(
+
−    const nsPresContext* aPresContext, const nsSize& aSize) {
+
−  return ExpandHeightForDynamicToolbarImpl(aPresContext, aSize);
+
−}