cc: Fix capitalization style in chromified files.

cc/scheduler/delay_based_time_source.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/delay_based_time_source.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/debug/trace_event.h"
@@ skipping 33 matching lines @@
       has_tick_target_(false),
       current_parameters_(interval, base::TimeTicks()),
       next_parameters_(interval, base::TimeTicks()),
       state_(STATE_INACTIVE),
       thread_(thread),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
 DelayBasedTimeSource::~DelayBasedTimeSource() {}
 
 void DelayBasedTimeSource::SetActive(bool active) {
-  TRACE_EVENT1("cc", "DelayBasedTimeSource::setActive", "active", active);
+  TRACE_EVENT1("cc", "DelayBasedTimeSource::SetActive", "active", active);
   if (!active) {
     state_ = STATE_INACTIVE;
     weak_factory_.InvalidateWeakPtrs();
     return;
   }
 
   if (state_ == STATE_STARTING || state_ == STATE_ACTIVE)
     return;
 
   if (!has_tick_target_) {
@@ skipping 80 matching lines @@
     return;
   }
 }
 
 base::TimeTicks DelayBasedTimeSource::Now() const {
   return base::TimeTicks::Now();
 }
 
 // This code tries to achieve an average tick rate as close to interval_ as
 // possible.  To do this, it has to deal with a few basic issues:
-//   1. postDelayedTask can delay only at a millisecond granularity. So, 16.666
+//   1. PostDelayedTask can delay only at a millisecond granularity. So, 16.666
 //   has to posted as 16 or 17.
 //   2. A delayed task may come back a bit late (a few ms), or really late
 //   (frames later)
 //
 // The basic idea with this scheduler here is to keep track of where we *want*
 // to run in tick_target_. We update this with the exact interval.
 //
 // Then, when we post our task, we take the floor of (tick_target_ and Now()).
 // If we started at now=0, and 60FPs (all times in milliseconds):
-//      now=0    target=16.667   postDelayedTask(16)
+//      now=0    target=16.667   PostDelayedTask(16)
 //
 // When our callback runs, we figure out how far off we were from that goal.
 // Because of the flooring operation, and assuming our timer runs exactly when
 // it should, this yields:
 //      now=16   target=16.667
 //
 // Since we can't post a 0.667 ms task to get to now=16, we just treat this as a
 // tick. Then, we update target to be 33.333. We now post another task based on
 // the difference between our target and now:
-//      now=16   tick_target=16.667  newTarget=33.333   -->
-//          postDelayedTask(floor(33.333 - 16)) --> postDelayedTask(17)
+//      now=16   tick_target=16.667  new_target=33.333   -->
+//          PostDelayedTask(floor(33.333 - 16)) --> PostDelayedTask(17)
 //
 // Over time, with no late tasks, this leads to us posting tasks like this:
-//      now=0    tick_target=0       newTarget=16.667   -->
-//          tick(), postDelayedTask(16)
-//      now=16   tick_target=16.667  newTarget=33.333   -->
-//          tick(), postDelayedTask(17)
-//      now=33   tick_target=33.333  newTarget=50.000   -->
-//          tick(), postDelayedTask(17)
-//      now=50   tick_target=50.000  newTarget=66.667   -->
-//          tick(), postDelayedTask(16)
+//      now=0    tick_target=0       new_target=16.667   -->
+//          tick(), PostDelayedTask(16)
+//      now=16   tick_target=16.667  new_target=33.333   -->
+//          tick(), PostDelayedTask(17)
+//      now=33   tick_target=33.333  new_target=50.000   -->
+//          tick(), PostDelayedTask(17)
+//      now=50   tick_target=50.000  new_target=66.667   -->
+//          tick(), PostDelayedTask(16)
 //
 // We treat delays in tasks differently depending on the amount of delay we
 // encounter. Suppose we posted a task with a target=16.667:
 //   Case 1: late but not unrecoverably-so
 //      now=18 tick_target=16.667
 //
 //   Case 2: so late we obviously missed the tick
 //      now=25.0 tick_target=16.667
 //
 // We treat the first case as a tick anyway, and assume the delay was unusual.
-// Thus, we compute the newTarget based on the old timebase:
-//      now=18   tick_target=16.667  newTarget=33.333   -->
-//          tick(), postDelayedTask(floor(33.333-18)) --> postDelayedTask(15)
+// Thus, we compute the new_target based on the old timebase:
+//      now=18   tick_target=16.667  new_target=33.333   -->
+//          tick(), PostDelayedTask(floor(33.333-18)) --> PostDelayedTask(15)
 // This brings us back to 18+15 = 33, which was where we would have been if the
 // task hadn't been late.
 //
 // For the really late delay, we we move to the next logical tick. The timebase
 // is not reset.
-//      now=37   tick_target=16.667  newTarget=50.000  -->
-//          tick(), postDelayedTask(floor(50.000-37)) --> postDelayedTask(13)
+//      now=37   tick_target=16.667  new_target=50.000  -->
+//          tick(), PostDelayedTask(floor(50.000-37)) --> PostDelayedTask(13)
 base::TimeTicks DelayBasedTimeSource::NextTickTarget(base::TimeTicks now) {
   base::TimeDelta new_interval = next_parameters_.interval;
   int intervals_elapsed =
       static_cast<int>(floor((now - next_parameters_.tick_target).InSecondsF() /
                              new_interval.InSecondsF()));
   base::TimeTicks last_effective_tick =
       next_parameters_.tick_target + new_interval * intervals_elapsed;
   base::TimeTicks new_tick_target = last_effective_tick + new_interval;
   DCHECK(new_tick_target > now);
 
@@ skipping 17 matching lines @@
          (1.0 + kDoubleTickThreshold));
   thread_->PostDelayedTask(base::Bind(&DelayBasedTimeSource::OnTimerFired,
                                       weak_factory_.GetWeakPtr()),
                            delay);
 
   next_parameters_.tick_target = new_tick_target;
   current_parameters_ = next_parameters_;
 }
 
 }  // namespace cc