Make GeometryMapper fully static

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 <algorithm>
 #include <memory>
 #include <utility>
 #include "cc/layers/content_layer_client.h"
@@ skipping 252 matching lines @@
           : paintArtifact.getDisplayItemList()[paintChunk.beginIndex].getId()));
 }
 
 scoped_refptr<cc::Layer>
 PaintArtifactCompositor::compositedLayerForPendingLayer(
     const PaintArtifact& paintArtifact,
     const PendingLayer& pendingLayer,
     gfx::Vector2dF& layerOffset,
     Vector<std::unique_ptr<ContentLayerClientImpl>>& newContentLayerClients,
     RasterInvalidationTrackingMap<const PaintChunk>* trackingMap,
-    bool storeDebugInfo,
-    GeometryMapper& geometryMapper) {
+    bool storeDebugInfo) {
   DCHECK(pendingLayer.paintChunks.size());
   const PaintChunk& firstPaintChunk = *pendingLayer.paintChunks[0];
   DCHECK(firstPaintChunk.size());
 
   // If the paint chunk is a foreign layer, just return that layer.
   if (scoped_refptr<cc::Layer> foreignLayer = foreignLayerForPaintChunk(
           paintArtifact, firstPaintChunk, layerOffset)) {
     DCHECK_EQ(pendingLayer.paintChunks.size(), 1u);
     return foreignLayer;
   }
 
   // The common case: create or reuse a PictureLayer for painted content.
   std::unique_ptr<ContentLayerClientImpl> contentLayerClient =
       clientForPaintChunk(firstPaintChunk, paintArtifact);
 
   gfx::Rect ccCombinedBounds(enclosingIntRect(pendingLayer.bounds));
 
   layerOffset = ccCombinedBounds.OffsetFromOrigin();
   scoped_refptr<cc::DisplayItemList> displayList =
-      PaintChunksToCcLayer::convert(
-          pendingLayer.paintChunks, pendingLayer.propertyTreeState, layerOffset,
-          paintArtifact.getDisplayItemList(), geometryMapper);
+      PaintChunksToCcLayer::convert(pendingLayer.paintChunks,
+                                    pendingLayer.propertyTreeState, layerOffset,
+                                    paintArtifact.getDisplayItemList());
   contentLayerClient->SetDisplayList(std::move(displayList));
   contentLayerClient->SetPaintableRegion(gfx::Rect(ccCombinedBounds.size()));
 
   scoped_refptr<cc::PictureLayer> ccPictureLayer =
       contentLayerClient->ccPictureLayer();
   ccPictureLayer->SetBounds(ccCombinedBounds.size());
   ccPictureLayer->SetIsDrawable(true);
   ccPictureLayer->SetContentsOpaque(pendingLayer.knownToBeOpaque);
   contentLayerClient->clearPaintChunkDebugData();
 
@@ skipping 39 matching lines @@
     const PaintChunk& firstPaintChunk,
     bool chunkIsForeign)
     : bounds(firstPaintChunk.bounds),
       knownToBeOpaque(firstPaintChunk.knownToBeOpaque),
       backfaceHidden(firstPaintChunk.properties.backfaceHidden),
       propertyTreeState(firstPaintChunk.properties.propertyTreeState),
       isForeign(chunkIsForeign) {
   paintChunks.push_back(&firstPaintChunk);
 }
 
