(reland) Adds TimeDomains to the TaskQueueManager

components/scheduler/base/task_queue_impl.cc

Index: components/scheduler/base/task_queue_impl.cc
diff --git a/components/scheduler/base/task_queue_impl.cc b/components/scheduler/base/task_queue_impl.cc
index 651770740e8a2f7ba6527c25fd042425b0eba6ea..ff349e38df350095095d2d5cb75c8c9dd9adc4dc 100644
--- a/components/scheduler/base/task_queue_impl.cc
+++ b/components/scheduler/base/task_queue_impl.cc
@@ -4,6 +4,7 @@
 
 #include "components/scheduler/base/task_queue_impl.h"
 
+#include "components/scheduler/base/delayed_task_delegate.h"
 #include "components/scheduler/base/task_queue_manager.h"
 #include "components/scheduler/base/task_queue_manager_delegate.h"
 
@@ -12,11 +13,12 @@ namespace internal {
 
 TaskQueueImpl::TaskQueueImpl(
     TaskQueueManager* task_queue_manager,
+    const scoped_refptr<DelayedTaskDelegate>& delayed_task_delegate,
     const Spec& spec,
     const char* disabled_by_default_tracing_category,
     const char* disabled_by_default_verbose_tracing_category)
     : thread_id_(base::PlatformThread::CurrentId()),
-      any_thread_(task_queue_manager, spec.pump_policy),
+      any_thread_(task_queue_manager, spec.pump_policy, delayed_task_delegate),
       name_(spec.name),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
@@ -53,9 +55,13 @@ TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from,
   sequence_num = sequence_number;
 }
 
-TaskQueueImpl::AnyThread::AnyThread(TaskQueueManager* task_queue_manager,
-                                    PumpPolicy pump_policy)
-    : task_queue_manager(task_queue_manager), pump_policy(pump_policy) {}
+TaskQueueImpl::AnyThread::AnyThread(
+    TaskQueueManager* task_queue_manager,
+    PumpPolicy pump_policy,
+    const scoped_refptr<DelayedTaskDelegate>& delayed_task_delegate)
+    : task_queue_manager(task_queue_manager),
+      pump_policy(pump_policy),
+      delayed_task_delegate(delayed_task_delegate) {}
 
 TaskQueueImpl::AnyThread::~AnyThread() {}
 
