cc: Move animate steps from proxies to LayerTreeHostImpl.

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 154 matching lines @@
   virtual bool CreateHostImpl(const LayerTreeSettings& settings,
                               scoped_ptr<OutputSurface> output_surface) {
     host_impl_ = LayerTreeHostImpl::Create(
         settings, this, &proxy_, &stats_instrumentation_,
         &shared_bitmap_manager_, &gpu_memory_buffer_manager_,
         &task_graph_runner_, 0);
     bool init = host_impl_->InitializeRenderer(output_surface.Pass());
     host_impl_->SetViewportSize(gfx::Size(10, 10));
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
     // Set the BeginFrameArgs so that methods which use it are able to.
-    host_impl_->WillBeginImplFrame(
-        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
+    host_impl_->WillBeginImplFrame(CreateBeginFrameArgsForTesting(
+        BEGINFRAME_FROM_HERE,
+        base::TimeTicks() + base::TimeDelta::FromMilliseconds(1)));
+    host_impl_->DidFinishImplFrame();
     return init;
   }
 
   void SetupRootLayerImpl(scoped_ptr<LayerImpl> root) {
     root->SetPosition(gfx::PointF());
     root->SetBounds(gfx::Size(10, 10));
     root->SetDrawsContent(true);
     root->draw_properties().visible_layer_rect = gfx::Rect(0, 0, 10, 10);
     root->SetHasRenderSurface(true);
     host_impl_->active_tree()->SetRootLayer(root.Pass());
@@ skipping 1453 matching lines @@
   DCHECK(scroll_layer);
 
   float min_page_scale = 0.5f;
   float max_page_scale = 4.f;
   base::TimeTicks start_time = base::TimeTicks() +
                                base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
 
+  BeginFrameArgs begin_frame_args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
+
   // Non-anchor zoom-in
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
     scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
 
     did_request_redraw_ = false;
     did_request_animate_ = false;
     host_impl_->active_tree()->SetPendingPageScaleAnimation(
         scoped_ptr<PendingPageScaleAnimation>(new PendingPageScaleAnimation(
             gfx::Vector2d(),
             false,
             2.f,
             duration)));
     host_impl_->ActivateSyncTree();
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_TRUE(did_request_animate_);
 
     did_request_redraw_ = false;
     did_request_animate_ = false;
-    host_impl_->Animate(start_time);
+    begin_frame_args.frame_time = start_time;
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
     EXPECT_TRUE(did_request_redraw_);
     EXPECT_TRUE(did_request_animate_);
+    host_impl_->DidFinishImplFrame();
 
     did_request_redraw_ = false;
     did_request_animate_ = false;
-    host_impl_->Animate(halfway_through_animation);
+    begin_frame_args.frame_time = halfway_through_animation;
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
     EXPECT_TRUE(did_request_redraw_);
     EXPECT_TRUE(did_request_animate_);
+    host_impl_->DidFinishImplFrame();
 
     did_request_redraw_ = false;
     did_request_animate_ = false;
     did_request_commit_ = false;
-    host_impl_->Animate(end_time);
+    begin_frame_args.frame_time = end_time;
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
     EXPECT_TRUE(did_request_commit_);
     EXPECT_FALSE(did_request_animate_);
+    host_impl_->DidFinishImplFrame();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, 2);
     EXPECT_TRUE(ScrollInfoContains(*scroll_info, scroll_layer->id(),
                                    gfx::Vector2d(-50, -50)));
   }
 
+  start_time += base::TimeDelta::FromSeconds(10);
+  halfway_through_animation += base::TimeDelta::FromSeconds(10);
+  end_time += base::TimeDelta::FromSeconds(10);
+
   // Anchor zoom-out
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
     scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
 
     did_request_redraw_ = false;
     did_request_animate_ = false;
     host_impl_->active_tree()->SetPendingPageScaleAnimation(
         scoped_ptr<PendingPageScaleAnimation> (new PendingPageScaleAnimation(
             gfx::Vector2d(25, 25),
             true,
             min_page_scale,
             duration)));
     host_impl_->ActivateSyncTree();
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_TRUE(did_request_animate_);
 
     did_request_redraw_ = false;
     did_request_animate_ = false;
