cc: Handle future timebases properly in DelayBasedTimeSource

cc/scheduler/delay_based_time_source.cc

Index: cc/scheduler/delay_based_time_source.cc
diff --git a/cc/scheduler/delay_based_time_source.cc b/cc/scheduler/delay_based_time_source.cc
index 1b162c9c88609e793a2794029597677af1a7adfc..412fd9a0064dfbb0c82d8b3e598b1c1ba2ff3b4f 100644
--- a/cc/scheduler/delay_based_time_source.cc
+++ b/cc/scheduler/delay_based_time_source.cc
@@ -193,9 +193,17 @@ base::TimeTicks DelayBasedTimeSource::Now() const {
 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)