Explicit animation support

ui/gfx/compositor/layer.cc

 // Copyright (c) 2011 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/gfx/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "ui/base/animation/animation.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/point3.h"
 
 namespace {
 
 const float EPSILON = 1e-3f;
 
 bool IsApproximateMultilpleOf(float value, float base) {
@@ skipping 77 matching lines @@
 }
 
 bool Layer::Contains(const Layer* other) const {
   for (const Layer* parent = other; parent; parent = parent->parent()) {
     if (parent == this)
       return true;
   }
   return false;
 }
 
-void Layer::SetAnimation(Animation* animation) {
-  if (animation) {
-    if (!animator_.get())
-      animator_.reset(new LayerAnimator(this));
-    animation->Start();
-    animator_->SetAnimation(animation);
-  } else {
-    animator_.reset();
+void Layer::SetAnimator(LayerAnimator* animator) {
+  animator->SetLayer(this);
+  animator_.reset(animator);
+}
+
+LayerAnimator& Layer::GetAnimator() {
+  if (!animator_.get()) {
+    SetAnimator(LayerAnimator::CreateDefaultAnimator());
   }
+  return *animator_;
 }
 
 void Layer::SetTransform(const ui::Transform& transform) {
-  StopAnimatingIfNecessary(LayerAnimator::TRANSFORM);
-  if (animator_.get() && animator_->IsRunning()) {
-    animator_->AnimateTransform(transform);
-    return;
-  }
-  SetTransformImmediately(transform);
+  if (animator_.get())
+    animator_->SetTransform(transform);
+  else
+    SetTransformImmediately(transform);
 }
 
 void Layer::SetBounds(const gfx::Rect& bounds) {
-  StopAnimatingIfNecessary(LayerAnimator::LOCATION);
-  if (animator_.get() && animator_->IsRunning() &&
-      bounds.size() == bounds_.size()) {
-    animator_->AnimateToPoint(bounds.origin());
-    return;
-  }
-  SetBoundsImmediately(bounds);
+  if (animator_.get())
+    animator_->SetBounds(bounds);
+  else
+    SetBoundsImmediately(bounds);
 }
 
 void Layer::SetOpacity(float opacity) {
-  StopAnimatingIfNecessary(LayerAnimator::OPACITY);
-  if (animator_.get() && animator_->IsRunning()) {
-    animator_->AnimateOpacity(opacity);
-    return;
-  }
-  SetOpacityImmediately(opacity);
+  if (animator_.get())
+    animator_->SetOpacity(opacity);
+  else
+    SetOpacityImmediately(opacity);
 }
 
 void Layer::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
 
   bool was_drawn = IsDrawn();
   visible_ = visible;
   bool is_drawn = IsDrawn();
   if (was_drawn == is_drawn)
@@ skipping 165 matching lines @@
     if (!children_[i]->IsCompletelyOpaque() || !children_[i]->visible_)
       continue;
 
     // Ignore children that aren't rotated by multiples of 90 degrees.
     float degrees;
     if (!InterpolatedTransform::FactorTRS(children_[i]->transform(),
                                           NULL, &degrees, NULL) ||
         !IsApproximateMultilpleOf(degrees, 90.0f))
       continue;
 
-    gfx::Rect candidate_hole = children_[i]->bounds();
-    children_[i]->transform().TransformRect(&candidate_hole);
+    // The reason why we don't just take the bounds and apply the transform is
+    // that the bounds encodes a position, too, so the effective transformation
+    // matrix is actually different that the one reported. As well, the bounds
+    // will not necessarily be at the origin.
+    gfx::Rect candidate_hole(children_[i]->bounds_.size());
+    ui::Transform transform = children_[i]->transform();
+    transform.ConcatTranslate(static_cast<float>(children_[i]->bounds_.x()),
+                              static_cast<float>(children_[i]->bounds_.y()));
+    transform.TransformRect(&candidate_hole);
 
     // This layer might not contain the child (e.g., a portion of the child may
     // be offscreen). Only the portion of the child that overlaps this layer is
     // of any importance, so take the intersection.
     candidate_hole = bounds().Intersect(candidate_hole);
 
     // Ensure we have the largest hole.
     if (candidate_hole.size().GetArea() > hole_rect_.size().GetArea())
       hole_rect_ = candidate_hole;
   }
 
   // Free up texture memory if the hole fills bounds of layer.
   if (!ShouldDraw() && !layer_updated_externally_)
-    texture_ = NULL;
+    DropTextures();
 }
 
 bool Layer::IsCompletelyOpaque() const {
   return fills_bounds_opaquely() && GetCombinedOpacity() == 1.0f;
 }
 
 // static
 void Layer::PunchHole(const gfx::Rect& rect,
                       const gfx::Rect& region_to_punch_out,
                       std::vector<gfx::Rect>* sides) {
@@ skipping 61 matching lines @@
   const Layer* p = this;
   for (; p && p != ancestor; p = p->parent()) {
     if (p->transform().HasChange())
       transform->ConcatTransform(p->transform());
     transform->ConcatTranslate(static_cast<float>(p->bounds().x()),
                                static_cast<float>(p->bounds().y()));
   }
   return p == ancestor;
 }
 
-void Layer::StopAnimatingIfNecessary(
-    LayerAnimator::AnimationProperty property) {
-  if (!animator_.get() || !animator_->IsRunning() ||
-      !animator_->got_initial_tick()) {
-    return;
-  }
-
-  if (property != LayerAnimator::LOCATION &&
-      animator_->IsAnimating(LayerAnimator::LOCATION)) {
-    SetBoundsImmediately(
-        gfx::Rect(animator_->GetTargetPoint(), bounds_.size()));
-  }
-  if (property != LayerAnimator::OPACITY &&
-      animator_->IsAnimating(LayerAnimator::OPACITY)) {
-    SetOpacityImmediately(animator_->GetTargetOpacity());
-  }
-  if (property != LayerAnimator::TRANSFORM &&
-      animator_->IsAnimating(LayerAnimator::TRANSFORM)) {
-    SetTransformImmediately(animator_->GetTargetTransform());
-  }
-  animator_.reset();
-}
-
 void Layer::SetBoundsImmediately(const gfx::Rect& bounds) {
   bounds_ = bounds;
 
   if (parent())
     parent()->RecomputeHole();
 }
 
 void Layer::SetTransformImmediately(const ui::Transform& transform) {
   transform_ = transform;
 
@@ skipping 16 matching lines @@
     while (!to_process.empty()) {
       Layer* current = to_process.front();
       to_process.pop();
       current->RecomputeHole();
       for (size_t i = 0; i < current->children_.size(); ++i)
         to_process.push(current->children_.at(i));
     }
   }
 }
 
-void Layer::SetBoundsFromAnimator(const gfx::Rect& bounds) {
+void Layer::SetBoundsFromAnimation(const gfx::Rect& bounds) {
   SetBoundsImmediately(bounds);
 }
 
-void Layer::SetTransformFromAnimator(const Transform& transform) {
+void Layer::SetTransformFromAnimation(const Transform& transform) {
   SetTransformImmediately(transform);
 }
 
-void Layer::SetOpacityFromAnimator(float opacity) {
+void Layer::SetOpacityFromAnimation(float opacity) {
   SetOpacityImmediately(opacity);
 }
 
+void Layer::ScheduleDrawForAnimation() {
+  ScheduleDraw();
+}
+
+const gfx::Rect& Layer::GetBoundsForAnimation() const {
+  return bounds();
+}
+
+const Transform& Layer::GetTransformForAnimation() const {
+  return transform();
+}
+
+const float Layer::GetOpacityForAnimation() const {
+  return opacity();
+}
+
 }  // namespace ui