CC Animation: Erase cc::LayerSettings everywhere.

cc/test/layer_tree_test.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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 28 matching lines @@
 #include "cc/trees/threaded_channel.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 
 void CreateVirtualViewportLayers(Layer* root_layer,
                                  scoped_refptr<Layer> outer_scroll_layer,
                                  const gfx::Size& inner_bounds,
                                  const gfx::Size& outer_bounds,
-                                 LayerTreeHost* host,
-                                 const LayerSettings& layer_settings) {
-    scoped_refptr<Layer> inner_viewport_container_layer =
-        Layer::Create(layer_settings);
-    scoped_refptr<Layer> inner_viewport_scroll_layer =
-        Layer::Create(layer_settings);
-    scoped_refptr<Layer> outer_viewport_container_layer =
-        Layer::Create(layer_settings);
-    scoped_refptr<Layer> page_scale_layer = Layer::Create(layer_settings);
+                                 LayerTreeHost* host) {
+  scoped_refptr<Layer> inner_viewport_container_layer = Layer::Create();
+  scoped_refptr<Layer> inner_viewport_scroll_layer = Layer::Create();
+  scoped_refptr<Layer> outer_viewport_container_layer = Layer::Create();
+  scoped_refptr<Layer> page_scale_layer = Layer::Create();
 
-    root_layer->AddChild(inner_viewport_container_layer);
-    inner_viewport_container_layer->AddChild(page_scale_layer);
-    page_scale_layer->AddChild(inner_viewport_scroll_layer);
-    inner_viewport_scroll_layer->AddChild(outer_viewport_container_layer);
-    outer_viewport_container_layer->AddChild(outer_scroll_layer);
+  root_layer->AddChild(inner_viewport_container_layer);
+  inner_viewport_container_layer->AddChild(page_scale_layer);
+  page_scale_layer->AddChild(inner_viewport_scroll_layer);
+  inner_viewport_scroll_layer->AddChild(outer_viewport_container_layer);
+  outer_viewport_container_layer->AddChild(outer_scroll_layer);
 
-    inner_viewport_scroll_layer->SetScrollClipLayerId(
-        inner_viewport_container_layer->id());
-    outer_scroll_layer->SetScrollClipLayerId(
-        outer_viewport_container_layer->id());
+  inner_viewport_scroll_layer->SetScrollClipLayerId(
+      inner_viewport_container_layer->id());
+  outer_scroll_layer->SetScrollClipLayerId(
+      outer_viewport_container_layer->id());
 
-    inner_viewport_container_layer->SetBounds(inner_bounds);
-    inner_viewport_scroll_layer->SetBounds(outer_bounds);
-    outer_viewport_container_layer->SetBounds(outer_bounds);
+  inner_viewport_container_layer->SetBounds(inner_bounds);
+  inner_viewport_scroll_layer->SetBounds(outer_bounds);
+  outer_viewport_container_layer->SetBounds(outer_bounds);
 
-    inner_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
-    outer_scroll_layer->SetIsContainerForFixedPositionLayers(true);
-    host->RegisterViewportLayers(NULL, page_scale_layer,
-                                 inner_viewport_scroll_layer,
-                                 outer_scroll_layer);
+  inner_viewport_scroll_layer->SetIsContainerForFixedPositionLayers(true);
+  outer_scroll_layer->SetIsContainerForFixedPositionLayers(true);
+  host->RegisterViewportLayers(NULL, page_scale_layer,
+                               inner_viewport_scroll_layer, outer_scroll_layer);
 }
 
 void CreateVirtualViewportLayers(Layer* root_layer,
                                  const gfx::Size& inner_bounds,
                                  const gfx::Size& outer_bounds,
                                  const gfx::Size& scroll_bounds,
-                                 LayerTreeHost* host,
-                                 const LayerSettings& layer_settings) {
-    scoped_refptr<Layer> outer_viewport_scroll_layer =
-        Layer::Create(layer_settings);
+                                 LayerTreeHost* host) {
+  scoped_refptr<Layer> outer_viewport_scroll_layer = Layer::Create();
 
-    outer_viewport_scroll_layer->SetBounds(scroll_bounds);
-    outer_viewport_scroll_layer->SetIsDrawable(true);
-    CreateVirtualViewportLayers(root_layer,
-                                outer_viewport_scroll_layer,
-                                inner_bounds,
-                                outer_bounds,
-                                host,
-                                layer_settings);
+  outer_viewport_scroll_layer->SetBounds(scroll_bounds);
+  outer_viewport_scroll_layer->SetIsDrawable(true);
+  CreateVirtualViewportLayers(root_layer, outer_viewport_scroll_layer,
+                              inner_bounds, outer_bounds, host);
 }
 
 // Creates a SingleThreadProxy that notifies the supplied |test_hooks| of
 // various actions.
 class SingleThreadProxyForTest : public SingleThreadProxy {
  public:
   static scoped_ptr<Proxy> Create(TestHooks* test_hooks,
                                   LayerTreeHost* host,
                                   LayerTreeHostSingleThreadClient* client,
                                   TaskRunnerProvider* task_runner_provider) {
@@ skipping 631 matching lines @@
   // Allow commits to happen once BeginTest() has had a chance to post tasks
   // so that those tasks will happen before the first commit.
   if (layer_tree_host_) {
     static_cast<LayerTreeHostForTesting*>(layer_tree_host_.get())
         ->set_test_started(true);
   }
 }
 
 void LayerTreeTest::SetupTree() {
   if (!layer_tree_host_->root_layer()) {
-    scoped_refptr<Layer> root_layer = Layer::Create(layer_settings_);
+    scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(1, 1));
     layer_tree_host_->SetRootLayer(root_layer);
   }
 
   gfx::Size root_bounds = layer_tree_host_->root_layer()->bounds();
   gfx::Size device_root_bounds = gfx::ScaleToCeiledSize(
       root_bounds, layer_tree_host_->device_scale_factor());
   layer_tree_host_->SetViewportSize(device_root_bounds);
   layer_tree_host_->root_layer()->SetIsDrawable(true);
 }
@@ skipping 110 matching lines @@
   gpu_memory_buffer_manager_.reset(new TestGpuMemoryBufferManager);
   task_graph_runner_.reset(new TestTaskGraphRunner);
 
   delegating_renderer_ = delegating_renderer;
 
   // Spend less time waiting for BeginFrame because the output is
   // mocked out.
   settings_.renderer_settings.refresh_rate = 200.0;
   settings_.background_animation_rate = 200.0;
   InitializeSettings(&settings_);
-  InitializeLayerSettings(&layer_settings_);
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LayerTreeTest::DoBeginTest, base::Unretained(this)));
 
   if (timeout_seconds_) {
     timeout_.Reset(base::Bind(&LayerTreeTest::Timeout, base::Unretained(this)));
     main_task_runner_->PostDelayedTask(
         FROM_HERE,
         timeout_.callback(),
@@ skipping 142 matching lines @@
 
 RemoteChannelImplForTest* LayerTreeTest::GetRemoteChannelImplForTest() const {
   DCHECK(IsRemoteTest());
   DCHECK(remote_client_layer_tree_host_);
 
   return static_cast<RemoteChannelImplForTest*>(
       remote_client_layer_tree_host_->proxy());
 }
 
 }  // namespace cc