CC Animation: Introduce some dirty flags to optimize PushProperties on commit

cc/animation/animation_player.cc

 // Copyright 2015 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/animation/animation_player.h"
 
 #include <algorithm>
 
 #include "cc/animation/animation_delegate.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/animation/element_animations.h"
 
 namespace cc {
 
 scoped_refptr<AnimationPlayer> AnimationPlayer::Create(int id) {
   return make_scoped_refptr(new AnimationPlayer(id));
 }
 
 AnimationPlayer::AnimationPlayer(int id)
     : animation_host_(),
       animation_timeline_(),
       element_animations_(),
       animation_delegate_(),
-      id_(id) {
+      id_(id),
+      needs_push_properties_(false) {
   DCHECK(id_);
 }
 
 AnimationPlayer::~AnimationPlayer() {
   DCHECK(!animation_timeline_);
   DCHECK(!element_animations_);
 }
 
 scoped_refptr<AnimationPlayer> AnimationPlayer::CreateImplInstance() const {
   scoped_refptr<AnimationPlayer> player = AnimationPlayer::Create(id());
@@ skipping 61 matching lines @@
   animation_host_->UnregisterPlayerForElement(element_id_, this);
 }
 
 void AnimationPlayer::BindElementAnimations() {
   DCHECK(!element_animations_);
   element_animations_ =
       animation_host_->GetElementAnimationsForElementId(element_id_);
   DCHECK(element_animations_);
 
   // Pass all accumulated animations to ElementAnimations.
-  for (auto& animation : animations_) {
+  for (auto& animation : animations_)
     element_animations_->AddAnimation(std::move(animation));
-  }
+
   if (!animations_.empty())
     SetNeedsCommit();
+  SetNeedsPushProperties();
+
   animations_.clear();
 }
 
 void AnimationPlayer::UnbindElementAnimations() {
+  SetNeedsPushProperties();
+
   element_animations_ = nullptr;
   DCHECK(animations_.empty());
 }
 
 void AnimationPlayer::AddAnimation(std::unique_ptr<Animation> animation) {
   DCHECK(animation->target_property() != TargetProperty::SCROLL_OFFSET ||
          (animation_host_ && animation_host_->SupportsScrollAnimations()));
 
   if (element_animations_) {
     element_animations_->AddAnimation(std::move(animation));
     SetNeedsCommit();
+    SetNeedsPushProperties();
   } else {
     animations_.push_back(std::move(animation));
   }
 }
 
 void AnimationPlayer::PauseAnimation(int animation_id, double time_offset) {
   DCHECK(element_animations_);
   element_animations_->PauseAnimation(
       animation_id, base::TimeDelta::FromSecondsD(time_offset));
   SetNeedsCommit();
+  SetNeedsPushProperties();
 }
 
 void AnimationPlayer::RemoveAnimation(int animation_id) {
   if (element_animations_) {
     element_animations_->RemoveAnimation(animation_id);
     SetNeedsCommit();
+    SetNeedsPushProperties();
   } else {
     auto animations_to_remove = std::remove_if(
         animations_.begin(), animations_.end(),
         [animation_id](const std::unique_ptr<Animation>& animation) {
           return animation->id() == animation_id;
         });
     animations_.erase(animations_to_remove, animations_.end());
   }
 }
 
 void AnimationPlayer::AbortAnimation(int animation_id) {
   DCHECK(element_animations_);
   element_animations_->AbortAnimation(animation_id);
   SetNeedsCommit();
+  SetNeedsPushProperties();
 }
 
 void AnimationPlayer::AbortAnimations(TargetProperty::Type target_property,
                                       bool needs_completion) {
   if (element_animations_) {
     element_animations_->AbortAnimations(target_property, needs_completion);
     SetNeedsCommit();
+    SetNeedsPushProperties();
   } else {
     auto animations_to_remove = std::remove_if(
         animations_.begin(), animations_.end(),
         [target_property](const std::unique_ptr<Animation>& animation) {
           return animation->target_property() == target_property;
         });
     animations_.erase(animations_to_remove, animations_.end());
   }
 }
 
 void AnimationPlayer::PushPropertiesTo(AnimationPlayer* player_impl) {
+  if (!needs_push_properties_)
+    return;
+  needs_push_properties_ = false;
+
   if (element_id_ != player_impl->element_id()) {
     if (player_impl->element_id())
       player_impl->DetachElement();
     if (element_id_)
       player_impl->AttachElement(element_id_);
   }
 }
 
 void AnimationPlayer::NotifyAnimationStarted(
     base::TimeTicks monotonic_time,
@@ skipping 15 matching lines @@
 
 void AnimationPlayer::NotifyAnimationAborted(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     int group) {
   if (animation_delegate_)
     animation_delegate_->NotifyAnimationAborted(monotonic_time, target_property,
                                                 group);
 }
 
+void AnimationPlayer::NotifyAnimationWaitingForDeletion() {
+  // We need to purge animations marked for deletion.
+  SetNeedsPushProperties();
+}
+
 void AnimationPlayer::NotifyAnimationTakeover(
     base::TimeTicks monotonic_time,
     TargetProperty::Type target_property,
     double animation_start_time,
     std::unique_ptr<AnimationCurve> curve) {
+  // We need to purge animations marked for deletion on CT.
+  SetNeedsPushProperties();
+
   if (animation_delegate_) {
     DCHECK(curve);
     animation_delegate_->NotifyAnimationTakeover(
         monotonic_time, target_property, animation_start_time,
         std::move(curve));
   }
 }
 
 void AnimationPlayer::SetNeedsCommit() {
   DCHECK(animation_host_);
   animation_host_->SetNeedsCommit();
-  animation_host_->SetNeedsRebuildPropertyTrees();
+}
+
+void AnimationPlayer::SetNeedsPushProperties() {
+  needs_push_properties_ = true;
+
+  DCHECK(animation_timeline_);
+  animation_timeline_->SetNeedsPushProperties();
+
+  DCHECK(element_animations_);
+  element_animations_->SetNeedsPushProperties();
 }
 
 }  // namespace cc