CC Animation: Erase old animation system in UI Compositor.

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 <utility>
 
 #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/layers/layer_settings.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"
@@ skipping 15 matching lines @@
 #include "ui/gfx/interpolated_transform.h"
 
 namespace {
 
 const ui::Layer* GetRoot(const ui::Layer* layer) {
   while (layer->parent())
     layer = layer->parent();
   return layer;
 }
 
-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 51 matching lines @@
   if (layer_mask_)
     SetMaskLayer(NULL);
   if (layer_mask_back_link_)
     layer_mask_back_link_->SetMaskLayer(NULL);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->parent_ = NULL;
 
   cc_layer_->RemoveFromParent();
 }
 
-// static
-const cc::LayerSettings& Layer::UILayerSettings() {
-  return g_ui_layer_settings.Get();
-}
-
-// static
-void Layer::InitializeUILayerSettings() {
-  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-  g_ui_layer_settings.Get().use_compositor_animation_timelines =
-      !command_line->HasSwitch(
-          switches::kUIDisableCompositorAnimationTimelines);
-}
-
 const Compositor* Layer::GetCompositor() const {
   return GetRoot(this)->compositor_;
 }
 
 float Layer::opacity() const {
   return cc_layer_->opacity();
 }
 
 void Layer::SetCompositor(Compositor* compositor,
                           scoped_refptr<cc::Layer> root_layer) {
   // This function must only be called to set the compositor on the root ui
   // layer.
   DCHECK(compositor);
   DCHECK(!compositor_);
   DCHECK(compositor->root_layer() == this);
   DCHECK(!parent_);
 
   compositor_ = compositor;
   OnDeviceScaleFactorChanged(compositor->device_scale_factor());
 
   root_layer->AddChild(cc_layer_);
   SetCompositorForAnimatorsInTree(compositor);
-  SendPendingThreadedAnimations();
 }
 
 void Layer::ResetCompositor() {
   DCHECK(!parent_);
   if (compositor_) {
     ResetCompositorForAnimatorsInTree(compositor_);
     compositor_ = nullptr;
   }
 }
 
 void Layer::Add(Layer* child) {
   DCHECK(!child->compositor_);
   if (child->parent_)
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
   cc_layer_->AddChild(child->cc_layer_);
   child->OnDeviceScaleFactorChanged(device_scale_factor_);
   Compositor* compositor = GetCompositor();
-  if (compositor) {
+  if (compositor)
     child->SetCompositorForAnimatorsInTree(compositor);
-    child->SendPendingThreadedAnimations();
-  }
 }
 
 void Layer::Remove(Layer* child) {
   // Current bounds are used to calculate offsets when layers are reparented.
   // Stop (and complete) an ongoing animation to update the bounds immediately.
   LayerAnimator* child_animator = child->animator_.get();
   if (child_animator)
     child_animator->StopAnimatingProperty(ui::LayerAnimationElement::BOUNDS);
 
   Compositor* compositor = GetCompositor();
@@ skipping 337 matching lines @@
   cc_layer_->SetContentsOpaque(fills_bounds_opaquely_);
   cc_layer_->SetForceRenderSurface(force_render_surface_);
   cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
   cc_layer_->SetHideLayerAndSubtree(!visible_);
 
   SetLayerFilters();
   SetLayerBackgroundFilters();
 }
 
 bool Layer::HasPendingThreadedAnimationsForTesting() const {
-  if (UILayerSettings().use_compositor_animation_timelines)
-    return animator_->HasPendingThreadedAnimationsForTesting();
-  else
-    return !pending_threaded_animations_.empty();
+  return animator_->HasPendingThreadedAnimationsForTesting();
 }
 
 void Layer::SwitchCCLayerForTest() {
   scoped_refptr<cc::Layer> new_layer =
-      cc::PictureLayer::Create(UILayerSettings(), this);
+      cc::PictureLayer::Create(cc::LayerSettings(), 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(UILayerSettings(), this);
+        cc::TextureLayer::CreateForMailbox(cc::LayerSettings(), 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(gpu::SyncToken(), false);
   mailbox_release_callback_ = std::move(release_callback);
@@ skipping 23 matching lines @@
 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(
-      UILayerSettings(), satisfy_callback, require_callback);
+      cc::LayerSettings(), 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(UILayerSettings());
+      cc::SolidColorLayer::Create(cc::LayerSettings());
   SwitchToLayer(new_layer);
   solid_color_layer_ = new_layer;
 
   mailbox_ = cc::TextureMailbox();
   if (mailbox_release_callback_) {
     mailbox_release_callback_->Run(gpu::SyncToken(), false);
     mailbox_release_callback_.reset();
   }
   RecomputeDrawsContentAndUVRect();
 }
@@ skipping 332 matching lines @@
   // The NULL check is here since this is invoked regardless of whether we have
   // been configured as LAYER_SOLID_COLOR.
   return solid_color_layer_.get() ?
       solid_color_layer_->background_color() : SK_ColorBLACK;
 }
 
 float Layer::GetDeviceScaleFactor() const {
   return device_scale_factor_;
 }
 
-void Layer::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) {
-  DCHECK(cc_layer_);
-  DCHECK(!UILayerSettings().use_compositor_animation_timelines);
-  // Until this layer has a compositor (and hence cc_layer_ has a
-  // LayerTreeHost), addAnimation will fail.
-  if (GetCompositor()) {
-    cc_layer_->AddAnimation(std::move(animation));
-  } else {
-    pending_threaded_animations_.push_back(std::move(animation));
-  }
-}
-
-void Layer::RemoveThreadedAnimation(int animation_id) {
-  DCHECK(cc_layer_);
-  DCHECK(!UILayerSettings().use_compositor_animation_timelines);
-  if (pending_threaded_animations_.size() == 0) {
-    cc_layer_->RemoveAnimation(animation_id);
-    return;
-  }
-
-  pending_threaded_animations_.erase(
-      std::remove_if(
-          pending_threaded_animations_.begin(),
-          pending_threaded_animations_.end(),
-          [animation_id](const scoped_ptr<cc::Animation>& animation) {
-            return animation->id() == animation_id;
-          }),
-      pending_threaded_animations_.end());
-}
-
 LayerAnimatorCollection* Layer::GetLayerAnimatorCollection() {
   Compositor* compositor = GetCompositor();
   return compositor ? compositor->layer_animator_collection() : NULL;
 }
 
 cc::Layer* Layer::GetCcLayer() const {
   return cc_layer_;
 }
 
 LayerThreadedAnimationDelegate* Layer::GetThreadedAnimationDelegate() {
-  if (UILayerSettings().use_compositor_animation_timelines) {
-    DCHECK(animator_);
-    return animator_.get();
-  } else {
-    return this;
-  }
-}
-
-void Layer::SendPendingThreadedAnimations() {
-  if (UILayerSettings().use_compositor_animation_timelines) {
-    DCHECK(pending_threaded_animations_.empty());
-    return;
-  }
-
-  for (auto& animation : pending_threaded_animations_)
-    cc_layer_->AddAnimation(std::move(animation));
-  pending_threaded_animations_.clear();
-
-  for (auto* child : children_)
-    child->SendPendingThreadedAnimations();
+  DCHECK(animator_);
+  return animator_.get();
 }
 
 void Layer::CreateCcLayer() {
   if (type_ == LAYER_SOLID_COLOR) {
-    solid_color_layer_ = cc::SolidColorLayer::Create(UILayerSettings());
+    solid_color_layer_ = cc::SolidColorLayer::Create(cc::LayerSettings());
     cc_layer_ = solid_color_layer_.get();
   } else if (type_ == LAYER_NINE_PATCH) {
-    nine_patch_layer_ = cc::NinePatchLayer::Create(UILayerSettings());
+    nine_patch_layer_ = cc::NinePatchLayer::Create(cc::LayerSettings());
     cc_layer_ = nine_patch_layer_.get();
   } else {
-    content_layer_ = cc::PictureLayer::Create(UILayerSettings(), this);
+    content_layer_ = cc::PictureLayer::Create(cc::LayerSettings(), this);
     cc_layer_ = content_layer_.get();
   }
   cc_layer_->SetTransformOrigin(gfx::Point3F());
   cc_layer_->SetContentsOpaque(true);
   cc_layer_->SetIsDrawable(type_ != LAYER_NOT_DRAWN);
   cc_layer_->SetLayerClient(this);
   RecomputePosition();
 }
 
 gfx::Transform Layer::transform() const {
@@ skipping 43 matching lines @@
     animator_->ResetCompositor(compositor);
     if (animator_->is_animating())
       animator_->RemoveFromCollection(collection);
   }
 
   for (auto* child : children_)
     child->ResetCompositorForAnimatorsInTree(compositor);
 }
 
 }  // namespace ui