Make cc output surface creation async

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_common.h"
 
 #include <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 67 matching lines @@
   // and with identity transforms, then the draw transform,
   // screen space transform, and the hierarchy passed on to children
   // layers should also be identity transforms.
 
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   parent->AddChild(child);
   child->AddChild(grand_child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
@@ skipping 23 matching lines @@
                                   grand_child->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotSkipLayersWithHandlers) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   parent->AddChild(child);
   child->AddChild(grand_child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
@@ skipping 32 matching lines @@
   scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
                                false);
   root->AddChild(layer);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // Case 2: Setting the bounds of the layer should not affect either the draw
   // transform or the screenspace transform.
   gfx::Transform translation_to_center;
   translation_to_center.Translate(5.0, 6.0);
   SetLayerPropertiesForTesting(layer.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
@@ skipping 188 matching lines @@
 TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
   gfx::Transform identity_matrix;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   root->AddChild(parent);
   parent->AddChild(child);
   child->AddChild(grand_child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // One-time setup of root layer
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
                                false);
@@ skipping 106 matching lines @@
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(parent);
   parent->AddChild(child);
   child->AddChild(grand_child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // One-time setup of root layer
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
@@ skipping 76 matching lines @@
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> child_replica = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(parent);
   parent->AddChild(child);
   child->AddChild(grand_child);
   child->SetReplicaLayer(child_replica.get());
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // One-time setup of root layer
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(1, 2),
                                true,
@@ skipping 100 matching lines @@
   parent->AddChild(child_of_root);
   render_surface1->AddChild(child_of_rs1);
   render_surface1->AddChild(render_surface2);
   render_surface2->AddChild(child_of_rs2);
   child_of_root->AddChild(grand_child_of_root);
   child_of_rs1->AddChild(grand_child_of_rs1);
   child_of_rs2->AddChild(grand_child_of_rs2);
   render_surface1->SetReplicaLayer(replica_of_rs1.get());
   render_surface2->SetReplicaLayer(replica_of_rs2.get());
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // In combination with descendant draws content, opacity != 1 forces the layer
   // to have a new render surface.
   render_surface1->SetOpacity(0.5f);
   render_surface2->SetOpacity(0.33f);
 
   // One-time setup of root layer
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 274 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                true,
                                false);
 
   root->AddChild(child);
   child->AddChild(grand_child);
   child->SetForceRenderSurface(true);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // No layers in this test should preserve 3d.
   ASSERT_TRUE(root->should_flatten_transform());
   ASSERT_TRUE(child->should_flatten_transform());
   ASSERT_TRUE(grand_child->should_flatten_transform());
 
   gfx::Transform expected_child_draw_transform = rotation_about_y_axis;
   gfx::Transform expected_child_screen_space_transform = rotation_about_y_axis;
   gfx::Transform expected_grand_child_draw_transform =
@@ skipping 58 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                true,
                                false);
 
   root->AddChild(child);
   child->AddChild(grand_child);
   child->SetForceRenderSurface(true);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   ASSERT_TRUE(child->render_surface());
   // This is the real test, the rest are sanity checks.
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   grand_child->draw_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
   // Transformations applied at the root of the tree should be forwarded
   // to child layers instead of applied to the root RenderSurface.
   const gfx::Transform identity_matrix;
   scoped_refptr<LayerWithForcedDrawsContent> root =
       new LayerWithForcedDrawsContent;
   scoped_refptr<LayerWithForcedDrawsContent> child =
       new LayerWithForcedDrawsContent;
   child->SetScrollClipLayerId(root->id());
   root->AddChild(child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                true,
                                false);
   SetLayerPropertiesForTesting(child.get(),
@@ skipping 126 matching lines @@
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForRenderSurfaceWithClippedLayer) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> render_surface1 = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                true,
                                false);
@@ skipping 33 matching lines @@
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(1U, render_surface_layer_list.size());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> render_surface1 = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(render_surface1.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                true,
                                false);
@@ skipping 26 matching lines @@
   EXPECT_EQ(gfx::Rect(), parent->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> render_surface1 = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   render_surface1->SetForceRenderSurface(true);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                true,
                                false);
