Rename Animate as Begin(Main)Frame

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 754 matching lines @@
     impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   virtual void WillBeginImplFrameOnThread(LayerTreeHostImpl* impl,
                                           const BeginFrameArgs& args) OVERRIDE {
     if (impl->pending_tree())
       frame_count_with_pending_tree_++;
 
     if (frame_count_with_pending_tree_ == 1) {
       EXPECT_EQ(first_frame_time_.ToInternalValue(), 0);
-      first_frame_time_ = impl->CurrentFrameTimeTicks();
+      first_frame_time_ = impl->CurrentBeginFrameArgs().frame_time;
     } else if (frame_count_with_pending_tree_ == 2) {
       impl->BlockNotifyReadyToActivateForTesting(false);
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (frame_count_with_pending_tree_ > 1) {
       EXPECT_NE(first_frame_time_.ToInternalValue(), 0);
       EXPECT_NE(first_frame_time_.ToInternalValue(),
-                impl->CurrentFrameTimeTicks().ToInternalValue());
+                impl->CurrentBeginFrameArgs().frame_time.ToInternalValue());
       EndTest();
       return;
     }
 
     EXPECT_FALSE(impl->settings().impl_side_painting);
     EndTest();
   }
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (impl->settings().impl_side_painting)
       EXPECT_NE(frame_count_with_pending_tree_, 1);
@@ skipping 18 matching lines @@
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     frame_++;
     if (frame_ == 1) {
-      first_frame_time_ = impl->CurrentFrameTimeTicks();
+      first_frame_time_ = impl->CurrentBeginFrameArgs().frame_time;
       impl->SetNeedsRedraw();
 
       // Since we might use a low-resolution clock on Windows, we need to
       // make sure that the clock has incremented past first_frame_time_.
       while (first_frame_time_ == gfx::FrameTime::Now()) {
       }
 
       return;
     }
 
-    EXPECT_NE(first_frame_time_, impl->CurrentFrameTimeTicks());
+    EXPECT_NE(first_frame_time_, impl->CurrentBeginFrameArgs().frame_time);
     EndTest();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     // Ensure there isn't a commit between the two draws, to ensure that a
     // commit isn't required for updating the current frame time. We can
     // only check for this in the multi-threaded case, since in the single-
     // threaded case there will always be a commit between consecutive draws.
     if (HasImplThread())
       EXPECT_EQ(0, frame_);
@@ skipping 4081 matching lines @@
     double milliseconds_per_frame =
         1000 / layer_tree_host()->settings().refresh_rate;
     EndTestAfterDelay(50 * kExpectedNumCommits * milliseconds_per_frame);
     MainThreadTaskRunner()->PostTask(
         FROM_HERE,
         base::Bind(
             &LayerTreeHostTestContinuousPainting::EnableContinuousPainting,
             base::Unretained(this)));
   }
 
-  virtual void Animate(base::TimeTicks monotonic_time) OVERRIDE {
+  virtual void BeginMainFrame(const BeginFrameArgs& args) OVERRIDE {
     child_layer_->SetNeedsDisplay();
   }
 
   virtual void AfterTest() OVERRIDE {
     EXPECT_LE(kExpectedNumCommits, num_commits_);
     EXPECT_LE(kExpectedNumCommits, num_draws_);
     int update_count = content_layer_ ? content_layer_->PaintContentsCount()
                                       : picture_layer_->update_count();
     EXPECT_LE(kExpectedNumCommits, update_count);
   }
@@ skipping 19 matching lines @@
   const gfx::Size bounds_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayerWithUpdateTracking> content_layer_;
   scoped_refptr<FakePictureLayer> picture_layer_;
   Layer* child_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousPainting);
 
 }  // namespace cc