CC Animations: Redirect all compositor animation requests to AnimationHost.

cc/layers/layer.cc

 // Copyright 2010 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 "cc/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/location.h"
@@ skipping 138 matching lines @@
     children_[i]->SetLayerTreeHost(host);
 
   if (mask_layer_.get())
     mask_layer_->SetLayerTreeHost(host);
   if (replica_layer_.get())
     replica_layer_->SetLayerTreeHost(host);
 
   if (host)
     RegisterForAnimations(host->animation_registrar());
 
-  if (host && layer_animation_controller_->has_any_animation())
+  bool has_any_animation = false;
+  if (layer_animation_controller_)
+    has_any_animation = layer_animation_controller_->has_any_animation();
+  else if (layer_tree_host_)
+    has_any_animation = layer_tree_host_->HasAnyAnimation(this);
+
+  if (host && has_any_animation)
     host->SetNeedsCommit();
 }
 
 void Layer::SetNeedsUpdate() {
   if (layer_tree_host_ && !ignore_set_needs_commit_)
     layer_tree_host_->SetNeedsUpdateLayers();
 }
 
 void Layer::SetNeedsCommit() {
   if (!layer_tree_host_)
@@ skipping 325 matching lines @@
 
 void Layer::SetFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (filters_ == filters)
     return;
   filters_ = filters;
   SetNeedsCommit();
 }
 
 bool Layer::FilterIsAnimating() const {
-  return layer_animation_controller_->IsAnimatingProperty(Animation::FILTER);
+  DCHECK(layer_tree_host_);
+  return layer_animation_controller_
+             ? layer_animation_controller_->IsAnimatingProperty(
+                   Animation::FILTER)
+             : layer_tree_host_->IsAnimatingFilterProperty(this);
 }
 
 void Layer::SetBackgroundFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (background_filters_ == filters)
     return;
   background_filters_ = filters;
   SetNeedsCommit();
 }
 
 void Layer::SetOpacity(float opacity) {
   DCHECK(IsPropertyChangeAllowed());
   if (opacity_ == opacity)
     return;
   opacity_ = opacity;
   SetNeedsCommit();
 }
 
 bool Layer::OpacityIsAnimating() const {
-  return layer_animation_controller_->IsAnimatingProperty(Animation::OPACITY);
+  DCHECK(layer_tree_host_);
+  return layer_animation_controller_
+             ? layer_animation_controller_->IsAnimatingProperty(
+                   Animation::OPACITY)
+             : layer_tree_host_->IsAnimatingOpacityProperty(this);
+}
+
+bool Layer::HasPotentiallyRunningOpacityAnimation() const {
+  if (layer_animation_controller_) {
+    if (Animation* animation =
+            layer_animation_controller()->GetAnimation(Animation::OPACITY)) {
+      return !animation->is_finished();
+    }
+    return false;
+  } else {
+    DCHECK(layer_tree_host_);
+    return layer_tree_host_->HasPotentiallyRunningOpacityAnimation(this);
+  }
 }
 
 bool Layer::OpacityCanAnimateOnImplThread() const {
   return false;
 }
 
 void Layer::SetBlendMode(SkXfermode::Mode blend_mode) {
   DCHECK(IsPropertyChangeAllowed());
   if (blend_mode_ == blend_mode)
     return;
@@ skipping 163 matching lines @@
       layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
       SetNeedsCommitNoRebuild();
       return;
     }
   }
 
   SetNeedsCommit();
 }
 
 bool Layer::AnimationsPreserveAxisAlignment() const {
-  return layer_animation_controller_->AnimationsPreserveAxisAlignment();
+  DCHECK(layer_tree_host_);
+  return layer_animation_controller_
+             ? layer_animation_controller_->AnimationsPreserveAxisAlignment()
+             : layer_tree_host_->AnimationsPreserveAxisAlignment(this);
 }
 
 bool Layer::TransformIsAnimating() const {
-  return layer_animation_controller_->IsAnimatingProperty(Animation::TRANSFORM);
+  DCHECK(layer_tree_host_);
+  return layer_animation_controller_
+             ? layer_animation_controller_->IsAnimatingProperty(
+                   Animation::TRANSFORM)
+             : layer_tree_host_->IsAnimatingTransformProperty(this);
+}
+
+bool Layer::HasPotentiallyRunningTransformAnimation() const {
+  if (layer_animation_controller_) {
+    if (Animation* animation =
+            layer_animation_controller()->GetAnimation(Animation::TRANSFORM)) {
+      return !animation->is_finished();
+    }
+    return false;
+  } else {
+    DCHECK(layer_tree_host_);
+    return layer_tree_host_->HasPotentiallyRunningTransformAnimation(this);
+  }
+}
+
+bool Layer::ScrollOffsetAnimationWasInterrupted() const {
+  DCHECK(layer_tree_host_);
+  return layer_animation_controller_
+             ? layer_animation_controller_
+                   ->scroll_offset_animation_was_interrupted()
+             : layer_tree_host_->ScrollOffsetAnimationWasInterrupted(this);
 }
 
 void Layer::SetScrollParent(Layer* parent) {
   DCHECK(IsPropertyChangeAllowed());
   if (scroll_parent_ == parent)
     return;
 
   if (scroll_parent_)
     scroll_parent_->RemoveScrollChild(this);
 
@@ skipping 489 matching lines @@
     }
     layer->SetClipChildren(clip_children);
   } else {
     layer->SetClipChildren(nullptr);
   }
 
   // When a scroll offset animation is interrupted the new scroll position on
   // the pending tree will clobber any impl-side scrolling occuring on the
   // active tree. To do so, avoid scrolling the pending tree along with it
   // instead of trying to undo that scrolling later.
