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);

[the sun, 2017/02/22 13:42:57]

Where's the limit of 64 from? To my knowledge, the Linux kernel puts a cap at 15
characters, so if we want to enforce readability in logs/profile results, I'd go
with that.

[tommi, 2017/02/22 15:04:00]

15 sounds good to me. I think we break that though already in some cases. OK if
we tackle that in another CL and put down a TODO for now?

Wrt 64, it comes from Windows or rather from Windows debuggers.  The name can be
longer, but debuggers such as WinDbg copy the name into an internal buffer which
iirc is 64 chars long. If the name is 64 chars long or longer, the debugger will
actually use a non-terminated string, resulting in garbaged printouts and
interesting UI artifacts.

Enforcing some sort of a limit made sense to me, so I picked that limit. 15
works too.

[the sun, 2017/02/22 16:31:30]

sgtm

+  worker_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());
   RTC_DCHECK(name_.length() < 64);
+  worker_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)
+  worker_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(worker_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(worker_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