cc: Rename FinishCommit to NotifyReadyToCommit

cc/scheduler/scheduler_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/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 17 matching lines @@
 #define EXPECT_SINGLE_ACTION(action, client) \
   EXPECT_ACTION(action, client, 0, 1)
 
 namespace cc {
 namespace {
 
 void InitializeOutputSurfaceAndFirstCommit(Scheduler* scheduler) {
   scheduler->DidCreateAndInitializeOutputSurface();
   scheduler->SetNeedsCommit();
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   // Go through the motions to draw the commit.
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   scheduler->OnBeginImplFrameDeadline();
   // We need another BeginImplFrame so Scheduler calls
   // SetNeedsBeginImplFrame(false).
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   scheduler->OnBeginImplFrameDeadline();
 }
 
 class FakeSchedulerClient : public SchedulerClient {
@@ skipping 182 matching lines @@
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // If we don't swap on the deadline, we need to request another
   // BeginImplFrame.
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
-  // FinishCommit should commit
+  // NotifyReadyToCommit should trigger the commit.
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // BeginImplFrame should prepare the draw.
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
@@ skipping 41 matching lines @@
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // Now SetNeedsCommit again. Calling here means we need a second commit.
   scheduler->SetNeedsCommit();
   EXPECT_EQ(client.num_actions_(), 0);
   client.Reset();
 
   // Finish the first commit.
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
   EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
 
   // Because we just swapped, the Scheduler should also request the next
   // BeginImplFrame from the OutputSurface.
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // Since another commit is needed, the next BeginImplFrame should initiate
   // the second commit.
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_EQ(client.num_actions_(), 2);
   EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
   EXPECT_TRUE(client.HasAction("PostBeginImplFrameDeadlineTask"));
   client.Reset();
 
   // Finishing the commit before the deadline should post a new deadline task
   // to trigger the deadline early.
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
   EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // On the next BeginImplFrame, verify we go back to a quiescent state and
@@ skipping 66 matching lines @@
   EXPECT_EQ(0, client.num_actions_());
 
   client.Reset();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
 
   // Commit will release the texture.
   client.Reset();
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   EXPECT_TRUE(scheduler->RedrawPending());
 
   // Now we can draw again after the commit happens.
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
   EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
   EXPECT_FALSE(scheduler->RedrawPending());
@@ skipping 36 matching lines @@
 
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
 
   // Although the compositor cannot draw because textures are locked by main
   // thread, we continue requesting SetNeedsBeginImplFrame in anticipation of
   // the unlock.
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
-  // Trigger the commit
+  // Trigger the commit.
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
   // Between commit and draw, texture acquisition for main thread delayed,
   // and main thread blocks.
   client.Reset();
   scheduler->SetMainThreadNeedsLayerTextures();
   EXPECT_EQ(0, client.num_actions_());
 
   // No implicit commit is expected.
   client.Reset();
@@ skipping 26 matching lines @@
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
   client.Reset();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   client.Reset();
 
   // Trigger the commit, which will trigger the deadline task early.
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // Verify we draw on the next BeginImplFrame deadline
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
   EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 }
 
 TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   client.Reset();
   scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsCommit();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   scheduler->OnBeginImplFrameDeadline();
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   scheduler->SetMainThreadNeedsLayerTextures();
   scheduler->SetNeedsCommit();
   client.Reset();
   // Verify that pending texture acquisition fires when visibility
   // is lost in order to avoid a deadlock.
   scheduler->SetVisible(false);
   EXPECT_SINGLE_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                        client);
 
   client.Reset();
@@ skipping 174 matching lines @@
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
   client.SetNeedsCommitOnNextDraw();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   client.SetNeedsCommitOnNextDraw();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(client.needs_begin_impl_frame());
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
 
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_EQ(2, client.num_draws());
 
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(scheduler->CommitPending());
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
   // We stop requesting BeginImplFrames after a BeginImplFrame where we don't
@@ skipping 93 matching lines @@
 
   // Tell the client that it will fail to swap.
   client.SetDrawWillHappen(true);
   client.SetSwapWillHappenIfDrawHappens(false);
 
   // Get the compositor to do a ScheduledActionDrawAndReadback.
   scheduler->SetCanDraw(true);
   scheduler->SetNeedsRedraw();
   scheduler->SetNeedsForcedCommitForReadback();
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndReadback"));
 }
 
 TEST(SchedulerTest, BackToBackReadbackAllowed) {
   // Some clients call readbacks twice in a row before the replacement
   // commit comes in.  Make sure it is allowed.
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
 
   // Get the compositor to do 2 ScheduledActionDrawAndReadbacks before
   // the replacement commit comes in.
   scheduler->SetCanDraw(true);
   scheduler->SetNeedsRedraw();
   scheduler->SetNeedsForcedCommitForReadback();
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndReadback"));
 
   client.Reset();
   scheduler->SetNeedsForcedCommitForReadback();
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndReadback"));
 
   // The replacement commit comes in after 2 readbacks.
   client.Reset();
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
 }
 
 
 class SchedulerClientNeedsManageTilesInDraw : public FakeSchedulerClient {
  public:
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
       OVERRIDE {
     scheduler_->SetNeedsManageTiles();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
@@ skipping 244 matching lines @@
 
   // Impl thread hits deadline before commit finishes.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_FALSE(scheduler->MainThreadIsInHighLatencyMode());
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_FALSE(scheduler->MainThreadIsInHighLatencyMode());
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_TRUE(scheduler->MainThreadIsInHighLatencyMode());
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   EXPECT_TRUE(scheduler->MainThreadIsInHighLatencyMode());
   EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
 
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(scheduler->MainThreadIsInHighLatencyMode());
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_TRUE(scheduler->MainThreadIsInHighLatencyMode());
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_EQ(scheduler->MainThreadIsInHighLatencyMode(),
@@ skipping 38 matching lines @@
   Scheduler* scheduler = client.CreateScheduler(settings);
 
   scheduler->SetCanDraw(true);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(scheduler->CommitPending());
   scheduler->NotifyBeginMainFrameStarted();
-  scheduler->FinishCommit();
+  scheduler->NotifyReadyToCommit();
   scheduler->SetNeedsRedraw();
   BeginFrameArgs impl_frame_args = BeginFrameArgs::CreateForTesting();
   const int interval = 1;
   impl_frame_args.interval = base::TimeDelta::FromMilliseconds(interval);
   scheduler->BeginImplFrame(impl_frame_args);
   scheduler->OnBeginImplFrameDeadline();
 
   // At this point, we've drawn a frame.  Start another commit, but hold off on
-  // the FinishCommit for now.
+  // the NotifyReadyToCommit for now.
   EXPECT_FALSE(scheduler->CommitPending());
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(scheduler->CommitPending());
 
   // Spin the event loop a few times and make sure we get more
   // DidAnticipateDrawTimeChange calls every time.
   int actions_so_far = client.num_actions_();
 
   // Does three iterations to make sure that the timer is properly repeating.
   for (int i = 0; i < 3; ++i) {
     // Wait for 2x the frame interval to match
     // Scheduler::advance_commit_state_timer_'s rate.
     SpinForMillis(interval * 2);
     EXPECT_GT(client.num_actions_(), actions_so_far);
     EXPECT_STREQ(client.Action(client.num_actions_() - 1),
                  "DidAnticipatedDrawTimeChange");
     actions_so_far = client.num_actions_();
   }
 }
 
 }  // namespace
 }  // namespace cc