-    host_impl_->Animate(start_time);
+    begin_frame_args.frame_time = start_time;
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
     EXPECT_TRUE(did_request_redraw_);
     EXPECT_TRUE(did_request_animate_);
+    host_impl_->DidFinishImplFrame();
 
     did_request_redraw_ = false;
     did_request_commit_ = false;
     did_request_animate_ = false;
-    host_impl_->Animate(end_time);
+    begin_frame_args.frame_time = end_time;
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
     EXPECT_TRUE(did_request_redraw_);
     EXPECT_FALSE(did_request_animate_);
     EXPECT_TRUE(did_request_commit_);
+    host_impl_->DidFinishImplFrame();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, min_page_scale);
     // Pushed to (0,0) via clamping against contents layer size.
     EXPECT_TRUE(ScrollInfoContains(*scroll_info, scroll_layer->id(),
                                    gfx::Vector2d(-50, -50)));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, PageScaleAnimationNoOp) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
   LayerImpl* scroll_layer = host_impl_->InnerViewportScrollLayer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 0.5f;
   float max_page_scale = 4.f;
   base::TimeTicks start_time = base::TimeTicks() +
                                base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
 
+  BeginFrameArgs begin_frame_args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
+
   // Anchor zoom with unchanged page scale should not change scroll or scale.
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
     scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
 
     host_impl_->active_tree()->SetPendingPageScaleAnimation(
         scoped_ptr<PendingPageScaleAnimation>(new PendingPageScaleAnimation(
             gfx::Vector2d(),
             true,
             1.f,
             duration)));
     host_impl_->ActivateSyncTree();
-    host_impl_->Animate(start_time);
-    host_impl_->Animate(halfway_through_animation);
+    begin_frame_args.frame_time = start_time;
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
+    host_impl_->DidFinishImplFrame();
+
+    begin_frame_args.frame_time = halfway_through_animation;
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
     EXPECT_TRUE(did_request_redraw_);
-    host_impl_->Animate(end_time);
+    host_impl_->DidFinishImplFrame();
+
+    begin_frame_args.frame_time = end_time;
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
     EXPECT_TRUE(did_request_commit_);
+    host_impl_->DidFinishImplFrame();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, 1);
     ExpectNone(*scroll_info, scroll_layer->id());
   }
 }
 
 TEST_F(LayerTreeHostImplTest, PageScaleAnimationTransferedOnSyncTreeActivate) {
   host_impl_->CreatePendingTree();
@@ skipping 14 matching lines @@
   host_impl_->ActivateSyncTree();
 
   base::TimeTicks start_time = base::TimeTicks() +
                                base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
   base::TimeTicks third_through_animation = start_time + duration / 3;
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
   float target_scale = 2.f;
 
+  BeginFrameArgs begin_frame_args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
+
   scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
 
   // Make sure TakePageScaleAnimation works properly.
 
   host_impl_->sync_tree()->SetPendingPageScaleAnimation(
       scoped_ptr<PendingPageScaleAnimation>(new PendingPageScaleAnimation(
           gfx::Vector2d(),
           false,
           target_scale,
           duration)));
   scoped_ptr<PendingPageScaleAnimation> psa =
       host_impl_->sync_tree()->TakePendingPageScaleAnimation();
   EXPECT_EQ(target_scale, psa->scale);
   EXPECT_EQ(duration, psa->duration);
   EXPECT_EQ(nullptr, host_impl_->sync_tree()->TakePendingPageScaleAnimation());
 
   // Recreate the PSA. Nothing should happen here since the tree containing the
   // PSA hasn't been activated yet.
   did_request_redraw_ = false;
   did_request_animate_ = false;
   host_impl_->sync_tree()->SetPendingPageScaleAnimation(
       scoped_ptr<PendingPageScaleAnimation>(new PendingPageScaleAnimation(
           gfx::Vector2d(),
           false,
           target_scale,
           duration)));
-  host_impl_->Animate(halfway_through_animation);
+  begin_frame_args.frame_time = halfway_through_animation;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   EXPECT_FALSE(did_request_animate_);
   EXPECT_FALSE(did_request_redraw_);
+  host_impl_->DidFinishImplFrame();
 
   // Activate the sync tree. This should cause the animation to become enabled.
   // It should also clear the pointer on the sync tree.
   host_impl_->ActivateSyncTree();
   EXPECT_EQ(nullptr,
       host_impl_->sync_tree()->TakePendingPageScaleAnimation().get());
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_TRUE(did_request_animate_);
 
+  start_time += base::TimeDelta::FromSeconds(10);
+  third_through_animation += base::TimeDelta::FromSeconds(10);
+  halfway_through_animation += base::TimeDelta::FromSeconds(10);
+  end_time += base::TimeDelta::FromSeconds(10);
+
   // From here on, make sure the animation runs as normal.
   did_request_redraw_ = false;
   did_request_animate_ = false;
-  host_impl_->Animate(start_time);
+  begin_frame_args.frame_time = start_time;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_animate_);
+  host_impl_->DidFinishImplFrame();
 
   did_request_redraw_ = false;
   did_request_animate_ = false;
