CC Animations: Make LayerAnimationController creation optional

cc/layers/tiled_layer_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/layers/tiled_layer.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/location.h"
@@ skipping 86 matching lines @@
     layer_tree_host_ = LayerTreeHost::CreateThreaded(
         &synchonous_output_surface_client_, shared_bitmap_manager_.get(),
         nullptr, nullptr, settings_, base::ThreadTaskRunnerHandle::Get(),
         impl_thread_.task_runner(), nullptr);
     synchonous_output_surface_client_.SetLayerTreeHost(layer_tree_host_.get());
     proxy_ = layer_tree_host_->proxy();
     resource_manager_ = PrioritizedResourceManager::Create(proxy_);
     layer_tree_host_->SetLayerTreeHostClientReady();
     CHECK(synchonous_output_surface_client_.EnsureOutputSurfaceCreated());
 
-    layer_tree_host_->SetRootLayer(Layer::Create());
+    layer_tree_host_->SetRootLayer(Layer::Create(layer_settings_));
 
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(proxy_);
     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
                                                   shared_bitmap_manager_.get(),
                                                   nullptr,
                                                   nullptr,
                                                   0,
@@ skipping 109 matching lines @@
       LayerPushPropertiesTo(layer1.get(), layer_impl1.get());
     if (layer2.get())
       LayerPushPropertiesTo(layer2.get(), layer_impl2.get());
 
     return needs_update;
   }
 
  public:
   Proxy* proxy_;
   LayerTreeSettings settings_;
+  LayerSettings layer_settings_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<OutputSurface> output_surface_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<ResourceUpdateQueue> queue_;
   PriorityCalculator priority_calculator_;
   base::Thread impl_thread_;
   SynchronousOutputSurfaceClient synchonous_output_surface_client_;
   scoped_ptr<LayerTreeHost> layer_tree_host_;
   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
   scoped_ptr<PrioritizedResourceManager> resource_manager_;
   TestOcclusionTracker* occlusion_;
 };
 
 TEST_F(TiledLayerTest, PushDirtyTiles) {
   layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100, so this invalidates and then paints two tiles.
   layer->SetBounds(gfx::Size(100, 200));
   CalcDrawProps(&render_surface_layer_list);
   UpdateAndPush(layer, layer_impl);
@@ skipping 11 matching lines @@
   // not painted.
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, Scale) {
   layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
   layer_tree_host_->SetDeviceScaleFactor(1.5);
 
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   layer->SetBounds(gfx::Size(100, 200));
   CalcDrawProps(&render_surface_layer_list);
 
   // Change the width so that it doesn't divide cleanly by the scale.
   layer->SetBounds(gfx::Size(101, 200));
   UpdateAndPush(layer, layer_impl);
 
   EXPECT_EQ(1.5, layer->fake_layer_updater()->last_contents_width_scale());
 }
 
 TEST_F(TiledLayerTest, PushOccludedDirtyTiles) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
   layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
@@ skipping 21 matching lines @@
     // We should still have both tiles, as part of the top tile is still
     // unoccluded.
     EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
   }
 }
 
 TEST_F(TiledLayerTest, PushDeletedTiles) {
   layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100, so this invalidates and then paints two tiles.
   layer->SetBounds(gfx::Size(100, 200));
   CalcDrawProps(&render_surface_layer_list);
   UpdateAndPush(layer, layer_impl);
@@ skipping 17 matching lines @@
   // This should recreate and update one of the deleted textures.
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
   UpdateAndPush(layer, layer_impl);
 
   // We should have one tiles on the impl side.
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, PushIdlePaintTiles) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100. Setup 5x5 tiles with one visible tile in the
   // center.  This paints 1 visible of the 25 invalid tiles.
   layer->SetBounds(gfx::Size(500, 500));
   CalcDrawProps(&render_surface_layer_list);
