Make GeometryMapper fully static

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

 // Copyright 2017 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/PaintChunksToCcLayer.h"
 
 #include "cc/paint/compositing_display_item.h"
 #include "cc/paint/display_item_list.h"
 #include "cc/paint/drawing_display_item.h"
 #include "cc/paint/filter_display_item.h"
 #include "cc/paint/float_clip_display_item.h"
 #include "cc/paint/transform_display_item.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "platform/graphics/paint/GeometryMapper.h"
 #include "platform/graphics/paint/PaintChunk.h"
 #include "platform/graphics/paint/PropertyTreeState.h"
 
 namespace blink {
 
 namespace {
 
 enum EndDisplayItemType { EndTransform, EndClip, EndEffect };
 
 // Applies the clips between |localState| and |ancestorState| into a single
 // combined cc::FloatClipDisplayItem on |ccList|.
-static void applyClipsBetweenStates(const PropertyTreeState& localState,
-                                    const PropertyTreeState& ancestorState,
-                                    cc::DisplayItemList& ccList,
-                                    Vector<EndDisplayItemType>& endDisplayItems,
-                                    GeometryMapper& geometryMapper) {
+static void applyClipsBetweenStates(
+    const PropertyTreeState& localState,
+    const PropertyTreeState& ancestorState,
+    cc::DisplayItemList& ccList,
+    Vector<EndDisplayItemType>& endDisplayItems) {
   DCHECK(localState.transform() == ancestorState.transform());
 #if DCHECK_IS_ON()
   const TransformPaintPropertyNode* transformNode =
       localState.clip()->localTransformSpace();
   if (transformNode != ancestorState.transform()) {
     const TransformationMatrix& localToAncestorMatrix =
-        geometryMapper.localToAncestorMatrix(transformNode,
-                                             ancestorState.transform());
+        GeometryMapper::localToAncestorMatrix(transformNode,
+                                              ancestorState.transform());
     // Clips are only in descendant spaces that are transformed by one
     // or more scrolls.
     DCHECK(localToAncestorMatrix.isIdentityOrTranslation());
   }
 #endif
 
   const FloatClipRect& combinedClip =
-      geometryMapper.localToAncestorClipRect(localState, ancestorState);
+      GeometryMapper::localToAncestorClipRect(localState, ancestorState);
 
   ccList.CreateAndAppendPairedBeginItem<cc::FloatClipDisplayItem>(
       gfx::RectF(combinedClip.rect()));
   endDisplayItems.push_back(EndClip);
 }
 
 static void recordPairedBeginDisplayItems(
     const Vector<PropertyTreeState>& pairedStates,
     const PropertyTreeState& pendingLayerState,
     cc::DisplayItemList& ccList,
-    Vector<EndDisplayItemType>& endDisplayItems,
-    GeometryMapper& geometryMapper) {
+    Vector<EndDisplayItemType>& endDisplayItems) {
   PropertyTreeState mappedClipDestinationSpace = pendingLayerState;
   PropertyTreeState clipSpace = pendingLayerState;
   bool hasClip = false;
 
   for (Vector<PropertyTreeState>::const_reverse_iterator pairedState =
            pairedStates.rbegin();
        pairedState != pairedStates.rend(); ++pairedState) {
     switch (pairedState->innermostNode()) {
       case PropertyTreeState::Transform: {
         if (hasClip) {
           applyClipsBetweenStates(clipSpace, mappedClipDestinationSpace, ccList,
-                                  endDisplayItems, geometryMapper);
+                                  endDisplayItems);
           hasClip = false;
         }
         mappedClipDestinationSpace = *pairedState;
         clipSpace = *pairedState;
 
         TransformationMatrix matrix = pairedState->transform()->matrix();
         matrix.applyTransformOrigin(pairedState->transform()->origin());
 
         gfx::Transform transform(gfx::Transform::kSkipInitialization);
         transform.matrix() = TransformationMatrix::toSkMatrix44(matrix);
@@ skipping 28 matching lines @@
 
         FloatRect clipRect =
             pairedState->effect()->outputClip()->clipRect().rect();
         // TODO(chrishtr): specify origin of the filter.
         FloatPoint filterOrigin;
         if (pairedState->effect()->localTransformSpace() !=
             pairedState->transform()) {
           const TransformPaintPropertyNode* transformNode =
               pairedState->effect()->localTransformSpace();
           const TransformationMatrix& localToAncestorMatrix =
-              geometryMapper.localToAncestorMatrix(transformNode,
-                                                   pairedState->transform());
+              GeometryMapper::localToAncestorMatrix(transformNode,
+                                                    pairedState->transform());
           // 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;
         ccList.CreateAndAppendPairedBeginItem<cc::CompositingDisplayItem>(
@@ skipping 13 matching lines @@
         endDisplayItems.push_back(EndEffect);
         break;
       }
       case PropertyTreeState::None:
         break;
     }
   }
 
   if (hasClip) {
     applyClipsBetweenStates(clipSpace, mappedClipDestinationSpace, ccList,
-                            endDisplayItems, geometryMapper);
+                            endDisplayItems);
   }
 }
 
 static void recordPairedEndDisplayItems(
     const Vector<EndDisplayItemType>& endDisplayItemTypes,
     cc::DisplayItemList* ccList) {
   for (Vector<EndDisplayItemType>::const_reverse_iterator endType =
            endDisplayItemTypes.rbegin();
        endType != endDisplayItemTypes.rend(); ++endType) {
     switch (*endType) {
@@ skipping 32 matching lines @@
                                                              std::move(record));
   }
 }
 
 }  // unnamed namespace
 
 scoped_refptr<cc::DisplayItemList> PaintChunksToCcLayer::convert(
     const Vector<const PaintChunk*>& paintChunks,
     const PropertyTreeState& layerState,
     const gfx::Vector2dF& layerOffset,
-    const DisplayItemList& displayItems,
-    GeometryMapper& geometryMapper) {
+    const DisplayItemList& displayItems) {
   auto ccList = make_scoped_refptr(new cc::DisplayItemList);
 
   gfx::Transform counterOffset;
   counterOffset.Translate(-layerOffset.x(), -layerOffset.y());
   ccList->CreateAndAppendPairedBeginItem<cc::TransformDisplayItem>(
       counterOffset);
 
   for (const auto* paintChunk : paintChunks) {
     const PropertyTreeState* state = &paintChunk->properties.propertyTreeState;
     PropertyTreeStateIterator iterator(*state);
     Vector<PropertyTreeState> pairedStates;
     for (; state && *state != layerState; state = iterator.next()) {
       if (state->innermostNode() != PropertyTreeState::None)
         pairedStates.push_back(*state);
     }
 
     // TODO(chrishtr): we can avoid some extra paired display items if
     // multiple PaintChunks share them. We can also collapse clips between
     // transforms into single clips in the same way that PaintLayerClipper does.
     Vector<EndDisplayItemType> endDisplayItems;
 
     recordPairedBeginDisplayItems(pairedStates, layerState, *ccList.get(),
-                                  endDisplayItems, geometryMapper);
+                                  endDisplayItems);
 
     for (const auto& displayItem : displayItems.itemsInPaintChunk(*paintChunk))
       appendDisplayItemToCcDisplayItemList(displayItem, ccList.get());
 
     recordPairedEndDisplayItems(endDisplayItems, ccList.get());
   }
 
   ccList->CreateAndAppendPairedEndItem<cc::EndTransformDisplayItem>();
 
   ccList->Finalize();
   return ccList;
 }
 
 }  // namespace blink