-  host_impl_->Animate(third_through_animation);
+  begin_frame_args.frame_time = third_through_animation;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_animate_);
+  host_impl_->DidFinishImplFrame();
 
   // Another activation shouldn't have any effect on the animation.
   host_impl_->ActivateSyncTree();
 
   did_request_redraw_ = false;
   did_request_animate_ = false;
-  host_impl_->Animate(halfway_through_animation);
+  begin_frame_args.frame_time = halfway_through_animation;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_animate_);
+  host_impl_->DidFinishImplFrame();
 
   did_request_redraw_ = false;
   did_request_animate_ = false;
   did_request_commit_ = false;
-  host_impl_->Animate(end_time);
+  begin_frame_args.frame_time = end_time;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   EXPECT_TRUE(did_request_commit_);
   EXPECT_FALSE(did_request_animate_);
+  host_impl_->DidFinishImplFrame();
 
   scoped_ptr<ScrollAndScaleSet> scroll_info =
       host_impl_->ProcessScrollDeltas();
   EXPECT_EQ(scroll_info->page_scale_delta, target_scale);
   EXPECT_TRUE(ScrollInfoContains(*scroll_info, scroll_layer->id(),
                                  gfx::Vector2d(-50, -50)));
 }
 
 TEST_F(LayerTreeHostImplTest, PageScaleAnimationCompletedNotification) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
   LayerImpl* scroll_layer = host_impl_->InnerViewportScrollLayer();
   DCHECK(scroll_layer);
 
   base::TimeTicks start_time =
       base::TimeTicks() + base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
 
+  BeginFrameArgs begin_frame_args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
+
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 4.f);
   scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(50, 50));
 
   did_complete_page_scale_animation_ = false;
   host_impl_->active_tree()->SetPendingPageScaleAnimation(
       scoped_ptr<PendingPageScaleAnimation>(new PendingPageScaleAnimation(
           gfx::Vector2d(), false, 2.f, duration)));
   host_impl_->ActivateSyncTree();
-  host_impl_->Animate(start_time);
+  begin_frame_args.frame_time = start_time;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   EXPECT_FALSE(did_complete_page_scale_animation_);
+  host_impl_->DidFinishImplFrame();
 
-  host_impl_->Animate(halfway_through_animation);
+  begin_frame_args.frame_time = halfway_through_animation;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   EXPECT_FALSE(did_complete_page_scale_animation_);
+  host_impl_->DidFinishImplFrame();
 