@@ skipping 18 matching lines @@
   // We should have pre-painted all of the surrounding tiles.
   for (int i = 0; i < 5; i++) {
     for (int j = 0; j < 5; j++)
       EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(i, j));
   }
 
   EXPECT_FALSE(needs_update);
 }
 
 TEST_F(TiledLayerTest, PredictivePainting) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // Prepainting should occur in the scroll direction first, and the
   // visible rect should be extruded only along the dominant axis.
   gfx::Vector2d directions[6] = { gfx::Vector2d(-10, 0), gfx::Vector2d(10, 0),
                                   gfx::Vector2d(0, -10), gfx::Vector2d(0, 10),
                                   gfx::Vector2d(10, 20),
@@ skipping 57 matching lines @@
     for (int i = 0; i < 20; i++)
       needs_update = UpdateAndPush(layer, layer_impl);
     EXPECT_FALSE(needs_update);
   }
 }
 
 TEST_F(TiledLayerTest, PushTilesAfterIdlePaintFailed) {
   // Start with 2mb of memory, but the test is going to try to use just more
   // than 1mb, so we reduce to 1mb later.
   resource_manager_->SetMaxMemoryLimitBytes(2 * 1024 * 1024);
-  scoped_refptr<FakeTiledLayer> layer1 =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer1 = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl1 =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
-  scoped_refptr<FakeTiledLayer> layer2 =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer2 = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl2 =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 2));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer1);
   layer_tree_host_->root_layer()->AddChild(layer2);
 
   // For this test we have two layers. layer1 exhausts most texture memory,
   // leaving room for 2 more tiles from layer2, but not all three tiles. First
   // we paint layer1, and one tile from layer2. Then when we idle paint layer2,
@@ skipping 35 matching lines @@
   EXPECT_TRUE(layer_impl2->HasResourceIdForTileAt(0, 0));
   EXPECT_TRUE(layer_impl2->HasResourceIdForTileAt(0, 0));
   EXPECT_TRUE(layer_impl2->HasResourceIdForTileAt(0, 1));
   EXPECT_TRUE(layer_impl2->HasResourceIdForTileAt(0, 1));
 
   EXPECT_FALSE(needs_update);
   EXPECT_FALSE(layer_impl2->HasResourceIdForTileAt(0, 2));
 }
 
 TEST_F(TiledLayerTest, PushIdlePaintedOccludedTiles) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100, so this invalidates one occluded tile, culls it
   // during paint, but prepaints it.
   occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(0, 0, 100, 100)));
 
   layer->SetBounds(gfx::Size(100, 100));
   CalcDrawProps(&render_surface_layer_list);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
   UpdateAndPush(layer, layer_impl);
 
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
 }
 
 TEST_F(TiledLayerTest, PushTilesMarkedDirtyDuringPaint) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100, so this invalidates and then paints two tiles.
   // However, during the paint, we invalidate one of the tiles. This should
   // not prevent the tile from being pushed.
   layer->fake_layer_updater()->SetRectToInvalidate(
       gfx::Rect(0, 50, 100, 50), layer.get());
   layer->SetBounds(gfx::Size(100, 200));
   CalcDrawProps(&render_surface_layer_list);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
   UpdateAndPush(layer, layer_impl);
 
   // We should have both tiles on the impl side.
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, PushTilesLayerMarkedDirtyDuringPaintOnNextLayer) {
-  scoped_refptr<FakeTiledLayer> layer1 =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
-  scoped_refptr<FakeTiledLayer> layer2 =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer1 = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer2 = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer1_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   scoped_ptr<FakeTiledLayerImpl> layer2_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 2));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer1);
   layer_tree_host_->root_layer()->AddChild(layer2);
 
   // Invalidate a tile on layer1, during update of layer 2.
   layer2->fake_layer_updater()->SetRectToInvalidate(
       gfx::Rect(0, 50, 100, 50), layer1.get());
   layer1->SetBounds(gfx::Size(100, 200));
   layer2->SetBounds(gfx::Size(100, 200));
   CalcDrawProps(&render_surface_layer_list);
   layer1->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
   layer2->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
   UpdateAndPush(layer1, layer1_impl, layer2, layer2_impl);
 
   // We should have both tiles on the impl side for all layers.
   EXPECT_TRUE(layer1_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_TRUE(layer1_impl->HasResourceIdForTileAt(0, 1));
   EXPECT_TRUE(layer2_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_TRUE(layer2_impl->HasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, PushTilesLayerMarkedDirtyDuringPaintOnPreviousLayer) {
-  scoped_refptr<FakeTiledLayer> layer1 =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
-  scoped_refptr<FakeTiledLayer> layer2 =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer1 = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer2 = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer1_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   scoped_ptr<FakeTiledLayerImpl> layer2_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 2));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer1);
   layer_tree_host_->root_layer()->AddChild(layer2);
 
   layer1->fake_layer_updater()->SetRectToInvalidate(
@@ skipping 25 matching lines @@
     int memory_for_layer = layer_width * layer_height * 4;
     layer_tree_host_->SetViewportSize(
         gfx::Size(viewport_width, viewport_height));
 
     // Use 10x5 tiles to run out of memory.
     if (run_out_of_memory[i])
       layer_width *= 2;
 
     resource_manager_->SetMaxMemoryLimitBytes(memory_for_layer);
 
-    scoped_refptr<FakeTiledLayer> layer =
-        make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+    scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+        new FakeTiledLayer(layer_settings_, resource_manager_.get()));
     scoped_ptr<FakeTiledLayerImpl> layer_impl =
         make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
     RenderSurfaceLayerList render_surface_layer_list;
 
     layer_tree_host_->root_layer()->AddChild(layer);
 
     // Full size layer with half being visible.
     layer->SetBounds(gfx::Size(layer_width, layer_height));
     gfx::Rect visible_rect(0, 0, layer_width / 2, layer_height);
     CalcDrawProps(&render_surface_layer_list);
