(reland) Adds TimeDomains to the TaskQueueManager

components/scheduler/base/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 "components/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
-#include "components/scheduler/base/lazy_now.h"
+#include "components/scheduler/base/delayed_task_delegate_impl.h"
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_manager_delegate.h"
 #include "components/scheduler/base/task_queue_selector.h"
 #include "components/scheduler/base/task_queue_sets.h"
 
 namespace {
 const int64_t kMaxTimeTicks = std::numeric_limits<int64>::max();
 }
 
 namespace scheduler {
@@ skipping 17 matching lines @@
       weak_factory_(this) {
   DCHECK(delegate->RunsTasksOnCurrentThread());
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(disabled_by_default_tracing_category,
                                      "TaskQueueManager", this);
   selector_.SetTaskQueueSelectorObserver(this);
 
   decrement_pending_and_do_work_closure_ =
       base::Bind(&TaskQueueManager::DoWork, weak_factory_.GetWeakPtr(), true);
   do_work_closure_ =
       base::Bind(&TaskQueueManager::DoWork, weak_factory_.GetWeakPtr(), false);
+
+  delayed_task_delegate_ = make_scoped_refptr(
+      new DelayedTaskDelegateImpl(delegate.get(), do_work_closure_));
 }
 
 TaskQueueManager::~TaskQueueManager() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(disabled_by_default_tracing_category_,
                                      "TaskQueueManager", this);
 
   while (!queues_.empty())
     (*queues_.begin())->UnregisterTaskQueue();
 
   selector_.SetTaskQueueSelectorObserver(nullptr);
 }
 
 scoped_refptr<internal::TaskQueueImpl> TaskQueueManager::NewTaskQueue(
     const TaskQueue::Spec& spec) {
   TRACE_EVENT1(tracing_category_,
                "TaskQueueManager::NewTaskQueue", "queue_name", spec.name);
   DCHECK(main_thread_checker_.CalledOnValidThread());
   scoped_refptr<internal::TaskQueueImpl> queue(
       make_scoped_refptr(new internal::TaskQueueImpl(
-          this, spec, disabled_by_default_tracing_category_,
+          this, spec.delayed_task_delegate ? spec.delayed_task_delegate
+                                           : delayed_task_delegate_,
+          spec, disabled_by_default_tracing_category_,
           disabled_by_default_verbose_tracing_category_)));
   queues_.insert(queue);
   selector_.AddQueue(queue.get());
   return queue;
 }
 
 void TaskQueueManager::SetObserver(Observer* observer) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   observer_ = observer;
 }
 
 void TaskQueueManager::UnregisterTaskQueue(
     scoped_refptr<internal::TaskQueueImpl> task_queue) {
   TRACE_EVENT1(tracing_category_,
                "TaskQueueManager::UnregisterTaskQueue", "queue_name",
                task_queue->GetName());
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (observer_)
     observer_->OnUnregisterTaskQueue(task_queue);
 
   // Add |task_queue| to |queues_to_delete_| so we can prevent it from being
   // freed while any of our structures hold hold a raw pointer to it.
   queues_to_delete_.insert(task_queue);
   queues_.erase(task_queue);
   selector_.RemoveQueue(task_queue.get());
 
-  // We need to remove |task_queue| from delayed_wakeup_multimap_ which is a
-  // little awkward since it's keyed by time. O(n) running time.
-  for (DelayedWakeupMultimap::iterator iter = delayed_wakeup_multimap_.begin();
-       iter != delayed_wakeup_multimap_.end();) {
-    if (iter->second == task_queue.get()) {
-      DelayedWakeupMultimap::iterator temp = iter;
-      iter++;
-      // O(1) amortized.
-      delayed_wakeup_multimap_.erase(temp);
-    } else {
-      iter++;
-    }
-  }
-
   // |newly_updatable_| might contain |task_queue|, we use
   // MoveNewlyUpdatableQueuesIntoUpdatableQueueSet to flush it out.
   MoveNewlyUpdatableQueuesIntoUpdatableQueueSet();
   updatable_queue_set_.erase(task_queue.get());
 }
 
 base::TimeTicks TaskQueueManager::NextPendingDelayedTaskRunTime() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   bool found_pending_task = false;
   base::TimeTicks next_pending_delayed_task(
@@ skipping 45 matching lines @@
     newly_updatable_.pop_back();
   }
 }
 
 void TaskQueueManager::UpdateWorkQueues(
     bool should_trigger_wakeup,
     const internal::TaskQueueImpl::Task* previous_task) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   TRACE_EVENT0(disabled_by_default_tracing_category_,
                "TaskQueueManager::UpdateWorkQueues");
