cc: Use BeginFrameArgs

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 68 matching lines @@
     num_draws_++;
     if (!impl->active_tree()->source_frame_number())
       EndTest();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_commits_++;
   }
 
   virtual void AfterTest() OVERRIDE {
-    EXPECT_GE(1, num_commits_);
-    EXPECT_GE(1, num_draws_);
+    EXPECT_GE(num_commits_, 1);

[enne (OOO), 2013/08/15 19:47:59]

I think this isn't what this test is looking for.  Given the comment above the
class, I'd expect this to be:

    EXPECT_EQ(1, num_commits_);
    EXPECT_GE(num_draws_, 1);

...although I don't see where a second draw would come from and it seems like
that should be EXPECT_EQ as well.

[brianderson, 2013/08/15 23:05:10]

I tried to make the code match the comments here ("at least 1 commit and at
least 1 draw"), but looking at the code I would expect exactly 1 of each as
well.  I made this change pretty early on, when my changes were likely
misbehaving, so I will change it to EXPECT_EQ and see how it goes.

+    EXPECT_GE(num_draws_, 1);
   }
 
  private:
   int num_commits_;
   int num_draws_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit1);
 
 // A SetNeedsCommit should lead to 1 commit. Issuing a second commit after that
@@ skipping 514 matching lines @@
 
 // A compositeAndReadback while invisible should force a normal commit without
 // assertion.
 class LayerTreeHostTestCompositeAndReadbackWhileInvisible
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestCompositeAndReadbackWhileInvisible() : num_commits_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     num_commits_++;
     if (num_commits_ == 1) {
       layer_tree_host()->SetVisible(false);
       layer_tree_host()->SetNeedsCommit();
       layer_tree_host()->SetNeedsCommit();
       char pixels[4];
       layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
     } else {
       EndTest();
     }
@@ skipping 58 matching lines @@
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestCommit);
 
 // This test verifies that LayerTreeHostImpl's current frame time gets
 // updated in consecutive frames when it doesn't draw due to tree
 // activation failure.
 class LayerTreeHostTestFrameTimeUpdatesAfterActivationFails
     : public LayerTreeHostTest {
  public:
-  LayerTreeHostTestFrameTimeUpdatesAfterActivationFails() : frame_(0) {}
+  LayerTreeHostTestFrameTimeUpdatesAfterActivationFails()
+  : frame_count_with_pending_tree_(0) {}

[enne (OOO), 2013/08/15 19:47:59]

style nit: indentation.  Consider 'git cl format'-ing your change.

[brianderson, 2013/08/15 23:05:10]

Magic! Thanks for the pointer.

 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
 
     PostSetNeedsCommitToMainThread();
   }
 
+  virtual void WillBeginFrameOnThread(LayerTreeHostImpl* host_impl,
+                              const BeginFrameArgs &args) OVERRIDE {
+    if (host_impl->pending_tree())
+      frame_count_with_pending_tree_++;
+  }
+
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    if (frame_ >= 1) {
-      EXPECT_NE(first_frame_time_, impl->CurrentFrameTimeTicks());
+    if (frame_count_with_pending_tree_ > 1) {

[enne (OOO), 2013/08/15 19:47:59]

Why do you need two begin frames before the first draw? I only see one
PostSetNeedsCommit; where does the second begin frame come from?

[brianderson, 2013/08/15 23:05:10]

I really need to clarify the uses of "BeginFrame" in the code. 
WillBeginFrameOnThread refers to the iml thread's BeginFrame not the commit's
BeginFrame.

In this test, the first BeginFrame on the impl thread does not activate or draw,
then the second BeginFrame activates and draws.

I should actually remove CanActivatePendingTreeIfNeeded from this test all
together since it should no longer be called after the activation changes in
more recent versions of this patch.

[enne (OOO), 2013/08/16 00:53:22]

OH.  One confusing begin frame name to rule them all.  :(

+      EXPECT_NE(first_frame_time_.ToInternalValue(),
+                impl->CurrentFrameTimeTicks().ToInternalValue());
       EndTest();
       return;
     }
 
     EXPECT_FALSE(impl->settings().impl_side_painting);
     EndTest();
   }
 
   virtual bool CanActivatePendingTree(LayerTreeHostImpl* impl) OVERRIDE {
-    if (frame_ >= 1)
-      return true;
-
-    return false;
+    return frame_count_with_pending_tree_ > 1;
   }
 
   virtual bool CanActivatePendingTreeIfNeeded(LayerTreeHostImpl* impl)
       OVERRIDE {
-    frame_++;
-    if (frame_ == 1) {
+    if (frame_count_with_pending_tree_ > 1)
+      return true;
+
+    if (first_frame_time_.is_null()) {
       first_frame_time_ = impl->CurrentFrameTimeTicks();
 
       // Since base::TimeTicks::Now() uses a low-resolution clock on
       // Windows, we need to make sure that the clock has incremented past
       // first_frame_time_.
       while (first_frame_time_ == base::TimeTicks::Now()) {}
+    }
+    return false;
+  }
 
-      return false;
-    }
-
-    return true;
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl *impl) OVERRIDE {
+    if (impl->settings().impl_side_painting)
+      EXPECT_NE(frame_count_with_pending_tree_, 1);
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
-  int frame_;
+  int frame_count_with_pending_tree_;
   base::TimeTicks first_frame_time_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestFrameTimeUpdatesAfterActivationFails);
 
 // This test verifies that LayerTreeHostImpl's current frame time gets
 // updated in consecutive frames when it draws in each frame.
 class LayerTreeHostTestFrameTimeUpdatesAfterDraw : public LayerTreeHostTest {
  public:
@@ skipping 61 matching lines @@
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta, float scale)
       OVERRIDE {
     gfx::Vector2d offset = scroll_layer_->scroll_offset();
     scroll_layer_->SetScrollOffset(offset + scroll_delta);
     layer_tree_host()->SetPageScaleFactorAndLimits(scale, 0.5f, 2.f);
   }
 
