Compute a more correct "screen scope" transform for SVGSVGElement

third_party/WebKit/Source/core/svg/SVGGraphicsElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  * Copyright (C) 2014 Google, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/svg/SVGGraphicsElement.h"
 
 #include "core/SVGNames.h"
 #include "core/dom/StyleChangeReason.h"
+#include "core/frame/FrameView.h"
 #include "core/layout/LayoutObject.h"
+#include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/svg/SVGElementRareData.h"
 #include "core/svg/SVGMatrixTearOff.h"
 #include "core/svg/SVGRectTearOff.h"
 #include "platform/transforms/AffineTransform.h"
 
 namespace blink {
 
 SVGGraphicsElement::SVGGraphicsElement(const QualifiedName& tagName,
                                        Document& document,
                                        ConstructionType constructionType)
@@ skipping 27 matching lines @@
 
   AffineTransform ctm;
   bool done = false;
 
   for (const Element* currentElement = this; currentElement && !done;
        currentElement = currentElement->parentOrShadowHostElement()) {
     if (!currentElement->isSVGElement())
       break;
 
     ctm = toSVGElement(currentElement)
-              ->localCoordinateSpaceTransform(mode)
+              ->localCoordinateSpaceTransform()
               .multiply(ctm);
 
     switch (mode) {
       case NearestViewportScope:
         // Stop at the nearest viewport ancestor.
         done = currentElement != this && isViewportElement(*currentElement);
         break;
       case AncestorScope:
         // Stop at the designated ancestor.
         done = currentElement == ancestor;
         break;
       default:
-        ASSERT(mode == ScreenScope);
+        NOTREACHED();
         break;
     }
   }
 
   return ctm;
 }
 
 AffineTransform SVGGraphicsElement::getCTM(
     StyleUpdateStrategy styleUpdateStrategy) {
   return computeCTM(NearestViewportScope, styleUpdateStrategy);
 }
 
 AffineTransform SVGGraphicsElement::getScreenCTM(
     StyleUpdateStrategy styleUpdateStrategy) {
-  return computeCTM(ScreenScope, styleUpdateStrategy);
+  if (styleUpdateStrategy == AllowStyleUpdate)
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+  TransformationMatrix transform;
+  if (LayoutObject* layoutObject = this->layoutObject()) {
+    // Adjust for the zoom level factored into CSS coordinates (WK bug #96361).
+    transform.scale(1.0 / layoutObject->styleRef().effectiveZoom());
+
+    // Origin in the document. (This, together with the inverse-scale above,
+    // performs the same operation as
+    // Document::adjustFloatRectForScrollAndAbsoluteZoom, but in transformation
+    // matrix form.)
+    if (FrameView* view = document().view()) {
+      LayoutRect visibleContentRect(view->visibleContentRect());
+      transform.translate(-visibleContentRect.x(), -visibleContentRect.y());
+    }
+
+    // Apply transforms from our ancestor coordinate space, including any
+    // non-SVG ancestor transforms.
+    transform.multiply(layoutObject->localToAbsoluteTransform());
+
+    // At the SVG/HTML boundary (aka LayoutSVGRoot), we need to apply the
+    // localToBorderBoxTransform to map an element from SVG viewport
+    // coordinates to CSS box coordinates.
+    if (layoutObject->isSVGRoot()) {
+      transform.multiply(
+          toLayoutSVGRoot(layoutObject)->localToBorderBoxTransform());
+    }
+  }
+  // Drop any potential non-affine parts, because we're not able to convey that
+  // information further anyway until getScreenCTM returns a DOMMatrix (4x4
+  // matrix.)
+  return transform.toAffineTransform();
 }
 
 SVGMatrixTearOff* SVGGraphicsElement::getCTMFromJavascript() {
   return SVGMatrixTearOff::create(getCTM());
 }
 
 SVGMatrixTearOff* SVGGraphicsElement::getScreenCTMFromJavascript() {
   return SVGMatrixTearOff::create(getScreenCTM());
 }
 
@@ skipping 72 matching lines @@
 
   return layoutObject()->objectBoundingBox();
 }
 
 SVGRectTearOff* SVGGraphicsElement::getBBoxFromJavascript() {
   return SVGRectTearOff::create(SVGRect::create(getBBox()), 0,
                                 PropertyIsNotAnimVal);
 }
 
 }  // namespace blink