Add |joinable| to Thread::Options

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 <stddef.h>
 
 #include <memory>
 #include <string>
 
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
+#include "base/synchronization/atomic_flag.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 
 namespace base {
 
 class MessagePump;
 class RunLoop;
 
@@ skipping 37 matching lines @@
     // MessageLoop::Type to TYPE_CUSTOM.
     MessagePumpFactory message_pump_factory;
 
     // Specifies the maximum stack size that the thread is allowed to use.
     // This does not necessarily correspond to the thread's initial stack size.
     // A value of 0 indicates that the default maximum should be used.
     size_t stack_size = 0;
 
     // Specifies the initial thread priority.
     ThreadPriority priority = ThreadPriority::NORMAL;
+
+    // If false, the thread will not be joined on destruction. This is intended
+    // for threads that want TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN
+    // semantics. Stop() will not be synchronous and will instead merely have
+    // StopSoon() semantics on such threads. Thread instances can only be
+    // destroyed after their ThreadMain() returns (which typically means that
+    // non-joinable instances must be leaked).
+    // TODO(gab): allow non-joinable instances to be deleted without causing
+    // user-after-frees (proposal @ https://crbug.com/629139#c14)
+    bool joinable = true;
   };
 
   // Constructor.
   // name is a display string to identify the thread.
   explicit Thread(const std::string& name);
 
   // Destroys the thread, stopping it if necessary.
   //
   // NOTE: ALL SUBCLASSES OF Thread MUST CALL Stop() IN THEIR DESTRUCTORS (or
   // guarantee Stop() is explicitly called before the subclass is destroyed).
@@ skipping 37 matching lines @@
   // 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() 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).
+  // Signals the thread to exit and returns once the thread has exited (or right
+  // away if the thread is non-joinable).  For joinable threads only: 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) -- non-joinable
+  // threads are not re-usable.
   //
   // Stop may be called multiple times and is simply ignored if the thread is
-  // already stopped.
+  // already stopped or currently stopping.
   //
   // 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
@@ skipping 71 matching lines @@
 
   // Called to start the run loop
   virtual void Run(RunLoop* run_loop);
 
   // Called just after the message loop ends
   virtual void CleanUp() {}
 
   static void SetThreadWasQuitProperly(bool flag);
   static bool GetThreadWasQuitProperly();
 
-  void set_message_loop(MessageLoop* message_loop) {
-    DCHECK(owning_sequence_checker_.CalledOnValidSequencedThread());
-    message_loop_ = message_loop;
-  }
+  // Bind this Thread to an existing MessageLoop instead of starting a new one.
+  void SetMessageLoop(MessageLoop* message_loop);
 
  private:
 #if defined(OS_WIN)
   enum ComStatus {
     NONE,
     STA,
     MTA,
   };
 #endif
 
@@ skipping 23 matching lines @@
 
   // The thread's id once it has started.
   PlatformThreadId id_ = kInvalidThreadId;
   mutable WaitableEvent id_event_;  // Protects |id_|.
 
   // The thread's MessageLoop and RunLoop. Valid only while the thread is alive.
   // Set by the created thread.
   MessageLoop* message_loop_ = nullptr;
   RunLoop* run_loop_ = nullptr;
 
+  // True only if |message_loop_| was externally provided by |SetMessageLoop()|
+  // in which case this Thread has no underlying |thread_| and should merely
+  // drop |message_loop_| on Stop().
+  bool using_external_message_loop_ = false;
+
   // Stores Options::timer_slack_ until the message loop has been bound to
   // a thread.
   TimerSlack message_loop_timer_slack_ = TIMER_SLACK_NONE;
 
   // The name of the thread.  Used for debugging purposes.
   const std::string name_;
 
   // Signaled when the created thread gets ready to use the message loop.
   mutable WaitableEvent start_event_;
 
   // This class is not thread-safe, use this to verify access from the owning
   // sequence of the Thread.
   SequenceChecker owning_sequence_checker_;
 
+  // Set when ThreadMain() returns. The pointer itself is null until the thread
+  // is started for the first time. so a Thread()/Start()/Stop()/Start()/...
+  // sequence will result in null/false/true/false/... state for
+  // |thread_main_exited_|.
+  std::unique_ptr<AtomicFlag> thread_main_exited_;
+
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_THREAD_H_