Thread ui opacity animations

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/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 90 matching lines @@
   if (compositor_)
     compositor_->SetRootLayer(NULL);
   if (parent_)
     parent_->Remove(this);
   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_->removeLayerAnimationEventObserver(this);
   cc_layer_->removeFromParent();
 }
 
 Compositor* Layer::GetCompositor() {
   return GetRoot(this)->compositor_;
 }
 
 void Layer::SetCompositor(Compositor* compositor) {
   // This function must only be called to set the compositor on the root layer,
   // or to reset it.
@@ skipping 302 matching lines @@
       new_layer = texture_layer_.get();
     } else {
       old_texture_layer->willModifyTexture();
       content_layer_ = cc::ContentLayer::create(this);
       new_layer = content_layer_.get();
     }
     if (parent_) {
       DCHECK(parent_->cc_layer_);
       parent_->cc_layer_->replaceChild(cc_layer_, new_layer);
     }
+    cc_layer_->removeLayerAnimationEventObserver(this);
     cc_layer_= new_layer;
+    cc_layer_->addLayerAnimationEventObserver(this);
     cc_layer_is_accelerated_ = layer_updated_externally_;
     for (size_t i = 0; i < children_.size(); ++i) {
       DCHECK(children_[i]->cc_layer_);
       cc_layer_->addChild(children_[i]->cc_layer_);
     }
     cc_layer_->setAnchorPoint(gfx::PointF());
     cc_layer_->setContentsOpaque(fills_bounds_opaquely_);
     cc_layer_->setOpacity(visible_ ? opacity_ : 0.f);
     cc_layer_->setForceRenderSurface(force_render_surface_);
     cc_layer_->setIsDrawable(true);
@@ skipping 99 matching lines @@
 }
 
 void Layer::SetForceRenderSurface(bool force) {
   if (force_render_surface_ == force)
     return;
 
   force_render_surface_ = force;
   cc_layer_->setForceRenderSurface(force_render_surface_);
 }
 
+void Layer::OnAnimationStarted(const cc::AnimationEvent& event) {
+  if (animator_)
+    animator_->OnThreadedAnimationStarted(event);
+}
+
 void Layer::StackRelativeTo(Layer* child, Layer* other, bool above) {
   DCHECK_NE(child, other);
   DCHECK_EQ(this, child->parent());
   DCHECK_EQ(this, other->parent());
 
   const size_t child_i =
       std::find(children_.begin(), children_.end(), child) - children_.begin();
   const size_t other_i =
       std::find(children_.begin(), children_.end(), other) - children_.begin();
   if ((above && child_i == other_i + 1) || (!above && child_i + 1 == other_i))
@@ skipping 171 matching lines @@
 }
 
 SkColor Layer::GetColorForAnimation() const {
   // WebColor is equivalent to SkColor, per WebColor.h.
   // 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_->backgroundColor() : SK_ColorBLACK;
 }
 
+void Layer::AddThreadedAnimation(scoped_ptr<cc::Animation> animation) {
+  DCHECK(cc_layer_);
+  cc_layer_->addAnimation(animation.Pass());
+}
+
+void Layer::RemoveThreadedAnimation(int animation_id) {
+  DCHECK(cc_layer_);
+  cc_layer_->removeAnimation(animation_id);
+}
+
 void Layer::CreateWebLayer() {
   if (type_ == LAYER_SOLID_COLOR) {
     solid_color_layer_ = cc::SolidColorLayer::create();
     cc_layer_ = solid_color_layer_.get();
   } else {
     content_layer_ = cc::ContentLayer::create(this);
     cc_layer_ = content_layer_.get();
   }
   cc_layer_is_accelerated_ = false;
   cc_layer_->setAnchorPoint(gfx::PointF());
   cc_layer_->setContentsOpaque(true);
   cc_layer_->setIsDrawable(type_ != LAYER_NOT_DRAWN);
+  cc_layer_->addLayerAnimationEventObserver(this);
 }
 
 void Layer::RecomputeTransform() {
   gfx::Transform scale_translate;
   scale_translate.matrix().set3x3(device_scale_factor_, 0, 0,
                                   0, device_scale_factor_, 0,
                                   0, 0, 1);
   // Start with the inverse matrix of above.
   gfx::Transform transform;
   transform.matrix().set3x3(1.0f / device_scale_factor_, 0, 0,
@@ skipping 24 matching lines @@
     gfx::PointF uv_bottom_right(
         static_cast<float>(size.width())/texture_size.width(),
         static_cast<float>(size.height())/texture_size.height());
     texture_layer_->setUV(uv_top_left, uv_bottom_right);
 
     cc_layer_->setBounds(ConvertSizeToPixel(this, size));
   }
 }
 
 }  // namespace ui