TaskScheduler [11] Support ExecutionMode::SINGLE_THREADED.

base/task_scheduler/scheduler_worker_thread.h

Index: base/task_scheduler/scheduler_worker_thread.h
diff --git a/base/task_scheduler/scheduler_worker_thread.h b/base/task_scheduler/scheduler_worker_thread.h
index 3022d100c61239b863c51d95b64e0252ef1360f1..5de245dcb019a3846b52e57368df2c29e84bd7da 100644
--- a/base/task_scheduler/scheduler_worker_thread.h
+++ b/base/task_scheduler/scheduler_worker_thread.h
@@ -37,8 +37,8 @@ class BASE_EXPORT SchedulerWorkerThread : public PlatformThread::Delegate {
    public:
     virtual ~Delegate() = default;
 
-    // Called when the main function of the SchedulerWorkerThread enters.
-    virtual void OnMainEntry() = 0;
+    // Called by |worker_thread| when it enters its main function.
+    virtual void OnMainEntry(SchedulerWorkerThread* worker_thread) = 0;
 
     // Called by |worker_thread| to get a Sequence from which to run a Task.
     virtual scoped_refptr<Sequence> GetWork(
@@ -68,6 +68,8 @@ class BASE_EXPORT SchedulerWorkerThread : public PlatformThread::Delegate {
   // returned by the GetWork() method of its delegate until it returns nullptr.
   void WakeUp();
 
+  SchedulerWorkerThread::Delegate* delegate() { return delegate_.get(); }

[danakj, 2016/04/27 20:38:13]

I also wonder about exposing the delegate here, this seems to be bad for law of
demeter. Maybe this could return the priority queue, and the fact that it goes
through delegate to get it is an implementation detail?

[gab, 2016/04/27 20:45:39]

I asked for this. Asking the SchedulerWorkerThread for the priority queue
doesn't work because the impl (which is defined and instantiated in
SchedulerThreadPoolImpl) has it (not the generic interface) and the
SchedulerWorkerThread thus can't reach it (it's not even aware of its
existence).

Prior to this there was a map in SchedulerThreadPoolImpl to map
SchedulerWorkerThreads to their PriorityQueue but I thought it felt silly to do
a map lookup to get something we already have hidden in the
SchedulerWorkerThread we're using to do the query..!

[danakj, 2016/04/27 20:53:28]

What if Delegate had a GetThreadPriorityQueue?

[robliao, 2016/04/27 21:14:53]

We would like the SchedulerWorkerThread to be agnostic to priority queues as all
manipulations about the priority queues are handled by the delegate.

In the implementation, the SchedulerThreadPool fully controls the delegate that
gets passed to the SchedulerWorkerThread. It stands to reason that the
SchedulerThreadPool should be able to get its own implementation back of the
delegate since it's the one that passed it in. I suspect it would be unexpected
if the delegate were to change materially after passing it in.

The other alternative is to allow two owners of the pointer, either via raw
pointer or via refcount. These two I don't like so much.

[danakj, 2016/04/27 21:56:38]

OK that is fair yeah. We do the same thing when we pass things into blink and
then down cast them back when blink hands that type back. Though there it's
because we're not allowed to expose the real thing to blink. I'm not sure it's
ideal, but it's certainly valid.
Yeh, I agree.

+
   // Joins this SchedulerWorkerThread. If a Task is already running, it will be
   // allowed to complete its execution. This can only be called once.
   void JoinForTesting();