-  if (layer_animation_controller_->scroll_offset_animation_was_interrupted())
+  if (ScrollOffsetAnimationWasInterrupted())
     layer->PushScrollOffsetFromMainThreadAndClobberActiveValue(scroll_offset_);
   else
     layer->PushScrollOffsetFromMainThread(scroll_offset_);
   layer->SetScrollCompensationAdjustment(ScrollCompensationAdjustment());
 
   // Wrap the copy_requests_ in a PostTask to the main thread.
   bool had_copy_requests = !copy_requests_.empty();
   ScopedPtrVector<CopyOutputRequest> main_thread_copy_requests;
   for (ScopedPtrVector<CopyOutputRequest>::iterator it = copy_requests_.begin();
        it != copy_requests_.end();
@@ skipping 19 matching lines @@
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
 
   layer->SetStackingOrderChanged(stacking_order_changed_);
 
-  layer_animation_controller_->PushAnimationUpdatesTo(
-      layer->layer_animation_controller());
+  if (layer->layer_animation_controller() && layer_animation_controller_)
+    layer_animation_controller_->PushAnimationUpdatesTo(
+        layer->layer_animation_controller());
 
   if (frame_timing_requests_dirty_) {
     layer->SetFrameTimingRequests(frame_timing_requests_);
     frame_timing_requests_dirty_ = false;
   }
 
   bool is_page_scale_layer = this == layer_tree_host()->page_scale_layer();
   bool parent_affected =
       layer->parent() && layer->parent()->IsAffectedByPageScale();
   layer->SetIsAffectedByPageScale(is_page_scale_layer || parent_affected);
@@ skipping 194 matching lines @@
 
 void Layer::RemoveAnimation(int animation_id,
                             Animation::TargetProperty property) {
   DCHECK(layer_animation_controller_);
   layer_animation_controller_->RemoveAnimation(animation_id, property);
   SetNeedsCommit();
 }
 
 void Layer::SetLayerAnimationControllerForTest(
     scoped_refptr<LayerAnimationController> controller) {
+  DCHECK(layer_animation_controller_);
   layer_animation_controller_->RemoveValueObserver(this);
   layer_animation_controller_ = controller;
   layer_animation_controller_->AddValueObserver(this);
   SetNeedsCommit();
 }
 
 bool Layer::HasActiveAnimation() const {
-  DCHECK(layer_animation_controller_);
-  return layer_animation_controller_->HasActiveAnimation();
+  DCHECK(layer_tree_host_);
+  return layer_animation_controller_
+             ? layer_animation_controller_->HasActiveAnimation()
+             : layer_tree_host_->HasActiveAnimation(this);
 }
 
 void Layer::RegisterForAnimations(AnimationRegistrar* registrar) {
   if (layer_animation_controller_)
     layer_animation_controller_->SetAnimationRegistrar(registrar);
 }
 
 void Layer::AddLayerAnimationEventObserver(
     LayerAnimationEventObserver* animation_observer) {
   DCHECK(layer_animation_controller_);
@@ skipping 102 matching lines @@
           ? layer_tree_host()->meta_information_sequence_number()
           : 0;
 }
 
 bool Layer::sorted_for_recursion() {
   return sorted_for_recursion_tracker_ ==
          layer_tree_host()->meta_information_sequence_number();
 }
 
 }  // namespace cc