CC Animation: Erase cc::LayerSettings everywhere.

cc/layers/texture_layer_unittest.cc

 // Copyright 2012 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/texture_layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 217 matching lines @@
   }
 
   scoped_ptr<MockLayerTreeHost> layer_tree_host_;
   FakeImplTaskRunnerProvider task_runner_provider_;
   FakeLayerTreeHostClient fake_client_;
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   scoped_ptr<OutputSurface> output_surface_;
   FakeLayerTreeHostImpl host_impl_;
   CommonMailboxObjects test_data_;
-  LayerSettings layer_settings_;
 };
 
 TEST_F(TextureLayerTest, CheckPropertyChangeCausesCorrectBehavior) {
   scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(layer_settings_, nullptr);
+      TextureLayer::CreateForMailbox(nullptr);
   EXPECT_SET_NEEDS_COMMIT(1, layer_tree_host_->SetRootLayer(test_layer));
 
   // Test properties that should call SetNeedsCommit.  All properties need to
   // be set to new values in order for SetNeedsCommit to be called.
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetFlipped(false));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetNearestNeighbor(true));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetUV(
       gfx::PointF(0.25f, 0.25f), gfx::PointF(0.75f, 0.75f)));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetVertexOpacity(
       0.5f, 0.5f, 0.5f, 0.5f));
@@ skipping 16 matching lines @@
     EXPECT_CALL(
         test_data_.mock_callback_,
         Release(test_data_.mailbox_name1_, test_data_.sync_token1_, false))
         .Times(1);
     TextureLayerTest::TearDown();
   }
 };
 
 TEST_F(TextureLayerWithMailboxTest, ReplaceMailboxOnMainThreadBeforeCommit) {
   scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(layer_settings_, nullptr);
+      TextureLayer::CreateForMailbox(nullptr);
   ASSERT_TRUE(test_layer.get());
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   test_layer->SetTextureMailbox(
       test_data_.mailbox1_,
       SingleReleaseCallback::Create(test_data_.release_mailbox1_));
@@ skipping 36 matching lines @@
 
   // Test destructor.
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
   test_layer->SetTextureMailbox(
       test_data_.mailbox1_,
       SingleReleaseCallback::Create(test_data_.release_mailbox1_));
 }
 
 TEST_F(TextureLayerTest, SetTextureMailboxWithoutReleaseCallback) {
   scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(layer_settings_, nullptr);
+      TextureLayer::CreateForMailbox(nullptr);
   ASSERT_TRUE(test_layer.get());
 
   // These use the same gpu::Mailbox, but different sync points.
   TextureMailbox mailbox1(MailboxFromChar('a'), SyncTokenFromUInt(1),
                           GL_TEXTURE_2D);
   TextureMailbox mailbox2(MailboxFromChar('a'), SyncTokenFromUInt(2),
                           GL_TEXTURE_2D);
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
@@ skipping 61 matching lines @@
   }
 
   scoped_ptr<TestMailboxHolder::MainThreadReference>
       main_ref_;
   base::Thread main_thread_;
   scoped_ptr<BlockingTaskRunner> main_thread_task_runner_;
 };
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_BothReleaseThenMain) {
   scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(layer_settings_, nullptr);
+      TextureLayer::CreateForMailbox(nullptr);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::CreateMainRef,
                             base::Unretained(this)));
 
   Wait(main_thread_);
 
   // The texture layer is attached to compositor1, and passes a reference to its
   // impl tree.
@@ skipping 32 matching lines @@
 
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::ReleaseMainRef,
                             base::Unretained(this)));
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleaseBetween) {
   scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(layer_settings_, nullptr);
+      TextureLayer::CreateForMailbox(nullptr);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::CreateMainRef,
                             base::Unretained(this)));
 
   Wait(main_thread_);
 
   // The texture layer is attached to compositor1, and passes a reference to its
   // impl tree.
@@ skipping 33 matching lines @@
       .Times(1);
 
   compositor2->Run(SyncTokenFromUInt(200), true,
                    main_thread_task_runner_.get());
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_MainReleasedFirst) {
   scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(layer_settings_, nullptr);
+      TextureLayer::CreateForMailbox(nullptr);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::CreateMainRef,
                             base::Unretained(this)));
 
   Wait(main_thread_);
 
   // The texture layer is attached to compositor1, and passes a reference to its
   // impl tree.
@@ skipping 33 matching lines @@
       .Times(1);
 
   compositor1->Run(SyncTokenFromUInt(100), true,
                    main_thread_task_runner_.get());
   Wait(main_thread_);
   Mock::VerifyAndClearExpectations(&test_data_.mock_callback_);
 }
 
 TEST_F(TextureLayerMailboxHolderTest, TwoCompositors_SecondImplRefShortcut) {
   scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(layer_settings_, nullptr);
+      TextureLayer::CreateForMailbox(nullptr);
   ASSERT_TRUE(test_layer.get());
 
   main_thread_.message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&TextureLayerMailboxHolderTest::CreateMainRef,
                             base::Unretained(this)));
 
   Wait(main_thread_);
 
   // The texture layer is attached to compositor1, and passes a reference to its
   // impl tree.
@@ skipping 82 matching lines @@
         TextureMailbox(MailboxFromChar(mailbox_char),
                        SyncTokenFromUInt(static_cast<uint32_t>(mailbox_char)),
                        GL_TEXTURE_2D),
         std::move(callback));
   }
 
   void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     gfx::Size bounds(100, 100);