@@ skipping 25 matching lines @@
         for (int j = 0; j < 5; ++j)
           EXPECT_EQ(layer_impl->HasResourceIdForTileAt(i, j), i < 5);
       }
     }
 
     layer->RemoveFromParent();
   }
 }
 
 TEST_F(TiledLayerTest, IdlePaintOutOfMemory) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // We have enough memory for only the visible rect, so we will run out of
   // memory in first idle paint.
   int memory_limit = 4 * 100 * 100;  // 1 tiles, 4 bytes per pixel.
   resource_manager_->SetMaxMemoryLimitBytes(memory_limit);
 
   // The tile size is 100x100, so this invalidates and then paints two tiles.
   bool needs_update = false;
   layer->SetBounds(gfx::Size(300, 300));
   CalcDrawProps(&render_surface_layer_list);
   layer->draw_properties().visible_content_rect = gfx::Rect(100, 100, 100, 100);
   for (int i = 0; i < 2; i++)
     needs_update = UpdateAndPush(layer, layer_impl);
 
   // Idle-painting should see no more priority tiles for painting.
   EXPECT_FALSE(needs_update);
 
   // We should have one tile on the impl side.
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(1, 1));
 }
 
 TEST_F(TiledLayerTest, IdlePaintZeroSizedLayer) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   bool animating[2] = { false, true };
   for (int i = 0; i < 2; i++) {
     // Pretend the layer is animating.
     layer->draw_properties().target_space_transform_is_animating = animating[i];
 
@@ skipping 11 matching lines @@
 
     // Empty layers don't need prepaint.
     EXPECT_FALSE(needs_update);
 
     // Empty layers don't have tiles.
     EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 0));
   }
 }
 
 TEST_F(TiledLayerTest, IdlePaintNonVisibleLayers) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
 
   // Alternate between not visible and visible.
   gfx::Rect v(0, 0, 100, 100);
   gfx::Rect nv(0, 0, 0, 0);
   gfx::Rect visible_rect[10] = { nv, nv, v, v, nv, nv, v, v, nv, nv };
   bool invalidate[10] = { true, true, true, true, true, true, true, true, false,
                           false };
 
@@ skipping 16 matching lines @@
     bool needs_update = UpdateAndPush(layer, layer_impl);
 
     // We should never signal idle paint, as we painted the entire layer
     // or the layer was not visible.
     EXPECT_FALSE(needs_update);
     EXPECT_EQ(layer_impl->HasResourceIdForTileAt(0, 0), have_tile[i]);
   }
 }
 
 TEST_F(TiledLayerTest, InvalidateFromPrepare) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100, so this invalidates and then paints two tiles.
   layer->SetBounds(gfx::Size(100, 200));
   CalcDrawProps(&render_surface_layer_list);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