@@ skipping 68 matching lines @@
   scoped_refptr<Layer> grand_child = Layer::Create();
   scoped_refptr<Layer> great_grand_child = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node1 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   parent->AddChild(child);
   child->AddChild(grand_child);
   grand_child->AddChild(great_grand_child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   // leaf_node1 ensures that parent and child are kept on the
   // render_surface_layer_list, even though grand_child and great_grand_child
   // should be clipped.
   child->AddChild(leaf_node1);
   great_grand_child->AddChild(leaf_node2);
 
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
@@ skipping 77 matching lines @@
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   parent->AddChild(child);
   child->AddChild(grand_child);
   grand_child->AddChild(leaf_node);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   SetLayerPropertiesForTesting(child.get(),
@@ skipping 81 matching lines @@
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(parent);
   parent->AddChild(child1);
   parent->AddChild(child2);
   child1->AddChild(grand_child);
   child2->AddChild(leaf_node2);
   grand_child->AddChild(leaf_node1);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   child2->SetForceRenderSurface(true);
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
@@ skipping 137 matching lines @@
   scoped_refptr<Layer> grand_child2 = Layer::Create();
   scoped_refptr<Layer> grand_child3 = Layer::Create();
   scoped_refptr<Layer> grand_child4 = Layer::Create();
 
   parent->AddChild(child);
   child->AddChild(grand_child1);
   child->AddChild(grand_child2);
   child->AddChild(grand_child3);
   child->AddChild(grand_child4);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(500, 500),
                                true,
                                false);
   SetLayerPropertiesForTesting(child.get(),
@@ skipping 80 matching lines @@
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> leaf_node4 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   parent->AddChild(child);
   child->AddChild(grand_child1);
   child->AddChild(grand_child2);
   child->AddChild(grand_child3);
   child->AddChild(grand_child4);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   // the leaf nodes ensure that these grand_children become render surfaces for
   // this test.
   grand_child1->AddChild(leaf_node1);
   grand_child2->AddChild(leaf_node2);
   grand_child3->AddChild(leaf_node3);
   grand_child4->AddChild(leaf_node4);
 
   SetLayerPropertiesForTesting(parent.get(),
@@ skipping 116 matching lines @@
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   parent->AddChild(render_surface1);
   parent->AddChild(child_of_root);
   render_surface1->AddChild(child_of_rs1);
   render_surface1->AddChild(render_surface2);
   render_surface2->AddChild(child_of_rs2);
   child_of_root->AddChild(grand_child_of_root);
   child_of_rs1->AddChild(grand_child_of_rs1);
   child_of_rs2->AddChild(grand_child_of_rs2);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   // Make our render surfaces.
   render_surface1->SetForceRenderSurface(true);
   render_surface2->SetForceRenderSurface(true);
 
   gfx::Transform layer_transform;
   layer_transform.Translate(1.0, 1.0);
 
   SetLayerPropertiesForTesting(parent.get(),
@@ skipping 467 matching lines @@
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child3 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child1);
   root->AddChild(child2);
   root->AddChild(child3);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
@@ skipping 47 matching lines @@
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> grand_child3 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child);
   child->AddChild(grand_child1);
   child->AddChild(grand_child2);
   child->AddChild(grand_child3);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
@@ skipping 60 matching lines @@
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child3 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(render_surface1);
   render_surface1->AddChild(child1);
   render_surface1->AddChild(child2);
   render_surface1->AddChild(child3);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
@@ skipping 55 matching lines @@
   EXPECT_RECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsForLayersWithUninvertibleTransform) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // Case 1: a truly degenerate matrix
   gfx::Transform identity_matrix;
   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
@@ skipping 53 matching lines @@
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SingularTransformDoesNotPreventClearingDrawProperties) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
@@ skipping 23 matching lines @@
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_FALSE(child->draw_properties().sorted_for_recursion);
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SingularNonAnimatingTransformDoesNotPreventClearingDrawProperties) {
   scoped_refptr<Layer> root = Layer::Create();
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
@@ skipping 18 matching lines @@
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child3 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(render_surface1);
   render_surface1->AddChild(child1);
   render_surface1->AddChild(child2);
   render_surface1->AddChild(child3);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
@@ skipping 69 matching lines @@
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child3 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(render_surface1);
   render_surface1->AddChild(render_surface2);
   render_surface2->AddChild(child1);
   render_surface2->AddChild(child2);
   render_surface2->AddChild(child3);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
@@ skipping 79 matching lines @@
   // Layers that have non-axis aligned bounds (due to transforms) have an
   // expanded, axis-aligned DrawableContentRect and visible content rect.
 
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> render_surface1 = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(render_surface1);
   render_surface1->AddChild(child1);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
@@ skipping 50 matching lines @@
   // Layers that have non-axis aligned bounds (due to transforms) have an
   // expanded, axis-aligned DrawableContentRect and visible content rect.
 
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> render_surface1 = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   root->AddChild(render_surface1);
   render_surface1->AddChild(child1);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   gfx::Transform child_rotation;
   child_rotation.Rotate(45.0);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
@@ skipping 54 matching lines @@
       CreateDrawableContentLayer(&client);
   scoped_refptr<ContentLayer> child1 = CreateDrawableContentLayer(&client);
   scoped_refptr<ContentLayer> child2 = CreateDrawableContentLayer(&client);
   scoped_refptr<ContentLayer> child3 = CreateDrawableContentLayer(&client);
   root->AddChild(render_surface1);
   render_surface1->AddChild(render_surface2);
   render_surface2->AddChild(child1);
   render_surface2->AddChild(child2);
   render_surface2->AddChild(child3);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
@@ skipping 106 matching lines @@
 
   parent->AddChild(front_facing_child);
   parent->AddChild(back_facing_child);
   parent->AddChild(front_facing_surface);
   parent->AddChild(back_facing_surface);
   front_facing_surface->AddChild(front_facing_child_of_front_facing_surface);
   front_facing_surface->AddChild(back_facing_child_of_front_facing_surface);
   back_facing_surface->AddChild(front_facing_child_of_back_facing_surface);
   back_facing_surface->AddChild(back_facing_child_of_back_facing_surface);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   // Nothing is double-sided
   front_facing_child->SetDoubleSided(false);
   back_facing_child->SetDoubleSided(false);
   front_facing_surface->SetDoubleSided(false);
   back_facing_surface->SetDoubleSided(false);
   front_facing_child_of_front_facing_surface->SetDoubleSided(false);
   back_facing_child_of_front_facing_surface->SetDoubleSided(false);
   front_facing_child_of_back_facing_surface->SetDoubleSided(false);
@@ skipping 185 matching lines @@
 
   parent->AddChild(front_facing_child);
   parent->AddChild(back_facing_child);
   parent->AddChild(front_facing_surface);
   parent->AddChild(back_facing_surface);
   front_facing_surface->AddChild(front_facing_child_of_front_facing_surface);
   front_facing_surface->AddChild(back_facing_child_of_front_facing_surface);
   back_facing_surface->AddChild(front_facing_child_of_back_facing_surface);
   back_facing_surface->AddChild(back_facing_child_of_back_facing_surface);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   // Nothing is double-sided
   front_facing_child->SetDoubleSided(false);
   back_facing_child->SetDoubleSided(false);
   front_facing_surface->SetDoubleSided(false);
   back_facing_surface->SetDoubleSided(false);
   front_facing_child_of_front_facing_surface->SetDoubleSided(false);
   back_facing_child_of_front_facing_surface->SetDoubleSided(false);
   front_facing_child_of_back_facing_surface->SetDoubleSided(false);
@@ skipping 145 matching lines @@
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   parent->AddChild(child);
   parent->AddChild(animating_surface);
   animating_surface->AddChild(child_of_animating_surface);
   parent->AddChild(animating_child);
   parent->AddChild(child2);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   // Nothing is double-sided
   child->SetDoubleSided(false);
   child2->SetDoubleSided(false);
   animating_surface->SetDoubleSided(false);
   child_of_animating_surface->SetDoubleSided(false);
   animating_child->SetDoubleSided(false);
 
   gfx::Transform backface_matrix;
@@ skipping 125 matching lines @@
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
 
   parent->AddChild(front_facing_surface);
   parent->AddChild(back_facing_surface);
   front_facing_surface->AddChild(child1);
   back_facing_surface->AddChild(child2);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   // RenderSurfaces are not double-sided
   front_facing_surface->SetDoubleSided(false);
   back_facing_surface->SetDoubleSided(false);
 
   gfx::Transform backface_matrix;
   backface_matrix.Translate(50.0, 50.0);
   backface_matrix.RotateAboutYAxis(180.0);
   backface_matrix.Translate(-50.0, -50.0);
@@ skipping 147 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   parent->AddChild(child);
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
@@ skipping 117 matching lines @@
                                false,
                                true);
 
   perspective_surface->SetForceRenderSurface(true);
   scale_surface->SetForceRenderSurface(true);
 
   parent->AddChild(perspective_surface);
   parent->AddChild(scale_surface);
   root->AddChild(parent);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 3.f;
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
@@ skipping 78 matching lines @@
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 13),
                                false,
                                true);
 
   parent->AddChild(child);
   parent->AddChild(child_no_scale);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   float device_scale_factor = 1.7f;
   float page_scale_factor = 1.f;
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
@@ skipping 117 matching lines @@
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
   parent->AddChild(child_scale);
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
@@ skipping 163 matching lines @@
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
   parent->AddChild(child_scale);
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
@@ skipping 61 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
   parent->AddChild(child_scale);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 0.01f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