-  host_impl_->Animate(end_time);
+  begin_frame_args.frame_time = end_time;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   EXPECT_TRUE(did_complete_page_scale_animation_);
+  host_impl_->DidFinishImplFrame();
 }
 
 class LayerTreeHostImplOverridePhysicalTime : public LayerTreeHostImpl {
  public:
   LayerTreeHostImplOverridePhysicalTime(
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* client,
       Proxy* proxy,
       SharedBitmapManager* manager,
       TaskGraphRunner* task_graph_runner,
@@ skipping 93 matching lines @@
 
     fake_now += requested_animation_delay_;
     requested_animation_delay_ = base::TimeDelta();
     animation_task_.Run();
     animation_task_ = base::Closure();
     EXPECT_TRUE(did_request_animate_);
     did_request_animate_ = false;
     EXPECT_FALSE(did_request_redraw_);
 
     // After the scrollbar animation begins, we should start getting redraws.
-    host_impl_->Animate(fake_now);
+    BeginFrameArgs begin_frame_args =
+        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, fake_now);
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
     EXPECT_TRUE(did_request_animate_);
     did_request_animate_ = false;
     EXPECT_TRUE(did_request_redraw_);
     did_request_redraw_ = false;
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
     EXPECT_TRUE(animation_task_.Equals(base::Closure()));
+    host_impl_->DidFinishImplFrame();
 
     // Setting the scroll offset outside a scroll should also cause the
     // scrollbar to appear and to schedule a scrollbar animation.
     host_impl_->InnerViewportScrollLayer()->PushScrollOffsetFromMainThread(
         gfx::ScrollOffset(5, 5));
     EXPECT_FALSE(did_request_animate_);
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
               requested_animation_delay_);
     EXPECT_FALSE(animation_task_.Equals(base::Closure()));
@@ skipping 4968 matching lines @@
 
  protected:
   static const int top_controls_height_;
 };
 
 const int LayerTreeHostImplWithTopControlsTest::top_controls_height_ = 50;
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, NoIdleAnimations) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100))
       ->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 10));
-  host_impl_->Animate(base::TimeTicks());
+  BeginFrameArgs begin_frame_args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   EXPECT_FALSE(did_request_redraw_);
+  host_impl_->DidFinishImplFrame();
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsHeightIsCommitted) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   EXPECT_FALSE(did_request_redraw_);
   host_impl_->CreatePendingTree();
   host_impl_->sync_tree()->set_top_controls_height(100);
   host_impl_->ActivateSyncTree();
   EXPECT_EQ(100, host_impl_->top_controls_manager()->TopControlsHeight());
 }
@@ skipping 148 matching lines @@
 
   // End the scroll while the controls are still offset from their limit.
   host_impl_->ScrollEnd();
   ASSERT_TRUE(host_impl_->top_controls_manager()->animation());
   EXPECT_TRUE(did_request_animate_);
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 
   // The top controls should properly animate until finished, despite the scroll
   // offset being at the origin.
-  base::TimeTicks animation_time = base::TimeTicks::Now();
+  BeginFrameArgs begin_frame_args = CreateBeginFrameArgsForTesting(
+      BEGINFRAME_FROM_HERE, base::TimeTicks::Now());
   while (did_request_animate_) {
     did_request_redraw_ = false;
     did_request_animate_ = false;
     did_request_commit_ = false;
 
     float old_offset =
         host_impl_->top_controls_manager()->ControlsTopOffset();
 
-    animation_time += base::TimeDelta::FromMilliseconds(5);
-    host_impl_->Animate(animation_time);
+    begin_frame_args.frame_time += base::TimeDelta::FromMilliseconds(5);
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
     EXPECT_EQ(gfx::Vector2dF().ToString(),
               scroll_layer->CurrentScrollOffset().ToString());
 
     float new_offset =
         host_impl_->top_controls_manager()->ControlsTopOffset();
 
     // No commit is needed as the controls are animating the content offset,
     // not the scroll offset.
     EXPECT_FALSE(did_request_commit_);
 
     if (new_offset != old_offset)
       EXPECT_TRUE(did_request_redraw_);
 
     if (new_offset != 0) {
       EXPECT_TRUE(host_impl_->top_controls_manager()->animation());
       EXPECT_TRUE(did_request_animate_);
     }
+    host_impl_->DidFinishImplFrame();
   }
   EXPECT_FALSE(host_impl_->top_controls_manager()->animation());
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsAnimationAfterScroll) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
   host_impl_->top_controls_manager()->UpdateTopControlsState(
       BOTH, SHOWN, false);
   float initial_scroll_offset = 50;
@@ skipping 22 matching lines @@
   did_request_commit_ = false;
 
   // End the scroll while the controls are still offset from the limit.
   host_impl_->ScrollEnd();
   ASSERT_TRUE(host_impl_->top_controls_manager()->animation());
   EXPECT_TRUE(did_request_animate_);
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 
   // Animate the top controls to the limit.
-  base::TimeTicks animation_time = base::TimeTicks::Now();
+  BeginFrameArgs begin_frame_args = CreateBeginFrameArgsForTesting(
+      BEGINFRAME_FROM_HERE, base::TimeTicks::Now());
   while (did_request_animate_) {
     did_request_redraw_ = false;
     did_request_animate_ = false;
     did_request_commit_ = false;
 
     float old_offset =
         host_impl_->top_controls_manager()->ControlsTopOffset();
 
-    animation_time += base::TimeDelta::FromMilliseconds(5);
-    host_impl_->Animate(animation_time);
+    begin_frame_args.frame_time += base::TimeDelta::FromMilliseconds(5);
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
 
     float new_offset =
         host_impl_->top_controls_manager()->ControlsTopOffset();
 
     if (new_offset != old_offset) {
       EXPECT_TRUE(did_request_redraw_);
       EXPECT_TRUE(did_request_commit_);
     }
+    host_impl_->DidFinishImplFrame();
   }
   EXPECT_FALSE(host_impl_->top_controls_manager()->animation());
   EXPECT_EQ(-top_controls_height_,
             host_impl_->top_controls_manager()->ControlsTopOffset());
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest,
        TopControlsAnimationAfterMainThreadFlingStopped) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
@@ skipping 25 matching lines @@
   did_request_commit_ = false;
 
   // End the fling while the controls are still offset from the limit.
   host_impl_->MainThreadHasStoppedFlinging();
   ASSERT_TRUE(host_impl_->top_controls_manager()->animation());
   EXPECT_TRUE(did_request_animate_);
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 
   // Animate the top controls to the limit.
-  base::TimeTicks animation_time = base::TimeTicks::Now();
+  BeginFrameArgs begin_frame_args = CreateBeginFrameArgsForTesting(
+      BEGINFRAME_FROM_HERE, base::TimeTicks::Now());
   while (did_request_animate_) {
     did_request_redraw_ = false;
     did_request_animate_ = false;
     did_request_commit_ = false;
 
     float old_offset = host_impl_->top_controls_manager()->ControlsTopOffset();
 
-    animation_time += base::TimeDelta::FromMilliseconds(5);
-    host_impl_->Animate(animation_time);
+    begin_frame_args.frame_time += base::TimeDelta::FromMilliseconds(5);
+    host_impl_->WillBeginImplFrame(begin_frame_args);
+    host_impl_->Animate();
 
     float new_offset = host_impl_->top_controls_manager()->ControlsTopOffset();
 
     if (new_offset != old_offset) {
       EXPECT_TRUE(did_request_redraw_);
       EXPECT_TRUE(did_request_commit_);
     }
+    host_impl_->DidFinishImplFrame();
   }
   EXPECT_FALSE(host_impl_->top_controls_manager()->animation());
   EXPECT_EQ(-top_controls_height_,
             host_impl_->top_controls_manager()->ControlsTopOffset());
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest,
        TopControlsScrollDeltaInOverScroll) {
   // Verifies that the overscroll delta should not have accumulated in
   // the top controls if we do a hide and show without releasing finger.
@@ skipping 425 matching lines @@
       external_transform, layer->draw_properties().target_space_transform);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollAnimated) {
   SetupScrollAndContentsLayers(gfx::Size(100, 200));
   DrawFrame();
 
   base::TimeTicks start_time =
       base::TimeTicks() + base::TimeDelta::FromMilliseconds(100);
 
+  BeginFrameArgs begin_frame_args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
+
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollAnimated(gfx::Point(), gfx::Vector2d(0, 50)));
 
   LayerImpl* scrolling_layer = host_impl_->CurrentlyScrollingLayer();
 
