Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 498 insertions, 0 deletions

diff --git a/layout/base/GeometryUtils.cpp b/layout/base/GeometryUtils.cpp
new file mode 100644
index 0000000000..dac899f755
--- /dev/null
+++ b/layout/base/GeometryUtils.cpp
@@ -0,0 +1,498 @@
+/* -*- 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 "GeometryUtils.h"
+
+#include "mozilla/PresShell.h"
+#include "mozilla/SVGUtils.h"
+#include "mozilla/dom/CharacterData.h"
+#include "mozilla/dom/DOMPointBinding.h"
+#include "mozilla/dom/GeometryUtilsBinding.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/Text.h"
+#include "mozilla/dom/DocumentInlines.h"
+#include "mozilla/dom/DOMPoint.h"
+#include "mozilla/dom/DOMQuad.h"
+#include "mozilla/dom/DOMRect.h"
+#include "mozilla/dom/BrowserChild.h"
+#include "nsIFrame.h"
+#include "nsContainerFrame.h"
+#include "nsContentUtils.h"
+#include "nsCSSFrameConstructor.h"
+#include "nsLayoutUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+namespace mozilla {
+
+enum GeometryNodeType {
+  GEOMETRY_NODE_ELEMENT,
+  GEOMETRY_NODE_TEXT,
+  GEOMETRY_NODE_DOCUMENT
+};
+
+static nsIFrame* GetFrameForNode(nsINode* aNode, GeometryNodeType aType,
+                                 bool aCreateFramesForSuppressedWhitespace) {
+  Document* doc = aNode->OwnerDoc();
+  if (aType == GEOMETRY_NODE_TEXT && aCreateFramesForSuppressedWhitespace) {
+    if (PresShell* presShell = doc->GetPresShell()) {
+      presShell->FrameConstructor()->EnsureFrameForTextNodeIsCreatedAfterFlush(
+          static_cast<CharacterData*>(aNode));
+    }
+  }
+  doc->FlushPendingNotifications(FlushType::Layout);
+
+  switch (aType) {
+    case GEOMETRY_NODE_TEXT:
+    case GEOMETRY_NODE_ELEMENT:
+      return aNode->AsContent()->GetPrimaryFrame();
+    case GEOMETRY_NODE_DOCUMENT: {
+      PresShell* presShell = doc->GetPresShell();
+      return presShell ? presShell->GetRootFrame() : nullptr;
+    }
+    default:
+      MOZ_ASSERT(false, "Unknown GeometryNodeType");
+      return nullptr;
+  }
+}
+
+static nsIFrame* GetFrameForGeometryNode(
+    const Optional<OwningGeometryNode>& aGeometryNode, nsINode* aDefaultNode,
+    bool aCreateFramesForSuppressedWhitespace) {
+  if (!aGeometryNode.WasPassed()) {
+    return GetFrameForNode(aDefaultNode->OwnerDoc(), GEOMETRY_NODE_DOCUMENT,
+                           aCreateFramesForSuppressedWhitespace);
+  }
+
+  const OwningGeometryNode& value = aGeometryNode.Value();
+  if (value.IsElement()) {
+    return GetFrameForNode(value.GetAsElement(), GEOMETRY_NODE_ELEMENT,
+                           aCreateFramesForSuppressedWhitespace);
+  }
+  if (value.IsDocument()) {
+    return GetFrameForNode(value.GetAsDocument(), GEOMETRY_NODE_DOCUMENT,
+                           aCreateFramesForSuppressedWhitespace);
+  }
+  return GetFrameForNode(value.GetAsText(), GEOMETRY_NODE_TEXT,
+                         aCreateFramesForSuppressedWhitespace);
+}
+
+static nsIFrame* GetFrameForGeometryNode(const GeometryNode& aGeometryNode) {
+  // This will create frames for suppressed whitespace nodes.
+  if (aGeometryNode.IsElement()) {
+    return GetFrameForNode(&aGeometryNode.GetAsElement(), GEOMETRY_NODE_ELEMENT,
+                           true);
+  }
+  if (aGeometryNode.IsDocument()) {
+    return GetFrameForNode(&aGeometryNode.GetAsDocument(),
+                           GEOMETRY_NODE_DOCUMENT, true);
+  }
+  return GetFrameForNode(&aGeometryNode.GetAsText(), GEOMETRY_NODE_TEXT, true);
+}
+
+static nsIFrame* GetFrameForNode(nsINode* aNode,
+                                 bool aCreateFramesForSuppressedWhitespace) {
+  if (aNode->IsElement()) {
+    return GetFrameForNode(aNode, GEOMETRY_NODE_ELEMENT,
+                           aCreateFramesForSuppressedWhitespace);
+  }
+  if (aNode == aNode->OwnerDoc()) {
+    return GetFrameForNode(aNode, GEOMETRY_NODE_DOCUMENT,
+                           aCreateFramesForSuppressedWhitespace);
+  }
+  NS_ASSERTION(aNode->IsText(), "Unknown node type");
+  return GetFrameForNode(aNode, GEOMETRY_NODE_TEXT,
+                         aCreateFramesForSuppressedWhitespace);
+}
+
+static nsIFrame* GetFirstNonAnonymousFrameForGeometryNode(
+    const Optional<OwningGeometryNode>& aNode, nsINode* aDefaultNode,
+    bool aCreateFramesForSuppressedWhitespace) {
+  nsIFrame* f = GetFrameForGeometryNode(aNode, aDefaultNode,
+                                        aCreateFramesForSuppressedWhitespace);
+  if (f) {
+    f = nsLayoutUtils::GetFirstNonAnonymousFrame(f);
+  }
+  return f;
+}
+
+static nsIFrame* GetFirstNonAnonymousFrameForGeometryNode(
+    const GeometryNode& aNode) {
+  // This will create frames for suppressed whitespace nodes.
+  nsIFrame* f = GetFrameForGeometryNode(aNode);
+  if (f) {
+    f = nsLayoutUtils::GetFirstNonAnonymousFrame(f);
+  }
+  return f;
+}
+
+static nsIFrame* GetFirstNonAnonymousFrameForNode(nsINode* aNode) {
+  // This will create frames for suppressed whitespace nodes.
+  nsIFrame* f = GetFrameForNode(aNode, true);
+  if (f) {
+    f = nsLayoutUtils::GetFirstNonAnonymousFrame(f);
+  }
+  return f;
+}
+
+/**
+ * This can modify aFrame to point to a different frame. This is needed to
+ * handle SVG, where SVG elements can only compute a rect that's valid with
+ * respect to the "outer SVG" frame.
+ */
+static nsRect GetBoxRectForFrame(nsIFrame** aFrame, CSSBoxType aType) {
+  nsRect r;
+  nsIFrame* f = SVGUtils::GetOuterSVGFrameAndCoveredRegion(*aFrame, &r);
+  if (f && f != *aFrame) {
+    // For non-outer SVG frames, the BoxType is ignored.
+    *aFrame = f;
+    return r;
+  }
+
+  f = *aFrame;
+  switch (aType) {
+    case CSSBoxType::Content:
+      r = f->GetContentRectRelativeToSelf();
+      break;
+    case CSSBoxType::Padding:
+      r = f->GetPaddingRectRelativeToSelf();
+      break;
+    case CSSBoxType::Border:
+      r = nsRect(nsPoint(0, 0), f->GetSize());
+      break;
+    case CSSBoxType::Margin:
+      r = f->GetMarginRectRelativeToSelf();
+      break;
+    default:
+      MOZ_ASSERT(false, "unknown box type");
+      return r;
+  }
+
+  return r;
+}
+
+class AccumulateQuadCallback : public nsLayoutUtils::BoxCallback {
+ public:
+  AccumulateQuadCallback(Document* aParentObject,
+                         nsTArray<RefPtr<DOMQuad> >& aResult,
+                         nsIFrame* aRelativeToFrame,
+                         const nsPoint& aRelativeToBoxTopLeft,
+                         CSSBoxType aBoxType)
+      : mParentObject(ToSupports(aParentObject)),
+        mResult(aResult),
+        mRelativeToFrame(aRelativeToFrame),
+        mRelativeToBoxTopLeft(aRelativeToBoxTopLeft),
+        mBoxType(aBoxType) {
+    if (mBoxType == CSSBoxType::Margin) {
+      // Don't include the caption margin when computing margins for a
+      // table
+      mIncludeCaptionBoxForTable = false;
+    }
+  }
+
+  void AddBox(nsIFrame* aFrame) override {
+    nsIFrame* f = aFrame;
+    if (mBoxType == CSSBoxType::Margin && f->IsTableFrame()) {
+      // Margin boxes for table frames should be taken from the table wrapper
+      // frame, since that has the margin.
+      f = f->GetParent();
+    }
+    nsRect box = GetBoxRectForFrame(&f, mBoxType);
+    nsPoint appUnits[4] = {box.TopLeft(), box.TopRight(), box.BottomRight(),
+                           box.BottomLeft()};
+    CSSPoint points[4];
+    for (uint32_t i = 0; i < 4; ++i) {
+      points[i] =
+          CSSPoint(nsPresContext::AppUnitsToFloatCSSPixels(appUnits[i].x),
+                   nsPresContext::AppUnitsToFloatCSSPixels(appUnits[i].y));
+    }
+    nsLayoutUtils::TransformResult rv = nsLayoutUtils::TransformPoints(
+        RelativeTo{f}, RelativeTo{mRelativeToFrame}, 4, points);
+    if (rv == nsLayoutUtils::TRANSFORM_SUCCEEDED) {
+      CSSPoint delta(
+          nsPresContext::AppUnitsToFloatCSSPixels(mRelativeToBoxTopLeft.x),
+          nsPresContext::AppUnitsToFloatCSSPixels(mRelativeToBoxTopLeft.y));
+      for (uint32_t i = 0; i < 4; ++i) {
+        points[i] -= delta;
+      }
+    } else {
+      PodArrayZero(points);
+    }
+    mResult.AppendElement(new DOMQuad(mParentObject, points));
+  }
+
+  nsISupports* mParentObject;
+  nsTArray<RefPtr<DOMQuad> >& mResult;
+  nsIFrame* mRelativeToFrame;
+  nsPoint mRelativeToBoxTopLeft;
+  CSSBoxType mBoxType;
+};
+
+static nsPresContext* FindTopLevelPresContext(nsPresContext* aPC) {
+  bool isChrome = aPC->IsChrome();
+  nsPresContext* pc = aPC;
+  for (;;) {
+    nsPresContext* parent = pc->GetParentPresContext();
+    if (!parent || parent->IsChrome() != isChrome) {
+      return pc;
+    }
+    pc = parent;
+  }
+}
+
+static bool CheckFramesInSameTopLevelBrowsingContext(nsIFrame* aFrame1,
+                                                     nsIFrame* aFrame2,
+                                                     CallerType aCallerType) {
+  nsPresContext* pc1 = aFrame1->PresContext();
+  nsPresContext* pc2 = aFrame2->PresContext();
+  if (pc1 == pc2) {
+    return true;
+  }
+  if (aCallerType == CallerType::System) {
+    return true;
+  }
+  if (FindTopLevelPresContext(pc1) == FindTopLevelPresContext(pc2)) {
+    return true;
+  }
+  return false;
+}
+
+void GetBoxQuads(nsINode* aNode, const dom::BoxQuadOptions& aOptions,
+                 nsTArray<RefPtr<DOMQuad> >& aResult, CallerType aCallerType,
+                 ErrorResult& aRv) {
+  nsIFrame* frame =
+      GetFrameForNode(aNode, aOptions.mCreateFramesForSuppressedWhitespace);
+  if (!frame) {
+    // No boxes to return
+    return;
+  }
+  AutoWeakFrame weakFrame(frame);
+  Document* ownerDoc = aNode->OwnerDoc();
+  nsIFrame* relativeToFrame = GetFirstNonAnonymousFrameForGeometryNode(
+      aOptions.mRelativeTo, ownerDoc,
+      aOptions.mCreateFramesForSuppressedWhitespace);
+  // The first frame might be destroyed now if the above call lead to an
+  // EnsureFrameForTextNode call.  We need to get the first frame again
+  // when that happens and re-check it.
+  if (!weakFrame.IsAlive()) {
+    frame =
+        GetFrameForNode(aNode, aOptions.mCreateFramesForSuppressedWhitespace);
+    if (!frame) {
+      // No boxes to return
+      return;
+    }
+  }
+  if (!relativeToFrame) {
+    // XXXbz There's no spec for this.
+    return aRv.ThrowNotFoundError("No box to get quads relative to");
+  }
+  if (!CheckFramesInSameTopLevelBrowsingContext(frame, relativeToFrame,
+                                                aCallerType)) {
+    aRv.ThrowNotFoundError(
+        "Can't get quads relative to a box in a different toplevel browsing "
+        "context");
+    return;
+  }
+  // GetBoxRectForFrame can modify relativeToFrame so call it first.
+  nsPoint relativeToTopLeft =
+      GetBoxRectForFrame(&relativeToFrame, CSSBoxType::Border).TopLeft();
+  AccumulateQuadCallback callback(ownerDoc, aResult, relativeToFrame,
+                                  relativeToTopLeft, aOptions.mBox);
+
+  // Bug 1624653: Refactor this to get boxes in layer pixels, which we will
+  // then convert into CSS units.
+  nsLayoutUtils::GetAllInFlowBoxes(frame, &callback);
+}
+
+void GetBoxQuadsFromWindowOrigin(nsINode* aNode,
+                                 const dom::BoxQuadOptions& aOptions,
+                                 nsTArray<RefPtr<DOMQuad> >& aResult,
+                                 ErrorResult& aRv) {
+  // We want the quads relative to the window. To do this, we ignore the
+  // provided aOptions.mRelativeTo and instead use the document node of
+  // the top-most in-process document. Later, we'll check if there is a
+  // browserChild associated with that document, and if so, transform the
+  // calculated quads with the browserChild's to-parent matrix, which
+  // will get us to top-level coordinates.
+  if (aOptions.mRelativeTo.WasPassed()) {
+    return aRv.ThrowNotSupportedError(
+        "Can't request quads in window origin space relative to another "
+        "node.");
+  }
+
+  // We're going to call GetBoxQuads with our parameters, but we supply
+  // a new BoxQuadOptions object that uses the top in-process document
+  // as the relativeTo target.
+  BoxQuadOptions bqo(aOptions);
+
+  RefPtr<Document> topInProcessDoc =
+      nsContentUtils::GetInProcessSubtreeRootDocument(aNode->OwnerDoc());
+
+  OwningGeometryNode ogn;
+  ogn.SetAsDocument() = topInProcessDoc;
+  bqo.mRelativeTo.Construct(ogn);
+
+  // Bug 1624653: Refactor this to get boxes in layer pixels, which we can
+  // transform directly with the GetChildToParentConversionMatrix below,
+  // and convert to CSS units as a final step.
+  GetBoxQuads(aNode, bqo, aResult, CallerType::System, aRv);
+  if (aRv.Failed()) {
+    return;
+  }
+
+  // Now we have aResult filled with DOMQuads with values relative to the
+  // top in-process document. See if topInProcessDoc is associated with a
+  // BrowserChild, and if it is, get its transformation matrix and use that
+  // to transform the DOMQuads in place to make them relative to the window
+  // origin.
+  nsIDocShell* docShell = topInProcessDoc->GetDocShell();
+  if (!docShell) {
+    return aRv.ThrowInvalidStateError(
+        "Returning untranslated quads because top in process document has "
+        "no docshell.");
+  }
+
+  BrowserChild* browserChild = BrowserChild::GetFrom(docShell);
+  if (!browserChild) {
+    return;
+  }
+
+  nsPresContext* presContext = docShell->GetPresContext();
+  if (!presContext) {
+    return;
+  }
+  int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();
+
+  LayoutDeviceToLayoutDeviceMatrix4x4 matrix =
+      browserChild->GetChildToParentConversionMatrix();
+
+  // For each DOMQuad in aResult, change the css units into layer pixels,
+  // then transform them by matrix, then change them back into css units
+  // and overwrite the original points.
+  LayoutDeviceToCSSScale ld2cScale((float)appUnitsPerDevPixel /
+                                   (float)AppUnitsPerCSSPixel());
+  CSSToLayoutDeviceScale c2ldScale = ld2cScale.Inverse();
+
+  for (auto& quad : aResult) {
+    for (uint32_t i = 0; i < 4; i++) {
+      DOMPoint* p = quad->Point(i);
+      CSSPoint cp(p->X(), p->Y());
+
+      LayoutDevicePoint windowLdp = matrix.TransformPoint(cp * c2ldScale);
+
+      CSSPoint windowCp = windowLdp * ld2cScale;
+      p->SetX(windowCp.x);
+      p->SetY(windowCp.y);
+    }
+  }
+}
+
+static void TransformPoints(nsINode* aTo, const GeometryNode& aFrom,
+                            uint32_t aPointCount, CSSPoint* aPoints,
+                            const ConvertCoordinateOptions& aOptions,
+                            CallerType aCallerType, ErrorResult& aRv) {
+  nsIFrame* fromFrame = GetFirstNonAnonymousFrameForGeometryNode(aFrom);
+  AutoWeakFrame weakFrame(fromFrame);
+  nsIFrame* toFrame = GetFirstNonAnonymousFrameForNode(aTo);
+  // The first frame might be destroyed now if the above call lead to an
+  // EnsureFrameForTextNode call.  We need to get the first frame again
+  // when that happens.
+  if (fromFrame && !weakFrame.IsAlive()) {
+    fromFrame = GetFirstNonAnonymousFrameForGeometryNode(aFrom);
+  }
+  if (!fromFrame || !toFrame) {
+    aRv.ThrowNotFoundError(
+        "Can't transform coordinates between nonexistent boxes");
+    return;
+  }
+  if (!CheckFramesInSameTopLevelBrowsingContext(fromFrame, toFrame,
+                                                aCallerType)) {
+    aRv.ThrowNotFoundError(
+        "Can't transform coordinates between boxes in different toplevel "
+        "browsing contexts");
+    return;
+  }
+
+  nsPoint fromOffset =
+      GetBoxRectForFrame(&fromFrame, aOptions.mFromBox).TopLeft();
+  nsPoint toOffset = GetBoxRectForFrame(&toFrame, aOptions.mToBox).TopLeft();
+  CSSPoint fromOffsetGfx(nsPresContext::AppUnitsToFloatCSSPixels(fromOffset.x),
+                         nsPresContext::AppUnitsToFloatCSSPixels(fromOffset.y));
+  for (uint32_t i = 0; i < aPointCount; ++i) {
+    aPoints[i] += fromOffsetGfx;
+  }
+  nsLayoutUtils::TransformResult rv = nsLayoutUtils::TransformPoints(
+      RelativeTo{fromFrame}, RelativeTo{toFrame}, aPointCount, aPoints);
+  if (rv == nsLayoutUtils::TRANSFORM_SUCCEEDED) {
+    CSSPoint toOffsetGfx(nsPresContext::AppUnitsToFloatCSSPixels(toOffset.x),
+                         nsPresContext::AppUnitsToFloatCSSPixels(toOffset.y));
+    for (uint32_t i = 0; i < aPointCount; ++i) {
+      aPoints[i] -= toOffsetGfx;
+    }
+  } else {
+    PodZero(aPoints, aPointCount);
+  }
+}
+
+already_AddRefed<DOMQuad> ConvertQuadFromNode(
+    nsINode* aTo, dom::DOMQuad& aQuad, const GeometryNode& aFrom,
+    const dom::ConvertCoordinateOptions& aOptions, CallerType aCallerType,
+    ErrorResult& aRv) {
+  CSSPoint points[4];
+  for (uint32_t i = 0; i < 4; ++i) {
+    DOMPoint* p = aQuad.Point(i);
+    if (p->W() != 1.0 || p->Z() != 0.0) {
+      aRv.ThrowInvalidStateError("Point is not 2d");
+      return nullptr;
+    }
+    points[i] = CSSPoint(p->X(), p->Y());
+  }
+  TransformPoints(aTo, aFrom, 4, points, aOptions, aCallerType, aRv);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+  RefPtr<DOMQuad> result = new DOMQuad(aTo->GetParentObject().mObject, points);
+  return result.forget();
+}
+
+already_AddRefed<DOMQuad> ConvertRectFromNode(
+    nsINode* aTo, dom::DOMRectReadOnly& aRect, const GeometryNode& aFrom,
+    const dom::ConvertCoordinateOptions& aOptions, CallerType aCallerType,
+    ErrorResult& aRv) {
+  CSSPoint points[4];
+  double x = aRect.X(), y = aRect.Y(), w = aRect.Width(), h = aRect.Height();
+  points[0] = CSSPoint(x, y);
+  points[1] = CSSPoint(x + w, y);
+  points[2] = CSSPoint(x + w, y + h);
+  points[3] = CSSPoint(x, y + h);
+  TransformPoints(aTo, aFrom, 4, points, aOptions, aCallerType, aRv);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+  RefPtr<DOMQuad> result = new DOMQuad(aTo->GetParentObject().mObject, points);
+  return result.forget();
+}
+
+already_AddRefed<DOMPoint> ConvertPointFromNode(
+    nsINode* aTo, const dom::DOMPointInit& aPoint, const GeometryNode& aFrom,
+    const dom::ConvertCoordinateOptions& aOptions, CallerType aCallerType,
+    ErrorResult& aRv) {
+  if (aPoint.mW != 1.0 || aPoint.mZ != 0.0) {
+    aRv.ThrowInvalidStateError("Point is not 2d");
+    return nullptr;
+  }
+  CSSPoint point(aPoint.mX, aPoint.mY);
+  TransformPoints(aTo, aFrom, 1, &point, aOptions, aCallerType, aRv);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+  RefPtr<DOMPoint> result =
+      new DOMPoint(aTo->GetParentObject().mObject, point.x, point.y);
+  return result.forget();
+}
+
+}  // namespace mozilla