@@ skipping 127 matching lines @@
   parent->AddChild(surface_no_scale);
 
   surface_scale->SetForceRenderSurface(true);
   surface_scale->AddChild(surface_scale_child_scale);
   surface_scale->AddChild(surface_scale_child_no_scale);
 
   surface_no_scale->SetForceRenderSurface(true);
   surface_no_scale->AddChild(surface_no_scale_child_scale);
   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   SkMScalar device_scale_factor = 5;
   SkMScalar page_scale_factor = 7;
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
@@ skipping 180 matching lines @@
   parent->AddChild(surface_no_scale);
 
   surface_scale->SetForceRenderSurface(true);
   surface_scale->AddChild(surface_scale_child_scale);
   surface_scale->AddChild(surface_scale_child_no_scale);
 
   surface_no_scale->SetForceRenderSurface(true);
   surface_no_scale->AddChild(surface_no_scale_child_scale);
   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
 
   SkMScalar device_scale_factor = 5.0;
   SkMScalar page_scale_factor = 7.0;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
@@ skipping 122 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   root->AddChild(parent);
 
   parent->AddChild(child_scale);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // Now put an animating transform on child.
   int animation_id = AddAnimatedTransformToController(
       child_scale->layer_animation_controller(), 10.0, 30, 0);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