-    root_ = Layer::Create(layer_settings());
+    root_ = Layer::Create();
     root_->SetBounds(bounds);
 
-    layer_ = TextureLayer::CreateForMailbox(layer_settings(), nullptr);
+    layer_ = TextureLayer::CreateForMailbox(nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
     SetMailbox('1');
     EXPECT_EQ(0, callback_count_);
 
     // Case #1: change mailbox before the commit. The old mailbox should be
@@ skipping 93 matching lines @@
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(&TextureLayerMailboxIsActivatedDuringCommit::ReleaseCallback,
                    sync_token));
     layer_->SetTextureMailbox(TextureMailbox(MailboxFromChar(mailbox_char),
                                              sync_token, GL_TEXTURE_2D),
                               std::move(callback));
   }
 
   void BeginTest() override {
     gfx::Size bounds(100, 100);
-    root_ = Layer::Create(layer_settings());
+    root_ = Layer::Create();
     root_->SetBounds(bounds);
 
-    layer_ = TextureLayer::CreateForMailbox(layer_settings(), nullptr);
+    layer_ = TextureLayer::CreateForMailbox(nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
     SetMailbox('1');
 
     PostSetNeedsCommitToMainThread();
   }
@@ skipping 274 matching lines @@
 
   void MailboxReleased(const gpu::SyncToken& sync_token, bool lost_resource) {
     // Source frame number during callback is the same as the source frame
     // on which it was released.
     EXPECT_EQ(1, layer_tree_host()->source_frame_number());
     EXPECT_TRUE(sync_token.HasData());
     EndTest();
   }
 
   void SetupTree() override {
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
 
-    texture_layer_ = TextureLayer::CreateForMailbox(layer_settings(), this);
+    texture_layer_ = TextureLayer::CreateForMailbox(this);
     texture_layer_->SetBounds(gfx::Size(10, 10));
     texture_layer_->SetIsDrawable(true);
     root->AddChild(texture_layer_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 73 matching lines @@
                           SyncTokenFromUInt(static_cast<uint32_t>(name)),
                           GL_TEXTURE_2D);
   }
 
   void MailboxReleased(const gpu::SyncToken& sync_token, bool lost_resource) {
     EXPECT_TRUE(sync_token.HasData());
     ++mailbox_returned_;
   }
 
   void SetupTree() override {
-    scoped_refptr<Layer> root = Layer::Create(layer_settings());
+    scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
 
-    solid_layer_ = SolidColorLayer::Create(layer_settings());
+    solid_layer_ = SolidColorLayer::Create();
     solid_layer_->SetBounds(gfx::Size(10, 10));
     solid_layer_->SetIsDrawable(true);
     solid_layer_->SetBackgroundColor(SK_ColorWHITE);
     root->AddChild(solid_layer_);
 
-    parent_layer_ = Layer::Create(layer_settings());
+    parent_layer_ = Layer::Create();
     parent_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->SetIsDrawable(true);
     root->AddChild(parent_layer_);
 
-    texture_layer_ = TextureLayer::CreateForMailbox(layer_settings(), this);
+    texture_layer_ = TextureLayer::CreateForMailbox(this);
     texture_layer_->SetBounds(gfx::Size(10, 10));
     texture_layer_->SetIsDrawable(true);
     parent_layer_->AddChild(texture_layer_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 95 matching lines @@
   }
 
   void MailboxReleased(const gpu::SyncToken& sync_token, bool lost_resource) {
     mailbox_released_ = true;
   }
 
   void SetupTree() override {
     LayerTreeTest::SetupTree();
 
     scoped_refptr<TextureLayer> texture_layer =
-        TextureLayer::CreateForMailbox(layer_settings(), this);
+        TextureLayer::CreateForMailbox(this);
     texture_layer->SetBounds(gfx::Size(10, 10));
     texture_layer->SetIsDrawable(true);
 
     layer_tree_host()->root_layer()->AddChild(texture_layer);
   }
 
   void BeginTest() override {
     mailbox_released_ = false;
     PostSetNeedsCommitToMainThread();
   }
@@ skipping 45 matching lines @@
             base::Unretained(this)));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char),
                        SyncTokenFromUInt(static_cast<uint32_t>(mailbox_char)),
                        GL_TEXTURE_2D),
         std::move(callback));
   }
 
   void SetupTree() override {
     gfx::Size bounds(100, 100);
-    root_ = Layer::Create(layer_settings());
+    root_ = Layer::Create();
     root_->SetBounds(bounds);
 
-    layer_ = TextureLayer::CreateForMailbox(layer_settings(), nullptr);
+    layer_ = TextureLayer::CreateForMailbox(nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
   }
 
   void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
@@ skipping 47 matching lines @@
             base::Unretained(this)));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char),
                        SyncTokenFromUInt(static_cast<uint32_t>(mailbox_char)),
                        GL_TEXTURE_2D),
         std::move(callback));
   }
 
   void SetupTree() override {
     gfx::Size bounds(100, 100);
-    root_ = Layer::Create(layer_settings());
+    root_ = Layer::Create();
     root_->SetBounds(bounds);
 
-    layer_ = TextureLayer::CreateForMailbox(layer_settings(), nullptr);
+    layer_ = TextureLayer::CreateForMailbox(nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
   }
 
   void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
@@ skipping 28 matching lines @@
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc