(reland) Adds TimeDomains to the TaskQueueManager

components/scheduler/base/time_domain.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_TIME_DOMAIN_H_
+#define COMPONENTS_SCHEDULER_BASE_TIME_DOMAIN_H_
+
+#include <map>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/time/time.h"
+#include "components/scheduler/base/lazy_now.h"
+#include "components/scheduler/base/task_queue_impl.h"
+#include "components/scheduler/scheduler_export.h"
+
+namespace scheduler {
+namespace internal {
+class TaskQueueImpl;
+}  // internal
+class TaskQueueManager;
+class TaskQueueManagerDelegate;
+
+class SCHEDULER_EXPORT TimeDomain : public base::RefCounted<TimeDomain> {
+ public:
+  explicit TimeDomain(TaskQueueManagerDelegate* task_queue_manager_delegate);
+
+  // Returns a LazyNow that evaluate this TimeDomain's Now.
+  virtual LazyNow GetLazyNow() = 0;

[Sami, 2015/11/18 18:36:24]

nit: "Create" since this is creating a new one from scratch.

+
+  // Some TimeDomains support vitual time, this method tells us to advance time

[Sami, 2015/11/18 18:36:24]

typo: virtual

[alex clarke (OOO till 29th), 2015/11/19 12:20:12]

Done.

+  // if possible and return true if time was advanced.
+  virtual bool MaybeAdvanceTime() = 0;
+
+  // Returns the name of this time domain for tracing.
+  virtual const char* GetName() const = 0;
+
+ protected:
+  friend class internal::TaskQueueImpl;
+  friend class TaskQueueManager;
+  friend class base::RefCounted<TimeDomain>;
+
+  virtual ~TimeDomain();
+
+  void AsValueInto(base::trace_event::TracedValue* state) const;
+
+  // If there is a scheduled delayed task, |out_time| is set to the scheduled
+  // runtime for the next one and it returns true.  Returns false otherwise.
+  bool NextScheduledRunTime(base::TimeTicks* out_time) const;
+
+  // If there is a scheduled delayed task, |out_task_queue| is set to the queue
+  // the next task was posted to and it returns true.  Returns false otherwise.
+  bool NextScheduledTaskQueue(TaskQueue** out_task_queue) const;
+
+  // Adds |queue| to the set of task queues that UpdateWorkQueues calls
+  // UpdateWorkQueue on.
+  void RegisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue);
+
+  // Schedules a call to MoveReadyDelayedTasksToIncomingQueue when this

[Sami, 2015/11/18 18:36:24]

nit: might want to fully qualify this to make it clear where the function lives:

TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue()

[alex clarke (OOO till 29th), 2015/11/19 12:20:12]

Done.

+  // TimeDomain reaches |delayed_run_time|.
+  void ScheduleDelayedWork(internal::TaskQueueImpl* queue,
+                           base::TimeTicks delayed_run_time,
+                           LazyNow* lazy_now);
+
+  // Removes |queue| from the set of task queues that UpdateWorkQueues calls
+  // UpdateWorkQueue on.
+  void UnregisterAsUpdatableTaskQueue(internal::TaskQueueImpl* queue);
+
+  // Removes |queue| from all internal data structures.
+  void UnregisterQueue(internal::TaskQueueImpl* queue);
+
+  // Updates active queues associated with this TimeDomain.
+  void UpdateWorkQueues(bool should_trigger_wakeup,
+                        const internal::TaskQueueImpl::Task* previous_task);
+
+  TaskQueueManagerDelegate* task_queue_manager_delegate() const {
+    return task_queue_manager_delegate_;
+  }
+
+  // The implementaion must arrange for TaskQueueManager::DoWork to be run with
+  // |delay| with respect to the TimeDomain's time source.
+  virtual void ScheduleDoWork(base::TimeDelta delay) = 0;

[Sami, 2015/11/18 18:36:24]

I wonder if we can simplify this part a bit: the contract says that the
implementation should arrange for TQM::DoWork() to be called at a later time,
but TQM::DoWork() is private so you can't really implement this without TQM's
help.

What if we instead just exposed a (public) virtual ScheduleWakeup (or something)
that takes the function to run as a parameter? That way the time domain doesn't
really need to know anything about TQM.

[alex clarke (OOO till 29th), 2015/11/19 12:20:12]

It's looking like all the various forms of virtual time will have this function
be a NOP.  Given that I think the "DoWork" part of the name and the comment
possibly isn't helpful.

Instead of passing in a function I propose to rename this to RequestWakeup and
leave what it does up to the implementer. E.g. RealTimeDomain takes a do work
closure and posts it on the delegate.

+
+  // For implementation specific tracing.
+  virtual void AsValueIntoInternal(
+      base::trace_event::TracedValue* state) const = 0;
+
+ private:
+  // Function calling ScheduleDelayedWork that's suitable for use in base::Bind.
+  void ScheduleDelayedWorkTask(scoped_refptr<internal::TaskQueueImpl> queue,
+                               base::TimeTicks delayed_run_time);
+
+  // Call TaskQueueImpl::MoveReadyDelayedTasksToIncomingQueue for each
+  // queue where the delay has elapsed.
+  void WakeupReadyDelayedQueues(LazyNow* lazy_now);
+
+  void MoveNewlyUpdatableQueuesIntoUpdatableQueueSet();
+
+  typedef std::multimap<base::TimeTicks, internal::TaskQueueImpl*>
+      DelayedWakeupMultimap;
+
+  DelayedWakeupMultimap delayed_wakeup_multimap_;
+  TaskQueueManagerDelegate* task_queue_manager_delegate_;  // NOT OWNED

[Sami, 2015/11/18 18:36:24]

I wonder if we remove the dependency on TaskQueueManagerDelegate here? This
class barely needs it and the only subclass that needs it is the real time one.

The only need for the delegate here is for hopping onto the right thread if
we're posting a delayed task from a different one. I wonder if we could do that
in the TaskQueueImpl instead? That would also fix a bug that we have that
posting the thread-hop task onto the delegate (instead of a task queue) may
delay it indefinitely depending on the work batch size.

[alex clarke (OOO till 29th), 2015/11/19 12:20:12]

Done.

+
+  // This lock guards only |newly_updatable_|.  It's not expected to be heavily
+  // contended.
+  base::Lock newly_updatable_lock_;
+  std::vector<internal::TaskQueueImpl*> newly_updatable_;
+
+  // Set of task queues with avaliable work on the incoming queue.  This should
+  // only be accessed from the main thread.
+  std::set<internal::TaskQueueImpl*> updatable_queue_set_;
+
+  base::ThreadChecker main_thread_checker_;
+  base::WeakPtrFactory<TimeDomain> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(TimeDomain);
+};
+
+}  // namespace scheduler
+
+#endif  // COMPONENTS_SCHEDULER_BASE_TIME_DOMAIN_H_