Do not block in SimpleThread::Start().

base/threading/simple_thread.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // WARNING: You should probably be using Thread (thread.h) instead.  Thread is
 //          Chrome's message-loop based Thread abstraction, and if you are a
 //          thread running in the browser, there will likely be assumptions
 //          that your thread will have an associated message loop.
 //
 // This is a simple thread interface that backs to a native operating system
@@ skipping 12 matching lines @@
 //
 // Thread Safety: A SimpleThread is not completely thread safe.  It is safe to
 // access it from the creating thread or from the newly created thread.  This
 // implies that the creator thread should be the thread that calls Join.
 //
 // Example:
 //   class MyThreadRunner : public DelegateSimpleThread::Delegate { ... };
 //   MyThreadRunner runner;
 //   DelegateSimpleThread thread(&runner, "good_name_here");
 //   thread.Start();
-//   // Start will return after the Thread has been successfully started and
-//   // initialized.  The newly created thread will invoke runner->Run(), and
-//   // run until it returns.
+//   // The newly created thread will invoke runner->Run(), and run until it
+//   // returns.
 //   thread.Join();  // Wait until the thread has exited.  You *MUST* Join!
 //   // The SimpleThread object is still valid, however you may not call Join
 //   // or Start again.
 
 #ifndef BASE_THREADING_SIMPLE_THREAD_H_
 #define BASE_THREADING_SIMPLE_THREAD_H_
 
 #include <stddef.h>
 
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/compiler_specific.h"
+#include "base/logging.h"
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 
 // This is the base SimpleThread.  You can derive from it and implement the
 // virtual Run method, or you can use the DelegateSimpleThread interface.
 class BASE_EXPORT SimpleThread : public PlatformThread::Delegate {
@@ skipping 28 matching lines @@
   SimpleThread(const std::string& name_prefix, const Options& options);
 
   ~SimpleThread() override;
 
   virtual void Start();
   virtual void Join();
 
   // Subclasses should override the Run method.
   virtual void Run() = 0;
 
-  // Return the thread id, only valid after Start().
-  PlatformThreadId tid() { return tid_; }
-
-  // Return True if Start() has ever been called.
-  bool HasBeenStarted();
-
-  // Return True if Join() has ever been called.
-  bool HasBeenJoined() { return joined_; }
+  // Return the thread id.
+  PlatformThreadId GetTid() const;
 
   // Overridden from PlatformThread::Delegate:
   void ThreadMain() override;
 
  private:
   const std::string name_prefix_;
   std::string name_;
   const Options options_;
-  PlatformThreadHandle thread_;  // PlatformThread handle, reset after Join.
-  WaitableEvent event_;          // Signaled if Start() was ever called.
-  PlatformThreadId tid_ = kInvalidThreadId;  // The backing thread's id.
-  bool joined_ = false;                      // True if Join has been called.
+
+  // PlatformThread handle, reset after Join.
+  PlatformThreadHandle thread_;
+
+  // Signaled once |tid_| is set.
+  mutable WaitableEvent id_event_;
+
+  // The backing thread's id.
+  PlatformThreadId tid_ = kInvalidThreadId;
+
+#if DCHECK_IS_ON()
+  bool has_been_started_ = false;
+  bool has_been_joined_ = false;
+#endif
 
   DISALLOW_COPY_AND_ASSIGN(SimpleThread);
 };
 
 // A SimpleThread which delegates Run() to its Delegate. Non-joinable
 // DelegateSimpleThread are safe to delete after Run() was invoked, their
 // Delegates are also safe to delete after that point from this class' point of
 // view (although implementations must of course make sure that Run() will not
 // use their Delegate's member state after its deletion).
 class BASE_EXPORT DelegateSimpleThread : public SimpleThread {
@@ skipping 61 matching lines @@
   std::queue<Delegate*> delegates_;
   base::Lock lock_;            // Locks delegates_
   WaitableEvent dry_;    // Not signaled when there is no work to do.
 
   DISALLOW_COPY_AND_ASSIGN(DelegateSimpleThreadPool);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SIMPLE_THREAD_H_