CC: Plumb LayerSettings parameter for cc::Layer construction.

cc/trees/layer_tree_host_unittest_context.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/trees/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
@@ skipping 521 matching lines @@
 
   bool in_composite_;
 };
 
 SINGLE_THREAD_NOIMPL_TEST_F(LayerTreeHostContextTestAvoidUnnecessaryComposite);
 
 class LayerTreeHostContextTestLostContextSucceedsWithContent
     : public LayerTreeHostContextTestLostContextSucceeds {
  public:
   void SetupTree() override {
-    root_ = Layer::Create();
+    root_ = Layer::Create(layer_settings());
     root_->SetBounds(gfx::Size(10, 10));
     root_->SetIsDrawable(true);
 
     // Paint non-solid color.
     SkPaint paint;
     paint.setColor(SkColorSetARGB(100, 80, 200, 200));
     client_.add_draw_rect(gfx::Rect(0, 0, 5, 5), paint);
 
     if (layer_tree_host()->settings().impl_side_painting)
-      layer_ = FakePictureLayer::Create(&client_);
+      layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      layer_ = FakeContentLayer::Create(&client_);
+      layer_ = FakeContentLayer::Create(layer_settings(), &client_);
     layer_->SetBounds(gfx::Size(10, 10));
     layer_->SetIsDrawable(true);
 
     root_->AddChild(layer_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostContextTest::SetupTree();
   }
 
   void InvalidateAndSetNeedsCommit() override {
@@ skipping 68 matching lines @@
         num_commits_(0),
         lost_context_(false) {}
 
   void SetupTree() override {
     // Paint non-solid color.
     SkPaint paint;
     paint.setColor(SkColorSetARGB(100, 80, 200, 200));
     client_.add_draw_rect(gfx::Rect(0, 0, 5, 5), paint);
 
     if (layer_tree_host()->settings().impl_side_painting) {
-      picture_layer_ = FakePictureLayer::Create(&client_);
+      picture_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
       picture_layer_->SetBounds(gfx::Size(10, 20));
       layer_tree_host()->SetRootLayer(picture_layer_);
     } else {
-      content_layer_ = FakeContentLayer::Create(&client_);
+      content_layer_ = FakeContentLayer::Create(layer_settings(), &client_);
       content_layer_->SetBounds(gfx::Size(10, 20));
       layer_tree_host()->SetRootLayer(content_layer_);
     }
 
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void PostEvictTextures() {
@@ skipping 149 matching lines @@
         LayerTreeHostContextTest::CreateContext3d();
     if (times_to_lose_on_end_query_) {
       --times_to_lose_on_end_query_;
       context->set_times_end_query_succeeds(5);
     }
     return context.Pass();
   }
 
   void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting)
-      parent_ = FakePictureLayer::Create(&client_);
+      parent_ = FakePictureLayer::Create(layer_settings(), &client_);
     else
-      parent_ = FakeContentLayer::Create(&client_);
+      parent_ = FakeContentLayer::Create(layer_settings(), &client_);
 
     parent_->SetBounds(gfx::Size(num_children_, 1));
 
     for (int i = 0; i < num_children_; i++) {
       scoped_refptr<Layer> child;
       if (layer_tree_host()->settings().impl_side_painting)
-        child = FakePictureLayer::Create(&client_);
+        child = FakePictureLayer::Create(layer_settings(), &client_);
       else
-        child = FakeContentLayer::Create(&client_);
+        child = FakeContentLayer::Create(layer_settings(), &client_);
       child->SetPosition(gfx::PointF(i, 0.f));
       child->SetBounds(gfx::Size(1, 1));
       parent_->AddChild(child);
     }
 
     layer_tree_host()->SetRootLayer(parent_);
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 15 matching lines @@
 SINGLE_AND_MULTI_THREAD_NOIMPL_TEST_F(
     LayerTreeHostContextTestLostContextWhileUpdatingResources);
 
 class LayerTreeHostContextTestLayersNotified : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestLayersNotified()
       : LayerTreeHostContextTest(), num_commits_(0) {}
 
   void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting) {
-      root_ = FakePictureLayer::Create(&client_);
-      child_ = FakePictureLayer::Create(&client_);
-      grandchild_ = FakePictureLayer::Create(&client_);
+      root_ = FakePictureLayer::Create(layer_settings(), &client_);
+      child_ = FakePictureLayer::Create(layer_settings(), &client_);
+      grandchild_ = FakePictureLayer::Create(layer_settings(), &client_);
     } else {
-      root_ = FakeContentLayer::Create(&client_);
-      child_ = FakeContentLayer::Create(&client_);
-      grandchild_ = FakeContentLayer::Create(&client_);
+      root_ = FakeContentLayer::Create(layer_settings(), &client_);
+      child_ = FakeContentLayer::Create(layer_settings(), &client_);
+      grandchild_ = FakeContentLayer::Create(layer_settings(), &client_);
     }
 
     root_->AddChild(child_);
     child_->AddChild(grandchild_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 127 matching lines @@
         child_resource_provider_->CreateResource(
             gfx::Size(4, 4), GL_CLAMP_TO_EDGE,
             ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
     ResourceProvider::ScopedWriteLockGL lock(child_resource_provider_.get(),
                                              resource);
 
     gpu::Mailbox mailbox;
     gl->GenMailboxCHROMIUM(mailbox.name);
     GLuint sync_point = gl->InsertSyncPointCHROMIUM();
 
-    scoped_refptr<Layer> root = Layer::Create();
+    scoped_refptr<Layer> root = Layer::Create(layer_settings());
     root->SetBounds(gfx::Size(10, 10));
     root->SetIsDrawable(true);
 
     scoped_refptr<FakeDelegatedRendererLayer> delegated =
-        FakeDelegatedRendererLayer::Create(delegated_frame_provider_.get());
+        FakeDelegatedRendererLayer::Create(layer_settings(),
+                                           delegated_frame_provider_.get());
     delegated->SetBounds(gfx::Size(10, 10));
     delegated->SetIsDrawable(true);
     root->AddChild(delegated);
 
     scoped_refptr<Layer> layer;
     if (layer_tree_host()->settings().impl_side_painting)
-      layer = PictureLayer::Create(&client_);
+      layer = PictureLayer::Create(layer_settings(), &client_);
     else
-      layer = ContentLayer::Create(&client_);
+      layer = ContentLayer::Create(layer_settings(), &client_);
     layer->SetBounds(gfx::Size(10, 10));
     layer->SetIsDrawable(true);
     root->AddChild(layer);
 
-    scoped_refptr<TextureLayer> texture = TextureLayer::CreateForMailbox(NULL);
+    scoped_refptr<TextureLayer> texture =
+        TextureLayer::CreateForMailbox(layer_settings_, NULL);
     texture->SetBounds(gfx::Size(10, 10));
     texture->SetIsDrawable(true);
     texture->SetTextureMailbox(
         TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
         SingleReleaseCallback::Create(
             base::Bind(&LayerTreeHostContextTestDontUseLostResources::
                             EmptyReleaseCallback)));
     root->AddChild(texture);
 
     scoped_refptr<Layer> mask;
     if (layer_tree_host()->settings().impl_side_painting)
-      mask = PictureLayer::Create(&client_);
+      mask = PictureLayer::Create(layer_settings_, &client_);
     else
-      mask = ContentLayer::Create(&client_);
+      mask = ContentLayer::Create(layer_settings_, &client_);
     mask->SetBounds(gfx::Size(10, 10));
 
     scoped_refptr<Layer> layer_with_mask;
     if (layer_tree_host()->settings().impl_side_painting)
-      layer_with_mask = PictureLayer::Create(&client_);
+      layer_with_mask = PictureLayer::Create(layer_settings_, &client_);
     else
-      layer_with_mask = ContentLayer::Create(&client_);
+      layer_with_mask = ContentLayer::Create(layer_settings_, &client_);
     layer_with_mask->SetBounds(gfx::Size(10, 10));
     layer_with_mask->SetIsDrawable(true);
     layer_with_mask->SetMaskLayer(mask.get());
     root->AddChild(layer_with_mask);
 
-    scoped_refptr<VideoLayer> video_color =
-        VideoLayer::Create(&color_frame_provider_, media::VIDEO_ROTATION_0);
+    scoped_refptr<VideoLayer> video_color = VideoLayer::Create(
+        layer_settings_, &color_frame_provider_, media::VIDEO_ROTATION_0);
     video_color->SetBounds(gfx::Size(10, 10));
     video_color->SetIsDrawable(true);
     root->AddChild(video_color);
 
-    scoped_refptr<VideoLayer> video_hw =
-        VideoLayer::Create(&hw_frame_provider_, media::VIDEO_ROTATION_0);
+    scoped_refptr<VideoLayer> video_hw = VideoLayer::Create(
+        layer_settings_, &hw_frame_provider_, media::VIDEO_ROTATION_0);
     video_hw->SetBounds(gfx::Size(10, 10));
     video_hw->SetIsDrawable(true);
     root->AddChild(video_hw);
 
-    scoped_refptr<VideoLayer> video_scaled_hw =
-        VideoLayer::Create(&scaled_hw_frame_provider_, media::VIDEO_ROTATION_0);
+    scoped_refptr<VideoLayer> video_scaled_hw = VideoLayer::Create(
+        layer_settings_, &scaled_hw_frame_provider_, media::VIDEO_ROTATION_0);
     video_scaled_hw->SetBounds(gfx::Size(10, 10));
     video_scaled_hw->SetIsDrawable(true);
     root->AddChild(video_scaled_hw);
 
     color_video_frame_ = VideoFrame::CreateColorFrame(
         gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
     hw_video_frame_ = VideoFrame::WrapNativeTexture(
         gpu::MailboxHolder(mailbox, GL_TEXTURE_2D, sync_point),
         media::VideoFrame::ReleaseMailboxCB(), gfx::Size(4, 4),
         gfx::Rect(0, 0, 4, 4), gfx::Size(4, 4), base::TimeDelta(),
         false /* allow_overlay */, true /* has_alpha */);
     scaled_hw_video_frame_ = VideoFrame::WrapNativeTexture(
         gpu::MailboxHolder(mailbox, GL_TEXTURE_2D, sync_point),
         media::VideoFrame::ReleaseMailboxCB(), gfx::Size(4, 4),
         gfx::Rect(0, 0, 3, 2), gfx::Size(4, 4), base::TimeDelta(),
         false /* allow_overlay */, true /* has_alpha */);
 
     color_frame_provider_.set_frame(color_video_frame_);
     hw_frame_provider_.set_frame(hw_video_frame_);
     scaled_hw_frame_provider_.set_frame(scaled_hw_video_frame_);
 
     if (!delegating_renderer()) {
       // TODO(danakj): IOSurface layer can not be transported. crbug.com/239335
-      scoped_refptr<IOSurfaceLayer> io_surface = IOSurfaceLayer::Create();
+      scoped_refptr<IOSurfaceLayer> io_surface =
+          IOSurfaceLayer::Create(layer_settings_);
       io_surface->SetBounds(gfx::Size(10, 10));
       io_surface->SetIsDrawable(true);
       io_surface->SetIOSurfaceProperties(1, gfx::Size(10, 10));
       root->AddChild(io_surface);
     }
 
     // Enable the hud.
     LayerTreeDebugState debug_state;
     debug_state.show_property_changed_rects = true;
     layer_tree_host()->SetDebugState(debug_state);
 
     scoped_refptr<PaintedScrollbarLayer> scrollbar =
         PaintedScrollbarLayer::Create(
-            scoped_ptr<Scrollbar>(new FakeScrollbar).Pass(), layer->id());
+            layer_settings_, scoped_ptr<Scrollbar>(new FakeScrollbar).Pass(),
+            layer->id());
     scrollbar->SetBounds(gfx::Size(10, 10));
     scrollbar->SetIsDrawable(true);
     root->AddChild(scrollbar);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 56 matching lines @@
       delegated_resource_collection_;
   scoped_refptr<DelegatedFrameProvider> delegated_frame_provider_;
 
   scoped_refptr<VideoFrame> color_video_frame_;
   scoped_refptr<VideoFrame> hw_video_frame_;
   scoped_refptr<VideoFrame> scaled_hw_video_frame_;
 
   FakeVideoFrameProvider color_frame_provider_;
   FakeVideoFrameProvider hw_frame_provider_;
   FakeVideoFrameProvider scaled_hw_frame_provider_;
+
+  LayerSettings layer_settings_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostContextTestDontUseLostResources);
 
 class ImplSidePaintingLayerTreeHostContextTest
     : public LayerTreeHostContextTest {
  public:
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->impl_side_painting = true;
   }
 };
 
 class LayerTreeHostContextTestImplSidePainting
     : public ImplSidePaintingLayerTreeHostContextTest {
  public:
   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);
 
-    scoped_refptr<PictureLayer> picture = PictureLayer::Create(&client_);
+    scoped_refptr<PictureLayer> picture =
+        PictureLayer::Create(layer_settings(), &client_);
     picture->SetBounds(gfx::Size(10, 10));
     picture->SetIsDrawable(true);
     root->AddChild(picture);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override {
     times_to_lose_during_commit_ = 1;
     PostSetNeedsCommitToMainThread();
   }
 
   void AfterTest() override {}
 
   void DidInitializeOutputSurface() override { EndTest(); }
 
  private:
   FakeContentLayerClient client_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostContextTestImplSidePainting);
 
 class ScrollbarLayerLostContext : public LayerTreeHostContextTest {
  public:
   ScrollbarLayerLostContext() : commits_(0) {}
 
   void BeginTest() override {
-    scoped_refptr<Layer> scroll_layer = Layer::Create();
-    scrollbar_layer_ =
-        FakePaintedScrollbarLayer::Create(false, true, scroll_layer->id());
+    scoped_refptr<Layer> scroll_layer = Layer::Create(layer_settings());
+    scrollbar_layer_ = FakePaintedScrollbarLayer::Create(
+        layer_settings(), false, true, scroll_layer->id());
     scrollbar_layer_->SetBounds(gfx::Size(10, 100));
     layer_tree_host()->root_layer()->AddChild(scrollbar_layer_);
     layer_tree_host()->root_layer()->AddChild(scroll_layer);
     PostSetNeedsCommitToMainThread();
   }
 
   void AfterTest() override {}
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
@@ skipping 425 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(UIResourceLostEviction);
 
 class LayerTreeHostContextTestSurfaceCreateCallback
     : public LayerTreeHostContextTest {
  public:
   LayerTreeHostContextTestSurfaceCreateCallback()
       : LayerTreeHostContextTest() {}
 
   void SetupTree() override {
     if (layer_tree_host()->settings().impl_side_painting) {
-      picture_layer_ = FakePictureLayer::Create(&client_);
+      picture_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
       picture_layer_->SetBounds(gfx::Size(10, 20));
       layer_tree_host()->SetRootLayer(picture_layer_);
     } else {
-      content_layer_ = FakeContentLayer::Create(&client_);
+      content_layer_ = FakeContentLayer::Create(layer_settings(), &client_);
       content_layer_->SetBounds(gfx::Size(10, 20));
       layer_tree_host()->SetRootLayer(content_layer_);
     }
 
     LayerTreeHostContextTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
@@ skipping 94 matching lines @@
   void AfterTest() override {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc