The Tor Browser: layout/base/GeometryUtils.cpp@b8a032363ba2 (annotated)

layout/base/GeometryUtils.cpp@b8a032363ba2 (annotated)

layout/base/GeometryUtils.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/dom/DOMPointBinding.h"
 #include "mozilla/dom/GeometryUtilsBinding.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/Text.h"
 #include "mozilla/dom/DOMPoint.h"
 #include "mozilla/dom/DOMQuad.h"
 #include "mozilla/dom/DOMRect.h"
 #include "nsIFrame.h"
 #include "nsGenericDOMDataNode.h"
 #include "nsCSSFrameConstructor.h"
 #include "nsLayoutUtils.h"
 #include "nsSVGUtils.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)
 {
   nsIDocument* doc = aNode->OwnerDoc();
   doc->FlushPendingNotifications(Flush_Layout);
   switch (aType) {
   case GEOMETRY_NODE_ELEMENT:
     return aNode->AsContent()->GetPrimaryFrame();
   case GEOMETRY_NODE_TEXT: {
     nsIPresShell* presShell = doc->GetShell();
     if (presShell) {
       return presShell->FrameConstructor()->EnsureFrameForTextNode(
           static_cast<nsGenericDOMDataNode*>(aNode));
     }
     return nullptr;
   }
   case GEOMETRY_NODE_DOCUMENT: {
     nsIPresShell* presShell = doc->GetShell();
     return presShell ? presShell->GetRootFrame() : nullptr;
   }
   default:
     MOZ_ASSERT(false, "Unknown GeometryNodeType");
     return nullptr;
   }
 }
 static nsIFrame*
 GetFrameForGeometryNode(const Optional<OwningGeometryNode>& aGeometryNode,
                         nsINode* aDefaultNode)
 {
   if (!aGeometryNode.WasPassed()) {
     return GetFrameForNode(aDefaultNode->OwnerDoc(), GEOMETRY_NODE_DOCUMENT);
   }
   const OwningGeometryNode& value = aGeometryNode.Value();
   if (value.IsElement()) {
     return GetFrameForNode(value.GetAsElement(), GEOMETRY_NODE_ELEMENT);
   }
   if (value.IsDocument()) {
     return GetFrameForNode(value.GetAsDocument(), GEOMETRY_NODE_DOCUMENT);
   }
   return GetFrameForNode(value.GetAsText(), GEOMETRY_NODE_TEXT);
 }
 static nsIFrame*
 GetFrameForGeometryNode(const GeometryNode& aGeometryNode)
 {
   if (aGeometryNode.IsElement()) {
     return GetFrameForNode(&aGeometryNode.GetAsElement(), GEOMETRY_NODE_ELEMENT);
   }
   if (aGeometryNode.IsDocument()) {
     return GetFrameForNode(&aGeometryNode.GetAsDocument(), GEOMETRY_NODE_DOCUMENT);
   }
   return GetFrameForNode(&aGeometryNode.GetAsText(), GEOMETRY_NODE_TEXT);
 }
 static nsIFrame*
 GetFrameForNode(nsINode* aNode)
 {
   if (aNode->IsElement()) {
     return GetFrameForNode(aNode, GEOMETRY_NODE_ELEMENT);
   }
   if (aNode == aNode->OwnerDoc()) {
     return GetFrameForNode(aNode, GEOMETRY_NODE_DOCUMENT);
   }
   NS_ASSERTION(aNode->IsNodeOfType(nsINode::eTEXT), "Unknown node type");
   return GetFrameForNode(aNode, GEOMETRY_NODE_TEXT);
 }
 static nsIFrame*
 GetFirstNonAnonymousFrameForGeometryNode(const Optional<OwningGeometryNode>& aNode,
                                          nsINode* aDefaultNode)
 {
   nsIFrame* f = GetFrameForGeometryNode(aNode, aDefaultNode);
   if (f) {
     f = nsLayoutUtils::GetFirstNonAnonymousFrame(f);
   }
   return f;
 }
 static nsIFrame*
 GetFirstNonAnonymousFrameForGeometryNode(const GeometryNode& aNode)
 {
   nsIFrame* f = GetFrameForGeometryNode(aNode);
   if (f) {
     f = nsLayoutUtils::GetFirstNonAnonymousFrame(f);
   }
   return f;
 }
 static nsIFrame*
 GetFirstNonAnonymousFrameForNode(nsINode* aNode)
 {
   nsIFrame* f = GetFrameForNode(aNode);
   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 = nsSVGUtils::GetOuterSVGFrameAndCoveredRegion(*aFrame, &r);
   if (f) {
     // For SVG, 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 = nsRect(nsPoint(0, 0), f->GetSize());
     r.Inflate(f->GetUsedMargin());
     break;
   }
   default: MOZ_ASSERT(false, "unknown box type"); return r;
   }
   return r;
 }
 class AccumulateQuadCallback : public nsLayoutUtils::BoxCallback {
 public:
   AccumulateQuadCallback(nsISupports* aParentObject,
                          nsTArray<nsRefPtr<DOMQuad> >& aResult,
                          nsIFrame* aRelativeToFrame,
                          const nsPoint& aRelativeToBoxTopLeft,
                          CSSBoxType aBoxType)
     : mParentObject(aParentObject)
     , mResult(aResult)
     , mRelativeToFrame(aRelativeToFrame)
     , mRelativeToBoxTopLeft(aRelativeToBoxTopLeft)
     , mBoxType(aBoxType)
   {
   }
   virtual void AddBox(nsIFrame* aFrame) MOZ_OVERRIDE
   {
     nsIFrame* f = aFrame;
     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(f, 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<nsRefPtr<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)
 {
   nsPresContext* pc1 = aFrame1->PresContext();
   nsPresContext* pc2 = aFrame2->PresContext();
   if (pc1 == pc2) {
     return true;
   }
   if (nsContentUtils::IsCallerChrome()) {
     return true;
   }
   if (FindTopLevelPresContext(pc1) == FindTopLevelPresContext(pc2)) {
     return true;
   }
   return false;
 }
 void GetBoxQuads(nsINode* aNode,
                  const dom::BoxQuadOptions& aOptions,
                  nsTArray<nsRefPtr<DOMQuad> >& aResult,
                  ErrorResult& aRv)
 {
   nsIFrame* frame = GetFrameForNode(aNode);
   if (!frame) {
     // No boxes to return
     return;
   }
   nsIDocument* ownerDoc = aNode->OwnerDoc();
   nsIFrame* relativeToFrame =
     GetFirstNonAnonymousFrameForGeometryNode(aOptions.mRelativeTo, ownerDoc);
   if (!relativeToFrame) {
     aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
     return;
   }
   if (!CheckFramesInSameTopLevelBrowsingContext(frame, relativeToFrame)) {
     aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
     return;
   }
   // GetBoxRectForFrame can modify relativeToFrame so call it first.
   nsPoint relativeToTopLeft =
       GetBoxRectForFrame(&relativeToFrame, CSSBoxType::Border).TopLeft();
   AccumulateQuadCallback callback(ownerDoc, aResult, relativeToFrame,
                                   relativeToTopLeft, aOptions.mBox);
   nsLayoutUtils::GetAllInFlowBoxes(frame, &callback);
 }
 static void
 TransformPoints(nsINode* aTo, const GeometryNode& aFrom,
                 uint32_t aPointCount, CSSPoint* aPoints,
                 const ConvertCoordinateOptions& aOptions, ErrorResult& aRv)
 {
   nsIFrame* fromFrame = GetFirstNonAnonymousFrameForGeometryNode(aFrom);
   nsIFrame* toFrame = GetFirstNonAnonymousFrameForNode(aTo);
   if (!fromFrame || !toFrame) {
     aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
     return;
   }
   if (!CheckFramesInSameTopLevelBrowsingContext(fromFrame, toFrame)) {
     aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
     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(fromFrame, 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,
                     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.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
       return nullptr;
     }
     points[i] = CSSPoint(p->X(), p->Y());
   }
   TransformPoints(aTo, aFrom, 4, points, aOptions, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
   nsRefPtr<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,
                     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, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
   nsRefPtr<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,
                      ErrorResult& aRv)
 {
   if (aPoint.mW != 1.0 || aPoint.mZ != 0.0) {
     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return nullptr;
   }
   CSSPoint point(aPoint.mX, aPoint.mY);
   TransformPoints(aTo, aFrom, 1, &point, aOptions, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
   nsRefPtr<DOMPoint> result = new DOMPoint(aTo->GetParentObject().mObject, point.x, point.y);
   return result.forget();
 }
 }

The Tor Browser / annotate

layout/base/GeometryUtils.cpp@b8a032363ba2 (annotated)

layout/base/GeometryUtils.cpp