cc: Rename VSync to BeginFrame

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"
@@ skipping 50 matching lines @@
   }
 
   void SetDrawWillHappen(bool draw_will_happen) {
     draw_will_happen_ = draw_will_happen;
   }
   void SetSwapWillHappenIfDrawHappens(bool swap_will_happen_if_draw_happens) {
     swap_will_happen_if_draw_happens_ = swap_will_happen_if_draw_happens;
   }
 
   // Scheduler Implementation.
-  virtual void ScheduledActionBeginFrame() OVERRIDE {
-    actions_.push_back("ScheduledActionBeginFrame");
+  virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {
+    actions_.push_back("ScheduledActionSendBeginFrameToMainThread");
     states_.push_back(scheduler_->StateAsStringForTesting());
   }
   virtual ScheduledActionDrawAndSwapResult
   ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapIfPossible");
     states_.push_back(scheduler_->StateAsStringForTesting());
     num_draws_++;
     return ScheduledActionDrawAndSwapResult(draw_will_happen_,
                                             draw_will_happen_ &&
                                             swap_will_happen_if_draw_happens_);
@@ skipping 63 matching lines @@
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   client.Reset();
   scheduler->DidCreateAndInitializeOutputSurface();
 
   // SetNeedsCommit should begin the frame.
   scheduler->SetNeedsCommit();
-  EXPECT_SINGLE_ACTION("ScheduledActionBeginFrame", client);
+  EXPECT_SINGLE_ACTION("ScheduledActionSendBeginFrameToMainThread", client);
   EXPECT_FALSE(time_source->Active());
   client.Reset();
 
-  // BeginFrameComplete should commit
-  scheduler->BeginFrameComplete();
+  // FinishCommit should commit
+  scheduler->FinishCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
   EXPECT_TRUE(time_source->Active());
   client.Reset();
 
   // Tick should draw.
   time_source->Tick();
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client);
   EXPECT_FALSE(time_source->Active());
   client.Reset();
 
   // Timer should be off.
   EXPECT_FALSE(time_source->Active());
 }
 
-TEST(SchedulerTest, RequestCommitAfterBeginFrame) {
+TEST(SchedulerTest, RequestCommitAfterBeginFrameSentToMainThread) {
   FakeSchedulerClient client;
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(
       make_scoped_ptr(new FrameRateController(time_source)),
       default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   client.Reset();
   scheduler->DidCreateAndInitializeOutputSurface();
 
   // SetNedsCommit should begin the frame.
   scheduler->SetNeedsCommit();
-  EXPECT_SINGLE_ACTION("ScheduledActionBeginFrame", client);
+  EXPECT_SINGLE_ACTION("ScheduledActionSendBeginFrameToMainThread", client);
   client.Reset();
 
   // Now SetNeedsCommit again. Calling here means we need a second frame.
   scheduler->SetNeedsCommit();
 
-  // Since, another commit is needed, BeginFrameComplete should commit,
+  // Since another commit is needed, FinishCommit should commit,
   // then begin another frame.
-  scheduler->BeginFrameComplete();
+  scheduler->FinishCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
   client.Reset();
 
   // Tick should draw but then begin another frame.
   time_source->Tick();
   EXPECT_FALSE(time_source->Active());
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
-  EXPECT_ACTION("ScheduledActionBeginFrame", client, 1, 2);
+  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 1, 2);
   client.Reset();
 }
 
 TEST(SchedulerTest, TextureAcquisitionCollision) {
   FakeSchedulerClient client;
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(
       make_scoped_ptr(new FrameRateController(time_source)),
       default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   client.Reset();
   scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsCommit();
   scheduler->SetMainThreadNeedsLayerTextures();
-  EXPECT_ACTION("ScheduledActionBeginFrame", client, 0, 2);
+  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
   EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                 client,
                 1,
                 2);
   client.Reset();
 
   // Compositor not scheduled to draw because textures are locked by main thread
   EXPECT_FALSE(time_source->Active());
 
   // Trigger the commit
-  scheduler->BeginFrameComplete();
+  scheduler->FinishCommit();
   EXPECT_TRUE(time_source->Active());
   client.Reset();
 
   // Between commit and draw, texture acquisition for main thread delayed,
   // and main thread blocks.
   scheduler->SetMainThreadNeedsLayerTextures();
   EXPECT_EQ(0, client.num_actions_());
   client.Reset();
 
   // Once compositor draw complete, the delayed texture acquisition fires.
   time_source->Tick();
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 3);
   EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                 client,
                 1,
                 3);
