cc: Chromify FakeTimeSourceClient, FakeThread, FakeTimeSource, FakeDelayBasedTimeSource, FakeFrameRateController.

R=enne@chromium.org
BUG=none
NOTRY=true


Review URL: https://chromiumcodereview.appspot.com/12806008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@189822 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 292 insertions, 330 deletions

diff --git a/cc/resources/resource_update_controller_unittest.cc b/cc/resources/resource_update_controller_unittest.cc
index 9c56cae..666fa2f 100644
--- a/cc/resources/resource_update_controller_unittest.cc
+++ b/cc/resources/resource_update_controller_unittest.cc
@@ -372,11 +372,11 @@ protected:
     size_t m_updateMoreTexturesSize;
 };
 
-static void runPendingTask(FakeThread* thread, FakeResourceUpdateController* controller)
+static void RunPendingTask(FakeThread* thread, FakeResourceUpdateController* controller)
 {
-    EXPECT_TRUE(thread->hasPendingTask());
-    controller->setNow(controller->Now() + base::TimeDelta::FromMilliseconds(thread->pendingDelayMs()));
-    thread->runPendingTask();
+    EXPECT_TRUE(thread->HasPendingTask());
+    controller->setNow(controller->Now() + base::TimeDelta::FromMilliseconds(thread->PendingDelayMs()));
+    thread->RunPendingTask();
 }
 
 TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures)
@@ -400,7 +400,7 @@ TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures)
     // Not enough time for any updates.
     controller->PerformMoreUpdates(
         controller->Now() + base::TimeDelta::FromMilliseconds(90));
-    EXPECT_FALSE(thread.hasPendingTask());
+    EXPECT_FALSE(thread.HasPendingTask());
 
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(100));
@@ -408,7 +408,7 @@ TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures)
     // Only enough time for 1 update.
     controller->PerformMoreUpdates(
         controller->Now() + base::TimeDelta::FromMilliseconds(120));
-    EXPECT_FALSE(thread.hasPendingTask());
+    EXPECT_FALSE(thread.HasPendingTask());
     EXPECT_EQ(1, m_numTotalUploads);
 
     // Complete one upload.
@@ -420,8 +420,8 @@ TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures)
     // Enough time for 2 updates.
     controller->PerformMoreUpdates(
         controller->Now() + base::TimeDelta::FromMilliseconds(220));
-    runPendingTask(&thread, controller.get());
-    EXPECT_FALSE(thread.hasPendingTask());
+    RunPendingTask(&thread, controller.get());
+    EXPECT_FALSE(thread.HasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(3, m_numTotalUploads);
 }
@@ -447,8 +447,8 @@ TEST_F(ResourceUpdateControllerTest, NoMoreUpdates)
     // Enough time for 3 updates but only 2 necessary.
     controller->PerformMoreUpdates(
         controller->Now() + base::TimeDelta::FromMilliseconds(310));
-    runPendingTask(&thread, controller.get());
-    EXPECT_FALSE(thread.hasPendingTask());
+    RunPendingTask(&thread, controller.get());
+    EXPECT_FALSE(thread.HasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numTotalUploads);
 
@@ -459,8 +459,8 @@ TEST_F(ResourceUpdateControllerTest, NoMoreUpdates)
     controller->PerformMoreUpdates(
         controller->Now() + base::TimeDelta::FromMilliseconds(310));
     // 0-delay task used to call readyToFinalizeTextureUpdates().
-    runPendingTask(&thread, controller.get());
-    EXPECT_FALSE(thread.hasPendingTask());
+    RunPendingTask(&thread, controller.get());
+    EXPECT_FALSE(thread.HasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numTotalUploads);
 }
@@ -492,11 +492,11 @@ TEST_F(ResourceUpdateControllerTest, UpdatesCompleteInFiniteTime)
         controller->PerformMoreUpdates(
             controller->Now() + base::TimeDelta::FromMilliseconds(400));
 
-        if (thread.hasPendingTask())
-            runPendingTask(&thread, controller.get());
+        if (thread.HasPendingTask())
+            RunPendingTask(&thread, controller.get());
     }
 
-    EXPECT_FALSE(thread.hasPendingTask());
+    EXPECT_FALSE(thread.HasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numTotalUploads);
 }
diff --git a/cc/scheduler/delay_based_time_source_unittest.cc b/cc/scheduler/delay_based_time_source_unittest.cc
index 8343cce..a4493a5 100644
--- a/cc/scheduler/delay_based_time_source_unittest.cc
+++ b/cc/scheduler/delay_based_time_source_unittest.cc
@@ -20,56 +20,56 @@ TEST(DelayBasedTimeSourceTest, TaskPostedAndTickCalled) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
 
   timer->SetActive(true);
   EXPECT_TRUE(timer->Active());
-  EXPECT_TRUE(thread.hasPendingTask());
+  EXPECT_TRUE(thread.HasPendingTask());
 
-  timer->setNow(timer->Now() + base::TimeDelta::FromMilliseconds(16));
-  thread.runPendingTask();
+  timer->SetNow(timer->Now() + base::TimeDelta::FromMilliseconds(16));
+  thread.RunPendingTask();
   EXPECT_TRUE(timer->Active());
-  EXPECT_TRUE(client.tickCalled());
+  EXPECT_TRUE(client.TickCalled());
 }
 
 TEST(DelayBasedTimeSource, TickNotCalledWithTaskPosted) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
-  EXPECT_TRUE(thread.hasPendingTask());
+  EXPECT_TRUE(thread.HasPendingTask());
   timer->SetActive(false);
-  thread.runPendingTask();
-  EXPECT_FALSE(client.tickCalled());
+  thread.RunPendingTask();
+  EXPECT_FALSE(client.TickCalled());
 }
 
 TEST(DelayBasedTimeSource, StartTwiceEnqueuesOneTask) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
-  EXPECT_TRUE(thread.hasPendingTask());
-  thread.reset();
+  EXPECT_TRUE(thread.HasPendingTask());
+  thread.Reset();
   timer->SetActive(true);
-  EXPECT_FALSE(thread.hasPendingTask());
+  EXPECT_FALSE(thread.HasPendingTask());
 }
 
 TEST(DelayBasedTimeSource, StartWhenRunningDoesntTick) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
-  thread.runPendingTask();
-  thread.reset();
+  thread.RunPendingTask();
+  thread.Reset();
   timer->SetActive(true);
-  EXPECT_FALSE(thread.hasPendingTask());
+  EXPECT_FALSE(thread.HasPendingTask());
 }
 
 // At 60Hz, when the tick returns at exactly the requested next time, make sure
@@ -78,18 +78,18 @@ TEST(DelayBasedTimeSource, NextDelaySaneWhenExactlyOnRequestedTime) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
   // Run the first task, as that activates the timer and picks up a timebase.
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
-  timer->setNow(timer->Now() + Interval());
-  thread.runPendingTask();
+  timer->SetNow(timer->Now() + Interval());
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 }
 
 // At 60Hz, when the tick returns at slightly after the requested next time,
@@ -98,19 +98,19 @@ TEST(DelayBasedTimeSource, NextDelaySaneWhenSlightlyAfterRequestedTime) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
   // Run the first task, as that activates the timer and picks up a timebase.
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
-  timer->setNow(timer->Now() + Interval() +
+  timer->SetNow(timer->Now() + Interval() +
                 base::TimeDelta::FromMicroseconds(1));
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 }
 
 // At 60Hz, when the tick returns at exactly 2*interval after the requested next
@@ -119,18 +119,18 @@ TEST(DelayBasedTimeSource, NextDelaySaneWhenExactlyTwiceAfterRequestedTime) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
   // Run the first task, as that activates the timer and picks up a timebase.
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
-  timer->setNow(timer->Now() + 2 * Interval());
-  thread.runPendingTask();
+  timer->SetNow(timer->Now() + 2 * Interval());
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 }
 
 // At 60Hz, when the tick returns at 2*interval and a bit after the requested
@@ -139,19 +139,19 @@ TEST(DelayBasedTimeSource, NextDelaySaneWhenSlightlyAfterTwiceRequestedTime) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
   // Run the first task, as that activates the timer and picks up a timebase.
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
-  timer->setNow(timer->Now() + 2 * Interval() +
+  timer->SetNow(timer->Now() + 2 * Interval() +
                 base::TimeDelta::FromMicroseconds(1));
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 }
 
 // At 60Hz, when the tick returns halfway to the next frame time, make sure
@@ -160,19 +160,19 @@ TEST(DelayBasedTimeSource, NextDelaySaneWhenHalfAfterRequestedTime) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
   // Run the first task, as that activates the timer and picks up a timebase.
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
-  timer->setNow(timer->Now() + Interval() +
+  timer->SetNow(timer->Now() + Interval() +
                 base::TimeDelta::FromMilliseconds(8));
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(8, thread.pendingDelayMs());
+  EXPECT_EQ(8, thread.PendingDelayMs());
 }
 
 // If the timebase and interval are updated with a jittery source, we want to
@@ -181,114 +181,114 @@ TEST(DelayBasedTimeSource, SaneHandlingOfJitteryTimebase) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
   // Run the first task, as that activates the timer and picks up a timebase.
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
   // Jitter timebase ~1ms late
-  timer->setNow(timer->Now() + Interval());
+  timer->SetNow(timer->Now() + Interval());
   timer->SetTimebaseAndInterval(
       timer->Now() + base::TimeDelta::FromMilliseconds(1), Interval());
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  // Without double tick prevention, pendingDelayMs would be 1.
-  EXPECT_EQ(17, thread.pendingDelayMs());
+  // Without double tick prevention, PendingDelayMs would be 1.
+  EXPECT_EQ(17, thread.PendingDelayMs());
 
   // Jitter timebase ~1ms early
-  timer->setNow(timer->Now() + Interval());
+  timer->SetNow(timer->Now() + Interval());
   timer->SetTimebaseAndInterval(
       timer->Now() - base::TimeDelta::FromMilliseconds(1), Interval());
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(15, thread.pendingDelayMs());
+  EXPECT_EQ(15, thread.PendingDelayMs());
 }
 
 TEST(DelayBasedTimeSource, HandlesSignificantTimebaseChangesImmediately) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
   // Run the first task, as that activates the timer and picks up a timebase.
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
   // Tick, then shift timebase by +7ms.
-  timer->setNow(timer->Now() + Interval());
-  thread.runPendingTask();
+  timer->SetNow(timer->Now() + Interval());
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
-  client.reset();
-  thread.runPendingTaskOnOverwrite(true);
+  client.Reset();
+  thread.RunPendingTaskOnOverwrite(true);
   base::TimeDelta jitter = base::TimeDelta::FromMilliseconds(7) +
                            base::TimeDelta::FromMicroseconds(1);
   timer->SetTimebaseAndInterval(timer->Now() + jitter, Interval());
-  thread.runPendingTaskOnOverwrite(false);
+  thread.RunPendingTaskOnOverwrite(false);
 
