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

cc/test/animation_test_common.cc

 // Copyright 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 "cc/test/animation_test_common.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
@@ skipping 217 matching lines @@
   curve->SetInitialValue(initial_value);
 
   int id = AnimationIdProvider::NextAnimationId();
 
   std::unique_ptr<Animation> animation(Animation::Create(
       std::move(curve), id, AnimationIdProvider::NextGroupId(),
       TargetProperty::SCROLL_OFFSET));
   animation->set_is_impl_only(impl_only);
 
   target->AddAnimation(std::move(animation));
+  target->SetNeedsPushProperties();

[ajuma, 2016/08/24 15:52:37]

Wdyt of making ElementAnimations responsible for setting needs_push_properties
on itself on calls like AddAnimation, rather than making the caller responsible?
That seems more consistent with how needs_push_properties gets set on other
types, and also means we don't need to add these test-only calls to
SetNeedsPushProperties.

[loyso (OOO), 2016/08/25 00:38:24]

ElementAnimations::AddAnimation is a legacy from LAC. I want to move animations_
array (together with Add/Remove etc methods) from ElementAnimation to
AnimationPlayer as a next CL and as a part of http://crbug.com/592873

Overall, we decided with vollick@ that we should make ElementAnimations as small
as possible and hide it eventually.

Also, we must to rewrite ElementAnimations tests to use AnimationPlayer instead
(as a part of http://crbug.com/592873).

Anyway, I can move this SetNeedsPushProperties calls into ElementAnimations
temporarily (so it would be a bit redundant).

What do you think?

[loyso (OOO), 2016/08/25 03:59:02]

Done.

 
   return id;
 }
 
 int AddOpacityTransitionToElementAnimations(ElementAnimations* target,
                                             double duration,
                                             float start_opacity,
                                             float end_opacity,
                                             bool use_timing_function) {
+  target->SetNeedsPushProperties();
   return AddOpacityTransition(target, duration, start_opacity, end_opacity,
                               use_timing_function);
 }
 
 int AddAnimatedTransformToElementAnimations(ElementAnimations* target,
                                             double duration,
                                             int delta_x,
                                             int delta_y) {
+  target->SetNeedsPushProperties();
   return AddAnimatedTransform(target, duration, delta_x, delta_y);
 }
 
 int AddAnimatedFilterToElementAnimations(ElementAnimations* target,
                                          double duration,
                                          float start_brightness,
                                          float end_brightness) {
+  target->SetNeedsPushProperties();
   return AddAnimatedFilter(target, duration, start_brightness, end_brightness);
 }
 
+void AddAnimationToElementAnimations(ElementAnimations* target,
+                                     std::unique_ptr<Animation> animation) {
+  target->SetNeedsPushProperties();
+  target->AddAnimation(std::move(animation));
+}
+
+void RemoveAnimationFromElementAnimations(ElementAnimations* target,
+                                          int animation_id) {
+  target->SetNeedsPushProperties();
+  target->RemoveAnimation(animation_id);
+}
+
+void PauseAnimationInElementAnimations(ElementAnimations* target,
+                                       int animation_id,
+                                       base::TimeDelta time) {
+  target->SetNeedsPushProperties();
+  target->PauseAnimation(animation_id, time);
+}
+
+void AbortAnimationsInElementAnimations(ElementAnimations* target,
+                                        TargetProperty::Type target_property,
+                                        bool needs_completion) {
+  target->SetNeedsPushProperties();
+  target->AbortAnimations(target_property, needs_completion);
+}
+
 int AddAnimatedTransformToPlayer(AnimationPlayer* player,
                                  double duration,
                                  int delta_x,
                                  int delta_y) {
   return AddAnimatedTransform(player, duration, delta_x, delta_y);
 }
 
 int AddAnimatedTransformToPlayer(AnimationPlayer* player,
                                  double duration,
                                  TransformOperations start_operations,
@@ skipping 34 matching lines @@
       base::TimeDelta::FromSecondsD(duration), end_opacity, nullptr));
 
   int id = AnimationIdProvider::NextAnimationId();
 
   std::unique_ptr<Animation> animation(Animation::Create(
       std::move(curve), id, AnimationIdProvider::NextGroupId(),
       TargetProperty::OPACITY));
   animation->set_needs_synchronized_start_time(true);
 
   target->AddAnimation(std::move(animation));
+  target->SetNeedsPushProperties();
+
   return id;
 }
 
 void AddAnimationToElementWithPlayer(ElementId element_id,
                                      scoped_refptr<AnimationTimeline> timeline,
                                      std::unique_ptr<Animation> animation) {
   scoped_refptr<AnimationPlayer> player =
       AnimationPlayer::Create(AnimationIdProvider::NextPlayerId());
   timeline->AttachPlayer(player);
   player->AttachElement(element_id);
   DCHECK(player->element_animations());
   player->AddAnimation(std::move(animation));
 }
 
 void AddAnimationToElementWithExistingPlayer(
     ElementId element_id,
     scoped_refptr<AnimationTimeline> timeline,
     std::unique_ptr<Animation> animation) {
   scoped_refptr<ElementAnimations> element_animations =
       timeline->animation_host()->GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
   element_animations->AddAnimation(std::move(animation));
+  element_animations->SetNeedsPushProperties();
 }
 
 void RemoveAnimationFromElementWithExistingPlayer(
     ElementId element_id,
     scoped_refptr<AnimationTimeline> timeline,
     int animation_id) {
   scoped_refptr<ElementAnimations> element_animations =
       timeline->animation_host()->GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
   element_animations->RemoveAnimation(animation_id);
+  element_animations->SetNeedsPushProperties();
 }
 
 Animation* GetAnimationFromElementWithExistingPlayer(
     ElementId element_id,
     scoped_refptr<AnimationTimeline> timeline,
     int animation_id) {
   scoped_refptr<ElementAnimations> element_animations =
       timeline->animation_host()->GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
   return element_animations->GetAnimationById(animation_id);
@@ skipping 60 matching lines @@
 }
 
 void AbortAnimationsOnElementWithPlayer(
     ElementId element_id,
     scoped_refptr<AnimationTimeline> timeline,
     TargetProperty::Type target_property) {
   scoped_refptr<ElementAnimations> element_animations =
       timeline->animation_host()->GetElementAnimationsForElementId(element_id);
   DCHECK(element_animations);
   element_animations->AbortAnimations(target_property);
+  element_animations->SetNeedsPushProperties();
 }
 
 }  // namespace cc