Adding support for non joinable threads to PlatformThread

base/platform_thread_posix.cc

 // Copyright (c) 2006-2008 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.
 
 #include "base/platform_thread.h"
 
 #include <errno.h>
 #include <sched.h>
 
 #if defined(OS_MACOSX)
@@ skipping 50 matching lines @@
 // static
 void PlatformThread::SetName(const char* name) {
   // The POSIX standard does not provide for naming threads, and neither Linux
   // nor Mac OS X (our two POSIX targets) provide any non-portable way of doing
   // it either. (Some BSDs provide pthread_set_name_np but that isn't much of a
   // consolation prize.)
   // TODO(darin): decide whether stuffing the name in TLS or other in-memory
   // structure would be useful for debugging or not.
 }
 
-// static
-bool PlatformThread::Create(size_t stack_size, Delegate* delegate,
-                            PlatformThreadHandle* thread_handle) {
+namespace {
+
+bool CreateThread(size_t stack_size, bool joinable,
+                  PlatformThread::Delegate* delegate,
+                  PlatformThreadHandle* thread_handle) {
 #if defined(OS_MACOSX)
   base::InitThreading();
 #endif  // OS_MACOSX
 
   bool success = false;
   pthread_attr_t attributes;
   pthread_attr_init(&attributes);
 
-  // Pthreads are joinable by default, so we don't need to specify any special
-  // attributes to be able to call pthread_join later.
+  // Pthreads are joinable by default, so only specify the detached attribute if
+  // the thread should be non-joinable.
+  if (!joinable) {
+    pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED);
+  }
 
   if (stack_size > 0)
     pthread_attr_setstacksize(&attributes, stack_size);
 
   success = !pthread_create(thread_handle, &attributes, ThreadFunc, delegate);
 
   pthread_attr_destroy(&attributes);
   return success;
 }
 
+}  // anonymous namespace
+
+// static
+bool PlatformThread::Create(size_t stack_size, Delegate* delegate,
+                            PlatformThreadHandle* thread_handle) {
+  return CreateThread(stack_size, true /* joinable thread */,
+                      delegate, thread_handle);
+}
+
+// static
+bool PlatformThread::CreateNonJoinable(size_t stack_size, Delegate* delegate) {
+  PlatformThreadHandle unused;
+
+  bool result = CreateThread(stack_size, false /* non-joinable thread */,
+                             delegate, &unused);
+  return result;
+}
+
 // static
 void PlatformThread::Join(PlatformThreadHandle thread_handle) {
   pthread_join(thread_handle, NULL);
 }