Line data    Source code

       1             : /*
       2             :  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
       3             :  *
       4             :  *  Use of this source code is governed by a BSD-style license
       5             :  *  that can be found in the LICENSE file in the root of the source
       6             :  *  tree. An additional intellectual property rights grant can be found
       7             :  *  in the file PATENTS.  All contributing project authors may
       8             :  *  be found in the AUTHORS file in the root of the source tree.
       9             :  */
      10             : 
      11             : #ifndef WEBRTC_MODULES_UTILITY_INCLUDE_PROCESS_THREAD_H_
      12             : #define WEBRTC_MODULES_UTILITY_INCLUDE_PROCESS_THREAD_H_
      13             : 
      14             : #include <memory>
      15             : 
      16             : #include "webrtc/typedefs.h"
      17             : 
      18             : #if defined(WEBRTC_WIN)
      19             : // Due to a bug in the std::unique_ptr implementation that ships with MSVS,
      20             : // we need the full definition of QueuedTask, on Windows.
      21             : #include "webrtc/base/task_queue.h"
      22             : #else
      23             : namespace rtc {
      24             : class QueuedTask;
      25             : }
      26             : #endif
      27             : 
      28             : namespace webrtc {
      29             : class Module;
      30             : 
      31             : // TODO(tommi): ProcessThread probably doesn't need to be a virtual
      32             : // interface.  There exists one override besides ProcessThreadImpl,
      33             : // MockProcessThread, but when looking at how it is used, it seems
      34             : // a nullptr might suffice (or simply an actual ProcessThread instance).
      35           0 : class ProcessThread {
      36             :  public:
      37             :   virtual ~ProcessThread();
      38             : 
      39             :   static std::unique_ptr<ProcessThread> Create(const char* thread_name);
      40             : 
      41             :   // Starts the worker thread.  Must be called from the construction thread.
      42             :   virtual void Start() = 0;
      43             : 
      44             :   // Stops the worker thread.  Must be called from the construction thread.
      45             :   virtual void Stop() = 0;
      46             : 
      47             :   // Wakes the thread up to give a module a chance to do processing right
      48             :   // away.  This causes the worker thread to wake up and requery the specified
      49             :   // module for when it should be called back. (Typically the module should
      50             :   // return 0 from TimeUntilNextProcess on the worker thread at that point).
      51             :   // Can be called on any thread.
      52             :   virtual void WakeUp(Module* module) = 0;
      53             : 
      54             :   // Queues a task object to run on the worker thread.  Ownership of the
      55             :   // task object is transferred to the ProcessThread and the object will
      56             :   // either be deleted after running on the worker thread, or on the
      57             :   // construction thread of the ProcessThread instance, if the task did not
      58             :   // get a chance to run (e.g. posting the task while shutting down or when
      59             :   // the thread never runs).
      60             :   virtual void PostTask(std::unique_ptr<rtc::QueuedTask> task) = 0;
      61             : 
      62             :   // Adds a module that will start to receive callbacks on the worker thread.
      63             :   // Can be called from any thread.
      64             :   virtual void RegisterModule(Module* module) = 0;
      65             : 
      66             :   // Removes a previously registered module.
      67             :   // Can be called from any thread.
      68             :   virtual void DeRegisterModule(Module* module) = 0;
      69             : };
      70             : 
      71             : }  // namespace webrtc
      72             : 
      73             : #endif // WEBRTC_MODULES_UTILITY_INCLUDE_PROCESS_THREAD_H_