@@ -70,6 +76,9 @@ void TaskQueueImpl::UnregisterTaskQueue() {
   base::AutoLock lock(any_thread_lock_);
   if (!any_thread().task_queue_manager)
     return;
+
+  any_thread().delayed_task_delegate->CancelDelayedWork(this);
+  any_thread().delayed_task_delegate = scoped_refptr<DelayedTaskDelegate>();

[Sami, 2015/11/17 10:31:06]

nit: I think there's a release() or reset() for this.

[alex clarke (OOO till 29th), 2015/11/18 15:30:15]

I can't see anything like that on scoped_refptr

   any_thread().task_queue_manager->UnregisterTaskQueue(this);
 
   any_thread().task_queue_manager = nullptr;
@@ -104,8 +113,8 @@ bool TaskQueueImpl::PostDelayedTaskAt(
   base::AutoLock lock(any_thread_lock_);
   if (!any_thread().task_queue_manager)
     return false;
-  LazyNow lazy_now(any_thread().task_queue_manager->delegate().get());
-  return PostDelayedTaskLocked(&lazy_now, from_here, task, desired_run_time,
+  any_thread().delayed_task_delegate->InvalidateNowCache();
+  return PostDelayedTaskLocked(from_here, task, desired_run_time,
                                TaskType::NORMAL);
 }
 
@@ -117,16 +126,14 @@ bool TaskQueueImpl::PostDelayedTaskImpl(
   base::AutoLock lock(any_thread_lock_);
   if (!any_thread().task_queue_manager)
     return false;
-  LazyNow lazy_now(any_thread().task_queue_manager->delegate().get());
   base::TimeTicks desired_run_time;
+  any_thread().delayed_task_delegate->InvalidateNowCache();
   if (delay > base::TimeDelta())
-    desired_run_time = lazy_now.Now() + delay;
-  return PostDelayedTaskLocked(&lazy_now, from_here, task, desired_run_time,
-                               task_type);
+    desired_run_time = any_thread().delayed_task_delegate->CachedNow() + delay;
+  return PostDelayedTaskLocked(from_here, task, desired_run_time, task_type);
 }
 
 bool TaskQueueImpl::PostDelayedTaskLocked(
-    LazyNow* lazy_now,
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeTicks desired_run_time,
@@ -138,13 +145,14 @@ bool TaskQueueImpl::PostDelayedTaskLocked(
   any_thread().task_queue_manager->DidQueueTask(pending_task);
 
   if (!desired_run_time.is_null()) {
-    pending_task.delayed_run_time = std::max(lazy_now->Now(), desired_run_time);
+    pending_task.delayed_run_time = std::max(
+        any_thread().delayed_task_delegate->CachedNow(), desired_run_time);
     // TODO(alexclarke): consider emplace() when C++11 library features allowed.
     any_thread().delayed_task_queue.push(pending_task);
     TraceQueueSize(true);
     // Schedule a later call to MoveReadyDelayedTasksToIncomingQueue.
-    any_thread().task_queue_manager->ScheduleDelayedWork(this, desired_run_time,
-                                                         lazy_now);
+    any_thread().delayed_task_delegate->ScheduleDelayedWork(this,
+                                                            desired_run_time);
     return true;
   }
   pending_task.set_enqueue_order(pending_task.sequence_num);
@@ -152,20 +160,19 @@ bool TaskQueueImpl::PostDelayedTaskLocked(
   return true;
 }
 
-void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue(LazyNow* lazy_now) {
+void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue() {
   base::AutoLock lock(any_thread_lock_);
   if (!any_thread().task_queue_manager)
     return;
 
-  MoveReadyDelayedTasksToIncomingQueueLocked(lazy_now);
+  MoveReadyDelayedTasksToIncomingQueueLocked();
 }
 
-void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueueLocked(
-    LazyNow* lazy_now) {
+void TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueueLocked() {
   // Enqueue all delayed tasks that should be running now.
   while (!any_thread().delayed_task_queue.empty() &&
          any_thread().delayed_task_queue.top().delayed_run_time <=
-             lazy_now->Now()) {
+             any_thread().delayed_task_delegate->CachedNow()) {
     // TODO(alexclarke): consider std::move() when allowed.
     EnqueueDelayedTaskLocked(any_thread().delayed_task_queue.top());
     any_thread().delayed_task_queue.pop();
@@ -232,14 +239,13 @@ bool TaskQueueImpl::NextPendingDelayedTaskRunTime(
   return true;
 }
 
-void TaskQueueImpl::UpdateWorkQueue(LazyNow* lazy_now,
-                                    bool should_trigger_wakeup,
+void TaskQueueImpl::UpdateWorkQueue(bool should_trigger_wakeup,
                                     const Task* previous_task) {
   DCHECK(main_thread_only().work_queue.empty());
   base::AutoLock lock(any_thread_lock_);
   if (!ShouldAutoPumpQueueLocked(should_trigger_wakeup, previous_task))
     return;
-  MoveReadyDelayedTasksToIncomingQueueLocked(lazy_now);
+  MoveReadyDelayedTasksToIncomingQueueLocked();
   std::swap(main_thread_only().work_queue, any_thread().incoming_queue);
   // |any_thread().incoming_queue| is now empty so
   // TaskQueueManager::UpdateQueues no longer needs to consider
@@ -322,8 +328,8 @@ void TaskQueueImpl::PumpQueueLocked() {
   if (!any_thread().task_queue_manager)
     return;
 
-  LazyNow lazy_now(any_thread().task_queue_manager->delegate().get());
-  MoveReadyDelayedTasksToIncomingQueueLocked(&lazy_now);
+  any_thread().delayed_task_delegate->InvalidateNowCache();
+  MoveReadyDelayedTasksToIncomingQueueLocked();
 
   bool was_empty = main_thread_only().work_queue.empty();
   while (!any_thread().incoming_queue.empty()) {
@@ -516,5 +522,10 @@ void TaskQueueImpl::TaskAsValueInto(const Task& task,
   state->EndDictionary();
 }
 
+size_t TaskQueueImpl::IncommingQueueSizeForTest() const {
+  base::AutoLock lock(any_thread_lock_);
+  return any_thread().incoming_queue.size();
+}
+
 }  // namespace internal
 }  // namespace scheduler