Check animation notify values first while sending notification to Observers

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 347 matching lines @@
   for (size_t i = 0; i < animations_.size(); ++i) {
     if (animations_[i]->group() == event.group_id &&
         animations_[i]->target_property() == event.target_property) {
       animations_[i]->SetRunState(Animation::Aborted, event.monotonic_time);
     }
   }
 }
 
 void LayerAnimationController::NotifyAnimationPropertyUpdate(
     const AnimationEvent& event) {
-  bool notify_active_observers = true;
-  bool notify_pending_observers = true;

[ajuma, 2014/08/05 13:05:57]

These variables act as a form of documentation allowing someone reading this
code to understand what the 'true' arguments being passed below mean. So these
should not be removed.

[shreyas.g, 2014/08/05 13:41:52]

Done. Makes sense. Will keep that in mind for future changes.

   switch (event.target_property) {
     case Animation::Opacity:
-      NotifyObserversOpacityAnimated(
-          event.opacity, notify_active_observers, notify_pending_observers);
+      NotifyObserversOpacityAnimated(event.opacity, true, true);
       break;
     case Animation::Transform:
-      NotifyObserversTransformAnimated(
-          event.transform, notify_active_observers, notify_pending_observers);
+      NotifyObserversTransformAnimated(event.transform, true, true);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void LayerAnimationController::AddValueObserver(
     LayerAnimationValueObserver* observer) {
   if (!value_observers_.HasObserver(observer))
     value_observers_.AddObserver(observer);
@@ skipping 529 matching lines @@
 
 void LayerAnimationController::NotifyObserversOpacityAnimated(
     float opacity,
     bool notify_active_observers,
     bool notify_pending_observers) {
   if (value_observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL) {
-      if ((notify_active_observers && obs->IsActive()) ||
+      if ((notify_active_observers && notify_pending_observers) ||
+          (notify_active_observers && obs->IsActive()) ||
           (notify_pending_observers && !obs->IsActive()))
         obs->OnOpacityAnimated(opacity);
     }
   }
 }
 
 void LayerAnimationController::NotifyObserversTransformAnimated(
     const gfx::Transform& transform,
     bool notify_active_observers,
     bool notify_pending_observers) {
   if (value_observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL) {
-      if ((notify_active_observers && obs->IsActive()) ||
+      if ((notify_active_observers && notify_pending_observers) ||
+          (notify_active_observers && obs->IsActive()) ||
           (notify_pending_observers && !obs->IsActive()))
         obs->OnTransformAnimated(transform);
     }
   }
 }
 
 void LayerAnimationController::NotifyObserversFilterAnimated(
     const FilterOperations& filters,
     bool notify_active_observers,
     bool notify_pending_observers) {
   if (value_observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL) {
-      if ((notify_active_observers && obs->IsActive()) ||
+      if ((notify_active_observers && notify_pending_observers) ||
+          (notify_active_observers && obs->IsActive()) ||
           (notify_pending_observers && !obs->IsActive()))
         obs->OnFilterAnimated(filters);
     }
   }
 }
 
 void LayerAnimationController::NotifyObserversScrollOffsetAnimated(
     const gfx::Vector2dF& scroll_offset,
     bool notify_active_observers,
     bool notify_pending_observers) {
   if (value_observers_.might_have_observers()) {
     ObserverListBase<LayerAnimationValueObserver>::Iterator it(
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL) {
-      if ((notify_active_observers && obs->IsActive()) ||
+      if ((notify_active_observers && notify_pending_observers) ||
+          (notify_active_observers && obs->IsActive()) ||
           (notify_pending_observers && !obs->IsActive()))
         obs->OnScrollOffsetAnimated(scroll_offset);
     }
   }
 }
 
 void LayerAnimationController::NotifyObserversAnimationWaitingForDeletion() {
   FOR_EACH_OBSERVER(LayerAnimationValueObserver,
                     value_observers_,
                     OnAnimationWaitingForDeletion());
@@ skipping 14 matching lines @@
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc