CC Animations: Make LayerAnimationController creation optional

content/renderer/pepper/pepper_compositor_host.cc

 // Copyright 2014 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 "content/renderer/pepper/pepper_compositor_host.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
@@ skipping 127 matching lines @@
     if (!(*image_shm)->Map(desc.stride * desc.size.height)) {
       image_shm->reset();
       return PP_ERROR_NOMEMORY;
     }
     return PP_OK;
   }
 
   return PP_ERROR_BADARGUMENT;
 }
 
+cc::LayerSettings g_pepper_layer_settings;
+
 }  // namespace
 
 PepperCompositorHost::LayerData::LayerData(
     const scoped_refptr<cc::Layer>& cc,
     const ppapi::CompositorLayerData& pp) : cc_layer(cc), pp_layer(pp) {}
 
 PepperCompositorHost::LayerData::~LayerData() {}
 
 PepperCompositorHost::PepperCompositorHost(
     RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource)
     : ResourceHost(host->GetPpapiHost(), instance, resource),
       bound_instance_(NULL),
       weak_factory_(this) {
-  layer_ = cc::Layer::Create();
+  layer_ = cc::Layer::Create(PepperLayerSettings());
   // TODO(penghuang): SetMasksToBounds() can be expensive if the layer is
   // transformed. Possibly better could be to explicitly clip the child layers
   // (by modifying their bounds).
   layer_->SetMasksToBounds(true);
   layer_->SetIsDrawable(true);
 }
 
 PepperCompositorHost::~PepperCompositorHost() {
   // Unbind from the instance when destroyed if we're still bound.
   if (bound_instance_)
     bound_instance_->BindGraphics(bound_instance_->pp_instance(), 0);
 }
 
+// static
+const cc::LayerSettings& PepperCompositorHost::PepperLayerSettings() {
+  return g_pepper_layer_settings;
+}
+
+// static
+void PepperCompositorHost::SetPepperLayerSettings(
+    const cc::LayerSettings& settings) {
+  g_pepper_layer_settings = settings;
+}
+
 bool PepperCompositorHost::BindToInstance(
     PepperPluginInstanceImpl* new_instance) {
   if (new_instance && new_instance->pp_instance() != pp_instance())
     return false;  // Can't bind other instance's contexts.
   if (bound_instance_ == new_instance)
     return true;  // Rebinding the same device, nothing to do.
   if (bound_instance_ && new_instance)
     return false;  // Can't change a bound device.
   bound_instance_ = new_instance;
   if (!bound_instance_)
@@ skipping 53 matching lines @@
   layer->SetTransform(transform);
 
   // Consider a (0,0,0,0) rect as no clip rect.
   if (new_layer->common.clip_rect.point.x != 0 ||
       new_layer->common.clip_rect.point.y != 0 ||
       new_layer->common.clip_rect.size.width != 0 ||
       new_layer->common.clip_rect.size.height != 0) {
     scoped_refptr<cc::Layer> clip_parent = layer->parent();
     if (clip_parent.get() == layer_.get()) {
       // Create a clip parent layer, if it does not exist.
-      clip_parent = cc::Layer::Create();
+      clip_parent = cc::Layer::Create(PepperLayerSettings());
       clip_parent->SetMasksToBounds(true);
       clip_parent->SetIsDrawable(true);
       layer_->ReplaceChild(layer.get(), clip_parent);
       clip_parent->AddChild(layer);
     }
     gfx::Point position = PP_ToGfxPoint(new_layer->common.clip_rect.point);
     clip_parent->SetPosition(position);
     clip_parent->SetBounds(PP_ToGfxSize(new_layer->common.clip_rect.size));
     layer->SetPosition(gfx::Point(-position.x(), -position.y()));
   } else if (layer->parent() != layer_.get()) {
@@ skipping 121 matching lines @@
 
   for (size_t i = 0; i < layers.size(); ++i) {
     const ppapi::CompositorLayerData* pp_layer = &layers[i];
     LayerData* data = i >= layers_.size() ? NULL : &layers_[i];
     DCHECK(!data || data->cc_layer.get());
     scoped_refptr<cc::Layer> cc_layer = data ? data->cc_layer : NULL;
     ppapi::CompositorLayerData* old_layer = data ? &data->pp_layer : NULL;
 
     if (!cc_layer.get()) {
       if (pp_layer->color)
-        cc_layer = cc::SolidColorLayer::Create();
+        cc_layer = cc::SolidColorLayer::Create(PepperLayerSettings());
       else if (pp_layer->texture || pp_layer->image)
-        cc_layer = cc::TextureLayer::CreateForMailbox(NULL);
+        cc_layer =
+            cc::TextureLayer::CreateForMailbox(PepperLayerSettings(), NULL);
       layer_->AddChild(cc_layer);
     }
 
     UpdateLayer(cc_layer, old_layer, pp_layer, image_shms[i].Pass());
 
     if (old_layer)
       *old_layer = *pp_layer;
     else
       layers_.push_back(LayerData(cc_layer, *pp_layer));
   }
 
   // We need to force a commit for each CommitLayers() call, even if no layers
   // changed since the last call to CommitLayers(). This is so
   // WiewInitiatedPaint() will always be called.
   if (layer_->layer_tree_host())
     layer_->layer_tree_host()->SetNeedsCommit();
 
   // If the host is not bound to the instance, return PP_OK immediately.
   if (!bound_instance_)
     return PP_OK;
 
   commit_layers_reply_context_ = context->MakeReplyMessageContext();
   return PP_OK_COMPLETIONPENDING;
 }
 
 }  // namespace content