Remove wall time from NotifyAnimationStarted and NotifyAnimationFinished.

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 262 matching lines @@
     registrar_->UnregisterAnimationController(this);
 
   registrar_ = registrar;
   if (registrar_)
     registrar_->RegisterAnimationController(this);
 
   UpdateActivation(ForceActivation);
 }
 
 void LayerAnimationController::NotifyAnimationStarted(
-    const AnimationEvent& event,
-    double wall_clock_time) {
+    const AnimationEvent& event) {
   base::TimeTicks monotonic_time = base::TimeTicks::FromInternalValue(
       event.monotonic_time * base::Time::kMicrosecondsPerSecond);
   if (event.is_impl_only) {
     FOR_EACH_OBSERVER(LayerAnimationEventObserver, event_observers_,
                       OnAnimationStarted(event));
     if (layer_animation_delegate_)
-      layer_animation_delegate_->NotifyAnimationStarted(
-          wall_clock_time, monotonic_time, event.target_property);
+      layer_animation_delegate_->NotifyAnimationStarted(monotonic_time,
+                                                        event.target_property);
 
     return;
   }
 
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->group() == event.group_id &&
         active_animations_[i]->target_property() == event.target_property &&
         active_animations_[i]->needs_synchronized_start_time()) {
       active_animations_[i]->set_needs_synchronized_start_time(false);
       active_animations_[i]->set_start_time(event.monotonic_time);
 
       FOR_EACH_OBSERVER(LayerAnimationEventObserver, event_observers_,
                         OnAnimationStarted(event));
       if (layer_animation_delegate_)
         layer_animation_delegate_->NotifyAnimationStarted(
-            wall_clock_time, monotonic_time, event.target_property);
+            monotonic_time, event.target_property);
 
       return;
     }
   }
 }
 
 void LayerAnimationController::NotifyAnimationFinished(
-    const AnimationEvent& event,
-    double wall_clock_time) {
+    const AnimationEvent& event) {
   base::TimeTicks monotonic_time = base::TimeTicks::FromInternalValue(
       event.monotonic_time * base::Time::kMicrosecondsPerSecond);
   if (event.is_impl_only) {
     if (layer_animation_delegate_)
-      layer_animation_delegate_->NotifyAnimationFinished(
-          wall_clock_time, monotonic_time, event.target_property);
+      layer_animation_delegate_->NotifyAnimationFinished(monotonic_time,
+                                                         event.target_property);
     return;
   }
 
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->group() == event.group_id &&
         active_animations_[i]->target_property() == event.target_property) {
       active_animations_[i]->set_received_finished_event(true);
       if (layer_animation_delegate_)
         layer_animation_delegate_->NotifyAnimationFinished(
-            wall_clock_time, monotonic_time, event.target_property);
+            monotonic_time, event.target_property);
 
       return;
     }
   }
 }
 
 void LayerAnimationController::NotifyAnimationAborted(
     const AnimationEvent& event) {
   for (size_t i = 0; i < active_animations_.size(); ++i) {
     if (active_animations_[i]->group() == event.group_id &&
@@ skipping 481 matching lines @@
         value_observers_);
     LayerAnimationValueObserver* obs;
     while ((obs = it.GetNext()) != NULL)
       if (obs->IsActive())
         return true;
   }
   return false;
 }
 
 }  // namespace cc