-  EXPECT_FALSE(client.tickCalled());  // Make sure pending tasks were canceled.
-  EXPECT_EQ(7, thread.pendingDelayMs());
+  EXPECT_FALSE(client.TickCalled());  // Make sure pending tasks were canceled.
+  EXPECT_EQ(7, thread.PendingDelayMs());
 
   // Tick, then shift timebase by -7ms.
-  timer->setNow(timer->Now() + jitter);
-  thread.runPendingTask();
+  timer->SetNow(timer->Now() + jitter);
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
-  client.reset();
-  thread.runPendingTaskOnOverwrite(true);
+  client.Reset();
+  thread.RunPendingTaskOnOverwrite(true);
   timer->SetTimebaseAndInterval(base::TimeTicks() + Interval(), Interval());
-  thread.runPendingTaskOnOverwrite(false);
+  thread.RunPendingTaskOnOverwrite(false);
 
-  EXPECT_FALSE(client.tickCalled());  // Make sure pending tasks were canceled.
-  EXPECT_EQ(16 - 7, thread.pendingDelayMs());
+  EXPECT_FALSE(client.TickCalled());  // Make sure pending tasks were canceled.
+  EXPECT_EQ(16 - 7, thread.PendingDelayMs());
 }
 
 TEST(DelayBasedTimeSource, HanldlesSignificantIntervalChangesImmediately) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
   // Run the first task, as that activates the timer and picks up a timebase.
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
   // Tick, then double the interval.
-  timer->setNow(timer->Now() + Interval());
-  thread.runPendingTask();
+  timer->SetNow(timer->Now() + Interval());
+  thread.RunPendingTask();
 
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_EQ(16, thread.PendingDelayMs());
 
-  client.reset();
-  thread.runPendingTaskOnOverwrite(true);
+  client.Reset();
+  thread.RunPendingTaskOnOverwrite(true);
   timer->SetTimebaseAndInterval(base::TimeTicks() + Interval(), Interval() * 2);
-  thread.runPendingTaskOnOverwrite(false);
+  thread.RunPendingTaskOnOverwrite(false);
 
-  EXPECT_FALSE(client.tickCalled());  // Make sure pending tasks were canceled.
-  EXPECT_EQ(33, thread.pendingDelayMs());
+  EXPECT_FALSE(client.TickCalled());  // Make sure pending tasks were canceled.
+  EXPECT_EQ(33, thread.PendingDelayMs());
 
   // Tick, then halve the interval.
-  timer->setNow(timer->Now() + Interval() * 2);
-  thread.runPendingTask();
+  timer->SetNow(timer->Now() + Interval() * 2);
+  thread.RunPendingTask();
 
-  EXPECT_EQ(33, thread.pendingDelayMs());
+  EXPECT_EQ(33, thread.PendingDelayMs());
 
-  client.reset();
-  thread.runPendingTaskOnOverwrite(true);
+  client.Reset();
+  thread.RunPendingTaskOnOverwrite(true);
   timer->SetTimebaseAndInterval(base::TimeTicks() + Interval() * 3, Interval());
-  thread.runPendingTaskOnOverwrite(false);
+  thread.RunPendingTaskOnOverwrite(false);
 
-  EXPECT_FALSE(client.tickCalled());  // Make sure pending tasks were canceled.
-  EXPECT_EQ(16, thread.pendingDelayMs());
+  EXPECT_FALSE(client.TickCalled());  // Make sure pending tasks were canceled.
+  EXPECT_EQ(16, thread.PendingDelayMs());
 }
 
 TEST(DelayBasedTimeSourceTest, AchievesTargetRateWithNoNoise) {
@@ -297,20 +297,20 @@ TEST(DelayBasedTimeSourceTest, AchievesTargetRateWithNoNoise) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);
 
   double total_frame_time = 0.0;
   for (int i = 0; i < num_iterations; ++i) {
-    long long delay_ms = thread.pendingDelayMs();
+    long long delay_ms = thread.PendingDelayMs();
 
     // accumulate the "delay"
     total_frame_time += delay_ms / 1000.0;
 
     // Run the callback exactly when asked
-    timer->setNow(timer->Now() + base::TimeDelta::FromMilliseconds(delay_ms));
-    thread.runPendingTask();
+    timer->SetNow(timer->Now() + base::TimeDelta::FromMilliseconds(delay_ms));
+    thread.RunPendingTask();
   }
   double average_interval =
       total_frame_time / static_cast<double>(num_iterations);
@@ -321,60 +321,60 @@ TEST(DelayBasedTimeSource, TestDeactivateWhilePending) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
   timer->SetActive(true);  // Should post a task.
   timer->SetActive(false);
   timer = NULL;
-  thread.runPendingTask();  // Should run the posted task without crashing.
+  thread.RunPendingTask();  // Should run the posted task without crashing.
 }
 
 TEST(DelayBasedTimeSource, TestDeactivateAndReactivateBeforeNextTickTime) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
 
   // Should run the activate task, and pick up a new timebase.
   timer->SetActive(true);
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
   // Stop the timer
   timer->SetActive(false);
 
   // Task will be pending anyway, run it
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
   // Start the timer again, but before the next tick time the timer previously
   // planned on using. That same tick time should still be targeted.
-  timer->setNow(timer->Now() + base::TimeDelta::FromMilliseconds(4));
+  timer->SetNow(timer->Now() + base::TimeDelta::FromMilliseconds(4));
   timer->SetActive(true);
