TaskScheduler [11] Support ExecutionMode::SINGLE_THREADED.

base/task_scheduler/scheduler_thread_pool.cc

 // Copyright 2016 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 "base/task_scheduler/scheduler_thread_pool.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 107 matching lines @@
 class SchedulerThreadPool::SchedulerWorkerThreadDelegateImpl
     : public SchedulerWorkerThread::Delegate {
  public:
   SchedulerWorkerThreadDelegateImpl(
       SchedulerThreadPool* outer,
       const EnqueueSequenceCallback& enqueue_sequence_callback);
   ~SchedulerWorkerThreadDelegateImpl() override;
 
   // SchedulerWorkerThread::Delegate:
   void OnMainEntry() override;
-  scoped_refptr<Sequence> GetWork(
-      SchedulerWorkerThread* worker_thread) override;
+  scoped_refptr<Sequence> GetWork(SchedulerWorkerThread* worker_thread,
+                                  PriorityQueue* single_threaded_priority_queue,

[robliao, 2016/04/18 19:53:51]

single_thread_priority_queue -> alternate_priority_queue to match the signature
from SchedulerWorkerThread::Delegate.

Same with is_single_threaded_sequence.

[fdoray, 2016/04/18 20:40:55]

Done.

+                                  bool* is_single_threaded_sequence) override;
   void EnqueueSequence(scoped_refptr<Sequence> sequence) override;
 
  private:
   SchedulerThreadPool* outer_;
   const EnqueueSequenceCallback enqueue_sequence_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerThreadDelegateImpl);
 };
 
 SchedulerThreadPool::~SchedulerThreadPool() {
@@ skipping 94 matching lines @@
 SchedulerThreadPool::SchedulerWorkerThreadDelegateImpl::
     ~SchedulerWorkerThreadDelegateImpl() = default;
 
 void SchedulerThreadPool::SchedulerWorkerThreadDelegateImpl::OnMainEntry() {
   DCHECK(!tls_current_thread_pool.Get().Get());
   tls_current_thread_pool.Get().Set(outer_);
 }
 
 scoped_refptr<Sequence>
 SchedulerThreadPool::SchedulerWorkerThreadDelegateImpl::GetWork(
-    SchedulerWorkerThread* worker_thread) {
+    SchedulerWorkerThread* worker_thread,
+    PriorityQueue* single_threaded_priority_queue,
+    bool* is_single_threaded_sequence) {
+  // TODO(fdoray): Return a Sequence from |single_threaded_priority_queue| when
+  // appropriate.
+
   std::unique_ptr<PriorityQueue::Transaction> transaction(
       outer_->shared_priority_queue_.BeginTransaction());
   const auto sequence_and_sort_key = transaction->Peek();
 
   if (sequence_and_sort_key.is_null()) {
     // |transaction| is kept alive while |worker_thread| is added to
     // |idle_worker_threads_stack_| to avoid this race:
     // 1. This thread creates a Transaction, finds |shared_priority_queue_|
     //    empty and ends the Transaction.
     // 2. Other thread creates a Transaction, inserts a Sequence into
@@ skipping 36 matching lines @@
 
 bool SchedulerThreadPool::Initialize(ThreadPriority thread_priority,
                                      size_t max_threads) {
   AutoSchedulerLock auto_lock(idle_worker_threads_stack_lock_);
 
   DCHECK(worker_threads_.empty());
 
   for (size_t i = 0; i < max_threads; ++i) {
     std::unique_ptr<SchedulerWorkerThread> worker_thread =
         SchedulerWorkerThread::CreateSchedulerWorkerThread(
-            thread_priority, worker_thread_delegate_.get(), task_tracker_);
+            thread_priority, worker_thread_delegate_.get(), task_tracker_,
+            delayed_task_manager_, &shared_priority_queue_);
     if (!worker_thread)
       break;
     idle_worker_threads_stack_.push(worker_thread.get());
     worker_threads_.push_back(std::move(worker_thread));
   }
 
   return !worker_threads_.empty();
 }
 
 void SchedulerThreadPool::WakeUpOneThread() {
@@ skipping 18 matching lines @@
   if (idle_worker_threads_stack_.empty())
     return nullptr;
 
   auto worker_thread = idle_worker_threads_stack_.top();
   idle_worker_threads_stack_.pop();
   return worker_thread;
 }
 
 }  // namespace internal
 }  // namespace base