CC Animations: Make LayerAnimationController creation optional

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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 183 matching lines @@
     layer_tree_host_ = nullptr;
   }
 
   scoped_ptr<MockLayerTreeHost> layer_tree_host_;
   FakeImplProxy proxy_;
   FakeLayerTreeHostClient fake_client_;
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   FakeLayerTreeHostImpl host_impl_;
   CommonMailboxObjects test_data_;
+  LayerSettings layer_settings_;
 };
 
 TEST_F(TextureLayerTest, CheckPropertyChangeCausesCorrectBehavior) {
   scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(nullptr);
+      TextureLayer::CreateForMailbox(layer_settings_, 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));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetPremultipliedAlpha(false));
   EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetBlendBackgroundColor(true));
 }
 
 TEST_F(TextureLayerTest, VisibleContentOpaqueRegion) {
   const gfx::Size layer_bounds(100, 100);
   const gfx::Rect layer_rect(layer_bounds);
   const Region layer_region(layer_rect);
 
-  scoped_refptr<TextureLayer> layer = TextureLayer::CreateForMailbox(nullptr);
+  scoped_refptr<TextureLayer> layer =
+      TextureLayer::CreateForMailbox(layer_settings_, nullptr);
   layer->SetBounds(layer_bounds);
   layer->draw_properties().visible_content_rect = layer_rect;
   layer->SetBlendBackgroundColor(true);
 
   // Verify initial conditions.
   EXPECT_FALSE(layer->contents_opaque());
   EXPECT_EQ(0u, layer->background_color());
   EXPECT_EQ(Region().ToString(),
             layer->VisibleContentOpaqueRegion().ToString());
 
   // Opaque background.
   layer->SetBackgroundColor(SK_ColorWHITE);
   EXPECT_EQ(layer_region.ToString(),
             layer->VisibleContentOpaqueRegion().ToString());
 
   // Transparent background.
   layer->SetBackgroundColor(SkColorSetARGB(100, 255, 255, 255));
   EXPECT_EQ(Region().ToString(),
             layer->VisibleContentOpaqueRegion().ToString());
 }
 
 TEST_F(TextureLayerTest, RateLimiter) {
   FakeTextureLayerClient client;
-  scoped_refptr<TextureLayer> test_layer = TextureLayer::CreateForMailbox(
-      &client);
+  scoped_refptr<TextureLayer> test_layer =
+      TextureLayer::CreateForMailbox(layer_settings_, &client);
   test_layer->SetIsDrawable(true);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
 
   // Don't rate limit until we invalidate.
   EXPECT_CALL(*layer_tree_host_, StartRateLimiter()).Times(0);
   test_layer->SetRateLimitContext(true);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Do rate limit after we invalidate.
   EXPECT_CALL(*layer_tree_host_, StartRateLimiter());
   test_layer->SetNeedsDisplay();
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Stop rate limiter when we don't want it any more.
   EXPECT_CALL(*layer_tree_host_, StopRateLimiter());
   test_layer->SetRateLimitContext(false);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Or we clear the client.
   test_layer->SetRateLimitContext(true);
   EXPECT_CALL(*layer_tree_host_, StopRateLimiter());
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   test_layer->ClearClient();
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
   // Reset to a layer with a client, that started the rate limiter.
-  test_layer = TextureLayer::CreateForMailbox(
-      &client);
+  test_layer = TextureLayer::CreateForMailbox(layer_settings_, &client);
   test_layer->SetIsDrawable(true);
   test_layer->SetRateLimitContext(true);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
   EXPECT_CALL(*layer_tree_host_, StartRateLimiter()).Times(0);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
   EXPECT_CALL(*layer_tree_host_, StartRateLimiter());
   test_layer->SetNeedsDisplay();
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
@@ skipping 19 matching lines @@
     EXPECT_CALL(test_data_.mock_callback_,
                 Release(test_data_.mailbox_name1_,
                         test_data_.sync_point1_,
                         false)).Times(1);
     TextureLayerTest::TearDown();
   }
 };
 
 TEST_F(TextureLayerWithMailboxTest, ReplaceMailboxOnMainThreadBeforeCommit) {
   scoped_refptr<TextureLayer> test_layer =
-      TextureLayer::CreateForMailbox(nullptr);
+      TextureLayer::CreateForMailbox(layer_settings_, 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 37 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(nullptr);
+      TextureLayer::CreateForMailbox(layer_settings_, nullptr);
   ASSERT_TRUE(test_layer.get());
 
   // These use the same gpu::Mailbox, but different sync points.
   TextureMailbox mailbox1(MailboxFromChar('a'), GL_TEXTURE_2D, 1);
   TextureMailbox mailbox2(MailboxFromChar('a'), GL_TEXTURE_2D, 2);
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(test_layer);
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 
@@ skipping 59 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(nullptr);
+      TextureLayer::CreateForMailbox(layer_settings_, 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 29 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(nullptr);
+      TextureLayer::CreateForMailbox(layer_settings_, 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 30 matching lines @@
   EXPECT_CALL(test_data_.mock_callback_,
               Release(test_data_.mailbox_name1_, 200, true)).Times(1);
 
   compositor2->Run(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(nullptr);
+      TextureLayer::CreateForMailbox(layer_settings_, 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 30 matching lines @@
   EXPECT_CALL(test_data_.mock_callback_,
               Release(test_data_.mailbox_name1_, 100, true)).Times(1);
 
   compositor1->Run(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(nullptr);
+      TextureLayer::CreateForMailbox(layer_settings_, 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 77 matching lines @@
             base::Unretained(this)));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char), GL_TEXTURE_2D, 0),
         callback.Pass());
   }
 
   void BeginTest() override {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
 
     gfx::Size bounds(100, 100);
-    root_ = Layer::Create();
+    root_ = Layer::Create(layer_settings());
     root_->SetBounds(bounds);
 
-    layer_ = TextureLayer::CreateForMailbox(nullptr);
+    layer_ = TextureLayer::CreateForMailbox(layer_settings(), 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 97 matching lines @@
     scoped_ptr<SingleReleaseCallback> callback = SingleReleaseCallback::Create(
         base::Bind(
             &TextureLayerMailboxIsActivatedDuringCommit::ReleaseCallback));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char), GL_TEXTURE_2D, 0),
         callback.Pass());
   }
 
   void BeginTest() override {
     gfx::Size bounds(100, 100);
-    root_ = Layer::Create();
+    root_ = Layer::Create(layer_settings());
     root_->SetBounds(bounds);
 
-    layer_ = TextureLayer::CreateForMailbox(nullptr);
+    layer_ = TextureLayer::CreateForMailbox(layer_settings(), nullptr);
     layer_->SetIsDrawable(true);
     layer_->SetBounds(bounds);
 
     root_->AddChild(layer_);
     layer_tree_host()->SetRootLayer(root_);
     layer_tree_host()->SetViewportSize(bounds);
     SetMailbox('1');
 
     PostSetNeedsCommitToMainThread();
   }
