Update from https://crrev.com/316786

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 <string>
 
@@ skipping 216 matching lines @@
 //      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  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;
-
-  // |interval_offset| is the offset from |now| to the next multiple of
-  // |interval| after |tick_target|, possibly negative if in the past.
-  base::TimeDelta interval_offset = base::TimeDelta::FromInternalValue(
-      (next_parameters_.tick_target - now).ToInternalValue() %
-      new_interval.ToInternalValue());
-  // If |now| is exactly on the interval (i.e. offset==0), don't adjust.
-  // Otherwise, if |tick_target| was in the past, adjust forward to the next
-  // tick after |now|.
-  if (interval_offset.ToInternalValue() != 0 &&
-      next_parameters_.tick_target < now) {
-    interval_offset += new_interval;
-  }
-
-  base::TimeTicks new_tick_target = now + interval_offset;
+  base::TimeTicks new_tick_target = now.SnappedToNextTick(
+      next_parameters_.tick_target, next_parameters_.interval);
   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()
-      << "; interval_offset = " << interval_offset.ToInternalValue();
+      << "; new_interval = " << next_parameters_.interval.InMicroseconds()
+      << "; tick_target = " << next_parameters_.tick_target.ToInternalValue();
 
   // Avoid double ticks when:
   // 1) Turning off the timer and turning it right back on.
   // 2) Jittery data is passed to SetTimebaseAndInterval().
-  if (new_tick_target - last_tick_time_ <= new_interval / kDoubleTickDivisor)
-    new_tick_target += new_interval;
+  if (new_tick_target - last_tick_time_ <=
+      next_parameters_.interval / kDoubleTickDivisor)
+    new_tick_target += next_parameters_.interval;
 
   return new_tick_target;
 }
 
 void DelayBasedTimeSource::PostNextTickTask(base::TimeTicks now) {
   base::TimeTicks new_tick_target = NextTickTarget(now);
 
   // Post another task *before* the tick and update state
   base::TimeDelta delay;
   if (now <= new_tick_target)
     delay = new_tick_target - now;
   task_runner_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&DelayBasedTimeSource::OnTimerFired,
                                            weak_factory_.GetWeakPtr()),
                                 delay);
 
   next_parameters_.tick_target = new_tick_target;
   current_parameters_ = next_parameters_;
 }
 
 std::string DelayBasedTimeSource::TypeString() const {
   return "DelayBasedTimeSource";
 }
 
 std::string DelayBasedTimeSourceHighRes::TypeString() const {
   return "DelayBasedTimeSourceHighRes";
 }
 
-void DelayBasedTimeSource::AsValueInto(base::debug::TracedValue* state) const {
+void DelayBasedTimeSource::AsValueInto(
+    base::trace_event::TracedValue* state) const {
   state->SetString("type", TypeString());
   state->SetDouble("last_tick_time_us", LastTickTime().ToInternalValue());
   state->SetDouble("next_tick_time_us", NextTickTime().ToInternalValue());
 
   state->BeginDictionary("current_parameters");
   state->SetDouble("interval_us",
                    current_parameters_.interval.InMicroseconds());
   state->SetDouble("tick_target_us",
                    current_parameters_.tick_target.ToInternalValue());
   state->EndDictionary();
 
   state->BeginDictionary("next_parameters");
   state->SetDouble("interval_us", next_parameters_.interval.InMicroseconds());
   state->SetDouble("tick_target_us",
                    next_parameters_.tick_target.ToInternalValue());
   state->EndDictionary();
 
   state->SetBoolean("active", active_);
 }
 
 }  // namespace cc