-void PaintArtifactCompositor::PendingLayer::merge(
-    const PendingLayer& guest,
-    GeometryMapper& geometryMapper) {
+void PaintArtifactCompositor::PendingLayer::merge(const PendingLayer& guest) {
   DCHECK(!isForeign && !guest.isForeign);
   DCHECK_EQ(backfaceHidden, guest.backfaceHidden);
 
   paintChunks.appendVector(guest.paintChunks);
   FloatRect guestBoundsInHome = guest.bounds;
-  geometryMapper.localToAncestorVisualRect(
+  GeometryMapper::localToAncestorVisualRect(
       guest.propertyTreeState, propertyTreeState, guestBoundsInHome);
   FloatRect oldBounds = bounds;
   bounds.unite(guestBoundsInHome);
   if (bounds != oldBounds)
     knownToBeOpaque = false;
   // TODO(crbug.com/701991): Upgrade GeometryMapper.
   // If we knew the new bounds is enclosed by the mapped opaque region of
   // the guest layer, we can deduce the merged layer being opaque too.
 }
 
 static bool canUpcastTo(const PropertyTreeState& guest,
                         const PropertyTreeState& home);
 bool PaintArtifactCompositor::PendingLayer::canMerge(
     const PendingLayer& guest) const {
   if (isForeign || guest.isForeign)
     return false;
   if (backfaceHidden != guest.backfaceHidden)
     return false;
   if (propertyTreeState.effect() != guest.propertyTreeState.effect())
     return false;
   return canUpcastTo(guest.propertyTreeState, propertyTreeState);
 }
 
 void PaintArtifactCompositor::PendingLayer::upcast(
-    const PropertyTreeState& newState,
-    GeometryMapper& geometryMapper) {
+    const PropertyTreeState& newState) {
   DCHECK(!isForeign);
-  geometryMapper.localToAncestorVisualRect(propertyTreeState, newState, bounds);
+  GeometryMapper::localToAncestorVisualRect(propertyTreeState, newState,
+                                            bounds);
 
   propertyTreeState = newState;
   // TODO(crbug.com/701991): Upgrade GeometryMapper.
   // A local visual rect mapped to an ancestor space may become a polygon
   // (e.g. consider transformed clip), also effects may affect the opaque
   // region. To determine whether the layer is still opaque, we need to
   // query conservative opaque rect after mapping to an ancestor space,
   // which is not supported by GeometryMapper yet.
   knownToBeOpaque = false;
 }
@@ skipping 41 matching lines @@
     const EffectPaintPropertyNode* ancestor,
     const EffectPaintPropertyNode* node) {
   for (; node; node = node->parent()) {
     if (node->parent() == ancestor)
       return node;
   }
   return nullptr;
 }
 
 bool PaintArtifactCompositor::mightOverlap(const PendingLayer& layerA,
-                                           const PendingLayer& layerB,
-                                           GeometryMapper& geometryMapper) {
+                                           const PendingLayer& layerB) {
   PropertyTreeState rootPropertyTreeState(TransformPaintPropertyNode::root(),
                                           ClipPaintPropertyNode::root(),
                                           EffectPaintPropertyNode::root());
 
   FloatRect boundsA = layerA.bounds;
-  geometryMapper.localToAncestorVisualRect(layerA.propertyTreeState,
-                                           rootPropertyTreeState, boundsA);
+  GeometryMapper::localToAncestorVisualRect(layerA.propertyTreeState,
+                                            rootPropertyTreeState, boundsA);
   FloatRect boundsB = layerB.bounds;
-  geometryMapper.localToAncestorVisualRect(layerB.propertyTreeState,
-                                           rootPropertyTreeState, boundsB);
+  GeometryMapper::localToAncestorVisualRect(layerB.propertyTreeState,
+                                            rootPropertyTreeState, boundsB);
 
   return boundsA.intersects(boundsB);
 }
 
 bool PaintArtifactCompositor::canDecompositeEffect(
     const EffectPaintPropertyNode* effect,
     const PendingLayer& layer) {
   // If the effect associated with the layer is deeper than than the effect
   // we are attempting to decomposite, than implies some previous decision
   // did not allow to decomposite intermediate effects.
@@ skipping 10 matching lines @@
   if (!canUpcastTo(layer.propertyTreeState,
                    PropertyTreeState(effect->localTransformSpace(),
                                      effect->outputClip(), effect)))
     return false;
   return true;
 }
 
 void PaintArtifactCompositor::layerizeGroup(
     const PaintArtifact& paintArtifact,
     Vector<PendingLayer>& pendingLayers,
-    GeometryMapper& geometryMapper,
     const EffectPaintPropertyNode& currentGroup,
     Vector<PaintChunk>::const_iterator& chunkIt) {
   size_t firstLayerInCurrentGroup = pendingLayers.size();
   // The worst case time complexity of the algorithm is O(pqd), where
   // p = the number of paint chunks.
   // q = average number of trials to find a squash layer or rejected
   //     for overlapping.
   // d = (sum of) the depth of property trees.
   // The analysis as follows:
   // Every paint chunk will be visited by the main loop below for exactly once,
@@ skipping 25 matching lines @@
     } else {
       const EffectPaintPropertyNode* subgroup =
           strictChildOfAlongPath(&currentGroup, chunkEffect);
       // Case B: This means we need to close the current group without
       //         processing the next chunk.
       if (!subgroup)
         break;
       // Case C: The following chunks belong to a subgroup. Process them by
       //         a recursion call.
       size_t firstLayerInSubgroup = pendingLayers.size();
-      layerizeGroup(paintArtifact, pendingLayers, geometryMapper, *subgroup,
-                    chunkIt);
+      layerizeGroup(paintArtifact, pendingLayers, *subgroup, chunkIt);
       // Now the chunk iterator stepped over the subgroup we just saw.
       // If the subgroup generated 2 or more layers then the subgroup must be
       // composited to satisfy grouping requirement.
       // i.e. Grouping effects generally must be applied atomically,
       // for example,  Opacity(A+B) != Opacity(A) + Opacity(B), thus an effect
       // either applied 100% within a layer, or not at all applied within layer
       // (i.e. applied by compositor render surface instead).
       if (pendingLayers.size() != firstLayerInSubgroup + 1)
         continue;
       // Now attempt to "decomposite" subgroup.
       PendingLayer& subgroupLayer = pendingLayers[firstLayerInSubgroup];
       if (!canDecompositeEffect(subgroup, subgroupLayer))
         continue;
-      subgroupLayer.upcast(
-          PropertyTreeState(subgroup->localTransformSpace(),
-                            subgroup->outputClip(), &currentGroup),
-          geometryMapper);
+      subgroupLayer.upcast(PropertyTreeState(subgroup->localTransformSpace(),
+                                             subgroup->outputClip(),
+                                             &currentGroup));
     }
     // At this point pendingLayers.back() is the either a layer from a
     // "decomposited" subgroup or a layer created from a chunk we just
     // processed. Now determine whether it could be merged into a previous
     // layer.
     const PendingLayer& newLayer = pendingLayers.back();
     DCHECK(!newLayer.isForeign);
     DCHECK_EQ(&currentGroup, newLayer.propertyTreeState.effect());
     // This iterates pendingLayers[firstLayerInCurrentGroup:-1] in reverse.
     for (size_t candidateIndex = pendingLayers.size() - 1;
          candidateIndex-- > firstLayerInCurrentGroup;) {
       PendingLayer& candidateLayer = pendingLayers[candidateIndex];
       if (candidateLayer.canMerge(newLayer)) {
-        candidateLayer.merge(newLayer, geometryMapper);
+        candidateLayer.merge(newLayer);
         pendingLayers.pop_back();
         break;
       }
-      if (mightOverlap(newLayer, candidateLayer, geometryMapper))
+      if (mightOverlap(newLayer, candidateLayer))
         break;
     }
   }
 }
 
 void PaintArtifactCompositor::collectPendingLayers(
     const PaintArtifact& paintArtifact,
-    Vector<PendingLayer>& pendingLayers,
-    GeometryMapper& geometryMapper) {
+    Vector<PendingLayer>& pendingLayers) {
   Vector<PaintChunk>::const_iterator cursor =
       paintArtifact.paintChunks().begin();
-  layerizeGroup(paintArtifact, pendingLayers, geometryMapper,
-                *EffectPaintPropertyNode::root(), cursor);
+  layerizeGroup(paintArtifact, pendingLayers, *EffectPaintPropertyNode::root(),
+                cursor);
   DCHECK_EQ(paintArtifact.paintChunks().end(), cursor);
 }
 
 void PaintArtifactCompositor::update(
     const PaintArtifact& paintArtifact,
     RasterInvalidationTrackingMap<const PaintChunk>* rasterChunkInvalidations,
-    bool storeDebugInfo,
-    GeometryMapper& geometryMapper) {
+    bool storeDebugInfo) {
 #ifndef NDEBUG
   storeDebugInfo = true;
 #endif
 
   DCHECK(m_rootLayer);
 
   cc::LayerTreeHost* layerTreeHost = m_rootLayer->layer_tree_host();
 
   // The tree will be null after detaching and this update can be ignored.
   // See: WebViewImpl::detachPaintArtifactCompositor().
   if (!layerTreeHost)
     return;
 
   if (m_extraDataForTestingEnabled)
     m_extraDataForTesting = WTF::wrapUnique(new ExtraDataForTesting);
 
   m_rootLayer->RemoveAllChildren();
 
   m_rootLayer->set_property_tree_sequence_number(sPropertyTreeSequenceNumber);
 
   PropertyTreeManager propertyTreeManager(*layerTreeHost->property_trees(),
                                           m_rootLayer.get(),
                                           sPropertyTreeSequenceNumber);
 
   Vector<PendingLayer, 0> pendingLayers;
-  collectPendingLayers(paintArtifact, pendingLayers, geometryMapper);
+  collectPendingLayers(paintArtifact, pendingLayers);
 
   Vector<std::unique_ptr<ContentLayerClientImpl>> newContentLayerClients;
   newContentLayerClients.reserveCapacity(paintArtifact.paintChunks().size());
   for (const PendingLayer& pendingLayer : pendingLayers) {
     gfx::Vector2dF layerOffset;
     scoped_refptr<cc::Layer> layer = compositedLayerForPendingLayer(
         paintArtifact, pendingLayer, layerOffset, newContentLayerClients,
-        rasterChunkInvalidations, storeDebugInfo, geometryMapper);
+        rasterChunkInvalidations, storeDebugInfo);
 
     const auto* transform = pendingLayer.propertyTreeState.transform();
     int transformId =
         propertyTreeManager.ensureCompositorTransformNode(transform);
     int clipId = propertyTreeManager.ensureCompositorClipNode(
         pendingLayer.propertyTreeState.clip());
     int effectId = propertyTreeManager.switchToEffectNode(
         *pendingLayer.propertyTreeState.effect());
 
     layer->set_offset_to_transform_parent(layerOffset);
@@ skipping 26 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink