cc: Chromify TimeSource, DelayBasedTimeSource and test

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 "base/logging.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 80 matching lines @@
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   scheduler->SetCanBeginFrame(true);
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   // SetNeedsCommit should begin the frame.
   scheduler->SetNeedsCommit();
   EXPECT_EQ(1, client.num_actions_());
   EXPECT_STREQ("ScheduledActionBeginFrame", client.Action(0));
-  EXPECT_FALSE(time_source->active());
+  EXPECT_FALSE(time_source->Active());
   client.Reset();
 
   // BeginFrameComplete should commit
   scheduler->BeginFrameComplete();
   EXPECT_EQ(1, client.num_actions_());
   EXPECT_STREQ("ScheduledActionCommit", client.Action(0));
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
   client.Reset();
 
   // Tick should draw.
   time_source->tick();
   EXPECT_EQ(1, client.num_actions_());
   EXPECT_STREQ("ScheduledActionDrawAndSwapIfPossible", client.Action(0));
-  EXPECT_FALSE(time_source->active());
+  EXPECT_FALSE(time_source->Active());
   client.Reset();
 
   // Timer should be off.
-  EXPECT_FALSE(time_source->active());
+  EXPECT_FALSE(time_source->Active());
 }
 
 TEST(SchedulerTest, RequestCommitAfterBeginFrame) {
   FakeSchedulerClient client;
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
   SchedulerSettings default_scheduler_settings;
   scoped_ptr<Scheduler> scheduler =
       Scheduler::Create(&client,
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
@@ skipping 12 matching lines @@
 
   // Since, another commit is needed, BeginFrameComplete should commit,
   // then begin another frame.
   scheduler->BeginFrameComplete();
   EXPECT_EQ(1, client.num_actions_());
   EXPECT_STREQ("ScheduledActionCommit", client.Action(0));
   client.Reset();
 
   // Tick should draw but then begin another frame.
   time_source->tick();
-  EXPECT_FALSE(time_source->active());
+  EXPECT_FALSE(time_source->Active());
   EXPECT_EQ(2, client.num_actions_());
   EXPECT_STREQ("ScheduledActionDrawAndSwapIfPossible", client.Action(0));
   EXPECT_STREQ("ScheduledActionBeginFrame", client.Action(1));
   client.Reset();
 }
 
 TEST(SchedulerTest, TextureAcquisitionCollision) {
   FakeSchedulerClient client;
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
   SchedulerSettings default_scheduler_settings;
   scoped_ptr<Scheduler> scheduler =
       Scheduler::Create(&client,
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   scheduler->SetCanBeginFrame(true);
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   scheduler->SetNeedsCommit();
   scheduler->SetMainThreadNeedsLayerTextures();
   EXPECT_EQ(2, client.num_actions_());
   EXPECT_STREQ("ScheduledActionBeginFrame", client.Action(0));
   EXPECT_STREQ("ScheduledActionAcquireLayerTexturesForMainThread",
                client.Action(1));
   client.Reset();
 
   // Compositor not scheduled to draw because textures are locked by main thread
-  EXPECT_FALSE(time_source->active());
+  EXPECT_FALSE(time_source->Active());
 
   // Trigger the commit
   scheduler->BeginFrameComplete();
-  EXPECT_TRUE(time_source->active());
+  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();
@@ skipping 79 matching lines @@
       Scheduler::Create(&client,
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
   scheduler->SetCanBeginFrame(true);
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
   EXPECT_EQ(0, client.num_draws());
 
   time_source->tick();
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
 
   time_source->tick();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_FALSE(scheduler->RedrawPending());
-  EXPECT_FALSE(time_source->active());
+  EXPECT_FALSE(time_source->Active());
 }
 
 // Test that requesting redraw inside a failed draw doesn't lose the request.
 TEST(SchedulerTest, RequestRedrawInsideFailedDraw) {
   SchedulerClientThatsetNeedsDrawInsideDraw client;
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
   SchedulerSettings default_scheduler_settings;
   scoped_ptr<Scheduler> scheduler =
       Scheduler::Create(&client,
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
   scheduler->SetCanBeginFrame(true);
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   client.SetDrawWillHappen(false);
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
   EXPECT_EQ(0, client.num_draws());
 
   // Fail the draw.
   time_source->tick();
   EXPECT_EQ(1, client.num_draws());
 
   // We have a commit pending and the draw failed, and we didn't lose the redraw
   // request.
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
 
   // Fail the draw again.
   time_source->tick();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
 
   // 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());
+  EXPECT_FALSE(time_source->Active());
 }
 
 class SchedulerClientThatsetNeedsCommitInsideDraw : public FakeSchedulerClient {
  public:
   SchedulerClientThatsetNeedsCommitInsideDraw() : scheduler_(NULL) {}
 
   void SetScheduler(Scheduler* scheduler) { scheduler_ = scheduler; }
 
   virtual void ScheduledActionBeginFrame() OVERRIDE {}
   virtual ScheduledActionDrawAndSwapResult
@@ skipping 29 matching lines @@
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
   scheduler->SetCanBeginFrame(true);
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_EQ(0, client.num_draws());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
 
   time_source->tick();
-  EXPECT_FALSE(time_source->active());
+  EXPECT_FALSE(time_source->Active());
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   scheduler->BeginFrameComplete();
 
   time_source->tick();
   EXPECT_EQ(2, client.num_draws());
-  EXPECT_FALSE(time_source->active());
+  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;
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
   SchedulerSettings default_scheduler_settings;
   scoped_ptr<Scheduler> scheduler =
       Scheduler::Create(&client,
                         make_scoped_ptr(new FrameRateController(time_source)),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
   scheduler->SetCanBeginFrame(true);
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   client.SetDrawWillHappen(false);
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
   EXPECT_EQ(0, client.num_draws());
 
   // Fail the draw.
   time_source->tick();
   EXPECT_EQ(1, client.num_draws());
 
   // We have a commit pending and the draw failed, and we didn't lose the commit
   // request.
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
 
   // Fail the draw again.
   time_source->tick();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
 
   // 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());
+  EXPECT_FALSE(time_source->Active());
 }
 
 TEST(SchedulerTest, NoBeginFrameWhenDrawFails) {
   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;
   scoped_ptr<Scheduler> scheduler =
       Scheduler::Create(&client,
                         controller.PassAs<FrameRateController>(),
                         default_scheduler_settings);
   client.SetScheduler(scheduler.get());
   scheduler->SetCanBeginFrame(true);
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_EQ(0, controller_ptr->numFramesPending());
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  EXPECT_TRUE(time_source->Active());
   EXPECT_EQ(0, client.num_draws());
 
   // Draw successfully, this starts a new frame.
   time_source->tick();
   EXPECT_EQ(1, client.num_draws());
   EXPECT_EQ(1, controller_ptr->numFramesPending());
   scheduler->DidSwapBuffersComplete();
   EXPECT_EQ(0, controller_ptr->numFramesPending());
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
-  EXPECT_TRUE(time_source->active());
+  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) {
   scoped_refptr<FakeTimeSource> time_source(new FakeTimeSource());
@@ skipping 46 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->DidRecreateOutputSurface();
   EXPECT_EQ(0, controller_ptr->numFramesPending());
 }
 
 }  // namespace
 }  // namespace cc