Refactoring the way begin frame sources inside scheduler work.

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 25 matching lines @@
 // The following methods correspond to the DelayBasedTimeSource that uses
 // the base::TimeTicks::HighResNow as the timebase.
 scoped_refptr<DelayBasedTimeSourceHighRes> DelayBasedTimeSourceHighRes::Create(
     base::TimeDelta interval,
     base::SingleThreadTaskRunner* task_runner) {
   return make_scoped_refptr(
       new DelayBasedTimeSourceHighRes(interval, task_runner));
 }
 
 DelayBasedTimeSourceHighRes::DelayBasedTimeSourceHighRes(
-    base::TimeDelta interval, base::SingleThreadTaskRunner* task_runner)
-    : DelayBasedTimeSource(interval, task_runner) {}
+    base::TimeDelta interval,
+    base::SingleThreadTaskRunner* task_runner)
+    : DelayBasedTimeSource(interval, task_runner) {
+}
 
 DelayBasedTimeSourceHighRes::~DelayBasedTimeSourceHighRes() {}
 
 base::TimeTicks DelayBasedTimeSourceHighRes::Now() const {
   return base::TimeTicks::HighResNow();
 }
 
 // The following methods correspond to the DelayBasedTimeSource that uses
 // the base::TimeTicks::Now as the timebase.
 scoped_refptr<DelayBasedTimeSource> DelayBasedTimeSource::Create(
     base::TimeDelta interval,
     base::SingleThreadTaskRunner* task_runner) {
   return make_scoped_refptr(new DelayBasedTimeSource(interval, task_runner));
 }
 
 DelayBasedTimeSource::DelayBasedTimeSource(
-    base::TimeDelta interval, base::SingleThreadTaskRunner* task_runner)
+    base::TimeDelta interval,
+    base::SingleThreadTaskRunner* task_runner)
     : client_(NULL),
       last_tick_time_(base::TimeTicks() - interval),
       current_parameters_(interval, base::TimeTicks()),
       next_parameters_(interval, base::TimeTicks()),
       active_(false),
       task_runner_(task_runner),
-      weak_factory_(this) {}
+      weak_factory_(this) {
+  DCHECK_NE(interval.ToInternalValue(), 0);

[brianderson, 2014/05/07 17:20:16]

DCHECK_GE? Below too.

[mithro-old, 2014/05/07 23:42:28]

Done.

+}
 
 DelayBasedTimeSource::~DelayBasedTimeSource() {}
 
 base::TimeTicks DelayBasedTimeSource::SetActive(bool active) {
   TRACE_EVENT1("cc", "DelayBasedTimeSource::SetActive", "active", active);
   if (active == active_)
     return base::TimeTicks();
   active_ = active;
 
   if (!active_) {
@@ skipping 35 matching lines @@
   if (client_)
     client_->OnTimerTick();
 }
 
 void DelayBasedTimeSource::SetClient(TimeSourceClient* client) {
   client_ = client;
 }
 
 void DelayBasedTimeSource::SetTimebaseAndInterval(base::TimeTicks timebase,
                                                   base::TimeDelta interval) {
+  DCHECK(!timebase.is_null());
+  DCHECK_NE(interval.ToInternalValue(), 0);
   next_parameters_.interval = interval;
   next_parameters_.tick_target = timebase;
 
   if (!active_) {
     // If we aren't active, there's no need to reset the timer.
     return;
   }
 
   // If the change in interval is larger than the change threshold,
   // request an immediate reset.
@@ skipping 129 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