Adds clearer function to create rtc::Thread without Physical SocketServer

webrtc/base/thread.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.
  */
 
@@ skipping 81 matching lines @@
 
 // WARNING! SUBCLASSES MUST CALL Stop() IN THEIR DESTRUCTORS!  See ~Thread().
 
 class Thread : public MessageQueue {
  public:
   // Create a new Thread and optionally assign it to the passed SocketServer.
   // Subclasses that override Clear should pass false for init_queue and call
   // DoInit() from their constructor to prevent races with the
   // MessageQueueManager already using the object while the vtable is still
   // being created.
-  explicit Thread(SocketServer* ss = nullptr, bool init_queue = true);
+  Thread();
+  explicit Thread(SocketServer* ss);

[tommi, 2016/04/27 12:45:25]

Down the line, I think it would be good if the socket server dependency could be
moved to a derived class, e.g. SocketServerThread.

[danilchap, 2016/04/27 15:08:55]

I see this cl as a small step towards that goal.

 
   // NOTE: ALL SUBCLASSES OF Thread MUST CALL Stop() IN THEIR DESTRUCTORS (or
   // guarantee Stop() is explicitly called before the subclass is destroyed).
   // This is required to avoid a data race between the destructor modifying the
   // vtable, and the Thread::PreRun calling the virtual method Run().
   ~Thread() override;
 
+  static std::unique_ptr<Thread> CreateWithSocketServer();
+  static std::unique_ptr<Thread> Create();
   static Thread* Current();
 
   // Used to catch performance regressions. Use this to disallow blocking calls
   // (Invoke) for a given scope.  If a synchronous call is made while this is in
   // effect, an assert will be triggered.
   // Note that this is a single threaded class.
   class ScopedDisallowBlockingCalls {
    public:
     ScopedDisallowBlockingCalls();
     ~ScopedDisallowBlockingCalls();
@@ skipping 97 matching lines @@
   // These functions are public to avoid injecting test hooks. Don't call them
   // outside of tests.
   // This method should be called when thread is created using non standard
   // method, like derived implementation of rtc::Thread and it can not be
   // started by calling Start(). This will set started flag to true and
   // owned to false. This must be called from the current thread.
   bool WrapCurrent();
   void UnwrapCurrent();
 
  protected:
+  Thread(SocketServer* ss, bool init_queue);
+  Thread(std::unique_ptr<SocketServer> ss, bool init_queue);
+
   // Same as WrapCurrent except that it never fails as it does not try to
   // acquire the synchronization access of the thread. The caller should never
   // call Stop() or Join() on this thread.
   void SafeWrapCurrent();
 
   // Blocks the calling thread until this thread has terminated.
   void Join();
 
   static void AssertBlockingIsAllowedOnCurrentThread();
 
@@ skipping 47 matching lines @@
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 // AutoThread automatically installs itself at construction
 // uninstalls at destruction, if a Thread object is
 // _not already_ associated with the current OS thread.
 
 class AutoThread : public Thread {
  public:
-  explicit AutoThread(SocketServer* ss = nullptr);
+  AutoThread();
   ~AutoThread() override;
 
  private:
   RTC_DISALLOW_COPY_AND_ASSIGN(AutoThread);
 };
 
 // Win32 extension for threads that need to use COM
 #if defined(WEBRTC_WIN)
 class ComThread : public Thread {
  public:
@@ skipping 21 matching lines @@
 
  private:
   SocketServer* old_ss_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(SocketServerScope);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_THREAD_H_