Switch to use SharedBitmapManager all the time in cc_unittests

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/base/math_util.h"
@@ skipping 370 matching lines @@
 TEST_F(LayerTreeHostCommonTest, TransformsAboutScrollOffset) {
   const gfx::Vector2d kScrollOffset(50, 100);
   const gfx::Vector2dF kScrollDelta(2.34f, 5.67f);
   const gfx::Vector2d kMaxScrollOffset(200, 200);
   const gfx::PointF kScrollLayerPosition(-kScrollOffset.x(),
                                          -kScrollOffset.y());
   const float kPageScale = 0.888f;
   const float kDeviceScale = 1.666f;
 
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
 
   gfx::Transform identity_matrix;
   scoped_ptr<LayerImpl> sublayer_scoped_ptr(
       LayerImpl::Create(host_impl.active_tree(), 1));
   LayerImpl* sublayer = sublayer_scoped_ptr.get();
   sublayer->SetContentsScale(kPageScale * kDeviceScale,
                              kPageScale * kDeviceScale);
   SetLayerPropertiesForTesting(sublayer,
                                identity_matrix,
                                gfx::Point(),
@@ skipping 3632 matching lines @@
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(10, 20);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayer) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
@@ skipping 33 matching lines @@
 
   test_point = gfx::Point(99, 99);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerAndHud) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
   scoped_ptr<HeadsUpDisplayLayerImpl> hud =
       HeadsUpDisplayLayerImpl::Create(host_impl.active_tree(), 11111);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 50 matching lines @@
 
   test_point = gfx::Point(99, 99);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform uninvertible_transform;
   uninvertible_transform.matrix().set(0, 0, 0.0);
   uninvertible_transform.matrix().set(1, 1, 0.0);
   uninvertible_transform.matrix().set(2, 2, 0.0);
   uninvertible_transform.matrix().set(3, 3, 0.0);
   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 
@@ skipping 55 matching lines @@
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(-1, -1);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePositionedLayer) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   // this layer is positioned, and hit testing should correctly know where the
   // layer is located.
   gfx::PointF position(50.f, 50.f);
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
@@ skipping 37 matching lines @@
 
   test_point = gfx::Point(99, 99);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSingleRotatedLayer) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   gfx::Transform rotation45_degrees_about_center;
   rotation45_degrees_about_center.Translate(50.0, 50.0);
   rotation45_degrees_about_center.RotateAboutZAxis(45.0);
   rotation45_degrees_about_center.Translate(-50.0, -50.0);
   gfx::PointF anchor;
   gfx::PointF position;
@@ skipping 45 matching lines @@
   ASSERT_FALSE(result_layer);
 
   test_point = gfx::Point(-1, 50);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   ASSERT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePerspectiveLayer) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform identity_matrix;
 
   // perspective_projection_about_center * translation_by_z is designed so that
   // the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
   gfx::Transform perspective_projection_about_center;
   perspective_projection_about_center.Translate(50.0, 50.0);
   perspective_projection_about_center.ApplyPerspectiveDepth(1.0);
@@ skipping 57 matching lines @@
   // space. This test makes sure that hit testing works correctly accounts for
   // the contents scale.  A contents scale that is not 1 effectively forces a
   // non-identity transform between layer's content space and layer's origin
   // space. The hit testing code must take this into account.
   //
   // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
   // contents scale is ignored, then hit testing will mis-interpret the visible
   // content rect as being larger than the actual bounds of the layer.
   //
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                gfx::PointF(),
                                gfx::Size(100, 100),
@@ skipping 67 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
   // Test that hit-testing will only work for the visible portion of a layer,
   // and not the entire layer bounds. Here we just test the simple axis-aligned
   // case.
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
 
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     scoped_ptr<LayerImpl> clipping_layer =
@@ skipping 72 matching lines @@
   // multiple ancestors that clip in non axis-aligned ways. To pass this test,
   // the hit testing algorithm needs to recognize that multiple parent layers
   // may clip the layer, and should not actually hit those clipped areas.
   //
   // The child and grand_child layers are both initialized to clip the
   // rotated_leaf. The child layer is rotated about the top-left corner, so that
   // the root + child clips combined create a triangle. The rotated_leaf will
   // only be visible where it overlaps this triangle.
   //
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 123);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                position,
@@ skipping 132 matching lines @@
   EXPECT_EQ(2468, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
   // This test checks that hit testing code does not accidentally clip to layer
   // bounds for a layer that actually does not clip.
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
 
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     scoped_ptr<LayerImpl> intermediate_layer =
@@ skipping 63 matching lines @@
 
   test_point = gfx::Point(89, 89);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                position,
@@ skipping 126 matching lines @@
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
   //
   // The geometry is set up similarly to the previous case, but
   // all layers are forced to be render surfaces now.
   //
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                position,
@@ skipping 132 matching lines @@
   // be on top.
   test_point = gfx::Point(20, 51);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForEmptyLayers) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
 
   // Layer 1 - root
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 1);
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
@@ skipping 113 matching lines @@
 
   test_point = gfx::Point(10, 20);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
   gfx::PointF anchor;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
@@ skipping 63 matching lines @@
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForUninvertibleTransform) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform uninvertible_transform;
   uninvertible_transform.matrix().set(0, 0, 0.0);
   uninvertible_transform.matrix().set(1, 1, 0.0);
   uninvertible_transform.matrix().set(2, 2, 0.0);
   uninvertible_transform.matrix().set(3, 3, 0.0);
   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 
