Revert of Make GeometryMapper fully static

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

 // Copyright 2016 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 <memory>
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/layers/layer.h"
 #include "cc/test/fake_compositor_frame_sink.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/scroll_node.h"
 #include "cc/trees/transform_node.h"
 #include "platform/graphics/paint/EffectPaintPropertyNode.h"
+#include "platform/graphics/paint/GeometryMapper.h"
 #include "platform/graphics/paint/PaintArtifact.h"
 #include "platform/graphics/paint/ScrollPaintPropertyNode.h"
 #include "platform/testing/PaintPropertyTestHelpers.h"
 #include "platform/testing/PictureMatchers.h"
 #include "platform/testing/RuntimeEnabledFeaturesTestHelpers.h"
 #include "platform/testing/TestPaintArtifact.h"
 #include "platform/testing/WebLayerTreeViewImplForTesting.h"
 #include "public/platform/WebLayerScrollClient.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 81 matching lines @@
     return m_webLayerTreeView->layerTreeHost()
         ->property_trees()
         ->element_id_to_scroll_node_index[elementId];
   }
 
   const cc::TransformNode& transformNode(const cc::Layer* layer) {
     return *propertyTrees().transform_tree.Node(layer->transform_tree_index());
   }
 
   void update(const PaintArtifact& artifact) {
-    m_paintArtifactCompositor->update(artifact, nullptr, false);
+    std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
+    m_paintArtifactCompositor->update(artifact, nullptr, false,
+                                      *geometryMapper);
     m_webLayerTreeView->layerTreeHost()->LayoutAndUpdateLayers();
   }
 
   cc::Layer* rootLayer() { return m_paintArtifactCompositor->rootLayer(); }
 
   size_t contentLayerCount() {
     return m_paintArtifactCompositor->getExtraDataForTesting()
         ->contentLayers.size();
   }
 
@@ skipping 1302 matching lines @@
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, MightOverlap) {
   PaintChunk paintChunk;
   paintChunk.properties = defaultPaintChunkProperties();
   paintChunk.bounds = FloatRect(0, 0, 100, 100);
   PaintArtifactCompositor::PendingLayer pendingLayer(paintChunk, false);
 
   PaintChunk paintChunk2;
   paintChunk2.properties = defaultPaintChunkProperties();
   paintChunk2.bounds = FloatRect(0, 0, 100, 100);
 
+  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
+
   {
     PaintArtifactCompositor::PendingLayer pendingLayer2(paintChunk2, false);
-    EXPECT_TRUE(
-        PaintArtifactCompositor::mightOverlap(pendingLayer, pendingLayer2));
+    EXPECT_TRUE(PaintArtifactCompositor::mightOverlap(
+        pendingLayer, pendingLayer2, *geometryMapper));
   }
 
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(99, 0), FloatPoint3D(100, 100, 0),
           false);
   {
     paintChunk2.properties.propertyTreeState.setTransform(transform.get());
     PaintArtifactCompositor::PendingLayer pendingLayer2(paintChunk2, false);
-    EXPECT_TRUE(
-        PaintArtifactCompositor::mightOverlap(pendingLayer, pendingLayer2));
+    EXPECT_TRUE(PaintArtifactCompositor::mightOverlap(
+        pendingLayer, pendingLayer2, *geometryMapper));
   }
 
   RefPtr<TransformPaintPropertyNode> transform2 =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(100, 0), FloatPoint3D(100, 100, 0),
           false);
   {
     paintChunk2.properties.propertyTreeState.setTransform(transform2.get());
     PaintArtifactCompositor::PendingLayer pendingLayer2(paintChunk2, false);
-    EXPECT_FALSE(
-        PaintArtifactCompositor::mightOverlap(pendingLayer, pendingLayer2));
+    EXPECT_FALSE(PaintArtifactCompositor::mightOverlap(
+        pendingLayer, pendingLayer2, *geometryMapper));
   }
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayer) {
+  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
+
   PaintChunk chunk1;
   chunk1.properties.propertyTreeState = PropertyTreeState(
       TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
       EffectPaintPropertyNode::root());
   chunk1.properties.backfaceHidden = true;
   chunk1.knownToBeOpaque = true;
   chunk1.bounds = FloatRect(0, 0, 30, 40);
 
   PaintArtifactCompositor::PendingLayer pendingLayer(chunk1, false);
 
   EXPECT_TRUE(pendingLayer.backfaceHidden);
   EXPECT_TRUE(pendingLayer.knownToBeOpaque);
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 40), pendingLayer.bounds);
 
   PaintChunk chunk2;
   chunk2.properties.propertyTreeState = chunk1.properties.propertyTreeState;
   chunk2.properties.backfaceHidden = true;
   chunk2.knownToBeOpaque = true;
   chunk2.bounds = FloatRect(10, 20, 30, 40);