-  virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    impl->ProcessScrollDeltas();
+  virtual void SwapBuffersOnThread(LayerTreeHostImpl *impl, bool result)
+      OVERRIDE {
     // We get one commit before the first draw, and the animation doesn't happen
     // until the second draw.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_EQ(1.f, impl->active_tree()->page_scale_factor());
         // We'll start an animation when we get back to the main thread.
         break;
       case 1:
         EXPECT_EQ(1.f, impl->active_tree()->page_scale_factor());
-        PostSetNeedsRedrawToMainThread();
         break;
       case 2:
         EXPECT_EQ(1.25f, impl->active_tree()->page_scale_factor());
         EndTest();
         break;
       default:
         NOTREACHED();
     }
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
         layer_tree_host()->StartPageScaleAnimation(
             gfx::Vector2d(), false, 1.25f, base::TimeDelta());
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
@@ skipping 390 matching lines @@
     parent_->AddChild(child_);
 
     layer_tree_host()->SetRootLayer(parent_);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         parent_->SetNeedsDisplay();
         child_->SetNeedsDisplay();
         break;
       case 2:
         // Damage part of layers.
         parent_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
         child_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
         break;
@@ skipping 101 matching lines @@
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> parent_;
   scoped_refptr<FakeContentLayer> child_;
 };
 
 // Partial updates are not possible with a delegating renderer.
 SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
     LayerTreeHostTestAtomicCommitWithPartialUpdate);
 
 class LayerTreeHostTestFinishAllRendering : public LayerTreeHostTest {

[enne (OOO), 2013/08/15 19:47:59]

Since you're updating this, can you add a class-level comment for what this test
is trying to test?

It seems like it's trying to test that if the scheduler is asked to draw but
layer textures are acquired, that draws are still prevented?

[brianderson, 2013/08/15 23:05:10]

I will add a comment.

  public:
   LayerTreeHostTestFinishAllRendering() : once_(false), draw_count_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetNeedsRedraw();
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     if (once_)
       return;
     once_ = true;
     layer_tree_host()->SetNeedsRedraw();
     layer_tree_host()->AcquireLayerTextures();
     {
       base::AutoLock lock(lock_);
       draw_count_ = 0;
     }
     layer_tree_host()->FinishAllRendering();
@@ skipping 67 matching lines @@
     surface_layer2_->SetReplicaLayer(replica_layer2_.get());
 
     layer_tree_host()->SetRootLayer(root_layer_);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
+  virtual void DidActivateTreeOnThread(LayerTreeHostImpl *host_impl) OVERRIDE {
+    if (host_impl->active_tree()->source_frame_number() == 0) {

[enne (OOO), 2013/08/15 19:47:59]

It looks like you're changing the memory policy during activation of source
frame 0 but before drawing frame 0, whereas before it was between draw of frame
0 and draw of frame 1.  How is this still working?

[brianderson, 2013/08/15 23:05:10]

My understanding of the memory policy comes from the existing comment below. The
comment or my understanding of it may be wrong: I took the comment to mean that
new resources for tiles would not be allocated after changing the memory policy
here.

I believe this test was flaky after my changes because the second commit could
finish and start rasterizing before the first commit was drawn. If the memory
policy wasn't changed until the first draw, then the second commit could get
resources allocated to it.

So I changed the memory policy after the first activation, which definitely
occurs before the second commit.

[brianderson, 2013/08/15 23:30:25]

@reveman or @vmpstr, can changing the memory policy after activation affect the
subsequent draw?

[enne (OOO), 2013/08/16 00:53:22]

Ok.  Maybe this could be more robust if when you activate source frame #1 you
change the policy *and* manage tiles.  Otherwise, moving around when we manage
tiles could break this test.

[brianderson, 2013/08/16 01:20:49]

Hmmm. I tried calling ManageTiles after changing the memory policy for source
frame #0 and the first draw still succeeded. Is that expected?

I'm not sure if calling ManageTiles after the second activate will help make
this test more robust, since ManagegTiles might still be initiated after the
second commit but before the first draw.

I'm trying to think of a better way to write this test... maybe move the checks
for HaveCachedResourcesForRenderPassId for source frame #0 here.

+      // Reduce the memory limit to only fit the root layer and one render
+      // surface. This prevents any contents drawing into surfaces
+      // from being allocated.
+      host_impl->SetMemoryPolicy(ManagedMemoryPolicy(100 * 100 * 4 * 2));
+      host_impl->SetDiscardBackBufferWhenNotVisible(true);
+    }
+  }
+
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     Renderer* renderer = host_impl->renderer();
     RenderPass::Id surface1_render_pass_id = host_impl->active_tree()
         ->root_layer()->children()[0]->render_surface()->RenderPassId();
     RenderPass::Id surface2_render_pass_id =
         host_impl->active_tree()->root_layer()->children()[0]->children()[0]
         ->render_surface()->RenderPassId();
 
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(
             surface1_render_pass_id));
         EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(
             surface2_render_pass_id));
