cc: Fix capitalization style in chromified files.

cc/scheduler/scheduler_state_machine_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_state_machine.h"
 
 #include "cc/scheduler/scheduler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
@@ skipping 41 matching lines @@
 
     EXPECT_FALSE(state.VSyncCallbackNeeded());
 
     state.DidLeaveVSync();
     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
     EXPECT_FALSE(state.VSyncCallbackNeeded());
     state.DidEnterVSync();
     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   }
 
-  // If commit requested but canBeginFrame is still false, do nothing.
+  // If commit requested but can_begin_frame is still false, do nothing.
   {
     StateMachine state(default_scheduler_settings);
     state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
 
     EXPECT_FALSE(state.VSyncCallbackNeeded());
 
     state.DidLeaveVSync();
     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
     EXPECT_FALSE(state.VSyncCallbackNeeded());
     state.DidEnterVSync();
     EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   }
 
   // If commit requested, begin a frame.
   {
     StateMachine state(default_scheduler_settings);
     state.SetCommitState(SchedulerStateMachine::COMMIT_STATE_IDLE);
     state.SetCanBeginFrame(true);
     state.SetNeedsRedraw(false);
     state.SetVisible(true);
     EXPECT_FALSE(state.VSyncCallbackNeeded());
   }
 
-  // Begin the frame, make sure needsCommit and commitState update correctly.
+  // Begin the frame, make sure needs_commit and commit_state update correctly.
   {
     StateMachine state(default_scheduler_settings);
     state.SetCanBeginFrame(true);
     state.SetVisible(true);
     state.UpdateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
     EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS,
               state.CommitState());
     EXPECT_FALSE(state.NeedsCommit());
     EXPECT_FALSE(state.VSyncCallbackNeeded());
   }
@@ skipping 265 matching lines @@
       StateMachine state(default_scheduler_settings);
       state.SetCommitState(all_commit_states[i]);
       bool visible = j;
       if (!visible) {
         state.DidEnterVSync();
         state.SetVisible(false);
       } else {
         state.SetVisible(true);
       }
 
-      // Case 1: needsCommit=false
+      // Case 1: needs_commit=false
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
 
-      // Case 2: needsCommit=true
+      // Case 2: needs_commit=true
       state.SetNeedsCommit();
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
     }
   }
 
-  // When on vsync, or not on vsync but needsForcedRedraw set, should always
+  // When on vsync, or not on vsync but needs_forced_dedraw set, should always
   // draw except if you're ready to commit, in which case commit.
   for (size_t i = 0; i < num_commit_states; ++i) {
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCanDraw(true);
       state.SetCommitState(all_commit_states[i]);
       bool forced_draw = j;
       if (!forced_draw) {
         state.DidEnterVSync();
         state.SetNeedsRedraw(true);
         state.SetVisible(true);
       } else {
         state.SetNeedsForcedRedraw(true);
       }
 
       SchedulerStateMachine::Action expected_action;
       if (all_commit_states[i] !=
           SchedulerStateMachine::COMMIT_STATE_READY_TO_COMMIT) {
         expected_action =
             forced_draw ? SchedulerStateMachine::ACTION_DRAW_FORCED
                         : SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE;
       } else {
         expected_action = SchedulerStateMachine::ACTION_COMMIT;
       }
 
-      // Case 1: needsCommit=false.
+      // Case 1: needs_commit=false.
       EXPECT_TRUE(state.VSyncCallbackNeeded());
       EXPECT_EQ(expected_action, state.NextAction());
 
-      // Case 2: needsCommit=true.
+      // Case 2: needs_commit=true.
       state.SetNeedsCommit();
       EXPECT_TRUE(state.VSyncCallbackNeeded());
       EXPECT_EQ(expected_action, state.NextAction());
     }
   }
 }
 
 TEST(SchedulerStateMachineTest, TestNoCommitStatesRedrawWhenInvisible) {
   SchedulerSettings default_scheduler_settings;
 
   size_t num_commit_states =
       sizeof(all_commit_states) / sizeof(SchedulerStateMachine::CommitState);
   for (size_t i = 0; i < num_commit_states; ++i) {
     // There shouldn't be any drawing regardless of vsync.
     for (size_t j = 0; j < 2; ++j) {
       StateMachine state(default_scheduler_settings);
       state.SetCommitState(all_commit_states[i]);
       state.SetVisible(false);
       state.SetNeedsRedraw(true);
       state.SetNeedsForcedRedraw(false);
       if (j == 1)
         state.DidEnterVSync();
 
-      // Case 1: needsCommit=false.
+      // Case 1: needs_commit=false.
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
 
-      // Case 2: needsCommit=true.
+      // Case 2: needs_commit=true.
       state.SetNeedsCommit();
       EXPECT_NE(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE,
                 state.NextAction());
     }
   }
 }
 
 TEST(SchedulerStateMachineTest, TestCanRedraw_StopsDraw) {
   SchedulerSettings default_scheduler_settings;
 
@@ skipping 187 matching lines @@
   state.SetNeedsCommit();
   EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.NextAction());
 
   // Begin the frame while visible.
   state.UpdateState(SchedulerStateMachine::ACTION_BEGIN_FRAME);
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_FRAME_IN_PROGRESS,
             state.CommitState());
   EXPECT_FALSE(state.NeedsCommit());
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
-  // Become invisible and abort the beginFrame.
+  // Become invisible and abort the BeginFrame.
   state.SetVisible(false);
   state.BeginFrameAborted();
 
   // We should now be back in the idle state as if we didn't start a frame at
   // all.
   EXPECT_EQ(SchedulerStateMachine::COMMIT_STATE_IDLE, state.CommitState());
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   // Become visible again.
   state.SetVisible(true);
@@ skipping 56 matching lines @@
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
 
   // Recreate the context
   state.DidRecreateOutputSurface();
 
   // When the context is recreated, we should begin a commit
   EXPECT_EQ(SchedulerStateMachine::ACTION_BEGIN_FRAME, state.NextAction());
   state.UpdateState(state.NextAction());
 
   // Once the context is recreated, whether we draw should be based on
-  // setCanDraw.
+  // SetCanDraw.
   state.SetNeedsRedraw(true);
   state.DidEnterVSync();
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE, state.NextAction());
   state.SetCanDraw(false);
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.SetCanDraw(true);
   state.DidLeaveVSync();
 }
 
 TEST(SchedulerStateMachineTest, TestContextLostWhileCommitInProgress) {
@@ skipping 333 matching lines @@
   EXPECT_EQ(SchedulerStateMachine::ACTION_NONE, state.NextAction());
   state.SetNeedsForcedRedraw(true);
   EXPECT_EQ(SchedulerStateMachine::ACTION_DRAW_FORCED, state.NextAction());
   state.UpdateState(state.NextAction());
   state.DidDrawIfPossibleCompleted(true);
   state.DidLeaveVSync();
 }
 
 }  // namespace
 }  // namespace cc