@@ skipping 20 matching lines @@
   layer->fake_layer_updater()->ClearPrepareCount();
 
   // The layer should still be invalid as update invoked invalidate.
   UpdateAndPush(layer, layer_impl);  // visible
   EXPECT_EQ(1, layer->fake_layer_updater()->prepare_count());
 }
 
 TEST_F(TiledLayerTest, VerifyUpdateRectWhenContentBoundsAreScaled) {
   // The update rect (that indicates what was actually painted) should be in
   // layer space, not the content space.
-  scoped_refptr<FakeTiledLayerWithScaledBounds> layer = make_scoped_refptr(
-      new FakeTiledLayerWithScaledBounds(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayerWithScaledBounds> layer =
+      make_scoped_refptr(new FakeTiledLayerWithScaledBounds(
+          layer_settings_, resource_manager_.get()));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   gfx::Rect layer_bounds(0, 0, 300, 200);
   gfx::Rect content_bounds(0, 0, 150, 250);
 
   layer->SetBounds(layer_bounds.size());
   layer->SetContentBounds(content_bounds.size());
   layer->draw_properties().visible_content_rect = content_bounds;
   layer->draw_properties().contents_scale_x = .5f;
@@ skipping 28 matching lines @@
   gfx::Rect partial_damage(30, 100, 10, 10);
   layer->InvalidateContentRect(partial_damage);
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
   layer->Update(queue_.get(), nullptr);
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(60, 80, 20, 8), layer->update_rect());
 }
 
 TEST_F(TiledLayerTest, VerifyInvalidationWhenContentsScaleChanges) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   scoped_ptr<FakeTiledLayerImpl> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // Create a layer with one tile.
   layer->SetBounds(gfx::Size(100, 100));
   CalcDrawProps(&render_surface_layer_list);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
@@ skipping 52 matching lines @@
 }
 
 TEST_F(TiledLayerTest, SkipsDrawGetsReset) {
   // Create two 300 x 300 tiled layers.
   gfx::Size content_bounds(300, 300);
   gfx::Rect content_rect(content_bounds);
 
   // We have enough memory for only one of the two layers.
   int memory_limit = 4 * 300 * 300;  // 4 bytes per pixel.
 
-  scoped_refptr<FakeTiledLayer> root_layer = make_scoped_refptr(
-      new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
-  scoped_refptr<FakeTiledLayer> child_layer = make_scoped_refptr(
-      new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
+  scoped_refptr<FakeTiledLayer> root_layer =
+      make_scoped_refptr(new FakeTiledLayer(
+          layer_settings_, layer_tree_host_->contents_texture_manager()));
+  scoped_refptr<FakeTiledLayer> child_layer =
+      make_scoped_refptr(new FakeTiledLayer(
+          layer_settings_, layer_tree_host_->contents_texture_manager()));
   root_layer->AddChild(child_layer);
 
   root_layer->SetBounds(content_bounds);
   root_layer->draw_properties().visible_content_rect = content_rect;
   root_layer->SetPosition(gfx::PointF(0, 0));
   child_layer->SetBounds(content_bounds);
   child_layer->draw_properties().visible_content_rect = content_rect;
   child_layer->SetPosition(gfx::PointF(0, 0));
   root_layer->InvalidateContentRect(content_rect);
   child_layer->InvalidateContentRect(content_rect);
@@ skipping 16 matching lines @@
 
   layer_tree_host_->UpdateLayers(queue_.get());
   EXPECT_FALSE(root_layer->SkipsDraw());
 
   ResourceManagerClearAllMemory(layer_tree_host_->contents_texture_manager(),
                                 resource_provider_.get());
   layer_tree_host_->SetRootLayer(nullptr);
 }
 
 TEST_F(TiledLayerTest, ResizeToSmaller) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   layer->SetBounds(gfx::Size(700, 700));
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 700, 700);
   layer->InvalidateContentRect(gfx::Rect(0, 0, 700, 700));
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
   layer->Update(queue_.get(), nullptr);
 
   layer->SetBounds(gfx::Size(200, 200));
   layer->InvalidateContentRect(gfx::Rect(0, 0, 200, 200));
 }
 
 TEST_F(TiledLayerTest, HugeLayerUpdateCrash) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   int size = 1 << 30;
   layer->SetBounds(gfx::Size(size, size));
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 700, 700);
   layer->InvalidateContentRect(gfx::Rect(0, 0, size, size));
 
   // Ensure no crash for bounds where size * size would overflow an int.
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
   layer->Update(queue_.get(), nullptr);
 }
 
 class TiledLayerPartialUpdateTest : public TiledLayerTest {
  public:
   TiledLayerPartialUpdateTest() { settings_.max_partial_texture_updates = 4; }
 };
 
 TEST_F(TiledLayerPartialUpdateTest, PartialUpdates) {
   // Create one 300 x 200 tiled layer with 3 x 2 tiles.
   gfx::Size content_bounds(300, 200);
   gfx::Rect content_rect(content_bounds);
 
-  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
-      new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(
+      layer_settings_, layer_tree_host_->contents_texture_manager()));
   layer->SetBounds(content_bounds);
   layer->SetPosition(gfx::PointF(0, 0));
   layer->draw_properties().visible_content_rect = content_rect;
   layer->InvalidateContentRect(content_rect);
 
   layer_tree_host_->SetRootLayer(layer);
   layer_tree_host_->SetViewportSize(gfx::Size(300, 200));
 
   // Full update of all 6 tiles.
   layer_tree_host_->UpdateLayers(queue_.get());
