Revamp the ProcessThreadImpl implementation.

* Add a new WakeUp method that gives a module a chance to be called back right away on the worker thread.
* Wrote unit tests for the class.
* Significantly reduce the amount of locking.
  - ProcessThreadImpl itself does a lot less locking.
  - Reimplemented the way we keep track of when to make calls to Process.
    This reduces the amount of calls to TimeUntilNextProcess and since most implementations of that function grab a lock, this means less locking.
* Renamed ProcessThread::CreateProcessThread to ProcessThread::Create.
* Added thread checks for Start/Stop.  Threading model of other functions is now documented.
* We now log an error if an implementation of TimeUntilNextProcess returns a negative value (some implementations do, but the method should only return a positive nr of ms).
* Removed the DestroyProcessThread method and instead force callers to use scoped_ptr<> to maintain object lifetime.

BUG=2822
R=henrika@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/35999004

Cr-Commit-Position: refs/heads/master@{#8261}
git-svn-id: http://webrtc.googlecode.com/svn/trunk@8261 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/utility/interface/mock/mock_process_thread.h

@@ -21,6 +21,7 @@ class MockProcessThread : public ProcessThread {
  public:
   MOCK_METHOD0(Start, int32_t());
   MOCK_METHOD0(Stop, int32_t());
+  MOCK_METHOD1(WakeUp, void(Module* module));
   MOCK_METHOD1(RegisterModule, int32_t(Module* module));
   MOCK_METHOD1(DeRegisterModule, int32_t(const Module* module));
 };

webrtc/modules/utility/interface/process_thread.h

@@ -12,23 +12,39 @@
 #define WEBRTC_MODULES_UTILITY_INTERFACE_PROCESS_THREAD_H_
 
 #include "webrtc/typedefs.h"
+#include "webrtc/base/scoped_ptr.h"
 
 namespace webrtc {
 class Module;
 
-class ProcessThread
-{
-public:
-    static ProcessThread* CreateProcessThread();
-    static void DestroyProcessThread(ProcessThread* module);
+class ProcessThread {
+ public:
+  virtual ~ProcessThread();
 
-    virtual int32_t Start() = 0;
-    virtual int32_t Stop() = 0;
+  static rtc::scoped_ptr<ProcessThread> Create();
 
-    virtual int32_t RegisterModule(Module* module) = 0;
-    virtual int32_t DeRegisterModule(const Module* module) = 0;
-protected:
-    virtual ~ProcessThread();
+  // Starts the worker thread.  Must be called from the construction thread.
+  virtual int32_t Start() = 0;
+
+  // Stops the worker thread.  Must be called from the construction thread.
+  virtual int32_t Stop() = 0;
+
+  // Wakes the thread up to give a module a chance to do processing right
+  // away.  This causes the worker thread to wake up and requery the specified
+  // module for when it should be called back. (Typically the module should
+  // return 0 from TimeUntilNextProcess on the worker thread at that point).
+  // Can be called on any thread.
+  virtual void WakeUp(Module* module) = 0;
+
+  // Adds a module that will start to receive callbacks on the worker thread.
+  // Can be called from any thread.
+  virtual int32_t RegisterModule(Module* module) = 0;
+
+  // Removes a previously registered module.
+  // Can be called from any thread.
+  virtual int32_t DeRegisterModule(const Module* module) = 0;
 };
+
 }  // namespace webrtc
+
 #endif // WEBRTC_MODULES_UTILITY_INTERFACE_PROCESS_THREAD_H_