Revert "Neuter the "screen scale factor" computation for SVG <text>"

third_party/WebKit/Source/core/layout/svg/SVGLayoutSupport.cpp

 /*
  * Copyright (C) 2007, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.  All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 19 matching lines @@
 #include "core/layout/svg/LayoutSVGResourceClipper.h"
 #include "core/layout/svg/LayoutSVGResourceFilter.h"
 #include "core/layout/svg/LayoutSVGResourceMasker.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/LayoutSVGShape.h"
 #include "core/layout/svg/LayoutSVGText.h"
 #include "core/layout/svg/LayoutSVGTransformableContainer.h"
 #include "core/layout/svg/LayoutSVGViewportContainer.h"
 #include "core/layout/svg/SVGResources.h"
 #include "core/layout/svg/SVGResourcesCache.h"
+#include "core/page/Page.h"
 #include "core/paint/PaintLayer.h"
 #include "core/svg/SVGElement.h"
 #include "platform/geometry/TransformState.h"
 #include "platform/graphics/StrokeData.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
 struct SearchCandidate {
   SearchCandidate()
@@ skipping 462 matching lines @@
   AffineTransform contentTransformation =
       subtreeContentTransformation *
       AffineTransform(s_currentContentTransformation);
   contentTransformation.copyTransformTo(s_currentContentTransformation);
 }
 
 SubtreeContentTransformScope::~SubtreeContentTransformScope() {
   m_savedContentTransformation.copyTransformTo(s_currentContentTransformation);
 }
 
-float SVGLayoutSupport::calculateScreenFontSizeScalingFactor(
+AffineTransform SVGLayoutSupport::deprecatedCalculateTransformToLayer(
     const LayoutObject* layoutObject) {
   AffineTransform transform;
   while (layoutObject) {
     transform = layoutObject->localToSVGParentTransform() * transform;
     if (layoutObject->isSVGRoot())
       break;
     layoutObject = layoutObject->parent();
   }
-  transform.multiply(
-      SubtreeContentTransformScope::currentContentTransformation());
-  return clampTo<float>(
-      sqrt((transform.xScaleSquared() + transform.yScaleSquared()) / 2));
+
+  // Continue walking up the layer tree, accumulating CSS transforms.
+  // FIXME: this queries layer compositing state - which is not
+  // supported during layout. Hence, the result may not include all CSS
+  // transforms.
+  PaintLayer* layer = layoutObject ? layoutObject->enclosingLayer() : 0;
+  while (layer && layer->isAllowedToQueryCompositingState()) {
+    // We can stop at compositing layers, to match the backing resolution.
+    // FIXME: should we be computing the transform to the nearest composited
+    // layer, or the nearest composited layer that does not paint into its
+    // ancestor? I think this is the nearest composited ancestor since we will
+    // inherit its transforms in the composited layer tree.
+    if (layer->compositingState() != NotComposited)
+      break;
+
+    if (TransformationMatrix* layerTransform = layer->transform())
+      transform = layerTransform->toAffineTransform() * transform;
+
+    layer = layer->parent();
+  }
+
+  return transform;
+}
+
+float SVGLayoutSupport::calculateScreenFontSizeScalingFactor(
+    const LayoutObject* layoutObject) {
+  DCHECK(layoutObject);
+
+  // FIXME: trying to compute a device space transform at record time is wrong.
+  // All clients should be updated to avoid relying on this information, and the
+  // method should be removed.
+  AffineTransform ctm =
+      deprecatedCalculateTransformToLayer(layoutObject) *
+      SubtreeContentTransformScope::currentContentTransformation();
+  ctm.scale(layoutObject->document().page()->deviceScaleFactorDeprecated());
+
+  return clampTo<float>(sqrt((ctm.xScaleSquared() + ctm.yScaleSquared()) / 2));
 }
 
 static inline bool compareCandidateDistance(const SearchCandidate& r1,
                                             const SearchCandidate& r2) {
   return r1.candidateDistance < r2.candidateDistance;
 }
 
 static inline float distanceToChildLayoutObject(LayoutObject* child,
                                                 const FloatPoint& point) {
   const AffineTransform& localToParentTransform =
@@ skipping 63 matching lines @@
 }
 
 LayoutObject* SVGLayoutSupport::findClosestLayoutSVGText(
     LayoutObject* layoutObject,
     const FloatPoint& point) {
   return searchTreeForFindClosestLayoutSVGText(layoutObject, point)
       .candidateLayoutObject;
 }
 
 }  // namespace blink