-
-        // Reduce the memory limit to only fit the root layer and one render
-        // surface. This prevents any contents drawing into surfaces
-        // from being allocated.
-        host_impl->SetMemoryPolicy(ManagedMemoryPolicy(100 * 100 * 4 * 2));
-        host_impl->SetDiscardBackBufferWhenNotVisible(true);
         break;
       case 1:
         EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(
             surface1_render_pass_id));
         EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(
             surface2_render_pass_id));
-
         EndTest();
         break;
     }
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     if (layer_tree_host()->source_frame_number() < 2)
       root_layer_->SetNeedsDisplay();
   }
 
   virtual void AfterTest() OVERRIDE {
     EXPECT_LE(2u, root_layer_->update_count());
     EXPECT_LE(2u, surface_layer1_->update_count());
     EXPECT_LE(2u, surface_layer2_->update_count());
   }
 
@@ skipping 285 matching lines @@
     content_layer_ = ContentLayer::Create(&client_);
     content_layer_->SetBounds(gfx::Size(10, 10));
     content_layer_->SetPosition(gfx::PointF(0.f, 0.f));
     content_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
     content_layer_->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(content_layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {

[enne (OOO), 2013/08/15 19:47:59]

I think this change here is right, but this is a bizarre test.  It seems like
CommitCompleteOnThread should EXPECT_EQ(num_draw_layers, num_commit_complete++),
if it's actually trying to make sure that we don't commit without drawing?

[brianderson, 2013/08/15 23:05:10]

I will add that check since it would check all commits rather than just the
commits between the first and second draw.

     if (num_draw_layers_ == 2)
       return;
     content_layer_->SetNeedsDisplay();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (num_draw_layers_ == 1)
       num_commit_complete_++;
   }
 
@@ skipping 376 matching lines @@
     settings->begin_frame_scheduling_enabled = true;
     settings->using_synchronous_renderer_compositor = true;
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     // The BeginFrame notification is turned off now but will get enabled
     // once we return. End test while it's enabled.
     ImplThreadTaskRunner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LayerTreeHostTestBeginFrameNotification::EndTest,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(
+          &LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled::EndTest,

[enne (OOO), 2013/08/15 19:47:59]

style nit: indentation.

+          base::Unretained(this)));
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled);
 
 class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
     : public LayerTreeHostTest {
@@ skipping 231 matching lines @@
     root->AddChild(child);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     WaitForCallback();
   }
 
   void WaitForCallback() {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(
             &LayerTreeHostTestAsyncReadback::NextStep,
             base::Unretained(this)));
   }
@@ skipping 521 matching lines @@
         layer_tree_host()->SetNeedsRedraw();
         break;
       case 3:
         // CompositeAndReadback in Round 4, first commit.
         EXPECT_EQ(2, frame_);
         break;
       case 4:
         // Round 4 done.
         EXPECT_EQ(2, frame_);
         layer_tree_host()->SetNeedsCommit();