@@ skipping 84 matching lines @@
   layer_tree_host_->CommitComplete();
 
   ResourceManagerClearAllMemory(layer_tree_host_->contents_texture_manager(),
                                 resource_provider_.get());
   layer_tree_host_->SetRootLayer(nullptr);
 }
 
 TEST_F(TiledLayerTest, TilesPaintedWithoutOcclusion) {
   layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100, so this invalidates and then paints two tiles.
   layer->SetBounds(gfx::Size(100, 200));
   CalcDrawProps(&render_surface_layer_list);
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
   layer->Update(queue_.get(), nullptr);
   EXPECT_EQ(2, layer->fake_layer_updater()->update_count());
 }
 
 TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100.
 
   layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
@@ skipping 27 matching lines @@
   resource_manager_->PrioritizeTextures();
 
   occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(250, 250, 300, 100)));
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SavePaintProperties();
   layer->Update(queue_.get(), &occluded);
   EXPECT_EQ(36, layer->fake_layer_updater()->update_count());
 }
 
 TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndVisiblityConstraints) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100.
 
   layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
@@ skipping 35 matching lines @@
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 340);
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
   layer->Update(queue_.get(), &occluded);
   EXPECT_EQ(24 - 6, layer->fake_layer_updater()->update_count());
 }
 
 TEST_F(TiledLayerTest, TilesNotPaintedWithoutInvalidation) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100.
 
   layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
@@ skipping 15 matching lines @@
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
 
   // Repaint without marking it dirty. The 3 culled tiles will be pre-painted
   // now.
   layer->Update(queue_.get(), &occluded);
   EXPECT_EQ(3, layer->fake_layer_updater()->update_count());
 }
 
 TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndTransforms) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+  scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
