Introduce new constructor to PlatformThread.

webrtc/base/platform_thread.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 74 matching lines @@
 #else
 struct ThreadAttributes {
   ThreadAttributes() { pthread_attr_init(&attr); }
   ~ThreadAttributes() { pthread_attr_destroy(&attr); }
   pthread_attr_t* operator&() { return &attr; }
   pthread_attr_t attr;
 };
 #endif  // defined(WEBRTC_WIN)
 }
 
+PlatformThread::PlatformThread(ThreadRunFunctionDeprecated func,
+                               void* obj,
+                               const char* thread_name)
+    : run_function_deprecated_(func),
+      obj_(obj),
+      name_(thread_name ? thread_name : "webrtc") {
+  RTC_DCHECK(func);
+  RTC_DCHECK(name_.length() < 64);
+  spawned_thread_checker_.DetachFromThread();
+}
+
 PlatformThread::PlatformThread(ThreadRunFunction func,
                                void* obj,
-                               const char* thread_name)
-    : run_function_(func),
-      obj_(obj),
-      name_(thread_name ? thread_name : "webrtc") {
+                               const char* thread_name,
+                               ThreadPriority priority /*= kNormalPriority*/)
+    : run_function_(func), priority_(priority), obj_(obj), name_(thread_name) {
   RTC_DCHECK(func);
+  RTC_DCHECK(!name_.empty());
+  // TODO(tommi): Consider lowering the limit to 15 (limit on Linux).
   RTC_DCHECK(name_.length() < 64);
+  spawned_thread_checker_.DetachFromThread();
 }
 
 PlatformThread::~PlatformThread() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 #if defined(WEBRTC_WIN)
   RTC_DCHECK(!thread_);
   RTC_DCHECK(!thread_id_);
 #endif  // defined(WEBRTC_WIN)
 }
 
@@ skipping 60 matching lines @@
 #if defined(WEBRTC_WIN)
   // Set stop_ to |true| on the worker thread.
   bool queued = QueueAPC(&RaiseFlag, reinterpret_cast<ULONG_PTR>(&stop_));
   // Queuing the APC can fail if the thread is being terminated.
   RTC_CHECK(queued || GetLastError() == ERROR_GEN_FAILURE);
   WaitForSingleObject(thread_, INFINITE);
   CloseHandle(thread_);
   thread_ = nullptr;
   thread_id_ = 0;
 #else
-  RTC_CHECK_EQ(1, AtomicOps::Increment(&stop_flag_));
+  if (!run_function_)
+    RTC_CHECK_EQ(1, AtomicOps::Increment(&stop_flag_));
   RTC_CHECK_EQ(0, pthread_join(thread_, nullptr));
-  AtomicOps::ReleaseStore(&stop_flag_, 0);
+  if (!run_function_)
+    AtomicOps::ReleaseStore(&stop_flag_, 0);
   thread_ = 0;
 #endif  // defined(WEBRTC_WIN)
+  spawned_thread_checker_.DetachFromThread();
 }
 
 // TODO(tommi): Deprecate the loop behavior in PlatformThread.
 // * Introduce a new callback type that returns void.
 // * Remove potential for a busy loop in PlatformThread.
 // * Delegate the responsibility for how to stop the thread, to the
 //   implementation that actually uses the thread.
 // All implementations will need to be aware of how the thread should be stopped
 // and encouraging a busy polling loop, can be costly in terms of power and cpu.
 void PlatformThread::Run() {
-  if (!name_.empty())
-    rtc::SetCurrentThreadName(name_.c_str());
+  // Attach the worker thread checker to this thread.
+  RTC_DCHECK(spawned_thread_checker_.CalledOnValidThread());
+  rtc::SetCurrentThreadName(name_.c_str());
+
+  if (run_function_) {
+    SetPriority(priority_);
+    run_function_(obj_);
+    return;
+  }
+// TODO(tommi): Delete the below.
 #if !defined(WEBRTC_MAC) && !defined(WEBRTC_WIN)
   const struct timespec ts_null = {0};
 #endif
   do {
     // The interface contract of Start/Stop is that for a successful call to
     // Start, there should be at least one call to the run function.  So we
     // call the function before checking |stop_|.
-    if (!run_function_(obj_))
+    if (!run_function_deprecated_(obj_))
       break;
 #if defined(WEBRTC_WIN)
     // Alertable sleep to permit RaiseFlag to run and update |stop_|.
     SleepEx(0, true);
   } while (!stop_);
 #else
 #if defined(WEBRTC_MAC)
     sched_yield();
 #else
     nanosleep(&ts_null, nullptr);
 #endif
   } while (!AtomicOps::AcquireLoad(&stop_flag_));
 #endif  // defined(WEBRTC_WIN)
 }
 
 bool PlatformThread::SetPriority(ThreadPriority priority) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  RTC_DCHECK(IsRunning());
+#if RTC_DCHECK_IS_ON
+  if (run_function_) {
+    // The non-deprecated way of how this function gets called, is that it must
+    // be called on the worker thread itself.
+    RTC_DCHECK(spawned_thread_checker_.CalledOnValidThread());
+  } else {
+    // In the case of deprecated use of this method, it must be called on the
+    // same thread as the PlatformThread object is constructed on.
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(IsRunning());
+  }
+#endif
+
 #if defined(WEBRTC_WIN)
   return SetThreadPriority(thread_, priority) != FALSE;
 #elif defined(__native_client__)
   // Setting thread priorities is not supported in NaCl.
   return true;
 #elif defined(WEBRTC_CHROMIUM_BUILD) && defined(WEBRTC_LINUX)
   // TODO(tommi): Switch to the same mechanism as Chromium uses for changing
   // thread priorities.
   return true;
 #else
@@ skipping 41 matching lines @@
 #if defined(WEBRTC_WIN)
 bool PlatformThread::QueueAPC(PAPCFUNC function, ULONG_PTR data) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(IsRunning());
 
   return QueueUserAPC(function, thread_, data) != FALSE;
 }
 #endif
 
 }  // namespace rtc