-  EXPECT_EQ(12, thread.pendingDelayMs());
+  EXPECT_EQ(12, thread.PendingDelayMs());
 }
 
 TEST(DelayBasedTimeSource, TestDeactivateAndReactivateAfterNextTickTime) {
   FakeThread thread;
   FakeTimeSourceClient client;
   scoped_refptr<FakeDelayBasedTimeSource> timer =
-      FakeDelayBasedTimeSource::create(Interval(), &thread);
+      FakeDelayBasedTimeSource::Create(Interval(), &thread);
   timer->SetClient(&client);
 
   // Should run the activate task, and pick up a new timebase.
   timer->SetActive(true);
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
   // Stop the timer.
   timer->SetActive(false);
 
   // Task will be pending anyway, run it.
-  thread.runPendingTask();
+  thread.RunPendingTask();
 
   // Start the timer again, but before the next tick time the timer previously
   // planned on using. That same tick time should still be targeted.
-  timer->setNow(timer->Now() + base::TimeDelta::FromMilliseconds(20));
+  timer->SetNow(timer->Now() + base::TimeDelta::FromMilliseconds(20));
   timer->SetActive(true);
-  EXPECT_EQ(13, thread.pendingDelayMs());
+  EXPECT_EQ(13, thread.PendingDelayMs());
 }
 
 }  // namespace