@@ skipping 66 matching lines @@
   test_point = gfx::Point(-1, -1);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForSinglePositionedLayer) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
   gfx::PointF anchor;
   // this layer is positioned, and hit testing should correctly know where the
   // layer is located.
   gfx::PointF position(50.f, 50.f);
   gfx::Size bounds(100, 100);
@@ skipping 64 matching lines @@
   // space. This test makes sure that hit testing works correctly accounts for
   // the contents scale.  A contents scale that is not 1 effectively forces a
   // non-identity transform between layer's content space and layer's origin
   // space. The hit testing code must take this into account.
   //
   // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
   // contents scale is ignored, then hit checking will mis-interpret the visible
   // content rect as being larger than the actual bounds of the layer.
   //
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
 
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                gfx::PointF(),
                                gfx::Size(100, 100),
@@ skipping 86 matching lines @@
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale) {
   // The layer's device_scale_factor and page_scale_factor should scale the
   // content rect and we should be able to hit the touch handler region by
   // scaling the points accordingly.
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   // Set the bounds of the root layer big enough to fit the child when scaled.
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                gfx::PointF(),
                                gfx::Size(100, 100),
@@ skipping 110 matching lines @@
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForSimpleClippedLayer) {
   // Test that hit-checking will only work for the visible portion of a layer,
   // and not the entire layer bounds. Here we just test the simple axis-aligned
   // case.
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
 
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     scoped_ptr<LayerImpl> clipping_layer =
@@ skipping 79 matching lines @@
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        HitCheckingTouchHandlerOverlappingRegions) {
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
 
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                anchor,
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
                                false);
   {
     scoped_ptr<LayerImpl> touch_layer =
@@ skipping 1677 matching lines @@
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_FALSE(child->render_surface());
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(100, 100),
                                true,
@@ skipping 178 matching lines @@
   EXPECT_EQ(can_use_lcd_text_, child_->can_use_lcd_text());
   EXPECT_EQ(can_use_lcd_text_, grand_child_->can_use_lcd_text());
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
                         LCDTextTest,
                         testing::Combine(testing::Bool(), testing::Bool()));
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
   scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
@@ skipping 36 matching lines @@
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(child->id(), root->render_surface()->layer_list().at(1)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
@@ skipping 34 matching lines @@
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
   EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(2, root->render_surface()->layer_list().at(1)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
   scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
@@ skipping 35 matching lines @@
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
@@ skipping 35 matching lines @@
   // hidden itself and the grand child.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
 }
 
 void EmptyCopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
   scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
@@ skipping 125 matching lines @@
   // The copy_layer's render surface should have two contributing layers.
   ASSERT_EQ(2u, copy_layer->render_surface()->layer_list().size());
   EXPECT_EQ(copy_layer->id(),
             copy_layer->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(copy_child->id(),
             copy_layer->render_surface()->layer_list().at(1)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
   scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
@@ skipping 53 matching lines @@
   EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
 
   // The root render surface should only have 1 contributing layer, since the
   // other layers are empty/clipped away.
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
   scoped_refptr<Layer> root = Layer::Create();
   SetLayerPropertiesForTesting(root.get(),
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(),
                                gfx::Size(50, 50),
                                true,
@@ skipping 589 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 5, 5).ToString(),
             render_surface2->render_surface()->content_rect().ToString());
 
   // Sanity check our num_unclipped_descendants values.
   EXPECT_EQ(1, render_surface1->num_unclipped_descendants());
   EXPECT_EQ(0, render_surface2->num_unclipped_descendants());
 }
 
 TEST_F(LayerTreeHostCommonTest, CanRenderToSeparateSurface) {
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
   scoped_ptr<LayerImpl> child1 =
       LayerImpl::Create(host_impl.active_tree(), 123456);
   scoped_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 1234567);
   scoped_ptr<LayerImpl> child3 =
       LayerImpl::Create(host_impl.active_tree(), 12345678);
 
   gfx::Transform identity_matrix;
@@ skipping 568 matching lines @@
   //
   // + root
   //   + scroll_child
   //     + top_content
   //     + bottom_content
   //   + scroll_parent_border
   //     + scroll_parent_clip
   //       + scroll_parent
   //
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   scoped_ptr<LayerImpl> scroll_parent_border =
       LayerImpl::Create(host_impl.active_tree(), 2);
   scoped_ptr<LayerImpl> scroll_parent_clip =
       LayerImpl::Create(host_impl.active_tree(), 3);
   scoped_ptr<LayerImpl> scroll_parent =
       LayerImpl::Create(host_impl.active_tree(), 4);
   scoped_ptr<LayerImpl> scroll_child =
       LayerImpl::Create(host_impl.active_tree(), 5);
@@ skipping 105 matching lines @@
 TEST_F(LayerTreeHostCommonTest, ScrollCompensationWithRounding) {
   // This test verifies that a scrolling layer that gets snapped to
   // integer coordinates doesn't move a fixed position child.
   //
   // + root
   //   + container
   //     + scroller
   //       + fixed
   //
   FakeImplProxy proxy;
-  FakeLayerTreeHostImpl host_impl(&proxy);
+  TestSharedBitmapManager shared_bitmap_manager;
+  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   scoped_ptr<LayerImpl> container =
       LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* container_layer = container.get();
   scoped_ptr<LayerImpl> scroller =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* scroll_layer = scroller.get();
   scoped_ptr<LayerImpl> fixed = LayerImpl::Create(host_impl.active_tree(), 4);
   LayerImpl* fixed_layer = fixed.get();
@@ skipping 84 matching lines @@
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
                          .screen_space_transform.To2dTranslation(),
                      container_offset - rounded_scroll_delta);
   }
 }
 
 }  // namespace
 }  // namespace cc