@@ skipping 277 matching lines @@
   }
 
   void MailboxReleased(uint32 sync_point, 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());
     EndTest();
   }
 
   void SetupTree() override {
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
 
-    texture_layer_ = TextureLayer::CreateForMailbox(this);
+    texture_layer_ = TextureLayer::CreateForMailbox(layer_settings(), 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 70 matching lines @@
 
   TextureMailbox MakeMailbox(char name) {
     return TextureMailbox(MailboxFromChar(name), GL_TEXTURE_2D, 0);
   }
 
   void MailboxReleased(uint32 sync_point, bool lost_resource) {
     ++mailbox_returned_;
   }
 
   void SetupTree() override {
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
 
-    solid_layer_ = SolidColorLayer::Create();
+    solid_layer_ = SolidColorLayer::Create(layer_settings());
     solid_layer_->SetBounds(gfx::Size(10, 10));
     solid_layer_->SetIsDrawable(true);
     solid_layer_->SetBackgroundColor(SK_ColorWHITE);
     root->AddChild(solid_layer_);
 
-    parent_layer_ = Layer::Create();
+    parent_layer_ = Layer::Create(layer_settings());
     parent_layer_->SetBounds(gfx::Size(10, 10));
     parent_layer_->SetIsDrawable(true);
     root->AddChild(parent_layer_);
 
-    texture_layer_ = TextureLayer::CreateForMailbox(this);
+    texture_layer_ = TextureLayer::CreateForMailbox(layer_settings(), 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 94 matching lines @@
   }
 
   void MailboxReleased(unsigned sync_point, bool lost_resource) {
     mailbox_released_ = true;
   }
 
   void SetupTree() override {
     LayerTreeTest::SetupTree();
 
     scoped_refptr<TextureLayer> texture_layer =
-        TextureLayer::CreateForMailbox(this);
+        TextureLayer::CreateForMailbox(layer_settings(), 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 43 matching lines @@
         base::Bind(
             &TextureLayerWithMailboxMainThreadDeleted::ReleaseCallback,
             base::Unretained(this)));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char), GL_TEXTURE_2D, 0),
         callback.Pass());
   }
 
   void SetupTree() override {
     gfx::Size bounds(100, 100);
-    root_ = Layer::Create();
+    root_ = Layer::Create(layer_settings());
     root_->SetBounds(bounds);
 
-    layer_ = TextureLayer::CreateForMailbox(nullptr);
+    layer_ = TextureLayer::CreateForMailbox(layer_settings(), 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 45 matching lines @@
         base::Bind(
             &TextureLayerWithMailboxImplThreadDeleted::ReleaseCallback,
             base::Unretained(this)));
     layer_->SetTextureMailbox(
         TextureMailbox(MailboxFromChar(mailbox_char), GL_TEXTURE_2D, 0),
         callback.Pass());
   }
 
   void SetupTree() override {
     gfx::Size bounds(100, 100);
-    root_ = Layer::Create();
+    root_ = Layer::Create(layer_settings());
     root_->SetBounds(bounds);
 
-    layer_ = TextureLayer::CreateForMailbox(nullptr);
+    layer_ = TextureLayer::CreateForMailbox(layer_settings(), 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