+        // We can't SetNeedsRedraw immediately because it will race the commit.
+        break;
+      case 5:
+        EXPECT_EQ(2, frame_);
         layer_tree_host()->SetNeedsRedraw();
         break;
     }
   }
 
   virtual void DidCompleteSwapBuffers() OVERRIDE {
     int commit = layer_tree_host()->source_frame_number();
     ++frame_;
     char pixels[4] = {0};
     switch (frame_) {
@@ skipping 300 matching lines @@
       child2_->AddChild(leaf_picture_layer_);
     if (leaf_content_layer_)
       child2_->AddChild(leaf_content_layer_);
 
     other_root_ = PushPropertiesCountingLayer::Create();
 
     // Don't set the root layer here.
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     ++num_commits_;
 
     EXPECT_EQ(expected_push_properties_root_, root_->push_properties_count());
     EXPECT_EQ(expected_push_properties_child_, child_->push_properties_count());
     EXPECT_EQ(expected_push_properties_grandchild_,
               grandchild_->push_properties_count());
     EXPECT_EQ(expected_push_properties_child2_,
               child2_->push_properties_count());
     EXPECT_EQ(expected_push_properties_other_root_,
               other_root_->push_properties_count());
@@ skipping 173 matching lines @@
     bool has_thumb = false;
     scrollbar_layer_ =
         FakeScrollbarLayer::Create(paint_scrollbar, has_thumb, root_->id());
 
     root_->AddChild(scrollbar_layer_);
 
     layer_tree_host()->SetRootLayer(root_);
     LayerTreeHostTest::SetupTree();
   }
 
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
       case 1: {
         // During update, the ignore_set_needs_commit_ bit is set to true to
         // avoid causing a second commit to be scheduled. If a property change
         // is made during this, however, it needs to be pushed in the upcoming
         // commit.
         scoped_ptr<base::AutoReset<bool> > ignore =
             scrollbar_layer_->IgnoreSetNeedsCommit();
@@ skipping 62 matching lines @@
   size_t expected_push_properties_root_;
   size_t expected_push_properties_child_;
   size_t expected_push_properties_grandchild1_;
   size_t expected_push_properties_grandchild2_;
   size_t expected_push_properties_grandchild3_;
 };
 
 class LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
         EXPECT_FALSE(grandchild1_->needs_push_properties());
         EXPECT_FALSE(grandchild1_->descendant_needs_push_properties());
         EXPECT_FALSE(grandchild2_->needs_push_properties());
@@ skipping 19 matching lines @@
         break;
     }
   }
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesAddingToTreeRequiresPush);
 
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
@@ skipping 62 matching lines @@
         break;
     }
   }
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesRemovingChildStopsRecursion);
 
 class LayerTreeHostTestPushPropertiesRemovingChildStopsRecursionWithPersistence
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         grandchild1_->set_persist_needs_push_properties(true);
         grandchild2_->set_persist_needs_push_properties(true);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_TRUE(root_->descendant_needs_push_properties());
@@ skipping 27 matching lines @@
     }
   }
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesRemovingChildStopsRecursionWithPersistence);
 
 class LayerTreeHostTestPushPropertiesSetPropertiesWhileOutsideTree
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
@@ skipping 47 matching lines @@
     }
   }
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesSetPropertiesWhileOutsideTree);
 
 class LayerTreeHostTestPushPropertiesSetPropertyInParentThenChild
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
@@ skipping 43 matching lines @@
     }
   }
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestPushPropertiesSetPropertyInParentThenChild);
 
 class LayerTreeHostTestPushPropertiesSetPropertyInChildThenParent
     : public LayerTreeHostTestCasePushPropertiesThreeGrandChildren {
  protected:
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     int last_source_frame_number = layer_tree_host()->source_frame_number() - 1;
     switch (last_source_frame_number) {
       case 0:
         layer_tree_host()->SetRootLayer(root_);
         break;
       case 1:
         EXPECT_FALSE(root_->needs_push_properties());
         EXPECT_FALSE(root_->descendant_needs_push_properties());
         EXPECT_FALSE(child_->needs_push_properties());
         EXPECT_FALSE(child_->descendant_needs_push_properties());
@@ skipping 364 matching lines @@
   int num_will_begin_frames_;
   int num_impl_commits_;
 };
 
 // Commits can only be aborted when using the thread proxy.
 MULTI_THREAD_TEST_F(LayerTreeHostTestAbortEvictedTextures);
 
 }  // namespace
 
 }  // namespace cc