Consistancy in AccumulatePropertyUpdates for Animation Computation

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 134 matching lines @@
       continue;
 
     double trimmed = animation->TrimTimeToCurrentIteration(monotonic_time);
     switch (animation->target_property()) {
       case Animation::Opacity: {
         AnimationEvent event(AnimationEvent::PropertyUpdate,
                              id_,
                              animation->group(),
                              Animation::Opacity,
                              monotonic_time);
-        event.opacity = animation->curve()->ToFloatAnimationCurve()->GetValue(
-            trimmed);
+        const FloatAnimationCurve* float_animation_curve =
+            animation->curve()->ToFloatAnimationCurve();
+        event.opacity = float_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
         events->push_back(event);
         break;
       }
 
       case Animation::Transform: {
         AnimationEvent event(AnimationEvent::PropertyUpdate,
                              id_,
                              animation->group(),
                              Animation::Transform,
                              monotonic_time);
-        event.transform =
-            animation->curve()->ToTransformAnimationCurve()->GetValue(trimmed);
+        const TransformAnimationCurve* transform_animation_curve =
+            animation->curve()->ToTransformAnimationCurve();
+        event.transform = transform_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
         events->push_back(event);
         break;
       }
 
       case Animation::Filter: {
         AnimationEvent event(AnimationEvent::PropertyUpdate,
                              id_,
                              animation->group(),
                              Animation::Filter,
                              monotonic_time);
-        event.filters = animation->curve()->ToFilterAnimationCurve()->GetValue(
-            trimmed);
+        const FilterAnimationCurve* filter_animation_curve =
+            animation->curve()->ToFilterAnimationCurve();
+        event.filters = filter_animation_curve->GetValue(trimmed);
         event.is_impl_only = true;
         events->push_back(event);
         break;
       }
 
       case Animation::BackgroundColor: { break; }
 
       case Animation::ScrollOffset: {
         // Impl-side changes to scroll offset are already sent back to the
         // main thread (e.g. for user-driven scrolling), so a PropertyUpdate
@@ skipping 807 matching lines @@
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc