base/threading: fix a potential race issue on start_event_

base/threading/thread.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_THREADING_THREAD_H_
 #define BASE_THREADING_THREAD_H_
 
 #include <string>
 
 #include "base/base_export.h"
@@ skipping 68 matching lines @@
   // before it is destructed.
   ~Thread() override;
 
 #if defined(OS_WIN)
   // Causes the thread to initialize COM.  This must be called before calling
   // Start() or StartWithOptions().  If |use_mta| is false, the thread is also
   // started with a TYPE_UI message loop.  It is an error to call
   // init_com_with_mta(false) and then StartWithOptions() with any message loop
   // type other than TYPE_UI.
   void init_com_with_mta(bool use_mta) {
-    DCHECK(!start_event_);
+    DCHECK(!message_loop_);
     com_status_ = use_mta ? MTA : STA;
   }
 #endif
 
   // Starts the thread.  Returns true if the thread was successfully started;
   // otherwise, returns false.  Upon successful return, the message_loop()
   // getter will return non-null.
   //
   // Note: This function can't be called on Windows with the loader lock held;
   // i.e. during a DllMain, global object construction or destruction, atexit()
@@ skipping 11 matching lines @@
   // Starts the thread and wait for the thread to start and run initialization
   // before returning. It's same as calling Start() and then
   // WaitUntilThreadStarted().
   // Note that using this (instead of Start() or StartWithOptions() causes
   // jank on the calling thread, should be used only in testing code.
   bool StartAndWaitForTesting();
 
   // Blocks until the thread starts running. Called within StartAndWait().
   // Note that calling this causes jank on the calling thread, must be used
   // carefully for production code.
-  bool WaitUntilThreadStarted();
+  bool WaitUntilThreadStarted() const;
 
   // Signals the thread to exit and returns once the thread has exited.  After
   // this method returns, the Thread object is completely reset and may be used
   // as if it were newly constructed (i.e., Start may be called again).
   //
   // Stop may be called multiple times and is simply ignored if the thread is
   // already stopped.
   //
   // NOTE: If you are a consumer of Thread, it is not necessary to call this
   // before deleting your Thread objects, as the destructor will do it.
   // IF YOU ARE A SUBCLASS OF Thread, YOU MUST CALL THIS IN YOUR DESTRUCTOR.
   void Stop();
 
   // Signals the thread to exit in the near future.
   //
   // WARNING: This function is not meant to be commonly used. Use at your own
   // risk. Calling this function will cause message_loop() to become invalid in
   // the near future. This function was created to workaround a specific
   // deadlock on Windows with printer worker thread. In any other case, Stop()
   // should be used.
   //
   // StopSoon should not be called multiple times as it is risky to do so. It
   // could cause a timing issue in message_loop() access. Call Stop() to reset
   // the thread object once it is known that the thread has quit.
   void StopSoon();
 
   // Returns the message loop for this thread.  Use the MessageLoop's
   // PostTask methods to execute code on the thread.  This only returns
   // non-null after a successful call to Start.  After Stop has been called,
-  // this will return NULL.
+  // this will return nullptr.
   //
   // NOTE: You must not call this MessageLoop's Quit method directly.  Use
   // the Thread's Stop method instead.
   //
   MessageLoop* message_loop() const { return message_loop_; }
 
   // Returns a TaskRunner for this thread. Use the TaskRunner's PostTask
-  // methods to execute code on the thread. Returns NULL if the thread is not
+  // methods to execute code on the thread. Returns nullptr if the thread is not
   // running (e.g. before Start or after Stop have been called). Callers can
   // hold on to this even after the thread is gone; in this situation, attempts
   // to PostTask() will fail.
   scoped_refptr<SingleThreadTaskRunner> task_runner() const {
     return message_loop_ ? message_loop_->task_runner() : nullptr;
   }
 
   // Returns the name of this thread (for display in debugger too).
   const std::string& thread_name() const { return name_; }
 
@@ skipping 39 matching lines @@
 
   // PlatformThread::Delegate methods:
   void ThreadMain() override;
 
 #if defined(OS_WIN)
   // Whether this thread needs to initialize COM, and if so, in what mode.
   ComStatus com_status_;
 #endif
 
   // If true, we're in the middle of stopping, and shouldn't access
-  // |message_loop_|. It may non-NULL and invalid.
+  // |message_loop_|. It may non-nullptr and invalid.
+  // Should be written on the thread that created this thread. Also read data
+  // could be wrong on other threads.
   bool stopping_;
 
   // True while inside of Run().
   bool running_;
   mutable base::Lock running_lock_;  // Protects |running_|.
 
   // The thread's handle.
   PlatformThreadHandle thread_;
   mutable base::Lock thread_lock_;  // Protects |thread_|.
 
   // The thread's id once it has started.
   PlatformThreadId id_;
   mutable WaitableEvent id_event_;  // Protects |id_|.
 
   // The thread's message loop.  Valid only while the thread is alive.  Set
   // by the created thread.
   MessageLoop* message_loop_;
 
   // Stores Options::timer_slack_ until the message loop has been bound to
   // a thread.
   TimerSlack message_loop_timer_slack_;
 
   // The name of the thread.  Used for debugging purposes.
   std::string name_;
 
-  // Non-null if the thread has successfully started.
-  scoped_ptr<WaitableEvent> start_event_;
+  // Signaled when the created thread gets ready to use the message loop.
+  mutable WaitableEvent start_event_;
 
   friend void ThreadQuitHelper();
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_THREAD_H_