(reland) Adds TimeDomains to the TaskQueueManager

components/scheduler/base/delayed_task_delegate.h

+// Copyright 2015 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.
+
+#ifndef COMPONENTS_SCHEDULER_BASE_DELAYED_TASK_DELEGATE_H_
+#define COMPONENTS_SCHEDULER_BASE_DELAYED_TASK_DELEGATE_H_
+
+#include <map>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/time/time.h"
+#include "components/scheduler/scheduler_export.h"
+
+namespace scheduler {
+namespace internal {
+class TaskQueueImpl;
+}  // namespace internal
+
+class SCHEDULER_EXPORT DelayedTaskDelegate

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

This class exposes public functions that deal with classes from the internal
namespace, which seems weird. Should we split this further into the
implementation part and a pure virtual delegate that the virtual time code can
override?

I guess one option would be to add the new methods on the TQM delegate, but
perhaps that becomes too confusing.

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

We made them private as discussed offline.

+    : public base::RefCounted<DelayedTaskDelegate> {
+ public:
+  DelayedTaskDelegate();
+
+  // Returns the most recent cached Now, records a new cache entry if there
+  // isn't one.
+  virtual base::TimeTicks CachedNow() = 0;
+
+  // Clears the cahced Now.  Causes the next call to |CachedNow| to sample Now
+  // which can be moderately expensive.
+  virtual void InvalidateNowCache() = 0;

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

I kinda prefer the earlier way of passing around a LazyNow explicitly because
it's much clearer what the lifetime of the cached value is. With this API it's
much easier to accidentally forget to invalidate the cache. WDYT?

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

Done.

+
+  // Schedules a call to TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue
+  // to run at |delayed_run_time|.
+  void ScheduleDelayedWork(internal::TaskQueueImpl* queue,
+                           base::TimeTicks delayed_run_time);
+
+  // Cancels all scheduled callbacks to |queue|.
+  void CancelDelayedWork(internal::TaskQueueImpl* queue);
+
+  // Call TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue for each
+  // queue where the delay has elapsed.
+  void WakeupReadyDelayedQueues();
+
+ protected:
+  friend class base::RefCounted<DelayedTaskDelegate>;
+
+  virtual ~DelayedTaskDelegate();
+
+  // Function calling ScheduleDelayedWork that's suitable for use in base::Bind.
+  void ScheduleDelayedWorkTask(scoped_refptr<internal::TaskQueueImpl> queue,
+                               base::TimeTicks delayed_run_time);
+
+  virtual bool BelongsToCurrentThread() const = 0;
+  virtual void PostScheduleDelayedWorkTaskOnMainThread(
+      internal::TaskQueueImpl* queue,
+      base::TimeTicks delayed_run_time) = 0;
+  virtual void ScheduleDoWork(base::TimeDelta delay) = 0;
+
+  typedef std::multimap<base::TimeTicks, internal::TaskQueueImpl*>
+      DelayedWakeupMultimap;
+
+  DelayedWakeupMultimap delayed_wakeup_multimap_;
+
+  DISALLOW_COPY_AND_ASSIGN(DelayedTaskDelegate);
+};
+
+}  // namespace scheduler
+
+#endif  // COMPONENTS_SCHEDULER_BASE_DELAYED_TASK_DELEGATE_H_