FOR REFERENCE ONLY Task Scheduler COM Task Runner

base/task_scheduler/scheduler_worker.h

 // 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.
 
 #ifndef BASE_TASK_SCHEDULER_SCHEDULER_WORKER_H_
 #define BASE_TASK_SCHEDULER_SCHEDULER_WORKER_H_
 
 #include <memory>
 
 #include "base/base_export.h"
@@ skipping 24 matching lines @@
 //
 // The worker is free to release and reallocate the platform thread with
 // guidance from the delegate.
 //
 // This class is thread-safe.
 class BASE_EXPORT SchedulerWorker
     : public RefCountedThreadSafe<SchedulerWorker> {
  public:
   // Delegate interface for SchedulerWorker. The methods are always called from
   // the thread managed by the SchedulerWorker instance.
-  class Delegate {
+  class BASE_EXPORT Delegate {
    public:
     virtual ~Delegate() = default;
 
     // Called by a thread managed by |worker| when it enters its main function.
     // If a thread is recreated after detachment, |detach_duration| is the time
     // elapsed since detachment. Otherwise, if this is the first thread created
     // for |worker|, |detach_duration| is TimeDelta::Max().
     virtual void OnMainEntry(SchedulerWorker* worker) = 0;
 
     // Called by a thread managed by |worker| to get a Sequence from which to
     // run a Task.
     virtual scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) = 0;
 
     // Called by the SchedulerWorker after it ran a task.
     virtual void DidRunTask() = 0;
 
     // Called when |sequence| isn't empty after the SchedulerWorker pops a Task
     // from it. |sequence| is the last Sequence returned by GetWork().
     virtual void ReEnqueueSequence(scoped_refptr<Sequence> sequence) = 0;
 
     // Called by a thread to determine how long to sleep before the next call to
     // GetWork(). GetWork() may be called before this timeout expires if the
     // worker's WakeUp() method is called.
     virtual TimeDelta GetSleepTimeout() = 0;
 
+    // Called by a thread to wait for work. Override this method if the thread
+    // in question needs special handling to go to sleep. |wake_up_event| is a
+    // manually resettable event and is signaled on SchedulerWorker::WakeUp()
+    virtual void WaitForWork(WaitableEvent* wake_up_event);
+
     // Called by a thread if it is allowed to detach if the last call to
     // GetWork() returned nullptr.
     //
     // It is the responsibility of the delegate to determine if detachment is
     // safe. If the delegate is responsible for thread-affine work, detachment
     // is generally not safe.
     //
     // When true is returned:
     // - The next WakeUp() could be more costly due to new thread creation.
     // - The worker will take this as a signal that it can detach, but it is not
@@ skipping 111 matching lines @@
   // Set once JoinForTesting() has been called.
   AtomicFlag join_called_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorker);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_SCHEDULER_WORKER_H_