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

cc/animation/animation_host.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_host.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 25 matching lines @@
   if (thread_instance == ThreadInstance::IMPL)
     animation_host->SetSupportsScrollAnimations(true);
 
   return animation_host;
 }
 
 AnimationHost::AnimationHost(ThreadInstance thread_instance)
     : mutator_host_client_(nullptr),
       thread_instance_(thread_instance),
       supports_scroll_animations_(false),
-      animation_waiting_for_deletion_(false) {
+      needs_push_properties_(false) {
   if (thread_instance_ == ThreadInstance::IMPL) {
     scroll_offset_animations_impl_ =
         base::MakeUnique<ScrollOffsetAnimationsImpl>(this);
   } else {
     scroll_offset_animations_ = base::MakeUnique<ScrollOffsetAnimations>(this);
   }
 }
 
 AnimationHost::~AnimationHost() {
   scroll_offset_animations_impl_ = nullptr;
@@ skipping 27 matching lines @@
   timeline->ClearPlayers();
   timeline->SetAnimationHost(nullptr);
 }
 
 void AnimationHost::AddAnimationTimeline(
     scoped_refptr<AnimationTimeline> timeline) {
   DCHECK(timeline->id());
   timeline->SetAnimationHost(this);
   id_to_timeline_map_.insert(
       std::make_pair(timeline->id(), std::move(timeline)));
+  SetNeedsPushProperties();
 }
 
 void AnimationHost::RemoveAnimationTimeline(
     scoped_refptr<AnimationTimeline> timeline) {
   DCHECK(timeline->id());
   EraseTimeline(timeline);
   id_to_timeline_map_.erase(timeline->id());
+  SetNeedsPushProperties();
 }
 
 void AnimationHost::RegisterElement(ElementId element_id,
                                     ElementListType list_type) {
   scoped_refptr<ElementAnimations> element_animations =
       GetElementAnimationsForElementId(element_id);
   if (element_animations)
     element_animations->ElementRegistered(element_id, list_type);
 }
 
@@ skipping 41 matching lines @@
     UnregisterElementAnimations(element_animations.get());
     element_animations->SetAnimationHost(nullptr);
   }
 }
 
 void AnimationHost::SetMutatorHostClient(MutatorHostClient* client) {
   if (mutator_host_client_ == client)
     return;
 
   mutator_host_client_ = client;
+
+  if (needs_push_properties() && mutator_host_client())
+    SetNeedsPushProperties();
 }
 
 void AnimationHost::SetNeedsCommit() {
   DCHECK(mutator_host_client_);
   mutator_host_client_->SetMutatorsNeedCommit();
-}
-
-void AnimationHost::SetNeedsRebuildPropertyTrees() {
-  DCHECK(mutator_host_client_);
+  // TODO(loyso): Invalidate property trees only if really needed.
   mutator_host_client_->SetMutatorsNeedRebuildPropertyTrees();
 }
 
+void AnimationHost::SetNeedsPushProperties() {
+  needs_push_properties_ = true;
+}
+
 void AnimationHost::PushPropertiesTo(AnimationHost* host_impl) {
-  PushTimelinesToImplThread(host_impl);
-  RemoveTimelinesFromImplThread(host_impl);
-  PushPropertiesToImplThread(host_impl);
-  animation_waiting_for_deletion_ = false;
+  if (needs_push_properties_) {
+    needs_push_properties_ = false;
+    PushTimelinesToImplThread(host_impl);
+    RemoveTimelinesFromImplThread(host_impl);
+    PushPropertiesToImplThread(host_impl);
+    // This is redundant but used in tests.
+    host_impl->needs_push_properties_ = false;
+  }
 }
 
 void AnimationHost::PushTimelinesToImplThread(AnimationHost* host_impl) const {
   for (auto& kv : id_to_timeline_map_) {
     auto& timeline = kv.second;
     AnimationTimeline* timeline_impl =
         host_impl->GetTimelineById(timeline->id());
     if (timeline_impl)
       continue;
 
@@ skipping 16 matching lines @@
       it = timelines_impl.erase(it);
     }
   }
 }
 
 void AnimationHost::PushPropertiesToImplThread(AnimationHost* host_impl) {
   // Sync all players with impl thread to create ElementAnimations. This needs
   // to happen before the element animations are synced below.
   for (auto& kv : id_to_timeline_map_) {
     AnimationTimeline* timeline = kv.second.get();
-    AnimationTimeline* timeline_impl =
-        host_impl->GetTimelineById(timeline->id());
-    if (timeline_impl)
-      timeline->PushPropertiesTo(timeline_impl);
+    if (timeline->needs_push_properties()) {
+      AnimationTimeline* timeline_impl =
+          host_impl->GetTimelineById(timeline->id());
+      if (timeline_impl)
+        timeline->PushPropertiesTo(timeline_impl);
+    }
   }
 
   // Sync properties for created ElementAnimations.
   for (auto& kv : element_to_animations_map_) {
     const auto& element_animations = kv.second;
-    auto element_animations_impl =
-        host_impl->GetElementAnimationsForElementId(kv.first);
-    if (element_animations_impl)
-      element_animations->PushPropertiesTo(std::move(element_animations_impl));
+    if (element_animations->needs_push_properties()) {
+      auto element_animations_impl =
+          host_impl->GetElementAnimationsForElementId(kv.first);
+      if (element_animations_impl)
+        element_animations->PushPropertiesTo(
+            std::move(element_animations_impl));
+    }
   }
 
   // Update the impl-only scroll offset animations.
   scroll_offset_animations_->PushPropertiesTo(
       host_impl->scroll_offset_animations_impl_.get());
 }
 
 scoped_refptr<ElementAnimations>
 AnimationHost::GetElementAnimationsForElementId(ElementId element_id) const {
   if (!element_id)
@@ skipping 326 matching lines @@
 const AnimationHost::ElementToAnimationsMap&
 AnimationHost::active_element_animations_for_testing() const {
   return active_element_to_animations_map_;
 }
 
 const AnimationHost::ElementToAnimationsMap&
 AnimationHost::all_element_animations_for_testing() const {
   return element_to_animations_map_;
 }
 
-void AnimationHost::OnAnimationWaitingForDeletion() {
-  animation_waiting_for_deletion_ = true;
-}
-
 }  // namespace cc