Rename Animate as Begin(Main)Frame

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 21 matching lines @@
 class LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSetNeedsAnimateShouldNotSetCommitRequested()
       : num_commits_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void Animate(base::TimeTicks monotonic_time) OVERRIDE {
-    // We skip the first commit becasue its the commit that populates the
+  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+    // We skip the first commit because its the commit that populates the
     // impl thread with a tree. After the second commit, the test is done.
     if (num_commits_ != 1)
       return;
 
     layer_tree_host()->SetNeedsAnimate();
     // Right now, CommitRequested is going to be true, because during
     // BeginFrame, we force CommitRequested to true to prevent requests from
     // hitting the impl thread. But, when the next DidCommit happens, we should
     // verify that CommitRequested has gone back to false.
   }
@@ skipping 23 matching lines @@
 
 // Trigger a frame with SetNeedsCommit. Then, inside the resulting animate
 // callback, request another frame using SetNeedsAnimate. End the test when
 // animate gets called yet-again, indicating that the proxy is correctly
 // handling the case where SetNeedsAnimate() is called inside the BeginFrame
 // flow.
 class LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestSetNeedsAnimateInsideAnimationCallback()
-      : num_animates_(0) {}
+      : num_begin_frames_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void Animate(base::TimeTicks) OVERRIDE {
-    if (!num_animates_) {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+    if (!num_begin_frames_) {
       layer_tree_host()->SetNeedsAnimate();
-      num_animates_++;
+      num_begin_frames_++;
       return;
     }
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
-  int num_animates_;
+  int num_begin_frames_;
 };
 
 MULTI_THREAD_TEST_F(
     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) {
-  }
+      : num_begin_frames_(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_) {
+    if (!num_begin_frames_) {
       // The animation had zero duration so LayerTreeHostImpl should no
       // longer need to animate its layers.
       EXPECT_FALSE(has_unfinished_animation);
-      num_animates_++;
+      num_begin_frames_++;
       return;
     }
 
     if (received_animation_started_notification_) {
       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(
       base::TimeTicks monotonic_time,
       Animation::TargetProperty target_property) OVERRIDE {
     received_animation_started_notification_ = true;
     start_time_ = monotonic_time;
-    if (num_animates_) {
+    if (num_begin_frames_) {
       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_;
+  int num_begin_frames_;
   bool received_animation_started_notification_;
   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 {
@@ skipping 71 matching lines @@
   bool started_animating_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestAnimationsGetDeleted);
 
 // Ensures that animations continue to be ticked when we are backgrounded.
 class LayerTreeHostAnimationTestTickAnimationWhileBackgrounded
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestTickAnimationWhileBackgrounded()
-      : num_animates_(0) {}
+      : num_begin_frames_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     PostAddLongAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   // Use WillAnimateLayers to set visible false before the animation runs and
   // causes a commit, so we block the second visible animate in single-thread
   // mode.
   virtual void WillAnimateLayers(
       LayerTreeHostImpl* host_impl,
       base::TimeTicks monotonic_time) OVERRIDE {
     // Verify that the host can draw, it's just not visible.
     EXPECT_TRUE(host_impl->CanDraw());
-    if (num_animates_ < 2) {
-      if (!num_animates_) {
+    if (num_begin_frames_ < 2) {
+      if (!num_begin_frames_) {
         // We have a long animation running. It should continue to tick even
         // if we are not visible.
         PostSetVisibleToMainThread(false);
       }
-      num_animates_++;
+      num_begin_frames_++;
       return;
     }
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
-  int num_animates_;
+  int num_begin_frames_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestTickAnimationWhileBackgrounded);
 
 // Ensures that animation time remains monotonic when we switch from foreground
 // to background ticking and back, even if we're skipping draws due to
 // checkerboarding when in the foreground.
 class LayerTreeHostAnimationTestAnimationTickTimeIsMonotonic
     : public LayerTreeHostAnimationTest {
@@ skipping 414 matching lines @@
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestLayerAddedWithAnimation);
 
 class LayerTreeHostAnimationTestCancelAnimateCommit
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestCancelAnimateCommit()
-      : num_animate_calls_(0), num_commit_calls_(0), num_draw_calls_(0) {}
+      : num_begin_frames_(0), num_commit_calls_(0), num_draw_calls_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual void Animate(base::TimeTicks) OVERRIDE {
-    num_animate_calls_++;
+  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+    num_begin_frames_++;
     // No-op animate will cancel the commit.
     if (layer_tree_host()->source_frame_number() == 1) {
       EndTest();
       return;
     }
     layer_tree_host()->SetNeedsAnimate();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_commit_calls_++;
     if (impl->active_tree()->source_frame_number() > 1)
       FAIL() << "Commit should have been canceled.";
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_draw_calls_++;
     if (impl->active_tree()->source_frame_number() > 1)
       FAIL() << "Draw should have been canceled.";
   }
 
   virtual void AfterTest() OVERRIDE {
-    EXPECT_EQ(2, num_animate_calls_);
+    EXPECT_EQ(2, num_begin_frames_);
     EXPECT_EQ(1, num_commit_calls_);
     EXPECT_EQ(1, num_draw_calls_);
   }
 
  private:
-  int num_animate_calls_;
+  int num_begin_frames_;
   int num_commit_calls_;
   int num_draw_calls_;
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> content_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestCancelAnimateCommit);
 
 class LayerTreeHostAnimationTestForceRedraw
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestForceRedraw()
       : num_animate_(0), num_draw_layers_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual void Animate(base::TimeTicks) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
     if (++num_animate_ < 2)
       layer_tree_host()->SetNeedsAnimate();
   }
 
   virtual void Layout() OVERRIDE {
     layer_tree_host()->SetNextCommitForcesRedraw();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (++num_draw_layers_ == 2)
@@ skipping 15 matching lines @@
 MULTI_THREAD_TEST_F(LayerTreeHostAnimationTestForceRedraw);
 
 class LayerTreeHostAnimationTestAnimateAfterSetNeedsCommit
     : public LayerTreeHostAnimationTest {
  public:
   LayerTreeHostAnimationTestAnimateAfterSetNeedsCommit()
       : num_animate_(0), num_draw_layers_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual void Animate(base::TimeTicks) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
     if (++num_animate_ <= 2) {
       layer_tree_host()->SetNeedsCommit();
       layer_tree_host()->SetNeedsAnimate();
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (++num_draw_layers_ == 2)
       EndTest();
   }
@@ skipping 259 matching lines @@
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     // Make sure that drawing many times doesn't cause a checkerboarded
     // animation to start so we avoid flake in this test.
     settings->timeout_and_draw_when_animation_checkerboards = false;
   }
 
   virtual void BeginTest() OVERRIDE {
     PostAddAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
-  virtual void Animate(base::TimeTicks monotonic_time) OVERRIDE {
-    last_main_thread_tick_time_ = monotonic_time;
+  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
+    last_main_thread_tick_time_ = args.frame_time;
   }
 
   virtual void AnimateLayers(LayerTreeHostImpl* host_impl,
                              base::TimeTicks monotonic_time) OVERRIDE {
     if (TestEnded())
       return;
     if (!started_animating_) {
       started_animating_ = true;
       expected_impl_tick_time_ = monotonic_time;
     } else {
@@ skipping 179 matching lines @@
  private:
   scoped_refptr<Layer> content_;
   int num_swap_buffers_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAddAnimationAfterAnimating);
 
 }  // namespace
 }  // namespace cc