StartAnimation: Optimized the search for Animations which is waiting for TargetAvailability

cc/animation/layer_animation_controller.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/animation/layer_animation_controller.h"
 
 #include <algorithm>
 
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_delegate.h"
@@ skipping 584 matching lines @@
       animations_[i]->PushPropertiesTo(current_impl);
   }
 }
 
 void LayerAnimationController::StartAnimations(base::TimeTicks monotonic_time) {
   DCHECK(needs_to_start_animations_);
   needs_to_start_animations_ = false;
   // First collect running properties affecting each type of observer.
   TargetProperties blocked_properties_for_active_observers;
   TargetProperties blocked_properties_for_pending_observers;
+  std::vector<size_t> animations_waiting_for_target_index_;

[ajuma, 2014/07/23 16:02:18]

Calling this |animations_waiting_for_target| seems easier to read.

[shreyas.g, 2014/07/24 10:03:50]

Done.

+  size_t index = 0;
+
+  animations_waiting_for_target_index_.resize(animations_.size());

[ajuma, 2014/07/23 16:02:18]

How about using reserve instead of resize, and then just using push_back to
insert? Then you don't need |index| anymore.

[shreyas.g, 2014/07/24 10:03:50]

Done.

   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::Starting ||
         animations_[i]->run_state() == Animation::Running) {
       if (animations_[i]->affects_active_observers()) {
         blocked_properties_for_active_observers.insert(
             animations_[i]->target_property());
       }
       if (animations_[i]->affects_pending_observers()) {
         blocked_properties_for_pending_observers.insert(
             animations_[i]->target_property());
       }
+    } else if (animations_[i]->run_state() ==
+               Animation::WaitingForTargetAvailability) {
+      animations_waiting_for_target_index_[index++] = i;
     }
   }
 
-  for (size_t i = 0; i < animations_.size(); ++i) {
-    if (animations_[i]->run_state() ==
-        Animation::WaitingForTargetAvailability) {
+  for (size_t i = 0; i < index; ++i) {

[ajuma, 2014/07/23 16:02:18]

With the above suggestion to use |reserve| instead of |resize|, you can use
animations_waiting_for_target.size() here.

[shreyas.g, 2014/07/24 10:03:50]

Done.

       // Collect all properties for animations with the same group id (they
       // should all also be in the list of animations).
+    size_t animIndex = animations_waiting_for_target_index_[i];

[ajuma, 2014/07/23 16:02:18]

nit: animation_index

[shreyas.g, 2014/07/24 10:03:50]

Done.

+    Animation* animation_waiting_for_target = animations_[animIndex];

[ajuma, 2014/07/23 16:02:18]

You still need to check if this animation is actually waiting for target
availability. See the code below that changes run state
(animations_[j]->SetRunState...). It'd be helpful to add a (short) comment
explaining why this re-check is needed.

[shreyas.g, 2014/07/24 10:03:50]

Done.

       TargetProperties enqueued_properties;

[ajuma, 2014/07/23 16:02:18]

Nit: indentation needs to be fixed (just run 'git cl format').

[shreyas.g, 2014/07/24 10:03:50]

Done.

       bool affects_active_observers =
-          animations_[i]->affects_active_observers();
+          animation_waiting_for_target->affects_active_observers();
       bool affects_pending_observers =
-          animations_[i]->affects_pending_observers();
-      enqueued_properties.insert(animations_[i]->target_property());
-      for (size_t j = i + 1; j < animations_.size(); ++j) {
-        if (animations_[i]->group() == animations_[j]->group()) {
+          animation_waiting_for_target->affects_pending_observers();
+      enqueued_properties.insert(
+          animation_waiting_for_target->target_property());
+      for (size_t j = animIndex + 1; j < animations_.size(); ++j) {
+        if (animation_waiting_for_target->group() == animations_[j]->group()) {
           enqueued_properties.insert(animations_[j]->target_property());
           affects_active_observers |=
               animations_[j]->affects_active_observers();
           affects_pending_observers |=
               animations_[j]->affects_pending_observers();
         }
       }
 
       // Check to see if intersection of the list of properties affected by
       // the group and the list of currently blocked properties is null, taking
       // into account the type(s) of observers affected by the group. In any
       // case, the group's target properties need to be added to the lists of
       // blocked properties.
       bool null_intersection = true;
       for (TargetProperties::iterator p_iter = enqueued_properties.begin();
            p_iter != enqueued_properties.end();
            ++p_iter) {
         if (affects_active_observers &&
             !blocked_properties_for_active_observers.insert(*p_iter).second)
           null_intersection = false;
         if (affects_pending_observers &&
             !blocked_properties_for_pending_observers.insert(*p_iter).second)
           null_intersection = false;
       }
 
       // If the intersection is null, then we are free to start the animations
       // in the group.
       if (null_intersection) {
-        animations_[i]->SetRunState(Animation::Starting, monotonic_time);
-        for (size_t j = i + 1; j < animations_.size(); ++j) {
-          if (animations_[i]->group() == animations_[j]->group()) {
+        animation_waiting_for_target->SetRunState(Animation::Starting,
+                                                  monotonic_time);
+        for (size_t j = animIndex + 1; j < animations_.size(); ++j) {
+          if (animation_waiting_for_target->group() ==
+              animations_[j]->group()) {
             animations_[j]->SetRunState(Animation::Starting, monotonic_time);
           }
         }
       } else {
         needs_to_start_animations_ = true;
       }
-    }
   }
 }
 
 void LayerAnimationController::PromoteStartedAnimations(
     base::TimeTicks monotonic_time,
     AnimationEventsVector* events) {
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->run_state() == Animation::Starting &&
         animations_[i]->affects_active_observers()) {
       animations_[i]->SetRunState(Animation::Running, monotonic_time);
@@ skipping 291 matching lines @@
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc