Force non-joinable SimpleThreads to be leaked.

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 56 matching lines @@
 
     // Allow copies.
     Options(const Options& other) = default;
     Options& operator=(const Options& other) = default;
 
     // A custom stack size, or 0 for the system default.
     size_t stack_size = 0;
 
     ThreadPriority priority = ThreadPriority::NORMAL;
 
-    // If false, the thread's PlatformThreadHandle will not be kept around and
-    // the SimpleThread instance will not be required to be Join()'ed before
-    // being destroyed
+    // If false, the underlying thread's PlatformThreadHandle will not be kept
+    // around and as such the SimpleThread instance will not be Join()able and
+    // will have to be leaked. Useful for threads that want to have
+    // TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN semantics. Note: leaking a
+    // joinable thread would effictively have the same semantics, but making it
+    // non-joinable is cleaner as not keeping the PlatformThreadHandle around
+    // has the advantage of letting the system release resources associated with
+    // the thread immediately when it returns from ThreadMain().
     bool joinable = true;
   };
 
   // Create a SimpleThread.  |options| should be used to manage any specific
   // configuration involving the thread creation and management.
   // Every thread has a name, in the form of |name_prefix|/TID, for example
   // "my_thread/321".  The thread will not be created until Start() is called.
   explicit SimpleThread(const std::string& name_prefix);
   SimpleThread(const std::string& name_prefix, const Options& options);
 
@@ skipping 101 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_