Move autowrap from ThreadManager constructor to Thread::Current.

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.
  */
 
 #ifndef WEBRTC_BASE_THREAD_H_
 #define WEBRTC_BASE_THREAD_H_
 
 #include <algorithm>
 #include <list>
 #include <memory>
 #include <string>
 #include <vector>
 
 #if defined(WEBRTC_POSIX)
 #include <pthread.h>
 #endif
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/messagequeue.h"
+#include "webrtc/base/platform_thread_types.h"
 
 #if defined(WEBRTC_WIN)
 #include "webrtc/base/win32.h"
 #endif
 
 namespace rtc {
 
 class Thread;
 
 class ThreadManager {
  public:
   static const int kForever = -1;
 
-  ThreadManager();
-  ~ThreadManager();
-
+  // Singleton, constructor and destructor are private.
   static ThreadManager* Instance();
 
   Thread* CurrentThread();
   void SetCurrentThread(Thread* thread);
 
   // Returns a thread object with its thread_ ivar set
   // to whatever the OS uses to represent the thread.
   // If there already *is* a Thread object corresponding to this thread,
   // this method will return that.  Otherwise it creates a new Thread
   // object whose wrapped() method will return true, and whose
   // handle will, on Win32, be opened with only synchronization privileges -
   // if you need more privilegs, rather than changing this method, please
   // write additional code to adjust the privileges, or call a different
   // factory method of your own devising, because this one gets used in
   // unexpected contexts (like inside browser plugins) and it would be a
   // shame to break it.  It is also conceivable on Win32 that we won't even
   // be able to get synchronization privileges, in which case the result
   // will have a null handle.
   Thread *WrapCurrentThread();
   void UnwrapCurrentThread();
 
+  bool IsMainThread();
+
  private:
+  ThreadManager();
+  ~ThreadManager();
+
 #if defined(WEBRTC_POSIX)
   pthread_key_t key_;
 #endif
 
 #if defined(WEBRTC_WIN)
   DWORD key_;
 #endif
 
+  // The thread to potentially autowrap.
+  PlatformThreadRef main_thread_ref_;
+
   RTC_DISALLOW_COPY_AND_ASSIGN(ThreadManager);
 };
 
 struct _SendMessage {
   _SendMessage() {}
   Thread *thread;
   Message msg;
   bool *ready;
 };
 
@@ skipping 34 matching lines @@
   // Note that this is a single threaded class.
   class ScopedDisallowBlockingCalls {
    public:
     ScopedDisallowBlockingCalls();
     ~ScopedDisallowBlockingCalls();
    private:
     Thread* const thread_;
     const bool previous_state_;
   };
 
-  bool IsCurrent() const {
-    return Current() == this;
-  }
+  bool IsCurrent() const;
 
   // Sleeps the calling thread for the specified number of milliseconds, during
   // which time no processing is performed. Returns false if sleeping was
   // interrupted by a signal (POSIX only).
   static bool SleepMs(int millis);
 
   // Sets the thread's name, for debugging. Must be called before Start().
   // If |obj| is non-null, its value is appended to |name|.
   const std::string& name() const { return name_; }
   bool SetName(const std::string& name, const void* obj);
@@ skipping 180 matching lines @@
 
  private:
   SocketServer* old_ss_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(SocketServerScope);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_THREAD_H_