Add monotonic time and target property to cc::AnimationDelegate notifications

cc/trees/layer_tree_host_unittest_animation.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/trees/layer_tree_host.h"
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/scroll_offset_animation_curve.h"
 #include "cc/animation/timing_function.h"
@@ skipping 98 matching lines @@
     LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback);
 
 // Add a layer animation and confirm that
 // LayerTreeHostImpl::updateAnimationState does get called and continues to
 // get called.
 class LayerTreeHostAnimationTestAddAnimation
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAddAnimation()
       : num_animates_(0),
-        received_animation_started_notification_(false),
-        start_time_(0.0) {
+        received_animation_started_notification_(false) {
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   virtual void UpdateAnimationState(
       LayerTreeHostImpl* host_impl,
       bool has_unfinished_animation) OVERRIDE {
     if (!num_animates_) {
       // The animation had zero duration so LayerTreeHostImpl should no
       // longer need to animate its layers.
       EXPECT_FALSE(has_unfinished_animation);
       num_animates_++;
       return;
     }
 
     if (received_animation_started_notification_) {
-      EXPECT_LT(0.0, start_time_);
+      EXPECT_LT(base::TimeTicks(), start_time_);
 
       LayerAnimationController* controller_impl =
           host_impl->active_tree()->root_layer()->layer_animation_controller();
       Animation* animation_impl =
           controller_impl->GetAnimation(Animation::Opacity);
       if (animation_impl)
         controller_impl->RemoveAnimation(animation_impl->id());
 
       EndTest();
     }
   }
 
-  virtual void NotifyAnimationStarted(double wall_clock_time) OVERRIDE {
+  virtual void NotifyAnimationStarted(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     received_animation_started_notification_ = true;
-    start_time_ = wall_clock_time;
+    start_time_ = monotonic_time;
     if (num_animates_) {
-      EXPECT_LT(0.0, start_time_);
+      EXPECT_LT(base::TimeTicks(), start_time_);
 
       LayerAnimationController* controller =
           layer_tree_host()->root_layer()->layer_animation_controller();
       Animation* animation =
           controller->GetAnimation(Animation::Opacity);
       if (animation)
         controller->RemoveAnimation(animation->id());
 
       EndTest();
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_animates_;
   bool received_animation_started_notification_;
-  double start_time_;
+  base::TimeTicks start_time_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAddAnimation);
 
 // Add a layer animation to a layer, but continually fail to draw. Confirm that
 // after a while, we do eventually force a draw.
 class LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestCheckerboardDoesNotStarveDraws()
@@ skipping 48 matching lines @@
         active_animation_controllers().empty();
     if (!started_animating_ && have_animations) {
       started_animating_ = true;
       return;
     }
 
     if (started_animating_ && !have_animations)
       EndTest();
   }
 
-  virtual void NotifyAnimationFinished(double time) OVERRIDE {
+  virtual void NotifyAnimationFinished(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     // Animations on the impl-side controller only get deleted during a commit,
     // so we need to schedule a commit.
     layer_tree_host()->SetNeedsCommit();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   bool started_animating_;
 };
@@ skipping 49 matching lines @@
       : active_tree_was_animated_(false) {}
 
   virtual base::TimeDelta LowFrequencyAnimationInterval() const OVERRIDE {
     return base::TimeDelta::FromMilliseconds(4);
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
-  virtual void NotifyAnimationFinished(double time) OVERRIDE {
+  virtual void NotifyAnimationFinished(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     // Replace animated commits with an empty tree.
     layer_tree_host()->SetRootLayer(make_scoped_refptr<Layer>(NULL));
   }
 
   virtual void DidCommit() OVERRIDE {
     // This alternates setting an empty tree and a non-empty tree with an
     // animation.
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Wait for NotifyAnimationFinished to commit an empty tree.
@@ skipping 169 matching lines @@
     content_ = FakeContentLayer::Create(&client_);
     content_->SetBounds(gfx::Size(4, 4));
     content_->set_layer_animation_delegate(this);
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(content_.get());
   }
 
-  virtual void NotifyAnimationStarted(double time) OVERRIDE {
+  virtual void NotifyAnimationStarted(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->children()[0]->
         layer_animation_controller();
     Animation* animation =
         controller->GetAnimation(Animation::Opacity);
     main_start_time_ = animation->start_time();
     controller->RemoveAnimation(animation->id());
 
     if (impl_start_time_ > 0.0)
       EndTest();
@@ skipping 34 matching lines @@
 // Ensures that notify animation finished is called.
 class LayerTreeHostAnimationTestAnimationFinishedEvents
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimationFinishedEvents() {}
 
   virtual void BeginTest() OVERRIDE {
     PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
-  virtual void NotifyAnimationFinished(double time) OVERRIDE {
+  virtual void NotifyAnimationFinished(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->layer_animation_controller();
     Animation* animation =
         controller->GetAnimation(Animation::Opacity);
     if (animation)
       controller->RemoveAnimation(animation->id());
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ skipping 195 matching lines @@
     content_->SetBounds(gfx::Size(4, 4));
     content_->set_layer_animation_delegate(this);
     layer_tree_host()->root_layer()->AddChild(content_);
   }
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size());
     PostAddAnimationToMainThread(content_.get());
   }
 
-  virtual void NotifyAnimationStarted(double wall_clock_time) OVERRIDE {
+  virtual void NotifyAnimationStarted(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     started_times_++;
   }
 
-  virtual void NotifyAnimationFinished(double wall_clock_time) OVERRIDE {
+  virtual void NotifyAnimationFinished(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {
     EXPECT_EQ(1, started_times_);
   }
 
  private:
   int started_times_;
   FakeContentLayerClient client_;
@@ skipping 21 matching lines @@
   virtual void BeginTest() OVERRIDE {
     visible_ = true;
     PostAddAnimationToMainThread(content_.get());
   }
 
   virtual void DidCommit() OVERRIDE {
     visible_ = false;
     layer_tree_host()->SetVisible(false);
   }
 
-  virtual void NotifyAnimationStarted(double wall_clock_time) OVERRIDE {
+  virtual void NotifyAnimationStarted(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     EXPECT_FALSE(visible_);
     started_times_++;
   }
 
-  virtual void NotifyAnimationFinished(double wall_clock_time) OVERRIDE {
+  virtual void NotifyAnimationFinished(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     EXPECT_FALSE(visible_);
     EXPECT_EQ(1, started_times_);
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   bool visible_;
   int started_times_;
@@ skipping 51 matching lines @@
         added_animations_++;
         break;
       case 2:
         // This second animation will not be drawn so it should not start.
         AddAnimatedTransformToLayer(content_.get(), 0.1, 5, 5);
         added_animations_++;
         break;
     }
   }
 
-  virtual void NotifyAnimationStarted(double wall_clock_time) OVERRIDE {
+  virtual void NotifyAnimationStarted(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     if (TestEnded())
       return;
     started_times_++;
   }
 
-  virtual void NotifyAnimationFinished(double wall_clock_time) OVERRIDE {
+  virtual void NotifyAnimationFinished(
+      double wall_clock_time,
+      base::TimeTicks monotonic_time,
+      Animation::TargetProperty target_property) OVERRIDE {
     // We should be checkerboarding already, but it should still finish the
     // first animation.
     EXPECT_EQ(2, added_animations_);
     finished_times_++;
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {
     // Make sure we tried to draw the second animation but failed.
     EXPECT_LT(0, prevented_draw_);
@@ skipping 62 matching lines @@
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> scroll_layer_;
 };
 
 // SingleThreadProxy doesn't send scroll updates from LayerTreeHostImpl to
 // LayerTreeHost.
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestScrollOffsetChangesArePropagated);
 
 }  // namespace
 }  // namespace cc