FOR REFERENCE ONLY Task Scheduler COM Task Runner

base/task_scheduler/scheduler_worker.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_worker.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 23 matching lines @@
   }
 
   // PlatformThread::Delegate.
   void ThreadMain() override {
     // Set if this thread was detached.
     std::unique_ptr<Thread> detached_thread;
 
     outer_->delegate_->OnMainEntry(outer_.get());
 
     // A SchedulerWorker starts out waiting for work.
-    WaitForWork();
+    outer_->delegate_->WaitForWork(&wake_up_event_);
 
 #if defined(OS_WIN)
     std::unique_ptr<win::ScopedCOMInitializer> com_initializer;
     if (outer_->backward_compatibility_ ==
         SchedulerBackwardCompatibility::INIT_COM_STA) {
       com_initializer = MakeUnique<win::ScopedCOMInitializer>();
     }
 #endif
 
     while (!outer_->ShouldExit()) {
@@ skipping 10 matching lines @@
           outer_->delegate_->GetWork(outer_.get());
       if (!sequence) {
         if (outer_->delegate_->CanDetach(outer_.get())) {
           detached_thread = outer_->DetachThreadObject(DetachNotify::DELEGATE);
           if (detached_thread) {
             DCHECK_EQ(detached_thread.get(), this);
             PlatformThread::Detach(thread_handle_);
             break;
           }
         }
-        WaitForWork();
+        outer_->delegate_->WaitForWork(&wake_up_event_);
         continue;
       }
 
       if (outer_->task_tracker_->RunTask(sequence->TakeTask(),
                                          sequence->token())) {
         outer_->delegate_->DidRunTask();
       }
 
       const bool sequence_became_empty = sequence->Pop();
 
@@ skipping 50 matching lines @@
         current_thread_priority_(GetDesiredThreadPriority()) {
     DCHECK(outer_);
   }
 
   void Initialize() {
     constexpr size_t kDefaultStackSize = 0;
     PlatformThread::CreateWithPriority(kDefaultStackSize, this, &thread_handle_,
                                        current_thread_priority_);
   }
 
-  void WaitForWork() {
-    DCHECK(outer_);
-    const TimeDelta sleep_time = outer_->delegate_->GetSleepTimeout();
-    if (sleep_time.is_max()) {
-      // Calling TimedWait with TimeDelta::Max is not recommended per
-      // http://crbug.com/465948.
-      wake_up_event_.Wait();
-    } else {
-      wake_up_event_.TimedWait(sleep_time);
-    }
-    wake_up_event_.Reset();
-  }
-
   // Returns the priority for which the thread should be set based on the
   // priority hint, current shutdown state, and platform capabilities.
   ThreadPriority GetDesiredThreadPriority() {
     DCHECK(outer_);
 
     // All threads have a NORMAL priority when Lock doesn't handle multiple
     // thread priorities.
     if (!Lock::HandlesMultipleThreadPriorities())
       return ThreadPriority::NORMAL;
 
@@ skipping 25 matching lines @@
   // Event signaled to wake up this thread.
   WaitableEvent wake_up_event_;
 
   // Current priority of this thread. May be different from
   // |outer_->priority_hint_|.
   ThreadPriority current_thread_priority_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
+void SchedulerWorker::Delegate::WaitForWork(WaitableEvent* wake_up_event) {
+  DCHECK(wake_up_event);
+  const TimeDelta sleep_time = GetSleepTimeout();
+  if (sleep_time.is_max()) {
+    // Calling TimedWait with TimeDelta::Max is not recommended per
+    // http://crbug.com/465948.
+    wake_up_event->Wait();
+  } else {
+    wake_up_event->TimedWait(sleep_time);
+  }
+  wake_up_event->Reset();
+}
+
 scoped_refptr<SchedulerWorker> SchedulerWorker::Create(
     ThreadPriority priority_hint,
     std::unique_ptr<Delegate> delegate,
     TaskTracker* task_tracker,
     InitialState initial_state,
     SchedulerBackwardCompatibility backward_compatibility) {
   scoped_refptr<SchedulerWorker> worker(
       new SchedulerWorker(priority_hint, std::move(delegate), task_tracker,
                           backward_compatibility));
   // Creation happens before any other thread can reference this one, so no
@@ skipping 116 matching lines @@
   CreateThread();
 }
 
 bool SchedulerWorker::ShouldExit() {
   return task_tracker_->IsShutdownComplete() ||
          join_called_for_testing_.IsSet() || should_exit_.IsSet();
 }
 
 }  // namespace internal
 }  // namespace base