-  EXPECT_ACTION("ScheduledActionBeginFrame", client, 2, 3);
+  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 2, 3);
   client.Reset();
 }
 
 TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition) {
   FakeSchedulerClient client;
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(
       make_scoped_ptr(new FrameRateController(time_source)),
       default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   client.Reset();
   scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsCommit();
-  scheduler->BeginFrameComplete();
+  scheduler->FinishCommit();
   scheduler->SetMainThreadNeedsLayerTextures();
   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();
 
   // Regaining visibility with textures acquired by main thread while
   // compositor is waiting for first draw should result in a request
   // for a new frame in order to escape a deadlock.
   scheduler->SetVisible(true);
-  EXPECT_SINGLE_ACTION("ScheduledActionBeginFrame", client);
+  EXPECT_SINGLE_ACTION("ScheduledActionSendBeginFrameToMainThread", client);
   client.Reset();
 }
 
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
-  virtual void ScheduledActionBeginFrame() OVERRIDE {}
+  virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {}
   virtual ScheduledActionDrawAndSwapResult
   ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
     // Only SetNeedsRedraw the first time this is called
     if (!num_draws_)
       scheduler_->SetNeedsRedraw();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
   virtual ScheduledActionDrawAndSwapResult ScheduledActionDrawAndSwapForced()
       OVERRIDE {
@@ skipping 79 matching lines @@
   client.SetDrawWillHappen(true);
   time_source->Tick();
   EXPECT_EQ(3, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(time_source->Active());
 }
 
 class SchedulerClientThatsetNeedsCommitInsideDraw : public FakeSchedulerClient {
  public:
-  virtual void ScheduledActionBeginFrame() OVERRIDE {}
+  virtual void ScheduledActionSendBeginFrameToMainThread() OVERRIDE {}
   virtual ScheduledActionDrawAndSwapResult
   ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
     // Only SetNeedsCommit the first time this is called
     if (!num_draws_)
       scheduler_->SetNeedsCommit();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
 
   virtual ScheduledActionDrawAndSwapResult ScheduledActionDrawAndSwapForced()
       OVERRIDE {
@@ skipping 22 matching lines @@
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_EQ(0, client.num_draws());
   EXPECT_TRUE(time_source->Active());
 
   time_source->Tick();
   EXPECT_FALSE(time_source->Active());
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
-  scheduler->BeginFrameComplete();
+  scheduler->FinishCommit();
 
   time_source->Tick();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_FALSE(time_source->Active());
   EXPECT_FALSE(scheduler->RedrawPending());
 }
 
 // Tests that when a draw fails then the pending commit should not be dropped.
 TEST(SchedulerTest, RequestCommitInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw client;
@@ skipping 33 matching lines @@
 
   // Draw successfully.
   client.SetDrawWillHappen(true);
   time_source->Tick();
   EXPECT_EQ(3, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(time_source->Active());
 }
 
-TEST(SchedulerTest, NoBeginFrameWhenDrawFails) {
+TEST(SchedulerTest, NoSwapWhenDrawFails) {
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
   SchedulerClientThatsetNeedsCommitInsideDraw client;
   scoped_ptr<FakeFrameRateController> controller(
       new FakeFrameRateController(time_source));
   FakeFrameRateController* controller_ptr = controller.get();
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(
       controller.PassAs<FrameRateController>(),
       default_scheduler_settings);
   scheduler->SetCanStart();
@@ skipping 19 matching lines @@
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(time_source->Active());
 
   // Fail to draw, this should not start a frame.
   client.SetDrawWillHappen(false);
   time_source->Tick();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_EQ(0, controller_ptr->NumFramesPending());
 }
 
-TEST(SchedulerTest, NoBeginFrameWhenSwapFailsDuringForcedCommit) {
+TEST(SchedulerTest, NoSwapWhenSwapFailsDuringForcedCommit) {
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
   FakeSchedulerClient client;
   scoped_ptr<FakeFrameRateController> controller(
       new FakeFrameRateController(time_source));
   FakeFrameRateController* controller_ptr = controller.get();
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(
       controller.PassAs<FrameRateController>(),
       default_scheduler_settings);
 
@@ skipping 36 matching lines @@
   scheduler->DidLoseOutputSurface();
   // Verifying that it's 1 so that we know that it's reset on recreate.
   EXPECT_EQ(1, controller_ptr->NumFramesPending());
 
   scheduler->DidCreateAndInitializeOutputSurface();
   EXPECT_EQ(0, controller_ptr->NumFramesPending());
 }
 
 }  // namespace
 }  // namespace cc