-  internal::LazyNow lazy_now(delegate().get());
+  delayed_task_delegate_->InvalidateNowCache();
 
   // Move any ready delayed tasks into the incomming queues.
-  WakeupReadyDelayedQueues(&lazy_now);
+  delayed_task_delegate_->WakeupReadyDelayedQueues();
 
   MoveNewlyUpdatableQueuesIntoUpdatableQueueSet();
 
   auto iter = updatable_queue_set_.begin();
   while (iter != updatable_queue_set_.end()) {
     internal::TaskQueueImpl* queue = *iter++;
     // NOTE Update work queue may erase itself from |updatable_queue_set_|.
     // This is fine, erasing an element won't invalidate any interator, as long
     // as the iterator isn't the element being delated.
     if (queue->work_queue().empty())
-      queue->UpdateWorkQueue(&lazy_now, should_trigger_wakeup, previous_task);
+      queue->UpdateWorkQueue(should_trigger_wakeup, previous_task);
   }
 }
 
-void TaskQueueManager::ScheduleDelayedWorkTask(
-    scoped_refptr<internal::TaskQueueImpl> queue,
-    base::TimeTicks delayed_run_time) {
-  internal::LazyNow lazy_now(delegate().get());
-  ScheduleDelayedWork(queue.get(), delayed_run_time, &lazy_now);
-}
-
-void TaskQueueManager::ScheduleDelayedWork(internal::TaskQueueImpl* queue,
-                                           base::TimeTicks delayed_run_time,
-                                           internal::LazyNow* lazy_now) {
-  if (!delegate_->BelongsToCurrentThread()) {
-    // NOTE posting a delayed task from a different thread is not expected to be
-    // common. This pathway is less optimal than perhaps it could be because
-    // it causes two main thread tasks to be run.  Should this assumption prove
-    // to be false in future, we may need to revisit this.
-    delegate_->PostTask(
-        FROM_HERE, base::Bind(&TaskQueueManager::ScheduleDelayedWorkTask,
-                              weak_factory_.GetWeakPtr(),
-                              scoped_refptr<internal::TaskQueueImpl>(queue),
-                              delayed_run_time));
-    return;
-  }
-
-  // Make sure there's one (and only one) task posted to |delegate_|
-  // to call |DelayedDoWork| at |delayed_run_time|.
-  if (delayed_wakeup_multimap_.find(delayed_run_time) ==
-      delayed_wakeup_multimap_.end()) {
-    base::TimeDelta delay =
-        std::max(base::TimeDelta(), delayed_run_time - lazy_now->Now());
-    delegate_->PostDelayedTask(FROM_HERE, do_work_closure_, delay);
-  }
-  delayed_wakeup_multimap_.insert(std::make_pair(delayed_run_time, queue));
-}
-
-void TaskQueueManager::WakeupReadyDelayedQueues(internal::LazyNow* lazy_now) {
-  // Wake up any queues with pending delayed work.  Note std::multipmap stores
-  // the elements sorted by key, so the begin() iterator points to the earliest
-  // queue to wakeup.
-  std::set<internal::TaskQueueImpl*> dedup_set;
-  while (!delayed_wakeup_multimap_.empty()) {
-    DelayedWakeupMultimap::iterator next_wakeup =
-        delayed_wakeup_multimap_.begin();
-    if (next_wakeup->first > lazy_now->Now())
-      break;
-    // A queue could have any number of delayed tasks pending so it's worthwhile
-    // deduping calls to MoveReadyDelayedTasksToIncomingQueue since it takes a
-    // lock.  NOTE the order in which these are called matters since the order
-    // in which EnqueueTaskLocks is called is respected when choosing which
-    // queue to execute a task from.
-    if (dedup_set.insert(next_wakeup->second).second)
-      next_wakeup->second->MoveReadyDelayedTasksToIncomingQueue(lazy_now);
-    delayed_wakeup_multimap_.erase(next_wakeup);
-  }
-}
-
 void TaskQueueManager::MaybePostDoWorkOnMainRunner() {
   bool on_main_thread = delegate_->BelongsToCurrentThread();
   if (on_main_thread) {
     // We only want one pending DoWork posted from the main thread, or we risk
     // an explosion of pending DoWorks which could starve out everything else.
     if (pending_dowork_count_ > 0) {
       return;
     }
     pending_dowork_count_++;
     delegate_->PostTask(FROM_HERE, decrement_pending_and_do_work_closure_);
@@ skipping 177 matching lines @@
 }
 
 void TaskQueueManager::OnTaskQueueEnabled(internal::TaskQueueImpl* queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // Only schedule DoWork if there's something to do.
   if (!queue->work_queue().empty())
     MaybePostDoWorkOnMainRunner();
 }
 
 }  // namespace scheduler