Remove dependency on cc::TestNowSource from scheduler code

content/child/scheduler/task_queue_manager.cc

 // Copyright 2014 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 "content/child/scheduler/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
-#include "cc/test/test_now_source.h"
 #include "content/child/scheduler/nestable_single_thread_task_runner.h"
 #include "content/child/scheduler/task_queue_selector.h"
+#include "content/child/scheduler/time_source.h"
 
 namespace {
 const int64_t kMaxTimeTicks = std::numeric_limits<int64>::max();
 }
 
 namespace content {
 namespace internal {
 
 // Now() is somewhat expensive so it makes sense not to call Now() unless we
 // really need to.
@@ skipping 428 matching lines @@
 TaskQueueManager::TaskQueueManager(
     size_t task_queue_count,
     scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
     TaskQueueSelector* selector,
     const char* disabled_by_default_tracing_category)
     : main_task_runner_(main_task_runner),
       selector_(selector),
       task_was_run_bitmap_(0),
       pending_dowork_count_(0),
       work_batch_size_(1),
-      time_source_(nullptr),
+      time_source_(new TimeSource),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       deletion_sentinel_(new DeletionSentinel()),
       weak_factory_(this) {
   DCHECK(main_task_runner->RunsTasksOnCurrentThread());
   DCHECK_LE(task_queue_count, sizeof(task_was_run_bitmap_) * CHAR_BIT)
       << "You need a bigger int for task_was_run_bitmap_";
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(disabled_by_default_tracing_category,
                                      "TaskQueueManager", this);
 
@@ skipping 221 matching lines @@
 }
 
 void TaskQueueManager::RemoveTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   base::MessageLoop::current()->RemoveTaskObserver(task_observer);
   task_observers_.RemoveObserver(task_observer);
 }
 
 void TaskQueueManager::SetTimeSourceForTesting(
-    scoped_refptr<cc::TestNowSource> time_source) {
+    scoped_ptr<TimeSource> time_source) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
-  time_source_ = time_source;
+  time_source_ = time_source.Pass();
 }
 
 uint64 TaskQueueManager::GetAndClearTaskWasRunOnQueueBitmap() {
   uint64 bitmap = task_was_run_bitmap_;
   task_was_run_bitmap_ = 0;
   return bitmap;
 }
 
 base::TimeTicks TaskQueueManager::Now() const {
-  return UNLIKELY(time_source_) ? time_source_->Now() : base::TimeTicks::Now();
+  return time_source_->Now();
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 TaskQueueManager::AsValueWithSelectorResult(bool should_run,
                                             size_t selected_queue) const {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
   state->BeginArray("queues");
   for (auto& queue : queues_)
     queue->AsValueInto(state.get());
   state->EndArray();
   state->BeginDictionary("selector");
   selector_->AsValueInto(state.get());
   state->EndDictionary();
   if (should_run)
     state->SetInteger("selected_queue", selected_queue);
   return state;
 }
 
 void TaskQueueManager::OnTaskQueueEnabled() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   MaybePostDoWorkOnMainRunner();
 }
 
 }  // namespace content