-  host_impl_->Animate(start_time);
+  begin_frame_args.frame_time = start_time;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   EXPECT_EQ(gfx::ScrollOffset(), scrolling_layer->CurrentScrollOffset());
+  host_impl_->DidFinishImplFrame();
 
-  host_impl_->Animate(start_time + base::TimeDelta::FromMilliseconds(50));
+  begin_frame_args.frame_time =
+      start_time + base::TimeDelta::FromMilliseconds(50);
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   float y = scrolling_layer->CurrentScrollOffset().y();
   EXPECT_TRUE(y > 1 && y < 49);
 
   // Update target.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollAnimated(gfx::Point(), gfx::Vector2d(0, 50)));
+  host_impl_->DidFinishImplFrame();
 
-  host_impl_->Animate(start_time + base::TimeDelta::FromMilliseconds(200));
+  begin_frame_args.frame_time =
+      start_time + base::TimeDelta::FromMilliseconds(200);
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   y = scrolling_layer->CurrentScrollOffset().y();
   EXPECT_TRUE(y > 50 && y < 100);
   EXPECT_EQ(scrolling_layer, host_impl_->CurrentlyScrollingLayer());
+  host_impl_->DidFinishImplFrame();
 
-  host_impl_->Animate(start_time + base::TimeDelta::FromMilliseconds(250));
+  begin_frame_args.frame_time =
+      start_time + base::TimeDelta::FromMilliseconds(250);
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   EXPECT_VECTOR_EQ(gfx::ScrollOffset(0, 100),
                    scrolling_layer->CurrentScrollOffset());
   EXPECT_EQ(NULL, host_impl_->CurrentlyScrollingLayer());
+  host_impl_->DidFinishImplFrame();
 }
 
 // Evolved from LayerTreeHostImplTest.ScrollAnimated.
 TEST_F(LayerTreeHostImplTimelinesTest, ScrollAnimated) {
   SetupScrollAndContentsLayers(gfx::Size(100, 200));
   DrawFrame();
 
   base::TimeTicks start_time =
       base::TimeTicks() + base::TimeDelta::FromMilliseconds(100);
 
+  BeginFrameArgs begin_frame_args =
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
+
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollAnimated(gfx::Point(), gfx::Vector2d(0, 50)));
 
   LayerImpl* scrolling_layer = host_impl_->CurrentlyScrollingLayer();
 
-  host_impl_->Animate(start_time);
+  begin_frame_args.frame_time = start_time;
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   EXPECT_EQ(gfx::ScrollOffset(), scrolling_layer->CurrentScrollOffset());
+  host_impl_->DidFinishImplFrame();
 
-  host_impl_->Animate(start_time + base::TimeDelta::FromMilliseconds(50));
+  begin_frame_args.frame_time =
+      start_time + base::TimeDelta::FromMilliseconds(50);
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   float y = scrolling_layer->CurrentScrollOffset().y();
   EXPECT_TRUE(y > 1 && y < 49);
 
   // Update target.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollAnimated(gfx::Point(), gfx::Vector2d(0, 50)));
+  host_impl_->DidFinishImplFrame();
 
