cc: Handle future timebases properly in DelayBasedTimeSource

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/bind.h"
@@ skipping 175 matching lines @@
 // 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  new_target=50.000  -->
 //          tick(), PostDelayedTask(floor(50.000-37)) --> PostDelayedTask(13)
 base::TimeTicks DelayBasedTimeSource::NextTickTarget(base::TimeTicks now) {
   const base::TimeDelta epsilon(base::TimeDelta::FromMicroseconds(1));
   base::TimeDelta new_interval = next_parameters_.interval;
-  int intervals_elapsed =
-      (now - next_parameters_.tick_target + new_interval - epsilon) /
-      new_interval;
+
+  // Integer division rounds towards 0, but we always want to round down the
+  // number of intervals_elapsed, so we need the extra condition here.
+  int intervals_elapsed;
+  if (next_parameters_.tick_target < now) {

[jdduke (slow), 2013/08/14 22:39:37]

To make this a bit easier to read, what about defining something like:

base::TimeDelta time_since_tick_target = now - next_parameters_.tick_target;
if (time_since_tick_target > TimeDelta())
...

and re-using that value in the two computations?  I'm not incredibly familiar
with the context but the rest seems reasonable.  Do we have any utilities for
division rounding?

+    intervals_elapsed =
+        (now - next_parameters_.tick_target + new_interval - epsilon) /
+        new_interval;
+  } else {
+    intervals_elapsed = (now - next_parameters_.tick_target) / new_interval;
+  }
   base::TimeTicks new_tick_target =
       next_parameters_.tick_target + new_interval * intervals_elapsed;
   DCHECK(now <= new_tick_target)
       << "now = " << now.ToInternalValue()
       << "; new_tick_target = " << new_tick_target.ToInternalValue()
       << "; new_interval = " << new_interval.InMicroseconds()
       << "; tick_target = " << next_parameters_.tick_target.ToInternalValue()
       << "; intervals_elapsed = " << intervals_elapsed;
 
   // Avoid double ticks when:
@@ skipping 15 matching lines @@
   task_runner_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&DelayBasedTimeSource::OnTimerFired,
                                            weak_factory_.GetWeakPtr()),
                                 delay);
 
   next_parameters_.tick_target = new_tick_target;
   current_parameters_ = next_parameters_;
 }
 
 }  // namespace cc