Rename and change parameter type of some GeometryMapper methods

third_party/WebKit/Source/core/paint/PaintLayerClipper.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 198 matching lines @@
 LayoutRect PaintLayerClipper::localClipRect(
     const PaintLayer* clippingRootLayer) const {
   ClipRectsContext context(clippingRootLayer, PaintingClipRects);
   if (m_geometryMapper) {
     ClipRect clipRect = applyOverflowClipToBackgroundRectWithGeometryMapper(
         context, clipRectWithGeometryMapper(context, false));
 
     // The rect now needs to be transformed to the local space of this
     // PaintLayer.
     bool success = false;
+    const auto* clipRootLayerTransform = clippingRootLayer->layoutObject()
+                                             ->paintProperties()
+                                             ->localBorderBoxProperties()
+                                             ->transform();
+    const auto* layerTransform = m_layer.layoutObject()
+                                     ->paintProperties()
+                                     ->localBorderBoxProperties()
+                                     ->transform();
     FloatRect clippedRectInLocalSpace =
-        m_geometryMapper->mapRectToDestinationSpace(
-            FloatRect(clipRect.rect()), *clippingRootLayer->layoutObject()
-                                             ->paintProperties()
-                                             ->localBorderBoxProperties(),
-            *m_layer.layoutObject()
-                 ->paintProperties()
-                 ->localBorderBoxProperties(),
-            success);
+        m_geometryMapper->sourceToDestinationRect(FloatRect(clipRect.rect()),
+                                                  clipRootLayerTransform,
+                                                  layerTransform, success);
     DCHECK(success);
 
     return LayoutRect(clippedRectInLocalSpace);
   }
 
   LayoutRect layerBounds;
   ClipRect backgroundRect, foregroundRect;
   calculateRects(context, LayoutRect(LayoutRect::infiniteIntRect()),
                  layerBounds, backgroundRect, foregroundRect);
 
@@ skipping 14 matching lines @@
   CHECK((expected.isEmpty() && actual.isEmpty()) || expected == actual) \
       << "expected=" << expected.toString() << " actual=" << actual.toString()
 #endif
 
 void PaintLayerClipper::mapLocalToRootWithGeometryMapper(
     const ClipRectsContext& context,
     LayoutRect& layoutRect) const {
   DCHECK(m_geometryMapper);
   bool success;
 
-  const auto* layerBorderBoxProperties =
-      m_layer.layoutObject()->paintProperties()->localBorderBoxProperties();
+  const auto* layerTransform = m_layer.layoutObject()
+                                   ->paintProperties()
+                                   ->localBorderBoxProperties()
+                                   ->transform();
+  const auto* rootTransform = context.rootLayer->layoutObject()
+                                  ->paintProperties()
+                                  ->localBorderBoxProperties()
+                                  ->transform();
+
   FloatRect localRect(layoutRect);
   localRect.moveBy(FloatPoint(m_layer.layoutObject()->paintOffset()));
-
-  layoutRect = LayoutRect(m_geometryMapper->mapRectToDestinationSpace(
-      localRect, *layerBorderBoxProperties, *context.rootLayer->layoutObject()
-                                                 ->paintProperties()
-                                                 ->localBorderBoxProperties(),
-      success));
+  layoutRect = LayoutRect(m_geometryMapper->sourceToDestinationRect(
+      localRect, layerTransform, rootTransform, success));
   DCHECK(success);
 }
 
 void PaintLayerClipper::calculateRectsWithGeometryMapper(
     const ClipRectsContext& context,
     const LayoutRect& paintDirtyRect,
     LayoutRect& layerBounds,
     ClipRect& backgroundRect,
     ClipRect& foregroundRect,
     const LayoutPoint* offsetFromRoot) const {
@@ skipping 163 matching lines @@
   const auto* ancestorProperties =
       context.rootLayer->layoutObject()->paintProperties();
   DCHECK(ancestorProperties && ancestorProperties->localBorderBoxProperties());
   PropertyTreeState destinationPropertyTreeState =
       *ancestorProperties->localBorderBoxProperties();
   if (!context.rootLayer->clipper().shouldRespectOverflowClip(context)) {
     if (ancestorProperties->overflowClip())
       destinationPropertyTreeState.setClip(ancestorProperties->overflowClip());
   }
   FloatRect clippedRectInRootLayerSpace =
-      m_geometryMapper->mapToVisualRectInDestinationSpace(
+      m_geometryMapper->sourceToDestinationVisualRect(
           FloatRect(source), propertyTreeState, destinationPropertyTreeState,
           success);
   DCHECK(success);
   return ClipRect(LayoutRect(clippedRectInRootLayerSpace));
 }
 
 ClipRect PaintLayerClipper::applyOverflowClipToBackgroundRectWithGeometryMapper(
     const ClipRectsContext& context,
     const ClipRect& clip) const {
   const LayoutObject& layoutObject = *m_layer.layoutObject();
@@ skipping 86 matching lines @@
     const LayoutSize& subpixelAccumulation) const {
   DCHECK(!m_geometryMapper);
   ClipRectsContext context(rootLayer, PaintingClipRects,
                            IgnoreOverlayScrollbarSize, subpixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     context.setIgnoreOverflowClip();
   return getClipRects(context);
 }
 
 }  // namespace blink