Reduce copying of local data structures in GeometryMapper and PaintLayerClipper.

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 271 matching lines @@
   if (transformNode != ancestorState.transform()) {
     const TransformationMatrix& localToAncestorMatrix =
         geometryMapper.localToAncestorMatrix(transformNode,
                                              ancestorState.transform());
     // Clips are only in descendant spaces that are transformed by one
     // or more scrolls.
     DCHECK(localToAncestorMatrix.isIdentityOrTranslation());
   }
 #endif
 
-  FloatRect combinedClip =
-      geometryMapper.localToAncestorClipRect(localState, ancestorState).rect();
+  const FloatClipRect& combinedClip =
+      geometryMapper.localToAncestorClipRect(localState, ancestorState);
 
   ccList.CreateAndAppendPairedBeginItem<cc::FloatClipDisplayItem>(
-      gfx::RectF(combinedClip));
+      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) {
   PropertyTreeState mappedClipDestinationSpace = pendingLayerState;
@@ skipping 290 matching lines @@
 }
 
 bool PaintArtifactCompositor::mightOverlap(
     const PaintChunk& paintChunk,
     const PendingLayer& candidatePendingLayer,
     GeometryMapper& geometryMapper) {
   PropertyTreeState rootPropertyTreeState(TransformPaintPropertyNode::root(),
                                           ClipPaintPropertyNode::root(),
                                           EffectPaintPropertyNode::root());
 
-  FloatRect paintChunkScreenVisualRect =
-      geometryMapper
-          .localToAncestorVisualRect(paintChunk.bounds,
-                                     paintChunk.properties.propertyTreeState,
-                                     rootPropertyTreeState)
-          .rect();
+  FloatRect paintChunkScreenVisualRect = paintChunk.bounds;
+  geometryMapper.localToAncestorVisualRect(
+      paintChunk.properties.propertyTreeState, rootPropertyTreeState,
+      paintChunkScreenVisualRect);
 
-  FloatRect pendingLayerScreenVisualRect =
-      geometryMapper
-          .localToAncestorVisualRect(candidatePendingLayer.bounds,
-                                     candidatePendingLayer.propertyTreeState,
-                                     rootPropertyTreeState)
-          .rect();
+  FloatRect pendingLayerScreenVisualRect = candidatePendingLayer.bounds;
+  geometryMapper.localToAncestorVisualRect(
+      candidatePendingLayer.propertyTreeState, rootPropertyTreeState,
+      pendingLayerScreenVisualRect);
 
   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) {
-    mappedBounds = geometryMapper->localToAncestorRect(
-        mappedBounds, paintChunk.properties.propertyTreeState.transform(),
-        propertyTreeState.transform());
+    geometryMapper->localToAncestorRect(
+        paintChunk.properties.propertyTreeState.transform(),
+        propertyTreeState.transform(), mappedBounds);
   }
   bounds.unite(mappedBounds);
   if (bounds.size() != paintChunks[0]->bounds.size()) {
     if (bounds.size() != paintChunk.bounds.size())
       knownToBeOpaque = false;
     else
       knownToBeOpaque = paintChunk.knownToBeOpaque;
   }
 }
 
@@ skipping 101 matching lines @@
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink