Rename and change parameter type of some GeometryMapper methods

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/playback/compositing_display_item.h"
@@ skipping 268 matching lines @@
                                     cc::DisplayItemList& ccList,
                                     Vector<EndDisplayItemType>& endDisplayItems,
                                     GeometryMapper& geometryMapper) {
   DCHECK(localState.transform() == ancestorState.transform());
 #ifdef DCHECK_IS_ON
   const TransformPaintPropertyNode* transformNode =
       localState.clip()->localTransformSpace();
   if (transformNode != ancestorState.transform()) {
     bool success = false;
     const TransformationMatrix& localToAncestorMatrix =
-        geometryMapper.localToAncestorMatrix(transformNode, ancestorState,
-                                             success);
+        geometryMapper.localToAncestorMatrix(
+            transformNode, ancestorState.transform(), success);
     DCHECK(success);
     // Clips are only in descendant spaces that are transformed by one
     // or more scrolls.
     DCHECK(localToAncestorMatrix.isIdentityOrTranslation());
   }
 #endif
 
   FloatRect combinedClip;
   bool success = false;
   combinedClip = geometryMapper.localToAncestorClipRect(localState,
@@ skipping 65 matching lines @@
         FloatRect clipRect =
             pairedState->effect()->outputClip()->clipRect().rect();
         // TODO(chrishtr): specify origin of the filter.
         FloatPoint filterOrigin;
         if (pairedState->effect()->localTransformSpace() !=
             pairedState->transform()) {
           bool success = false;
           const TransformPaintPropertyNode* transformNode =
               pairedState->effect()->localTransformSpace();
           const TransformationMatrix& localToAncestorMatrix =
-              geometryMapper.localToAncestorMatrix(transformNode, *pairedState,
-                                                   success);
+              geometryMapper.localToAncestorMatrix(
+                  transformNode, pairedState->transform(), success);
           DCHECK(success);
           // Effects are only in descendant spaces that are transformed by one
           // or more scrolls.
           DCHECK(localToAncestorMatrix.isIdentityOrTranslation());
 
           clipRect = localToAncestorMatrix.mapRect(clipRect);
           filterOrigin = localToAncestorMatrix.mapPoint(filterOrigin);
         }
 
         const bool kLcdTextRequiresOpaqueLayer = true;
@@ skipping 686 matching lines @@
 bool PaintArtifactCompositor::mightOverlap(
     const PaintChunk& paintChunk,
     const PendingLayer& candidatePendingLayer,
     GeometryMapper& geometryMapper) {
   PropertyTreeState rootPropertyTreeState(
       TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
       EffectPaintPropertyNode::root(), ScrollPaintPropertyNode::root());
 
   bool success = false;
   FloatRect paintChunkScreenVisualRect =
-      geometryMapper.localToVisualRectInAncestorSpace(
+      geometryMapper.localToAncestorVisualRect(
           paintChunk.bounds, paintChunk.properties.propertyTreeState,
           rootPropertyTreeState, success);
   DCHECK(success);
 
   success = false;
   FloatRect pendingLayerScreenVisualRect =
-      geometryMapper.localToVisualRectInAncestorSpace(
+      geometryMapper.localToAncestorVisualRect(
           candidatePendingLayer.bounds, candidatePendingLayer.propertyTreeState,
           rootPropertyTreeState, success);
   DCHECK(success);
 
   return paintChunkScreenVisualRect.intersects(pendingLayerScreenVisualRect);
 }
 
 PaintArtifactCompositor::PendingLayer::PendingLayer(
     const PaintChunk& firstPaintChunk)
     : bounds(firstPaintChunk.bounds),
       knownToBeOpaque(firstPaintChunk.knownToBeOpaque),
       backfaceHidden(firstPaintChunk.properties.backfaceHidden),
       propertyTreeState(firstPaintChunk.properties.propertyTreeState) {
   paintChunks.push_back(&firstPaintChunk);
 }
 
 void PaintArtifactCompositor::PendingLayer::add(
     const PaintChunk& paintChunk,
     GeometryMapper* geometryMapper) {
   DCHECK(paintChunk.properties.backfaceHidden == backfaceHidden);
   paintChunks.push_back(&paintChunk);
   FloatRect mappedBounds = paintChunk.bounds;
   if (geometryMapper) {
     bool success = false;
     mappedBounds = geometryMapper->localToAncestorRect(
-        mappedBounds, paintChunk.properties.propertyTreeState,
-        propertyTreeState, success);
+        mappedBounds, paintChunk.properties.propertyTreeState.transform(),
+        propertyTreeState.transform(), success);
     DCHECK(success);
   }
   bounds.unite(mappedBounds);
   if (bounds.size() != paintChunks[0]->bounds.size()) {
     if (bounds.size() != paintChunk.bounds.size())
       knownToBeOpaque = false;
     else
       knownToBeOpaque = paintChunk.knownToBeOpaque;
   }
 }
@@ skipping 99 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink