cc: Cleanup DelayBasedTimeSource code.

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 45 matching lines @@
   TRACE_EVENT1("cc", "DelayBasedTimeSource::SetActive", "active", active);
   if (active == active_)
     return base::TimeTicks();
   active_ = active;
 
   if (!active_) {
     weak_factory_.InvalidateWeakPtrs();
     return base::TimeTicks();
   }
 
-  PostNextTickTask(Now());
+  base::TimeTicks now = Now();
+  PostNextTickTask(now);
+
+  if (current_parameters_.tick_target <= now)
+    return base::TimeTicks();
 
   // Determine if there was a tick that was missed while not active.
   base::TimeTicks last_tick_time_if_always_active =
     current_parameters_.tick_target - current_parameters_.interval;
   base::TimeTicks new_tick_time_threshold =
     last_tick_time_ + current_parameters_.interval / kDoubleTickDivisor;
   if (last_tick_time_if_always_active >  new_tick_time_threshold) {
     last_tick_time_ = last_tick_time_if_always_active;
     return last_tick_time_;
   }
@@ skipping 143 matching lines @@
   // 2) Jittery data is passed to SetTimebaseAndInterval().
   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);
+  DCHECK(new_tick_target >= now);

[brianderson, 2015/06/23 21:00:29]

DCHECK_GE

 
   // Post another task *before* the tick and update state
-  base::TimeDelta delay;
-  if (now <= new_tick_target)

[brianderson, 2015/06/23 21:00:29]

I forget why this was needed. Could small jitter in the timebase cause this
condition to hit?

[sunnyps, 2015/06/26 00:45:28]

This condition should always be true. See the DCHECK above.

-    delay = new_tick_target - now;
+  base::TimeDelta 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 {
@@ skipping 16 matching lines @@
   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