@@ skipping 24 matching lines @@
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        ChangeInContentBoundsOrScaleTriggersPushProperties) {
   MockContentLayerClient delegate;
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child = CreateDrawableContentLayer(&delegate);
   root->AddChild(child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
@@ skipping 73 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                false,
                                true);
 
   parent->AddChild(child);
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   RenderSurfaceLayerList render_surface_layer_list;
 
   float device_scale_factor = 1.5f;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
@@ skipping 114 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(13, 11),
                                false,
                                true);
 
   parent->AddChild(child);
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(parent);
 
   float device_scale_factor = 1.7f;
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
@@ skipping 44 matching lines @@
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   scoped_refptr<Layer> mask_layer = Layer::Create();
   scoped_refptr<Layer> replica_layer = Layer::Create();
 
   grand_child->SetReplicaLayer(replica_layer.get());
   child->AddChild(grand_child.get());
   child->SetMaskLayer(mask_layer.get());
   root->AddChild(child.get());
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   int nonexistent_id = -1;
   EXPECT_EQ(root.get(),
             LayerTreeHostCommon::FindLayerInSubtree(root.get(), root->id()));
   EXPECT_EQ(child.get(),
             LayerTreeHostCommon::FindLayerInSubtree(root.get(), child->id()));
   EXPECT_EQ(
       grand_child.get(),
       LayerTreeHostCommon::FindLayerInSubtree(root.get(), grand_child->id()));