diff --git a/cc/scheduler/frame_rate_controller_unittest.cc b/cc/scheduler/frame_rate_controller_unittest.cc
index 695c5d6..9818a66 100644
--- a/cc/scheduler/frame_rate_controller_unittest.cc
+++ b/cc/scheduler/frame_rate_controller_unittest.cc
@@ -31,7 +31,7 @@ TEST(FrameRateControllerTest, TestFrameThrottling_ImmediateAck) {
   base::TimeDelta interval = base::TimeDelta::FromMicroseconds(
       base::Time::kMicrosecondsPerSecond / 60);
   scoped_refptr<FakeDelayBasedTimeSource> time_source =
-      FakeDelayBasedTimeSource::create(interval, &thread);
+      FakeDelayBasedTimeSource::Create(interval, &thread);
   FrameRateController controller(time_source);
 
   controller.SetClient(&client);
@@ -40,9 +40,9 @@ TEST(FrameRateControllerTest, TestFrameThrottling_ImmediateAck) {
   base::TimeTicks elapsed;  // Muck around with time a bit
 
   // Trigger one frame, make sure the vsync callback is called
-  elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
-  time_source->setNow(elapsed);
-  thread.runPendingTask();
+  elapsed += base::TimeDelta::FromMilliseconds(thread.PendingDelayMs());
+  time_source->SetNow(elapsed);
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
   client.Reset();
 
@@ -50,16 +50,16 @@ TEST(FrameRateControllerTest, TestFrameThrottling_ImmediateAck) {
   controller.DidBeginFrame();
 
   // Tell the controller the frame ended 5ms later
-  time_source->setNow(time_source->Now() +
+  time_source->SetNow(time_source->Now() +
                       base::TimeDelta::FromMilliseconds(5));
   controller.DidFinishFrame();
 
   // Trigger another frame, make sure vsync runs again
-  elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
+  elapsed += base::TimeDelta::FromMilliseconds(thread.PendingDelayMs());
   // Sanity check that previous code didn't move time backward.
   EXPECT_GE(elapsed, time_source->Now());
-  time_source->setNow(elapsed);
-  thread.runPendingTask();
+  time_source->SetNow(elapsed);
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
 }
 
@@ -69,7 +69,7 @@ TEST(FrameRateControllerTest, TestFrameThrottling_TwoFramesInFlight) {
   base::TimeDelta interval = base::TimeDelta::FromMicroseconds(
       base::Time::kMicrosecondsPerSecond / 60);
   scoped_refptr<FakeDelayBasedTimeSource> time_source =
-      FakeDelayBasedTimeSource::create(interval, &thread);
+      FakeDelayBasedTimeSource::Create(interval, &thread);
   FrameRateController controller(time_source);
 
   controller.SetClient(&client);
@@ -79,9 +79,9 @@ TEST(FrameRateControllerTest, TestFrameThrottling_TwoFramesInFlight) {
   base::TimeTicks elapsed;  // Muck around with time a bit
 
   // Trigger one frame, make sure the vsync callback is called
-  elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
-  time_source->setNow(elapsed);
-  thread.runPendingTask();
+  elapsed += base::TimeDelta::FromMilliseconds(thread.PendingDelayMs());
+  time_source->SetNow(elapsed);
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
   client.Reset();
 
@@ -89,11 +89,11 @@ TEST(FrameRateControllerTest, TestFrameThrottling_TwoFramesInFlight) {
   controller.DidBeginFrame();
 
   // Trigger another frame, make sure vsync callback runs again
-  elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
+  elapsed += base::TimeDelta::FromMilliseconds(thread.PendingDelayMs());
   // Sanity check that previous code didn't move time backward.
   EXPECT_GE(elapsed, time_source->Now());
-  time_source->setNow(elapsed);
-  thread.runPendingTask();
+  time_source->SetNow(elapsed);
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
   client.Reset();
 
@@ -101,15 +101,15 @@ TEST(FrameRateControllerTest, TestFrameThrottling_TwoFramesInFlight) {
   controller.DidBeginFrame();
 
   // Trigger another frame. Since two frames are pending, we should not draw.
-  elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
+  elapsed += base::TimeDelta::FromMilliseconds(thread.PendingDelayMs());
   // Sanity check that previous code didn't move time backward.
   EXPECT_GE(elapsed, time_source->Now());
-  time_source->setNow(elapsed);
-  thread.runPendingTask();
+  time_source->SetNow(elapsed);
+  thread.RunPendingTask();
   EXPECT_FALSE(client.VSyncTicked());
 
   // Tell the controller the first frame ended 5ms later
-  time_source->setNow(time_source->Now() +
+  time_source->SetNow(time_source->Now() +
                       base::TimeDelta::FromMilliseconds(5));
   controller.DidFinishFrame();
 
@@ -118,11 +118,11 @@ TEST(FrameRateControllerTest, TestFrameThrottling_TwoFramesInFlight) {
 
   // Trigger yet another frame. Since one frames is pending, another vsync
   // callback should run.
-  elapsed += base::TimeDelta::FromMilliseconds(thread.pendingDelayMs());
+  elapsed += base::TimeDelta::FromMilliseconds(thread.PendingDelayMs());
   // Sanity check that previous code didn't move time backward.
   EXPECT_GE(elapsed, time_source->Now());
-  time_source->setNow(elapsed);
-  thread.runPendingTask();
+  time_source->SetNow(elapsed);
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
 }
 
@@ -136,41 +136,41 @@ TEST(FrameRateControllerTest, TestFrameThrottling_Unthrottled) {
 
   // setActive triggers 1st frame, make sure the vsync callback is called
   controller.SetActive(true);
-  thread.runPendingTask();
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
   client.Reset();
 
   // Even if we don't call DidBeginFrame, FrameRateController should
   // still attempt to vsync tick multiple times until it does result in
   // a DidBeginFrame.
-  thread.runPendingTask();
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
   client.Reset();
 
-  thread.runPendingTask();
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
   client.Reset();
 
   // DidBeginFrame triggers 2nd frame, make sure the vsync callback is called
   controller.DidBeginFrame();
-  thread.runPendingTask();
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
   client.Reset();
 
   // DidBeginFrame triggers 3rd frame (> maxFramesPending),
   // make sure the vsync callback is NOT called
   controller.DidBeginFrame();
-  thread.runPendingTask();
+  thread.RunPendingTask();
   EXPECT_FALSE(client.VSyncTicked());
   client.Reset();
 
   // Make sure there is no pending task since we can't do anything until we
   // receive a DidFinishFrame anyway.
-  EXPECT_FALSE(thread.hasPendingTask());
+  EXPECT_FALSE(thread.HasPendingTask());
 
   // DidFinishFrame triggers a frame, make sure the vsync callback is called
   controller.DidFinishFrame();
-  thread.runPendingTask();
+  thread.RunPendingTask();
   EXPECT_TRUE(client.VSyncTicked());
 }
 
diff --git a/cc/scheduler/scheduler_unittest.cc b/cc/scheduler/scheduler_unittest.cc
index 531c97a..f47a872 100644
--- a/cc/scheduler/scheduler_unittest.cc
+++ b/cc/scheduler/scheduler_unittest.cc
@@ -109,7 +109,7 @@ TEST(SchedulerTest, RequestCommit) {
   client.Reset();
 
   // Tick should draw.
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(1, client.num_actions_());
   EXPECT_STREQ("ScheduledActionDrawAndSwapIfPossible", client.Action(0));
   EXPECT_FALSE(time_source->Active());
@@ -148,7 +148,7 @@ TEST(SchedulerTest, RequestCommitAfterBeginFrame) {
   client.Reset();
 
   // Tick should draw but then begin another frame.
-  time_source->tick();
+  time_source->Tick();
   EXPECT_FALSE(time_source->Active());
   EXPECT_EQ(2, client.num_actions_());
   EXPECT_STREQ("ScheduledActionDrawAndSwapIfPossible", client.Action(0));
@@ -191,7 +191,7 @@ TEST(SchedulerTest, TextureAcquisitionCollision) {
   client.Reset();
 
   // Once compositor draw complete, the delayed texture acquisition fires.
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(3, client.num_actions_());
   EXPECT_STREQ("ScheduledActionDrawAndSwapIfPossible", client.Action(0));
   EXPECT_STREQ("ScheduledActionAcquireLayerTexturesForMainThread",
@@ -284,12 +284,12 @@ TEST(SchedulerTest, RequestRedrawInsideDraw) {
   EXPECT_TRUE(time_source->Active());
   EXPECT_EQ(0, client.num_draws());
 
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(time_source->Active());
 
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(time_source->Active());
@@ -316,7 +316,7 @@ TEST(SchedulerTest, RequestRedrawInsideFailedDraw) {
   EXPECT_EQ(0, client.num_draws());
 
   // Fail the draw.
-  time_source->tick();
+  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
@@ -326,7 +326,7 @@ TEST(SchedulerTest, RequestRedrawInsideFailedDraw) {
   EXPECT_TRUE(time_source->Active());
 
   // Fail the draw again.
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
@@ -334,7 +334,7 @@ TEST(SchedulerTest, RequestRedrawInsideFailedDraw) {
 
   // Draw successfully.
   client.SetDrawWillHappen(true);
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(3, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_FALSE(scheduler->RedrawPending());
@@ -390,13 +390,13 @@ TEST(SchedulerTest, RequestCommitInsideDraw) {
   EXPECT_EQ(0, client.num_draws());
   EXPECT_TRUE(time_source->Active());
 
-  time_source->tick();
+  time_source->Tick();
   EXPECT_FALSE(time_source->Active());
   EXPECT_EQ(1, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   scheduler->BeginFrameComplete();
 
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_FALSE(time_source->Active());
   EXPECT_FALSE(scheduler->RedrawPending());
@@ -423,7 +423,7 @@ TEST(SchedulerTest, RequestCommitInsideFailedDraw) {
   EXPECT_EQ(0, client.num_draws());
 
   // Fail the draw.
-  time_source->tick();
+  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
@@ -433,7 +433,7 @@ TEST(SchedulerTest, RequestCommitInsideFailedDraw) {
   EXPECT_TRUE(time_source->Active());
 
   // Fail the draw again.
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(2, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_TRUE(scheduler->RedrawPending());
@@ -441,7 +441,7 @@ TEST(SchedulerTest, RequestCommitInsideFailedDraw) {
 
   // Draw successfully.
   client.SetDrawWillHappen(true);
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(3, client.num_draws());
   EXPECT_TRUE(scheduler->CommitPending());
   EXPECT_FALSE(scheduler->RedrawPending());
@@ -464,7 +464,7 @@ TEST(SchedulerTest, NoBeginFrameWhenDrawFails) {
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
-  EXPECT_EQ(0, controller_ptr->numFramesPending());
+  EXPECT_EQ(0, controller_ptr->NumFramesPending());
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
@@ -472,11 +472,11 @@ TEST(SchedulerTest, NoBeginFrameWhenDrawFails) {
   EXPECT_EQ(0, client.num_draws());
 
   // Draw successfully, this starts a new frame.
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(1, client.num_draws());
-  EXPECT_EQ(1, controller_ptr->numFramesPending());
+  EXPECT_EQ(1, controller_ptr->NumFramesPending());
   scheduler->DidSwapBuffersComplete();
-  EXPECT_EQ(0, controller_ptr->numFramesPending());
+  EXPECT_EQ(0, controller_ptr->NumFramesPending());
 
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
@@ -484,9 +484,9 @@ TEST(SchedulerTest, NoBeginFrameWhenDrawFails) {
 
   // Fail to draw, this should not start a frame.
   client.SetDrawWillHappen(false);
-  time_source->tick();
+  time_source->Tick();
   EXPECT_EQ(2, client.num_draws());
-  EXPECT_EQ(0, controller_ptr->numFramesPending());
+  EXPECT_EQ(0, controller_ptr->NumFramesPending());
 }
 
 TEST(SchedulerTest, NoBeginFrameWhenSwapFailsDuringForcedCommit) {
@@ -501,7 +501,7 @@ TEST(SchedulerTest, NoBeginFrameWhenSwapFailsDuringForcedCommit) {
                         controller.PassAs<FrameRateController>(),
                         default_scheduler_settings);
 
-  EXPECT_EQ(0, controller_ptr->numFramesPending());
+  EXPECT_EQ(0, controller_ptr->NumFramesPending());
 
   // Tell the client that it will fail to swap.
   client.SetDrawWillHappen(true);
@@ -513,7 +513,7 @@ TEST(SchedulerTest, NoBeginFrameWhenSwapFailsDuringForcedCommit) {
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapForced"));
 
   // We should not have told the frame rate controller that we began a frame.
-  EXPECT_EQ(0, controller_ptr->numFramesPending());
+  EXPECT_EQ(0, controller_ptr->NumFramesPending());
 }
 
 TEST(SchedulerTest, RecreateOutputSurfaceClearsPendingDrawCount) {
@@ -534,15 +534,15 @@ TEST(SchedulerTest, RecreateOutputSurfaceClearsPendingDrawCount) {
 
   // Draw successfully, this starts a new frame.
   scheduler->SetNeedsRedraw();
-  time_source->tick();
-  EXPECT_EQ(1, controller_ptr->numFramesPending());
+  time_source->Tick();
+  EXPECT_EQ(1, controller_ptr->NumFramesPending());
 
   scheduler->DidLoseOutputSurface();
   // Verifying that it's 1 so that we know that it's reset on recreate.
-  EXPECT_EQ(1, controller_ptr->numFramesPending());
+  EXPECT_EQ(1, controller_ptr->NumFramesPending());
 
   scheduler->DidRecreateOutputSurface();
-  EXPECT_EQ(0, controller_ptr->numFramesPending());
+  EXPECT_EQ(0, controller_ptr->NumFramesPending());
 }
 
 }  // namespace
diff --git a/cc/scheduler/vsync_time_source_unittest.cc b/cc/scheduler/vsync_time_source_unittest.cc
index 73703f1..334dde7 100644
--- a/cc/scheduler/vsync_time_source_unittest.cc
+++ b/cc/scheduler/vsync_time_source_unittest.cc
@@ -50,7 +50,7 @@ TEST_F(VSyncTimeSourceTest, TaskPostedAndTickCalled) {
 
   base::TimeTicks frame_time = base::TimeTicks::Now();
   provider_.Trigger(frame_time);
-  EXPECT_TRUE(client_.tickCalled());
+  EXPECT_TRUE(client_.TickCalled());
   EXPECT_EQ(timer_->LastTickTime(), frame_time);
 }
 
@@ -61,23 +61,23 @@ TEST_F(VSyncTimeSourceTest, NotificationDisabledLazily) {
   timer_->SetActive(true);
   EXPECT_TRUE(provider_.IsVSyncNotificationEnabled());
   provider_.Trigger(frame_time);
-  EXPECT_TRUE(client_.tickCalled());
+  EXPECT_TRUE(client_.TickCalled());
 
   // Disabling the timer should not disable vsync notification immediately.
-  client_.reset();
+  client_.Reset();
   timer_->SetActive(false);
   EXPECT_TRUE(provider_.IsVSyncNotificationEnabled());
 
   // At the next vsync the notification is disabled, but the timer isn't ticked.
   provider_.Trigger(frame_time);
   EXPECT_FALSE(provider_.IsVSyncNotificationEnabled());
-  EXPECT_FALSE(client_.tickCalled());
+  EXPECT_FALSE(client_.TickCalled());
 
   // The notification should not be disabled multiple times.
   provider_.RequestVSyncNotification(timer_.get());
   provider_.Trigger(frame_time);
   EXPECT_TRUE(provider_.IsVSyncNotificationEnabled());
-  EXPECT_FALSE(client_.tickCalled());
+  EXPECT_FALSE(client_.TickCalled());
 }
 
 TEST_F(VSyncTimeSourceTest, ValidNextTickTime) {
diff --git a/cc/test/scheduler_test_common.cc b/cc/test/scheduler_test_common.cc
index e96bbbf..c1aa200 100644
--- a/cc/test/scheduler_test_common.cc
+++ b/cc/test/scheduler_test_common.cc
@@ -8,75 +8,43 @@
 
 namespace cc {
 
-void FakeTimeSourceClient::OnTimerTick()
-{
-    m_tickCalled = true;
-}
+void FakeTimeSourceClient::OnTimerTick() { tick_called_ = true; }
 
-FakeThread::FakeThread()
-{
-    reset();
-}
+FakeThread::FakeThread() { Reset(); }
 
-FakeThread::~FakeThread()
-{
-}
+FakeThread::~FakeThread() {}
 
-void FakeThread::runPendingTask()
-{
-    ASSERT_TRUE(m_pendingTask);
-    scoped_ptr<base::Closure> task = m_pendingTask.Pass();
-    task->Run();
+void FakeThread::RunPendingTask() {
+  ASSERT_TRUE(pending_task_);
+  scoped_ptr<base::Closure> task = pending_task_.Pass();
+  task->Run();
 }
 
-void FakeThread::PostTask(base::Closure cb)
-{
-    PostDelayedTask(cb, base::TimeDelta());
+void FakeThread::PostTask(base::Closure cb) {
+  PostDelayedTask(cb, base::TimeDelta());
 }
 
-void FakeThread::PostDelayedTask(base::Closure cb, base::TimeDelta delay)
-{
-    if (m_runPendingTaskOnOverwrite && hasPendingTask())
-        runPendingTask();
+void FakeThread::PostDelayedTask(base::Closure cb, base::TimeDelta delay) {
+  if (run_pending_task_on_overwrite_ && HasPendingTask())
+    RunPendingTask();
 
-    ASSERT_FALSE(hasPendingTask());
-    m_pendingTask.reset(new base::Closure(cb));
-    m_pendingTaskDelay = delay.InMilliseconds();
+  ASSERT_FALSE(HasPendingTask());
+  pending_task_.reset(new base::Closure(cb));
+  pending_task_delay_ = delay.InMilliseconds();
 }
 
-bool FakeThread::BelongsToCurrentThread() const
-{
-    return true;
-}
+bool FakeThread::BelongsToCurrentThread() const { return true; }
 
-void FakeTimeSource::SetClient(TimeSourceClient* client)
-{
-    m_client = client;
-}
+void FakeTimeSource::SetClient(TimeSourceClient* client) { client_ = client; }
 
-void FakeTimeSource::SetActive(bool b)
-{
-    m_active = b;
-}
+void FakeTimeSource::SetActive(bool b) { active_ = b; }
 
-bool FakeTimeSource::Active() const
-{
-    return m_active;
-}
+bool FakeTimeSource::Active() const { return active_; }
 
-base::TimeTicks FakeTimeSource::LastTickTime()
-{
-    return base::TimeTicks();
-}
+base::TimeTicks FakeTimeSource::LastTickTime() { return base::TimeTicks(); }
 
-base::TimeTicks FakeTimeSource::NextTickTime()
-{
-    return base::TimeTicks();
-}
+base::TimeTicks FakeTimeSource::NextTickTime() { return base::TimeTicks(); }
 
-base::TimeTicks FakeDelayBasedTimeSource::Now() const
-{
-    return m_now;
-}
+base::TimeTicks FakeDelayBasedTimeSource::Now() const { return now_; }
 
 }  // namespace cc
diff --git a/cc/test/scheduler_test_common.h b/cc/test/scheduler_test_common.h
index 2cd6363..521def9 100644
--- a/cc/test/scheduler_test_common.h
+++ b/cc/test/scheduler_test_common.h
@@ -15,112 +15,106 @@
 namespace cc {
 
 class FakeTimeSourceClient : public cc::TimeSourceClient {
-public:
-    FakeTimeSourceClient() { reset(); }
-    void reset() { m_tickCalled = false; }
-    bool tickCalled() const { return m_tickCalled; }
+ public:
+  FakeTimeSourceClient() { Reset(); }
+  void Reset() { tick_called_ = false; }
+  bool TickCalled() const { return tick_called_; }
 
-    // TimeSourceClient implementation.
-    virtual void OnTimerTick() OVERRIDE;
+  // TimeSourceClient implementation.
+  virtual void OnTimerTick() OVERRIDE;
 
-protected:
-    bool m_tickCalled;
+ protected:
+  bool tick_called_;
 };
 
 class FakeThread : public cc::Thread {
-public:
-    FakeThread();
-    virtual ~FakeThread();
-
-    void reset()
-    {
-        m_pendingTaskDelay = 0;
-        m_pendingTask.reset();
-        m_runPendingTaskOnOverwrite = false;
-    }
-
-    void runPendingTaskOnOverwrite(bool enable)
-    {
-        m_runPendingTaskOnOverwrite = enable;
-    }
-
-    bool hasPendingTask() const { return m_pendingTask; }
-    void runPendingTask();
-
-    long long pendingDelayMs() const
-    {
-        EXPECT_TRUE(hasPendingTask());
-        return m_pendingTaskDelay;
-    }
-
-    virtual void PostTask(base::Closure cb) OVERRIDE;
-    virtual void PostDelayedTask(base::Closure cb, base::TimeDelta delay)
-        OVERRIDE;
-    virtual bool BelongsToCurrentThread() const OVERRIDE;
-
-protected:
-    scoped_ptr<base::Closure> m_pendingTask;
-    long long m_pendingTaskDelay;
-    bool m_runPendingTaskOnOverwrite;
+ public:
+  FakeThread();
+  virtual ~FakeThread();
+
+  void Reset() {
+    pending_task_delay_ = 0;
+    pending_task_.reset();
+    run_pending_task_on_overwrite_ = false;
+  }
+
+  void RunPendingTaskOnOverwrite(bool enable) {
+    run_pending_task_on_overwrite_ = enable;
+  }
+
+  bool HasPendingTask() const { return pending_task_; }
+  void RunPendingTask();
+
+  long long PendingDelayMs() const {
+    EXPECT_TRUE(HasPendingTask());
+    return pending_task_delay_;
+  }
+
+  virtual void PostTask(base::Closure cb) OVERRIDE;
+  virtual void PostDelayedTask(base::Closure cb, base::TimeDelta delay)
+      OVERRIDE;
+  virtual bool BelongsToCurrentThread() const OVERRIDE;
+
+ protected:
+  scoped_ptr<base::Closure> pending_task_;
+  long long pending_task_delay_;
+  bool run_pending_task_on_overwrite_;
 };
 
 class FakeTimeSource : public cc::TimeSource {
-public:
-    FakeTimeSource()
-        : m_active(false)
-        , m_client(0)
-    {
-    }
-
-    virtual void SetClient(cc::TimeSourceClient* client) OVERRIDE;
-    virtual void SetActive(bool b) OVERRIDE;
-    virtual bool Active() const OVERRIDE;
-    virtual void SetTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval) OVERRIDE { }
-    virtual base::TimeTicks LastTickTime() OVERRIDE;
-    virtual base::TimeTicks NextTickTime() OVERRIDE;
-
-    void tick()
-    {
-        ASSERT_TRUE(m_active);
-        if (m_client)
-            m_client->OnTimerTick();
-    }
-
-    void setNextTickTime(base::TimeTicks nextTickTime) { m_nextTickTime = nextTickTime; }
-
-protected:
-    virtual ~FakeTimeSource() { }
-
-    bool m_active;
-    base::TimeTicks m_nextTickTime;
-    cc::TimeSourceClient* m_client;
+ public:
+  FakeTimeSource() : active_(false), client_(0) {}
+
+  virtual void SetClient(cc::TimeSourceClient* client) OVERRIDE;
+  virtual void SetActive(bool b) OVERRIDE;
+  virtual bool Active() const OVERRIDE;
+  virtual void SetTimebaseAndInterval(base::TimeTicks timebase,
+                                      base::TimeDelta interval) OVERRIDE {}
+  virtual base::TimeTicks LastTickTime() OVERRIDE;
+  virtual base::TimeTicks NextTickTime() OVERRIDE;
+
+  void Tick() {
+    ASSERT_TRUE(active_);
+    if (client_)
+      client_->OnTimerTick();
+  }
+
+  void SetNextTickTime(base::TimeTicks next_tick_time) {
+    next_tick_time_ = next_tick_time;
+  }
+
+ protected:
+  virtual ~FakeTimeSource() {}
+
+  bool active_;
+  base::TimeTicks next_tick_time_;
+  cc::TimeSourceClient* client_;
 };
 
 class FakeDelayBasedTimeSource : public cc::DelayBasedTimeSource {
-public:
-    static scoped_refptr<FakeDelayBasedTimeSource> create(base::TimeDelta interval, cc::Thread* thread)
-    {
-        return make_scoped_refptr(new FakeDelayBasedTimeSource(interval, thread));
-    }
-
-    void setNow(base::TimeTicks time) { m_now = time; }
-    virtual base::TimeTicks Now() const OVERRIDE;
-
-protected:
-    FakeDelayBasedTimeSource(base::TimeDelta interval, cc::Thread* thread)
-        : DelayBasedTimeSource(interval, thread)
-    {
-    }
-    virtual ~FakeDelayBasedTimeSource() { }
-
-    base::TimeTicks m_now;
+ public:
+  static scoped_refptr<FakeDelayBasedTimeSource> Create(
+      base::TimeDelta interval, cc::Thread* thread) {
+    return make_scoped_refptr(new FakeDelayBasedTimeSource(interval, thread));
+  }
+
+  void SetNow(base::TimeTicks time) { now_ = time; }
+  virtual base::TimeTicks Now() const OVERRIDE;
+
+ protected:
+  FakeDelayBasedTimeSource(base::TimeDelta interval, cc::Thread* thread)
+      : DelayBasedTimeSource(interval, thread) {}
+  virtual ~FakeDelayBasedTimeSource() {}
+
+  base::TimeTicks now_;
 };
 
 class FakeFrameRateController : public cc::FrameRateController {
-public:
-    FakeFrameRateController(scoped_refptr<cc::TimeSource> timer) : cc::FrameRateController(timer) { }
+ public:
+  FakeFrameRateController(scoped_refptr<cc::TimeSource> timer)
+      : cc::FrameRateController(timer) {}
 
-    int numFramesPending() const { return num_frames_pending_; }
+  int NumFramesPending() const { return num_frames_pending_; }
 };
 
 }  // namespace cc