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

ui/compositor/layer.cc

 // Copyright (c) 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 "ui/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/scoped_ptr_algorithm.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_renderer_layer.h"
 #include "cc/layers/nine_patch_layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/output/filter_operation.h"
 #include "cc/output/filter_operations.h"
 #include "cc/resources/transferable_resource.h"
+#include "cc/trees/layer_tree_settings.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/interpolated_transform.h"
 
 namespace {
 
 const ui::Layer* GetRoot(const ui::Layer* layer) {
   while (layer->parent())
     layer = layer->parent();
   return layer;
 }
 
 struct UIImplSidePaintingStatus {
   UIImplSidePaintingStatus()
       : enabled(ui::IsUIImplSidePaintingEnabled()) {
   }
   bool enabled;
 };
 base::LazyInstance<UIImplSidePaintingStatus> g_ui_impl_side_painting_status =
     LAZY_INSTANCE_INITIALIZER;
 
+base::LazyInstance<cc::LayerSettings> g_ui_layer_settings =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 namespace ui {
 
 Layer::Layer()
     : type_(LAYER_TEXTURED),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       force_render_surface_(false),
@@ skipping 58 matching lines @@
     children_[i]->parent_ = NULL;
   cc_layer_->RemoveLayerAnimationEventObserver(this);
   cc_layer_->RemoveFromParent();
 }
 
 // static
 bool Layer::UsingPictureLayer() {
   return g_ui_impl_side_painting_status.Get().enabled;
 }
 
+// static
+const cc::LayerSettings& Layer::UILayerSettings() {
+  return g_ui_layer_settings.Get();
+}
+
+// static
+void Layer::SetUILayerSettings(const cc::LayerSettings& settings) {
+  g_ui_layer_settings.Get() = settings;
+}
+
 const Compositor* Layer::GetCompositor() const {
   return GetRoot(this)->compositor_;
 }
 
 float Layer::opacity() const {
   return cc_layer_->opacity();
 }
 
 void Layer::SetCompositor(Compositor* compositor) {
   // This function must only be called to set the compositor on the root layer,
@@ skipping 369 matching lines @@
   cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
   cc_layer_->SetHideLayerAndSubtree(!visible_);
 
   SetLayerFilters();
   SetLayerBackgroundFilters();
 }
 
 void Layer::SwitchCCLayerForTest() {
   scoped_refptr<cc::Layer> new_layer;
   if (Layer::UsingPictureLayer())
-    new_layer = cc::PictureLayer::Create(this);
+    new_layer = cc::PictureLayer::Create(UILayerSettings(), this);
   else
-    new_layer = cc::ContentLayer::Create(this);
+    new_layer = cc::ContentLayer::Create(UILayerSettings(), this);
   SwitchToLayer(new_layer);
   content_layer_ = new_layer;
 }
 
 void Layer::SetTextureMailbox(
     const cc::TextureMailbox& mailbox,
     scoped_ptr<cc::SingleReleaseCallback> release_callback,
     gfx::Size texture_size_in_dip) {
   DCHECK(type_ == LAYER_TEXTURED || type_ == LAYER_SOLID_COLOR);
   DCHECK(mailbox.IsValid());
   DCHECK(release_callback);
   if (!texture_layer_.get()) {
     scoped_refptr<cc::TextureLayer> new_layer =
-        cc::TextureLayer::CreateForMailbox(this);
+        cc::TextureLayer::CreateForMailbox(UILayerSettings(), this);
     new_layer->SetFlipped(true);
     SwitchToLayer(new_layer);
     texture_layer_ = new_layer;
     // Reset the frame_size_in_dip_ so that SetTextureSize() will not early out,
     // the frame_size_in_dip_ was for a previous (different) |texture_layer_|.
     frame_size_in_dip_ = gfx::Size();
   }
   if (mailbox_release_callback_)
     mailbox_release_callback_->Run(0, false);
   mailbox_release_callback_ = release_callback.Pass();
@@ skipping 18 matching lines @@
 bool Layer::TextureFlipped() const {
   DCHECK(texture_layer_.get());
   return texture_layer_->flipped();
 }
 
 void Layer::SetShowDelegatedContent(cc::DelegatedFrameProvider* frame_provider,
                                     gfx::Size frame_size_in_dip) {
   DCHECK(type_ == LAYER_TEXTURED || type_ == LAYER_SOLID_COLOR);
 
   scoped_refptr<cc::DelegatedRendererLayer> new_layer =
-      cc::DelegatedRendererLayer::Create(frame_provider);
+      cc::DelegatedRendererLayer::Create(UILayerSettings(), frame_provider);
   SwitchToLayer(new_layer);
   delegated_renderer_layer_ = new_layer;
 
   frame_size_in_dip_ = frame_size_in_dip;
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetShowSurface(
     cc::SurfaceId surface_id,
     const cc::SurfaceLayer::SatisfyCallback& satisfy_callback,
     const cc::SurfaceLayer::RequireCallback& require_callback,
     gfx::Size surface_size,
     float scale,
     gfx::Size frame_size_in_dip) {
   DCHECK(type_ == LAYER_TEXTURED || type_ == LAYER_SOLID_COLOR);
 
-  scoped_refptr<cc::SurfaceLayer> new_layer =
-      cc::SurfaceLayer::Create(satisfy_callback, require_callback);
+  scoped_refptr<cc::SurfaceLayer> new_layer = cc::SurfaceLayer::Create(
+      UILayerSettings(), satisfy_callback, require_callback);
   new_layer->SetSurfaceId(surface_id, scale, surface_size);
   SwitchToLayer(new_layer);
   surface_layer_ = new_layer;
 
   frame_size_in_dip_ = frame_size_in_dip;
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetShowSolidColorContent() {
   DCHECK_EQ(type_, LAYER_SOLID_COLOR);
 
   if (solid_color_layer_.get())
     return;
 
-  scoped_refptr<cc::SolidColorLayer> new_layer = cc::SolidColorLayer::Create();
+  scoped_refptr<cc::SolidColorLayer> new_layer =
+      cc::SolidColorLayer::Create(UILayerSettings());
   SwitchToLayer(new_layer);
   solid_color_layer_ = new_layer;
 
   mailbox_ = cc::TextureMailbox();
   if (mailbox_release_callback_) {
     mailbox_release_callback_->Run(0, false);
     mailbox_release_callback_.reset();
   }
   RecomputeDrawsContentAndUVRect();
 }
@@ skipping 396 matching lines @@
     cc_layer_->AddAnimation(pending_threaded_animations_.take(it));
 
   pending_threaded_animations_.clear();
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SendPendingThreadedAnimations();
 }
 
 void Layer::CreateCcLayer() {
   if (type_ == LAYER_SOLID_COLOR) {
-    solid_color_layer_ = cc::SolidColorLayer::Create();
+    solid_color_layer_ = cc::SolidColorLayer::Create(UILayerSettings());
     cc_layer_ = solid_color_layer_.get();
   } else if (type_ == LAYER_NINE_PATCH) {
-    nine_patch_layer_ = cc::NinePatchLayer::Create();
+    nine_patch_layer_ = cc::NinePatchLayer::Create(UILayerSettings());
     cc_layer_ = nine_patch_layer_.get();
   } else {
     if (Layer::UsingPictureLayer())
-      content_layer_ = cc::PictureLayer::Create(this);
+      content_layer_ = cc::PictureLayer::Create(UILayerSettings(), this);
     else
-      content_layer_ = cc::ContentLayer::Create(this);
+      content_layer_ = cc::ContentLayer::Create(UILayerSettings(), this);
     cc_layer_ = content_layer_.get();
   }
   cc_layer_->SetTransformOrigin(gfx::Point3F());
   cc_layer_->SetContentsOpaque(true);
   cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
   cc_layer_->AddLayerAnimationEventObserver(this);
   cc_layer_->SetLayerClient(this);
   RecomputePosition();
 }
 
@@ skipping 43 matching lines @@
       children_.end(),
       std::bind2nd(std::mem_fun(&Layer::RemoveAnimatorsInTreeFromCollection),
                    collection));
 }
 
 bool Layer::IsAnimating() const {
   return animator_.get() && animator_->is_animating();
 }
 
 }  // namespace ui