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 29 matching lines @@
 
 Layer::Layer()
     : type_(LAYER_TEXTURED),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       is_drawn_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
       layer_updated_externally_(false),
-      opacity_(1.0f),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_x_offset_(0),
       zoom_y_offset_(0),
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       cc_layer_(NULL),
       scale_content_(true),
       device_scale_factor_(1.0f) {
   CreateWebLayer();
 }
 
 Layer::Layer(LayerType type)
     : type_(type),
       compositor_(NULL),
       parent_(NULL),
       visible_(true),
       is_drawn_(true),
       force_render_surface_(false),
       fills_bounds_opaquely_(true),
       layer_updated_externally_(false),
-      opacity_(1.0f),
       background_blur_radius_(0),
       layer_saturation_(0.0f),
       layer_brightness_(0.0f),
       layer_grayscale_(0.0f),
       layer_inverted_(false),
       layer_mask_(NULL),
       layer_mask_back_link_(NULL),
       zoom_x_offset_(0),
       zoom_y_offset_(0),
       zoom_(1),
@@ skipping 14 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_;
 }
 
+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,
   // or to reset it.
   DCHECK(!compositor || !compositor_);
   DCHECK(!compositor || compositor->root_layer() == this);
   DCHECK(!parent_);
   compositor_ = compositor;
   if (compositor)
     OnDeviceScaleFactorChanged(compositor->device_scale_factor());
 }
@@ skipping 88 matching lines @@
 
 bool Layer::GetMasksToBounds() const {
   return cc_layer_->masksToBounds();
 }
 
 void Layer::SetOpacity(float opacity) {
   GetAnimator()->SetOpacity(opacity);
 }
 
 float Layer::GetCombinedOpacity() const {
-  float opacity = opacity_;
+  float opacity = this->opacity();
   Layer* current = this->parent_;
   while (current) {
-    opacity *= current->opacity_;
+    opacity *= current->opacity();
     current = current->parent_;
   }
   return opacity;
 }
 
 void Layer::SetBackgroundBlur(int blur_radius) {
   background_blur_radius_ = blur_radius;
 
   SetLayerBackgroundFilters();
 }
@@ skipping 106 matching lines @@
         background_blur_radius_));
   }
 
   cc_layer_->setBackgroundFilters(filters);
 }
 
 float Layer::GetTargetOpacity() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::OPACITY))
     return animator_->GetTargetOpacity();
-  return opacity_;
+  return opacity();
 }
 
 void Layer::SetVisible(bool visible) {
   GetAnimator()->SetVisibility(visible);
 }
 
 bool Layer::GetTargetVisibility() const {
   if (animator_.get() && animator_->IsAnimatingProperty(
       LayerAnimationElement::VISIBILITY))
     return animator_->GetTargetVisibility();
@@ skipping 68 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);
+    new_layer->setOpacity(cc_layer_->opacity());
     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(opacity_);
     cc_layer_->setForceRenderSurface(force_render_surface_);
     cc_layer_->setIsDrawable(IsDrawn());
     RecomputeTransform();
   }
   RecomputeDrawsContentAndUVRect();
 }
 
 void Layer::SetColor(SkColor color) {
   GetAnimator()->SetColor(color);
 }
@@ skipping 91 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 72 matching lines @@
   }
 }
 
 void Layer::SetTransformImmediately(const gfx::Transform& transform) {
   transform_ = transform;
 
   RecomputeTransform();
 }
 
 void Layer::SetOpacityImmediately(float opacity) {
-  opacity_ = opacity;
-
   cc_layer_->setOpacity(opacity);
   ScheduleDraw();
 }
 
 void Layer::SetVisibilityImmediately(bool visible) {
   if (visible_ == visible)
     return;
 
   visible_ = visible;
   UpdateIsDrawn();
@@ skipping 73 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