[SPv2] Build trivial cc property trees in PaintArtifactCompositor.

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 "base/test/test_simple_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "cc/layers/layer.h"
+#include "cc/trees/layer_tree_host.h"
+#include "cc/trees/layer_tree_settings.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/PaintArtifact.h"
 #include "platform/testing/PictureMatchers.h"
 #include "platform/testing/TestPaintArtifact.h"
+#include "platform/testing/WebLayerTreeViewImplForTesting.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 namespace {
 
 using ::testing::Pointee;
 
 gfx::Transform translation(SkMScalar x, SkMScalar y)
 {
@@ skipping 320 matching lines @@
     artifact.chunk(PaintChunkProperties())
         .foreignLayer(FloatPoint(50, 100), IntSize(400, 300), layer);
     update(artifact.build());
 
     ASSERT_EQ(1u, rootLayer()->children().size());
     EXPECT_EQ(layer, rootLayer()->child_at(0));
     EXPECT_EQ(gfx::Size(400, 300), layer->bounds());
     EXPECT_EQ(translation(50, 100), layer->transform());
 }
 
+// Similar to the above, but for the path where we build cc property trees
+// directly. This will eventually supersede the above.
+
+class PaintArtifactCompositorTestWithPropertyTrees : public PaintArtifactCompositorTest {
+protected:
+    PaintArtifactCompositorTestWithPropertyTrees()
+        : m_taskRunner(new base::TestSimpleTaskRunner)
+        , m_taskRunnerHandle(m_taskRunner)
+    {
+    }
+
+    void SetUp() override
+    {
+        PaintArtifactCompositorTest::SetUp();
+
+        cc::LayerTreeSettings settings = WebLayerTreeViewImplForTesting::defaultLayerTreeSettings();
+        settings.use_layer_lists = true;
+        m_webLayerTreeView = adoptPtr(new WebLayerTreeViewImplForTesting(settings));
+        m_webLayerTreeView->setRootLayer(*getPaintArtifactCompositor().getWebLayer());
+    }
+
+    const cc::PropertyTrees& propertyTrees()
+    {
+        return *m_webLayerTreeView->layerTreeHost()->property_trees();
+    }
+
+    void update(const PaintArtifact& artifact)
+    {
+        PaintArtifactCompositorTest::update(artifact);
+        m_webLayerTreeView->layerTreeHost()->UpdateLayers();

[ajuma, 2016/05/06 20:33:35]

Try calling LayoutAndUpdateLayers instead to see if that fixes the test failures
(by causing the output surface to get created).

[jbroman, 2016/05/07 05:37:57]

Done, thanks.

I also have to set up enough extra infrastructure to allow a fake output surface
to be created (the current implementation doesn't make one, even if it's
requested), and I needed to turn off single_thread_proxy_scheduler so that
calling that method is legal.

+    }
+
+private:
+    scoped_refptr<base::TestSimpleTaskRunner> m_taskRunner;
+    base::ThreadTaskRunnerHandle m_taskRunnerHandle;
+    OwnPtr<WebLayerTreeViewImplForTesting> m_webLayerTreeView;
+};
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EmptyPaintArtifact)
+{
+    PaintArtifact emptyArtifact;
+    update(emptyArtifact);
+    EXPECT_TRUE(rootLayer()->children().empty());
+}
+
+TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneChunkWithAnOffset)
+{
+    TestPaintArtifact artifact;
+    artifact.chunk(PaintChunkProperties())
+        .rectDrawing(FloatRect(50, -50, 100, 100), Color::white);
+    update(artifact.build());
+
+    ASSERT_EQ(1u, rootLayer()->children().size());
+    const cc::Layer* child = rootLayer()->child_at(0);
+    EXPECT_THAT(child->GetPicture(),
+        Pointee(drawsRectangle(FloatRect(0, 0, 100, 100), Color::white)));
+    EXPECT_EQ(translation(50, -50), child->screen_space_transform());
+    EXPECT_EQ(gfx::Size(100, 100), child->bounds());
+}
+
 } // namespace
 } // namespace blink