@@ skipping 33 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(10, 10),
                                true,
                                false);
 
   root->AddChild(child);
   child->AddChild(grand_child);
   child->SetOpacity(0.5f);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_FALSE(child->render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
@@ skipping 72 matching lines @@
     SetLayerPropertiesForTesting(grand_child_.get(),
                                  identity_matrix,
                                  gfx::Point3F(),
                                  gfx::PointF(),
                                  gfx::Size(1, 1),
                                  true,
                                  false);
 
     child_->SetForceRenderSurface(std::tr1::get<1>(GetParam()));
 
-    host_ = FakeLayerTreeHost::Create();
+    host_ = CreateFakeLayerTreeHost();
     host_->SetRootLayer(root_);
   }
 
   bool can_use_lcd_text_;
   scoped_ptr<FakeLayerTreeHost> host_;
   scoped_refptr<Layer> root_;
   scoped_refptr<Layer> child_;
   scoped_refptr<Layer> grand_child_;
 };
 
@@ skipping 135 matching lines @@
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                true,
                                false);
   grand_child->SetIsDrawable(true);
   grand_child->SetHideLayerAndSubtree(true);
 
   child->AddChild(grand_child);
   root->AddChild(child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
@@ skipping 93 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(30, 30),
                                true,
                                false);
   grand_child->SetIsDrawable(true);
 
   child->AddChild(grand_child);
   root->AddChild(child);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
@@ skipping 137 matching lines @@
                                false);
   copy_grand_parent_sibling_after->SetIsDrawable(true);
 
   copy_layer->AddChild(copy_child);
   copy_parent->AddChild(copy_layer);
   copy_grand_parent->AddChild(copy_parent);
   root->AddChild(copy_grand_parent_sibling_before);
   root->AddChild(copy_grand_parent);
   root->AddChild(copy_grand_parent_sibling_after);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // Hide the copy_grand_parent and its subtree. But make a copy request in that
   // hidden subtree on copy_layer.
   copy_grand_parent->SetHideLayerAndSubtree(true);
   copy_grand_parent_sibling_before->SetHideLayerAndSubtree(true);
   copy_grand_parent_sibling_after->SetHideLayerAndSubtree(true);
   copy_layer->RequestCopyOfOutput(CopyOutputRequest::CreateRequest(
       base::Bind(&EmptyCopyOutputCallback)));
   EXPECT_TRUE(copy_layer->HasCopyRequest());
@@ skipping 93 matching lines @@
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                true,
                                false);
   copy_child->SetIsDrawable(true);
 
   copy_layer->AddChild(copy_child);
   copy_parent->AddChild(copy_layer);
   root->AddChild(copy_parent);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   copy_layer->RequestCopyOfOutput(CopyOutputRequest::CreateRequest(
       base::Bind(&EmptyCopyOutputCallback)));
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
@@ skipping 43 matching lines @@
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
   surface_child->SetIsDrawable(true);
 
   surface->AddChild(surface_child);
   root->AddChild(surface);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // The visible_content_rect for the |surface_child| should not be clipped by
   // the viewport.
@@ skipping 66 matching lines @@
                                true,
                                false);
   SetLayerPropertiesForTesting(clip_child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(1.f, 1.f),
                                gfx::Size(10, 10),
                                true,
                                false);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   ASSERT_TRUE(root->render_surface());
   ASSERT_TRUE(render_surface->render_surface());
 
   // Ensure that we've inherited our clip parent's clip and weren't affected
   // by the intervening clip layer.
   ASSERT_EQ(gfx::Rect(1, 1, 20, 20).ToString(),
@@ skipping 90 matching lines @@
                                true,
                                false);
   SetLayerPropertiesForTesting(clip_child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(-10.f, -10.f),
                                gfx::Size(60, 60),
                                true,
                                false);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
   EXPECT_TRUE(render_surface1->render_surface());
   EXPECT_TRUE(render_surface2->render_surface());
 
   // Since the render surfaces could have expanded, they should not clip (their
   // bounds would no longer be reliable). We should resort to layer clipping