-  host_impl_->Animate(start_time + base::TimeDelta::FromMilliseconds(200));
+  begin_frame_args.frame_time =
+      start_time + base::TimeDelta::FromMilliseconds(200);
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   y = scrolling_layer->CurrentScrollOffset().y();
   EXPECT_TRUE(y > 50 && y < 100);
   EXPECT_EQ(scrolling_layer, host_impl_->CurrentlyScrollingLayer());
+  host_impl_->DidFinishImplFrame();
 
-  host_impl_->Animate(start_time + base::TimeDelta::FromMilliseconds(250));
+  begin_frame_args.frame_time =
+      start_time + base::TimeDelta::FromMilliseconds(250);
+  host_impl_->WillBeginImplFrame(begin_frame_args);
+  host_impl_->Animate();
   host_impl_->UpdateAnimationState(true);
 
   EXPECT_VECTOR_EQ(gfx::ScrollOffset(0, 100),
                    scrolling_layer->CurrentScrollOffset());
   EXPECT_EQ(NULL, host_impl_->CurrentlyScrollingLayer());
+  host_impl_->DidFinishImplFrame();
 }
 
 TEST_F(LayerTreeHostImplTest, InvalidLayerNotAddedToRasterQueue) {
   host_impl_->CreatePendingTree();
 
   Region empty_invalidation;
   scoped_refptr<RasterSource> pile_with_tiles(
       FakePicturePileImpl::CreateFilledPileWithDefaultTileSize(
           gfx::Size(10, 10)));
 
@@ skipping 274 matching lines @@
   const BeginFrameArgs& begin_frame_args() const { return begin_frame_args_; }
 
   bool did_draw_frame() const { return did_draw_frame_; }
 
  private:
   BeginFrameArgs begin_frame_args_;
   bool did_draw_frame_ = false;
 };
 
 TEST_F(LayerTreeHostImplTest, AddVideoFrameControllerInsideFrame) {
-  host_impl_->DidFinishImplFrame();
-
   BeginFrameArgs begin_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
   FakeVideoFrameController controller;
 
   host_impl_->WillBeginImplFrame(begin_frame_args);
   EXPECT_FALSE(controller.begin_frame_args().IsValid());
   host_impl_->AddVideoFrameController(&controller);
   EXPECT_TRUE(controller.begin_frame_args().IsValid());
   host_impl_->DidFinishImplFrame();
 
   EXPECT_FALSE(controller.did_draw_frame());
   LayerTreeHostImpl::FrameData frame;
   host_impl_->DidDrawAllLayers(frame);
   EXPECT_TRUE(controller.did_draw_frame());
 
   controller.OnBeginFrame(begin_frame_args);
   EXPECT_FALSE(controller.did_draw_frame());
   host_impl_->RemoveVideoFrameController(&controller);
   host_impl_->DidDrawAllLayers(frame);
   EXPECT_FALSE(controller.did_draw_frame());
 }
 
 TEST_F(LayerTreeHostImplTest, AddVideoFrameControllerOutsideFrame) {
-  host_impl_->DidFinishImplFrame();
-
   BeginFrameArgs begin_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE);
   FakeVideoFrameController controller;
 
   host_impl_->WillBeginImplFrame(begin_frame_args);
   host_impl_->DidFinishImplFrame();
 
   EXPECT_FALSE(controller.begin_frame_args().IsValid());
   host_impl_->AddVideoFrameController(&controller);
   EXPECT_FALSE(controller.begin_frame_args().IsValid());
@@ skipping 100 matching lines @@
   // Hold an unowned pointer to the output surface to use for mock expectations.
   MockReclaimResourcesOutputSurface* mock_output_surface = output_surface.get();
 
   CreateHostImpl(DefaultSettings(), output_surface.Pass());
   EXPECT_CALL(*mock_output_surface, ForceReclaimResources()).Times(1);
   host_impl_->BeginCommit();
 }
 
 }  // namespace
 }  // namespace cc