CC Animation: Erase cc::LayerSettings everywhere.

cc/trees/layer_tree_host_unittest_picture.cc

 // Copyright 2013 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.h"
 
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace cc {
 namespace {
 
 // These tests deal with picture layers.
 class LayerTreeHostPictureTest : public LayerTreeTest {
  protected:
   void SetupTreeWithSinglePictureLayer(const gfx::Size& size) {
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(size);
 
-    root_picture_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
+    root_picture_layer_ = FakePictureLayer::Create(&client_);
     root_picture_layer_->SetBounds(size);
     root->AddChild(root_picture_layer_);
 
     layer_tree_host()->SetRootLayer(root);
     client_.set_bounds(size);
   }
 
   scoped_refptr<FakePictureLayer> root_picture_layer_;
   FakeContentLayerClient client_;
 };
@@ skipping 17 matching lines @@
         break;
       case 2:
         // Drop the picture layer from the tree so the activate will have an
         // active layer without a pending twin.
         layer_tree_host()->root_layer()->children()[0]->RemoveFromParent();
         break;
       case 3: {
         // Add a new picture layer so the activate will have a pending layer
         // without an active twin.
         scoped_refptr<FakePictureLayer> picture =
-            FakePictureLayer::Create(layer_settings(), &client_);
+            FakePictureLayer::Create(&client_);
         layer_tree_host()->root_layer()->AddChild(picture);
         break;
       }
       case 4:
         // Active while there are pending and active twins again.
         layer_tree_host()->SetNeedsCommit();
         break;
       case 5:
         EndTest();
         break;
@@ skipping 62 matching lines @@
 // There is no pending layers in single thread mode.
 MULTI_THREAD_TEST_F(LayerTreeHostPictureTestTwinLayer);
 
 class LayerTreeHostPictureTestResizeViewportWithGpuRaster
     : public LayerTreeHostPictureTest {
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->gpu_rasterization_forced = true;
   }
 
   void SetupTree() override {
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(768, 960));
     client_.set_bounds(root->bounds());
     client_.set_fill_with_nonsolid_color(true);
-    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(768, 960));
     root->AddChild(picture_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostPictureTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
@@ skipping 38 matching lines @@
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostPictureTestResizeViewportWithGpuRaster);
 
 class LayerTreeHostPictureTestChangeLiveTilesRectWithRecycleTree
     : public LayerTreeHostPictureTest {
   void SetupTree() override {
     frame_ = 0;
     did_post_commit_ = false;
 
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(100, 100));
     // The layer is big enough that the live tiles rect won't cover the full
     // layer.
     client_.set_fill_with_nonsolid_color(true);
-    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(100, 100000));
     root->AddChild(picture_);
 
     // picture_'s transform is going to be changing on the compositor thread, so
     // force it to have a transform node by making it scrollable.
     picture_->SetScrollClipLayerId(root->id());
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostPictureTest::SetupTree();
     client_.set_bounds(picture_->bounds());
@@ skipping 78 matching lines @@
   bool did_post_commit_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> picture_;
 };
 
 // Multi-thread only since there is no recycle tree in single thread.
 MULTI_THREAD_TEST_F(LayerTreeHostPictureTestChangeLiveTilesRectWithRecycleTree);
 
 class LayerTreeHostPictureTestRSLLMembership : public LayerTreeHostPictureTest {
   void SetupTree() override {
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(100, 100));
     client_.set_bounds(root->bounds());
 
-    child_ = Layer::Create(layer_settings());
+    child_ = Layer::Create();
     root->AddChild(child_);
 
     // Don't be solid color so the layer has tilings/tiles.
     client_.set_fill_with_nonsolid_color(true);
-    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(100, 100));
     child_->AddChild(picture_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostPictureTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
@@ skipping 60 matching lines @@
   FakeContentLayerClient client_;
   scoped_refptr<Layer> child_;
   scoped_refptr<FakePictureLayer> picture_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostPictureTestRSLLMembership);
 
 class LayerTreeHostPictureTestRSLLMembershipWithScale
     : public LayerTreeHostPictureTest {
   void SetupTree() override {
-    scoped_refptr<Layer> root_clip = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root_clip = Layer::Create();
     root_clip->SetBounds(gfx::Size(100, 100));
-    scoped_refptr<Layer> page_scale_layer = Layer::Create(layer_settings());
+    scoped_refptr<Layer> page_scale_layer = Layer::Create();
     page_scale_layer->SetBounds(gfx::Size(100, 100));
 
-    pinch_ = Layer::Create(layer_settings());
+    pinch_ = Layer::Create();
     pinch_->SetBounds(gfx::Size(500, 500));
     pinch_->SetScrollClipLayerId(root_clip->id());
     pinch_->SetIsContainerForFixedPositionLayers(true);
     page_scale_layer->AddChild(pinch_);
     root_clip->AddChild(page_scale_layer);
 
     // Don't be solid color so the layer has tilings/tiles.
     client_.set_fill_with_nonsolid_color(true);
-    picture_ = FakePictureLayer::Create(layer_settings(), &client_);
+    picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(100, 100));
     pinch_->AddChild(picture_);
 
     layer_tree_host()->RegisterViewportLayers(NULL, page_scale_layer, pinch_,
                                               nullptr);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
     layer_tree_host()->SetRootLayer(root_clip);
     LayerTreeHostPictureTest::SetupTree();
     client_.set_bounds(picture_->bounds());
   }
@@ skipping 136 matching lines @@
   int last_frame_drawn_;
   bool ready_to_draw_;
 };
 
 // Multi-thread only because in single thread you can't pinch zoom on the
 // compositor thread.
 MULTI_THREAD_TEST_F(LayerTreeHostPictureTestRSLLMembershipWithScale);
 
 }  // namespace
 }  // namespace cc