Use NullSocketServer instead of PhysicalSocketServer in SignalThread

webrtc/base/signalthread.h

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #ifndef WEBRTC_BASE_SIGNALTHREAD_H_
 #define WEBRTC_BASE_SIGNALTHREAD_H_
 
 #include <string>
 
 #include "webrtc/base/constructormagic.h"
+#include "webrtc/base/nullsocketserver.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
 
 ///////////////////////////////////////////////////////////////////////////////
 // SignalThread - Base class for worker threads.  The main thread should call
 //  Start() to begin work, and then follow one of these models:
 //   Normal: Wait for SignalWorkDone, and then call Release to destroy.
 //   Cancellation: Call Release(true), to abort the worker thread.
 //   Fire-and-forget: Call Release(false), which allows the thread to run to
 //    completion, and then self-destruct without further notification.
 //   Periodic tasks: Wait for SignalWorkDone, then eventually call Start()
 //    again to repeat the task. When the instance isn't needed anymore,
 //    call Release. DoWork, OnWorkStart and OnWorkStop are called again,
 //    on a new thread.
 //  The subclass should override DoWork() to perform the background task.  By
 //   periodically calling ContinueWork(), it can check for cancellation.
 //   OnWorkStart and OnWorkDone can be overridden to do pre- or post-work
 //   tasks in the context of the main thread.
 ///////////////////////////////////////////////////////////////////////////////
 
 class SignalThread
     : public sigslot::has_slots<>,
       protected MessageHandler {
  public:
-  SignalThread();
+  explicit SignalThread(bool use_socket_server = true);
 
   // Context: Main Thread.  Call before Start to change the worker's name.
   bool SetName(const std::string& name, const void* obj);
 
   // Context: Main Thread.  Call to begin the worker thread.
   void Start();
 
   // Context: Main Thread.  If the worker thread is not running, deletes the
   // object immediately.  Otherwise, asks the worker thread to abort processing,
   // and schedules the object to be deleted once the worker exits.
@@ skipping 41 matching lines @@
   enum State {
     kInit,            // Initialized, but not started
     kRunning,         // Started and doing work
     kReleasing,       // Same as running, but to be deleted when work is done
     kComplete,        // Work is done
     kStopping,        // Work is being interrupted
   };
 
   class Worker : public Thread {
    public:
-    explicit Worker(SignalThread* parent) : parent_(parent) {}
+    explicit Worker(SignalThread* parent, bool use_socket_server)
+        : Thread(use_socket_server
+                     ? SocketServer::CreateDefault()
+                     : std::unique_ptr<SocketServer>(new NullSocketServer())),
+          parent_(parent) {}
     ~Worker() override;
     void Run() override;
 
    private:
     SignalThread* parent_;
 
     RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Worker);
   };
 
   class SCOPED_LOCKABLE EnterExit {
@@ skipping 29 matching lines @@
   int refcount_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(SignalThread);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_SIGNALTHREAD_H_