@@ skipping 108 matching lines @@
                                true,
                                false);
   SetLayerPropertiesForTesting(clip_child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(-10.f, -10.f),
                                gfx::Size(60, 60),
                                true,
                                false);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
   EXPECT_TRUE(render_surface1->render_surface());
   EXPECT_TRUE(render_surface2->render_surface());
 
   // Since the render surfaces could have expanded, they should not clip (their
   // bounds would no longer be reliable). We should resort to layer clipping
@@ skipping 88 matching lines @@
                                true,
                                false);
   SetLayerPropertiesForTesting(child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(60, 60),
                                true,
                                false);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
 
   // Neither the clip child nor its descendant should have inherited the clip
   // from |intervening|.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
             clip_child->clip_rect().ToString());
@@ skipping 76 matching lines @@
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(5, 5),
                                true,
                                false);
 
   render_surface1->SetForceRenderSurface(true);
   render_surface2->SetForceRenderSurface(true);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
   EXPECT_TRUE(render_surface1->render_surface());
   EXPECT_TRUE(render_surface2->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 5, 5).ToString(),
             render_surface1->clip_rect().ToString());
@@ skipping 135 matching lines @@
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                true,
                                false);
 
   root->SetShouldFlattenTransform(false);
   root->Set3dSortingContextId(1);
   render_surface->SetDoubleSided(false);
   render_surface->SetForceRenderSurface(true);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_EQ(2u, render_surface_layer_list()->size());
   EXPECT_EQ(1u,
             render_surface_layer_list()->at(0)
                 ->render_surface()->layer_list().size());
   EXPECT_EQ(1u,
             render_surface_layer_list()->at(1)
@@ skipping 70 matching lines @@
                                true,
                                false);
   SetLayerPropertiesForTesting(scroll_child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30).ToString(),
             scroll_child->clip_rect().ToString());
   EXPECT_TRUE(scroll_child->is_clipped());
 }
@@ skipping 28 matching lines @@
   parent->SetForceRenderSurface(true);
   SetLayerPropertiesForTesting(child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                true,
                                true);
   child->SetForceRenderSurface(true);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_EQ(3u, render_surface_layer_list()->size());
 
   gfx::Transform singular_transform;
   singular_transform.Scale3d(
       SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
 
@@ skipping 71 matching lines @@
                                true,
                                false);
   SetLayerPropertiesForTesting(scroll_child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30).ToString(),
             scroll_child->clip_rect().ToString());
   EXPECT_TRUE(scroll_child->is_clipped());
 }
@@ skipping 92 matching lines @@
                                true,
                                false);
   SetLayerPropertiesForTesting(scroll_child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20).ToString(),
             scroll_child->clip_rect().ToString());
   EXPECT_TRUE(scroll_child->is_clipped());
 
@@ skipping 128 matching lines @@
                                true,
                                false);
   SetLayerPropertiesForTesting(scroll_child.get(),
                                identity_transform,
                                gfx::Point3F(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
                                false);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(),
       root->bounds(),
       identity_transform,
       &render_surface_layer_list);
 
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
@@ skipping 1077 matching lines @@
                                gfx::PointF(),
                                gfx::Size(768 / 2, 10000),
                                true,
                                false);
   content->SetIsDrawable(true);
   content->SetForceRenderSurface(true);
 
   root->AddChild(clip);
   clip->AddChild(content);
 
-  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
+  scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
   host->SetRootLayer(root);
 
   gfx::Size device_viewport_size(768, 582);
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       host->root_layer(), device_viewport_size, &render_surface_layer_list);
   inputs.device_scale_factor = 2.f;
   inputs.page_scale_factor = 1.f;
   inputs.page_scale_application_layer = NULL;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Layers in the root render surface have their visible content rect clipped
   // by the viewport.
   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), root->visible_content_rect());
 
   // Layers drawing to a child render surface should still have their visible
   // content rect clipped by the viewport.
   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), content->visible_content_rect());
 }
 
 }  // namespace
 }  // namespace cc