+      new FakeTiledLayer(layer_settings_, resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100.
 
   // This makes sure the painting works when the occluded region (in screen
   // space) is transformed differently than the layer.
@@ skipping 13 matching lines @@
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
   layer->Update(queue_.get(), &occluded);
   EXPECT_EQ(36 - 3, layer->fake_layer_updater()->update_count());
 }
 
 TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndScaling) {
   scoped_refptr<FakeTiledLayer> layer =
-      new FakeTiledLayer(resource_manager_.get());
+      new FakeTiledLayer(layer_settings_, resource_manager_.get());
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   scoped_refptr<FakeTiledLayer> scale_layer =
-      new FakeTiledLayer(resource_manager_.get());
+      new FakeTiledLayer(layer_settings_, resource_manager_.get());
   gfx::Transform scale_transform;
   scale_transform.Scale(2.0, 2.0);
   scale_layer->SetTransform(scale_transform);
 
   layer_tree_host_->root_layer()->AddChild(scale_layer);
 
   // The tile size is 100x100.
 
   // This makes sure the painting works when the content space is scaled to
   // a different layer space.
@@ skipping 62 matching lines @@
   int visible_tiles3 = 6 * 6 - 6;
   EXPECT_EQ(visible_tiles3, layer->fake_layer_updater()->update_count());
 }
 
 TEST_F(TiledLayerTest, DontAllocateContentsWhenTargetSurfaceCantBeAllocated) {
   // Tile size is 100x100.
   gfx::Rect root_rect(0, 0, 300, 200);
   gfx::Rect child_rect(0, 0, 300, 100);
   gfx::Rect child2_rect(0, 100, 300, 100);
 
-  scoped_refptr<FakeTiledLayer> root = make_scoped_refptr(
-      new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
-  scoped_refptr<Layer> surface = Layer::Create();
-  scoped_refptr<FakeTiledLayer> child = make_scoped_refptr(
-      new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
-  scoped_refptr<FakeTiledLayer> child2 = make_scoped_refptr(
-      new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
+  scoped_refptr<FakeTiledLayer> root = make_scoped_refptr(new FakeTiledLayer(
+      layer_settings_, layer_tree_host_->contents_texture_manager()));
+  scoped_refptr<Layer> surface = Layer::Create(layer_settings_);
+  scoped_refptr<FakeTiledLayer> child = make_scoped_refptr(new FakeTiledLayer(
+      layer_settings_, layer_tree_host_->contents_texture_manager()));
+  scoped_refptr<FakeTiledLayer> child2 = make_scoped_refptr(new FakeTiledLayer(
+      layer_settings_, layer_tree_host_->contents_texture_manager()));
 
   root->SetBounds(root_rect.size());
   root->draw_properties().drawable_content_rect = root_rect;
   root->draw_properties().visible_content_rect = root_rect;
   root->AddChild(surface);
 
   surface->SetForceRenderSurface(true);
   surface->SetOpacity(0.5);
   surface->AddChild(child);
   surface->AddChild(child2);
@@ skipping 147 matching lines @@
 
   gfx::Rect PaintedRect() const { return painted_rect_; }
   void ResetPaintedRect() { painted_rect_ = gfx::Rect(); }
 
  private:
   gfx::Rect painted_rect_;
 };
 
 class UpdateTrackingTiledLayer : public FakeTiledLayer {
  public:
-  explicit UpdateTrackingTiledLayer(PrioritizedResourceManager* manager)
-      : FakeTiledLayer(manager) {
+  explicit UpdateTrackingTiledLayer(const LayerSettings& settings,
+                                    PrioritizedResourceManager* manager)
+      : FakeTiledLayer(settings, manager) {
     scoped_ptr<TrackingLayerPainter> painter(TrackingLayerPainter::Create());
     tracking_layer_painter_ = painter.get();
     layer_updater_ = BitmapContentLayerUpdater::Create(painter.Pass(), 0);
   }
 
   TrackingLayerPainter* tracking_layer_painter() const {
     return tracking_layer_painter_;
   }
 
  private:
   LayerUpdater* Updater() const override { return layer_updater_.get(); }
   ~UpdateTrackingTiledLayer() override {}
 
   TrackingLayerPainter* tracking_layer_painter_;
   scoped_refptr<BitmapContentLayerUpdater> layer_updater_;
 };
 
 TEST_F(TiledLayerTest, NonIntegerContentsScaleIsNotDistortedDuringPaint) {
-  scoped_refptr<UpdateTrackingTiledLayer> layer =
-      make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get()));
+  scoped_refptr<UpdateTrackingTiledLayer> layer = make_scoped_refptr(
+      new UpdateTrackingTiledLayer(layer_settings_, resource_manager_.get()));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   gfx::Rect layer_rect(0, 0, 30, 31);
   layer->SetPosition(layer_rect.origin());
   layer->SetBounds(layer_rect.size());
   layer->UpdateContentsScale(1.5f);
 
   gfx::Rect content_rect(0, 0, 45, 47);
   EXPECT_EQ(content_rect.size(), layer->content_bounds());
@@ skipping 18 matching lines @@
 
   // Rounding leads to an extra pixel.
   gfx::Rect expanded_layer_rect(layer_rect);
   expanded_layer_rect.set_height(32);
   EXPECT_EQ(expanded_layer_rect,
             layer->tracking_layer_painter()->PaintedRect());
 }
 
 TEST_F(TiledLayerTest,
        NonIntegerContentsScaleIsNotDistortedDuringInvalidation) {
-  scoped_refptr<UpdateTrackingTiledLayer> layer =
-      make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get()));
+  scoped_refptr<UpdateTrackingTiledLayer> layer = make_scoped_refptr(
+      new UpdateTrackingTiledLayer(layer_settings_, resource_manager_.get()));
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   gfx::Rect layer_rect(0, 0, 30, 31);
   layer->SetPosition(layer_rect.origin());
   layer->SetBounds(layer_rect.size());
   layer->UpdateContentsScale(1.3f);
 
   gfx::Rect content_rect(layer->content_bounds());
   layer->draw_properties().visible_content_rect = content_rect;
@@ skipping 17 matching lines @@
 
   // Rounding leads to an extra pixel.
   gfx::Rect expanded_layer_rect(layer_rect);
   expanded_layer_rect.set_height(32);
   EXPECT_EQ(expanded_layer_rect,
             layer->tracking_layer_painter()->PaintedRect());
 }
 
 }  // namespace
 }  // namespace cc