-  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk2, false));
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk2, false),
+                     *geometryMapper);
 
   EXPECT_TRUE(pendingLayer.backfaceHidden);
   // Bounds not equal to one PaintChunk.
   EXPECT_FALSE(pendingLayer.knownToBeOpaque);
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 40, 60), pendingLayer.bounds);
 
   PaintChunk chunk3;
   chunk3.properties.propertyTreeState = chunk1.properties.propertyTreeState;
   chunk3.properties.backfaceHidden = true;
   chunk3.knownToBeOpaque = true;
   chunk3.bounds = FloatRect(-5, -25, 20, 20);
-  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk3, false));
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk3, false),
+                     *geometryMapper);
 
   EXPECT_TRUE(pendingLayer.backfaceHidden);
   EXPECT_FALSE(pendingLayer.knownToBeOpaque);
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(-5, -25, 45, 85), pendingLayer.bounds);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, PendingLayerWithGeometry) {
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(),
           TransformationMatrix().translate(20, 25), FloatPoint3D(100, 100, 0),
           false, 0);
 
   PaintChunk chunk1;
   chunk1.properties.propertyTreeState = PropertyTreeState(
       TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
       EffectPaintPropertyNode::root());
   chunk1.bounds = FloatRect(0, 0, 30, 40);
 
   PaintArtifactCompositor::PendingLayer pendingLayer(chunk1, false);
 
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 40), pendingLayer.bounds);
 
   PaintChunk chunk2;
   chunk2.properties.propertyTreeState = chunk1.properties.propertyTreeState;
   chunk2.properties.propertyTreeState.setTransform(transform);
   chunk2.bounds = FloatRect(0, 0, 50, 60);
-  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk2, false));
+  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk2, false),
+                     *geometryMapper);
 
   EXPECT_BLINK_FLOAT_RECT_EQ(FloatRect(0, 0, 70, 85), pendingLayer.bounds);
 }
 
 // TODO(crbug.com/701991):
 // The test is disabled because opaque rect mapping is not implemented yet.
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees,
        PendingLayerKnownOpaque_DISABLED) {
+  std::unique_ptr<GeometryMapper> geometryMapper = GeometryMapper::create();
+
   PaintChunk chunk1;
   chunk1.properties.propertyTreeState = PropertyTreeState(
       TransformPaintPropertyNode::root(), ClipPaintPropertyNode::root(),
       EffectPaintPropertyNode::root());
   chunk1.bounds = FloatRect(0, 0, 30, 40);
   chunk1.knownToBeOpaque = false;
   PaintArtifactCompositor::PendingLayer pendingLayer(chunk1, false);
 
   EXPECT_FALSE(pendingLayer.knownToBeOpaque);
 
   PaintChunk chunk2;
   chunk2.properties.propertyTreeState = chunk1.properties.propertyTreeState;
   chunk2.bounds = FloatRect(0, 0, 25, 35);
   chunk2.knownToBeOpaque = true;
-  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk2, false));
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk2, false),
+                     *geometryMapper);
 
   // Chunk 2 doesn't cover the entire layer, so not opaque.
   EXPECT_FALSE(pendingLayer.knownToBeOpaque);
 
   PaintChunk chunk3;
   chunk3.properties.propertyTreeState = chunk1.properties.propertyTreeState;
   chunk3.bounds = FloatRect(0, 0, 50, 60);
   chunk3.knownToBeOpaque = true;
-  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk3, false));
+  pendingLayer.merge(PaintArtifactCompositor::PendingLayer(chunk3, false),
+                     *geometryMapper);
 
   // Chunk 3 covers the entire layer, so now it's opaque.
   EXPECT_TRUE(pendingLayer.knownToBeOpaque);
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, TransformWithElementId) {
   CompositorElementId expectedCompositorElementId(2, 0);
   RefPtr<TransformPaintPropertyNode> transform =
       TransformPaintPropertyNode::create(
           TransformPaintPropertyNode::root(), TransformationMatrix().rotate(90),
@@ skipping 378 matching lines @@
   EXPECT_EQ(gfx::Size(50, 50), layer3->bounds());
   EXPECT_EQ(effectNode->id, layer3->effect_tree_index());
 
   const cc::Layer* layer4 = contentLayerAt(3);
   EXPECT_EQ(gfx::Vector2dF(100.f, 0.f), layer4->offset_to_transform_parent());
   EXPECT_EQ(gfx::Size(150, 150), layer4->bounds());
   EXPECT_EQ(1, layer4->effect_tree_index());
 }
 
 }  // namespace blink