Re-land 8810 "- Add a SetPriority method to ThreadWr..." > Revert 8810 "- Add a SetPriority method to ThreadWrapper" > Seeing if this is causing roll issues. > > > - Add a SetPriority method to ThreadWrapper > > - Remove 'priority' from CreateThread and related member variables from implementations > > - Make supplying a name for threads, non-optional > > > > BUG= > > R=magjed@webrtc.org > > > > Review URL: https://webrtc-codereview.appspot.com/44729004 > > TBR=tommi@webrtc.org > > Review URL: https://webrtc-codereview.appspot.com/48609004 TBR=tommi@webrtc.org Review URL: https://webrtc-codereview.appspot.com/50459005 Cr-Commit-Position: refs/heads/master@{#8819} git-svn-id: http://webrtc.googlecode.com/svn/trunk@8819 4adac7df-926f-26a2-2b94-8c16560cd09d

diff --git a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc
index 17be285..a600129 100644
--- a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc
+++ b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc

@@ -285,18 +285,11 @@
 
   AudioCodingModuleMtTest()
       : AudioCodingModuleTest(),
-        send_thread_(ThreadWrapper::CreateThread(CbSendThread,
-                                                 this,
-                                                 kRealtimePriority,
-                                                 "send")),
-        insert_packet_thread_(ThreadWrapper::CreateThread(CbInsertPacketThread,
-                                                          this,
-                                                          kRealtimePriority,
-                                                          "insert_packet")),
-        pull_audio_thread_(ThreadWrapper::CreateThread(CbPullAudioThread,
-                                                       this,
-                                                       kRealtimePriority,
-                                                       "pull_audio")),
+        send_thread_(ThreadWrapper::CreateThread(CbSendThread, this, "send")),
+        insert_packet_thread_(ThreadWrapper::CreateThread(
+            CbInsertPacketThread, this, "insert_packet")),
+        pull_audio_thread_(ThreadWrapper::CreateThread(
+            CbPullAudioThread, this, "pull_audio")),
         test_complete_(EventWrapper::Create()),
         send_count_(0),
         insert_packet_count_(0),
@@ -315,8 +308,11 @@
 
   void StartThreads() {
     ASSERT_TRUE(send_thread_->Start());
+    send_thread_->SetPriority(kRealtimePriority);
     ASSERT_TRUE(insert_packet_thread_->Start());
+    insert_packet_thread_->SetPriority(kRealtimePriority);
     ASSERT_TRUE(pull_audio_thread_->Start());
+    pull_audio_thread_->SetPriority(kRealtimePriority);
   }
 
   void TearDown() override {

diff --git a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc
index 829db2d..c083f28 100644
--- a/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc
+++ b/webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc

@@ -462,18 +462,11 @@
 
   AudioCodingModuleMtTestOldApi()
       : AudioCodingModuleTestOldApi(),
-        send_thread_(ThreadWrapper::CreateThread(CbSendThread,
-                                                 this,
-                                                 kRealtimePriority,
-                                                 "send")),
-        insert_packet_thread_(ThreadWrapper::CreateThread(CbInsertPacketThread,
-                                                          this,
-                                                          kRealtimePriority,
-                                                          "insert_packet")),
-        pull_audio_thread_(ThreadWrapper::CreateThread(CbPullAudioThread,
-                                                       this,
-                                                       kRealtimePriority,
-                                                       "pull_audio")),
+        send_thread_(ThreadWrapper::CreateThread(CbSendThread, this, "send")),
+        insert_packet_thread_(ThreadWrapper::CreateThread(
+            CbInsertPacketThread, this, "insert_packet")),
+        pull_audio_thread_(ThreadWrapper::CreateThread(
+            CbPullAudioThread, this, "pull_audio")),
         test_complete_(EventWrapper::Create()),
         send_count_(0),
         insert_packet_count_(0),
@@ -492,8 +485,11 @@
 
   void StartThreads() {
     ASSERT_TRUE(send_thread_->Start());
+    send_thread_->SetPriority(kRealtimePriority);
     ASSERT_TRUE(insert_packet_thread_->Start());
+    insert_packet_thread_->SetPriority(kRealtimePriority);
     ASSERT_TRUE(pull_audio_thread_->Start());
+    pull_audio_thread_->SetPriority(kRealtimePriority);
   }
 
   void TearDown() {

diff --git a/webrtc/modules/audio_coding/main/test/APITest.cc b/webrtc/modules/audio_coding/main/test/APITest.cc
index 83b24a8..8cfe0e3 100644
--- a/webrtc/modules/audio_coding/main/test/APITest.cc
+++ b/webrtc/modules/audio_coding/main/test/APITest.cc

@@ -532,40 +532,36 @@
   // A
   // PUSH
   rtc::scoped_ptr<ThreadWrapper> myPushAudioThreadA =
-      ThreadWrapper::CreateThread(PushAudioThreadA, this, kNormalPriority,
-                                  "PushAudioThreadA");
+      ThreadWrapper::CreateThread(PushAudioThreadA, this, "PushAudioThreadA");
   CHECK_THREAD_NULLITY(myPushAudioThreadA, "Unable to start A::PUSH thread");
   // PULL
   rtc::scoped_ptr<ThreadWrapper> myPullAudioThreadA =
-      ThreadWrapper::CreateThread(PullAudioThreadA, this, kNormalPriority,
-                                  "PullAudioThreadA");
+      ThreadWrapper::CreateThread(PullAudioThreadA, this, "PullAudioThreadA");
   CHECK_THREAD_NULLITY(myPullAudioThreadA, "Unable to start A::PULL thread");
   // Process
   rtc::scoped_ptr<ThreadWrapper> myProcessThreadA = ThreadWrapper::CreateThread(
-      ProcessThreadA, this, kNormalPriority, "ProcessThreadA");
+      ProcessThreadA, this, "ProcessThreadA");
   CHECK_THREAD_NULLITY(myProcessThreadA, "Unable to start A::Process thread");
   // API
   rtc::scoped_ptr<ThreadWrapper> myAPIThreadA = ThreadWrapper::CreateThread(
-      APIThreadA, this, kNormalPriority, "APIThreadA");
+      APIThreadA, this, "APIThreadA");
   CHECK_THREAD_NULLITY(myAPIThreadA, "Unable to start A::API thread");
   // B
   // PUSH
   rtc::scoped_ptr<ThreadWrapper> myPushAudioThreadB =
-      ThreadWrapper::CreateThread(PushAudioThreadB, this, kNormalPriority,
-                                  "PushAudioThreadB");
+      ThreadWrapper::CreateThread(PushAudioThreadB, this, "PushAudioThreadB");
   CHECK_THREAD_NULLITY(myPushAudioThreadB, "Unable to start B::PUSH thread");
   // PULL
   rtc::scoped_ptr<ThreadWrapper> myPullAudioThreadB =
-      ThreadWrapper::CreateThread(PullAudioThreadB, this, kNormalPriority,
-                                  "PullAudioThreadB");
+      ThreadWrapper::CreateThread(PullAudioThreadB, this, "PullAudioThreadB");
   CHECK_THREAD_NULLITY(myPullAudioThreadB, "Unable to start B::PULL thread");
   // Process
   rtc::scoped_ptr<ThreadWrapper> myProcessThreadB = ThreadWrapper::CreateThread(
-      ProcessThreadB, this, kNormalPriority, "ProcessThreadB");
+      ProcessThreadB, this, "ProcessThreadB");
   CHECK_THREAD_NULLITY(myProcessThreadB, "Unable to start B::Process thread");
   // API
   rtc::scoped_ptr<ThreadWrapper> myAPIThreadB = ThreadWrapper::CreateThread(
-      APIThreadB, this, kNormalPriority, "APIThreadB");
+      APIThreadB, this, "APIThreadB");
   CHECK_THREAD_NULLITY(myAPIThreadB, "Unable to start B::API thread");
 
   //_apiEventA->StartTimer(true, 5000);

diff --git a/webrtc/modules/audio_device/android/low_latency_event_unittest.cc b/webrtc/modules/audio_device/android/low_latency_event_unittest.cc
index 359625b..2138f1f 100644
--- a/webrtc/modules/audio_device/android/low_latency_event_unittest.cc
+++ b/webrtc/modules/audio_device/android/low_latency_event_unittest.cc

@@ -22,10 +22,8 @@
 class LowLatencyEventTest : public testing::Test {
  public:
   LowLatencyEventTest()
-      : process_thread_(ThreadWrapper::CreateThread(CbThread,
-                                                    this,
-                                                    kRealtimePriority,
-                                                    "test_thread")),
+      : process_thread_(ThreadWrapper::CreateThread(
+            CbThread, this, "test_thread")),
         terminated_(false),
         iteration_count_(0),
         allowed_iterations_(0) {
@@ -46,6 +44,7 @@
  private:
   void Start() {
     EXPECT_TRUE(process_thread_->Start());
+    process_thread_->SetPriority(kRealtimePriority);
   }
   void Stop() {
     terminated_ = true;

diff --git a/webrtc/modules/audio_device/android/opensles_input.cc b/webrtc/modules/audio_device/android/opensles_input.cc
index f0e5347..12640e7 100644
--- a/webrtc/modules/audio_device/android/opensles_input.cc
+++ b/webrtc/modules/audio_device/android/opensles_input.cc

@@ -470,13 +470,14 @@
 }
 
 bool OpenSlesInput::StartCbThreads() {
-  rec_thread_ = ThreadWrapper::CreateThread(CbThread, this, kRealtimePriority,
+  rec_thread_ = ThreadWrapper::CreateThread(CbThread, this,
                                             "opensl_rec_thread");
   assert(rec_thread_.get());
   if (!rec_thread_->Start()) {
     assert(false);
     return false;
   }
+  rec_thread_->SetPriority(kRealtimePriority);
   OPENSL_RETURN_ON_FAILURE(
       (*sles_recorder_itf_)->SetRecordState(sles_recorder_itf_,
                                             SL_RECORDSTATE_RECORDING),

diff --git a/webrtc/modules/audio_device/android/opensles_output.cc b/webrtc/modules/audio_device/android/opensles_output.cc
index 350b5de..5782973 100644
--- a/webrtc/modules/audio_device/android/opensles_output.cc
+++ b/webrtc/modules/audio_device/android/opensles_output.cc

@@ -510,7 +510,7 @@
 }
 
 bool OpenSlesOutput::StartCbThreads() {
-  play_thread_ = ThreadWrapper::CreateThread(CbThread, this, kRealtimePriority,
+  play_thread_ = ThreadWrapper::CreateThread(CbThread, this,
                                              "opensl_play_thread");
   assert(play_thread_.get());
   OPENSL_RETURN_ON_FAILURE(
@@ -522,6 +522,7 @@
     assert(false);
     return false;
   }
+  play_thread_->SetPriority(kRealtimePriority);
   return true;
 }
 

diff --git a/webrtc/modules/audio_device/dummy/file_audio_device.cc b/webrtc/modules/audio_device/dummy/file_audio_device.cc
index cce4f5c..82569e8 100644
--- a/webrtc/modules/audio_device/dummy/file_audio_device.cc
+++ b/webrtc/modules/audio_device/dummy/file_audio_device.cc

@@ -205,12 +205,6 @@
   }
 
   // PLAYOUT
-  const char* threadName = "webrtc_audio_module_play_thread";
-  _ptrThreadPlay = ThreadWrapper::CreateThread(PlayThreadFunc,
-                                               this,
-                                               kRealtimePriority,
-                                               threadName);
-
   if (!_outputFilename.empty() && _outputFile.OpenFile(
         _outputFilename.c_str(), false, false, false) == -1) {
     printf("Failed to open playout file %s!\n", _outputFilename.c_str());
@@ -220,6 +214,9 @@
     return -1;
   }
 
+  const char* threadName = "webrtc_audio_module_play_thread";
+  _ptrThreadPlay = ThreadWrapper::CreateThread(PlayThreadFunc, this,
+                                               threadName);
   if (!_ptrThreadPlay->Start()) {
       _ptrThreadPlay.reset();
       _playing = false;
@@ -227,7 +224,7 @@
       _playoutBuffer = NULL;
       return -1;
   }
-
+  _ptrThreadPlay->SetPriority(kRealtimePriority);
   return 0;
 }
 
@@ -281,10 +278,7 @@
   }
 
   const char* threadName = "webrtc_audio_module_capture_thread";
-  _ptrThreadRec = ThreadWrapper::CreateThread(RecThreadFunc,
-                                              this,
-                                              kRealtimePriority,
-                                              threadName);
+  _ptrThreadRec = ThreadWrapper::CreateThread(RecThreadFunc, this, threadName);
 
   if (!_ptrThreadRec->Start()) {
       _ptrThreadRec.reset();
@@ -293,6 +287,7 @@
       _recordingBuffer = NULL;
       return -1;
   }
+  _ptrThreadRec->SetPriority(kRealtimePriority);
 
   return 0;
 }

diff --git a/webrtc/modules/audio_device/ios/audio_device_ios.mm b/webrtc/modules/audio_device/ios/audio_device_ios.mm
index 6b973ab..178ce3e 100644
--- a/webrtc/modules/audio_device/ios/audio_device_ios.mm
+++ b/webrtc/modules/audio_device/ios/audio_device_ios.mm

@@ -107,12 +107,12 @@
 
     // Create and start capture thread
     if (!_captureWorkerThread) {
-        _captureWorkerThread
-            = ThreadWrapper::CreateThread(RunCapture, this, kRealtimePriority,
-                                          "CaptureWorkerThread");
+        _captureWorkerThread = ThreadWrapper::CreateThread(
+            RunCapture, this, "CaptureWorkerThread");
         bool res = _captureWorkerThread->Start();
         WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice,
                      _id, "CaptureWorkerThread started (res=%d)", res);
+        _captureWorkerThread->SetPriority(kRealtimePriority);
     } else {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice,
                      _id, "Thread already created");

diff --git a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.cc b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.cc
index e590663..3516d77 100644
--- a/webrtc/modules/audio_device/linux/audio_device_alsa_linux.cc
+++ b/webrtc/modules/audio_device/linux/audio_device_alsa_linux.cc

@@ -1365,10 +1365,8 @@
     }
     // RECORDING
     const char* threadName = "webrtc_audio_module_capture_thread";
-    _ptrThreadRec = ThreadWrapper::CreateThread(RecThreadFunc,
-                                                this,
-                                                kRealtimePriority,
-                                                threadName);
+    _ptrThreadRec = ThreadWrapper::CreateThread(
+        RecThreadFunc, this, threadName);
 
     if (!_ptrThreadRec->Start())
     {
@@ -1380,6 +1378,7 @@
         _recordingBuffer = NULL;
         return -1;
     }
+    _ptrThreadRec->SetPriority(kRealtimePriority);
 
     errVal = LATE(snd_pcm_prepare)(_handleRecord);
     if (errVal < 0)
@@ -1520,9 +1519,7 @@
 
     // PLAYOUT
     const char* threadName = "webrtc_audio_module_play_thread";
-    _ptrThreadPlay =  ThreadWrapper::CreateThread(PlayThreadFunc,
-                                                  this,
-                                                  kRealtimePriority,
+    _ptrThreadPlay =  ThreadWrapper::CreateThread(PlayThreadFunc, this,
                                                   threadName);
     if (!_ptrThreadPlay->Start())
     {
@@ -1534,6 +1531,7 @@
         _playoutBuffer = NULL;
         return -1;
     }
+    _ptrThreadPlay->SetPriority(kRealtimePriority);
 
     int errVal = LATE(snd_pcm_prepare)(_handlePlayout);
     if (errVal < 0)

diff --git a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.cc b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.cc
index fd16e9e..9098211 100644
--- a/webrtc/modules/audio_device/linux/audio_device_pulse_linux.cc
+++ b/webrtc/modules/audio_device/linux/audio_device_pulse_linux.cc

@@ -208,7 +208,7 @@
     // RECORDING
     const char* threadName = "webrtc_audio_module_rec_thread";
     _ptrThreadRec = ThreadWrapper::CreateThread(RecThreadFunc, this,
-                                                kRealtimePriority, threadName);
+                                                threadName);
     if (!_ptrThreadRec->Start())
     {
         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
@@ -218,10 +218,12 @@
         return -1;
     }
 
+    _ptrThreadRec->SetPriority(kRealtimePriority);
+
     // PLAYOUT
     threadName = "webrtc_audio_module_play_thread";
     _ptrThreadPlay = ThreadWrapper::CreateThread(PlayThreadFunc, this,
-                                                 kRealtimePriority, threadName);
+                                                 threadName);
     if (!_ptrThreadPlay->Start())
     {
         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
@@ -230,6 +232,7 @@
         _ptrThreadPlay.reset();
         return -1;
     }
+    _ptrThreadPlay->SetPriority(kRealtimePriority);
 
     _initialized = true;
 

diff --git a/webrtc/modules/audio_device/mac/audio_device_mac.cc b/webrtc/modules/audio_device/mac/audio_device_mac.cc
index 3e2a307..eb7962f 100644
--- a/webrtc/modules/audio_device/mac/audio_device_mac.cc
+++ b/webrtc/modules/audio_device/mac/audio_device_mac.cc

@@ -1667,10 +1667,10 @@
 
     DCHECK(!capture_worker_thread_.get());
     capture_worker_thread_ =
-        ThreadWrapper::CreateThread(RunCapture, this, kRealtimePriority,
-                                    "CaptureWorkerThread");
+        ThreadWrapper::CreateThread(RunCapture, this, "CaptureWorkerThread");
     DCHECK(capture_worker_thread_.get());
     capture_worker_thread_->Start();
+    capture_worker_thread_->SetPriority(kRealtimePriority);
 
     OSStatus err = noErr;
     if (_twoDevices)
@@ -1822,9 +1822,9 @@
 
     DCHECK(!render_worker_thread_.get());
     render_worker_thread_ =
-        ThreadWrapper::CreateThread(RunRender, this, kRealtimePriority,
-                                    "RenderWorkerThread");
+        ThreadWrapper::CreateThread(RunRender, this, "RenderWorkerThread");
     render_worker_thread_->Start();
+    render_worker_thread_->SetPriority(kRealtimePriority);
 
     if (_twoDevices || !_recording)
     {

diff --git a/webrtc/modules/audio_device/win/audio_device_wave_win.cc b/webrtc/modules/audio_device/win/audio_device_wave_win.cc
index c5f0a1a..bcea317 100644
--- a/webrtc/modules/audio_device/win/audio_device_wave_win.cc
+++ b/webrtc/modules/audio_device/win/audio_device_wave_win.cc

@@ -228,10 +228,7 @@
     }
 
     const char* threadName = "webrtc_audio_module_thread";
-    _ptrThread = ThreadWrapper::CreateThread(ThreadFunc,
-                                             this,
-                                             kRealtimePriority,
-                                             threadName);
+    _ptrThread = ThreadWrapper::CreateThread(ThreadFunc, this, threadName);
     if (!_ptrThread->Start())
     {
         WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
@@ -239,6 +236,7 @@
         _ptrThread.reset();
         return -1;
     }
+    _ptrThread->SetPriority(kRealtimePriority);
 
     const bool periodic(true);
     if (!_timeEvent.StartTimer(periodic, TIMER_PERIOD_MS))

diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc
index a3f52f9..0ed3572 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestLoadGenerator.cc

@@ -77,10 +77,11 @@
     _eventPtr = EventWrapper::Create();
 
     _genThread = ThreadWrapper::CreateThread(SenderThreadFunction, this,
-                                             kRealtimePriority, threadName);
+                                             threadName);
     _running = true;
 
     _genThread->Start();
+    _genThread->SetPriority(kRealtimePriority);
 
     return 0;
 }

diff --git a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc
index 839f579..e55d363 100644
--- a/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc
+++ b/webrtc/modules/rtp_rtcp/test/BWEStandAlone/TestSenderReceiver.cc

@@ -164,7 +164,7 @@
     }
 
     _procThread = ThreadWrapper::CreateThread(ProcThreadFunction, this,
-        kRealtimePriority, "TestSenderReceiver");
+                                              "TestSenderReceiver");
 
     _running = true;
 
@@ -178,6 +178,7 @@
     }
 
     _procThread->Start();
+    _procThread->SetPriority(kRealtimePriority);
 
     return 0;
 

diff --git a/webrtc/modules/utility/source/process_thread_impl.cc b/webrtc/modules/utility/source/process_thread_impl.cc
index 33a1c4f..5b50539 100644
--- a/webrtc/modules/utility/source/process_thread_impl.cc
+++ b/webrtc/modules/utility/source/process_thread_impl.cc

@@ -70,7 +70,7 @@
     m.module->ProcessThreadAttached(this);
 
   thread_ = ThreadWrapper::CreateThread(
-      &ProcessThreadImpl::Run, this, kNormalPriority, "ProcessThread");
+      &ProcessThreadImpl::Run, this, "ProcessThread");
   CHECK(thread_->Start());
 }
 

diff --git a/webrtc/modules/video_capture/linux/video_capture_linux.cc b/webrtc/modules/video_capture/linux/video_capture_linux.cc
index 41e0e84..23703aa 100644
--- a/webrtc/modules/video_capture/linux/video_capture_linux.cc
+++ b/webrtc/modules/video_capture/linux/video_capture_linux.cc

@@ -281,8 +281,9 @@
     if (!_captureThread)
     {
         _captureThread = ThreadWrapper::CreateThread(
-            VideoCaptureModuleV4L2::CaptureThread, this, kHighPriority);
+            VideoCaptureModuleV4L2::CaptureThread, this, "CaptureThread");
         _captureThread->Start();
+        _captureThread->SetPriority(kHighPriority);
     }
 
     // Needed to start UVC camera - from the uvcview application

diff --git a/webrtc/modules/video_render/android/video_render_android_impl.cc b/webrtc/modules/video_render/android/video_render_android_impl.cc
index 288d1fa..15b52d7 100644
--- a/webrtc/modules/video_render/android/video_render_android_impl.cc
+++ b/webrtc/modules/video_render/android/video_render_android_impl.cc

@@ -142,7 +142,6 @@
   }
 
   _javaRenderThread = ThreadWrapper::CreateThread(JavaRenderThreadFun, this,
-                                                  kRealtimePriority,
                                                   "AndroidRenderThread");
 
   if (_javaRenderThread->Start())
@@ -153,6 +152,7 @@
                  "%s: Could not start send thread", __FUNCTION__);
     return -1;
   }
+  _javaRenderThread->SetPriority(kRealtimePriority);
   return 0;
 }
 

diff --git a/webrtc/modules/video_render/incoming_video_stream.cc b/webrtc/modules/video_render/incoming_video_stream.cc
index 40966bd..6e9e8a4 100644
--- a/webrtc/modules/video_render/incoming_video_stream.cc
+++ b/webrtc/modules/video_render/incoming_video_stream.cc

@@ -179,8 +179,7 @@
   assert(incoming_render_thread_ == NULL);
 
   incoming_render_thread_ = ThreadWrapper::CreateThread(
-      IncomingVideoStreamThreadFun, this, kRealtimePriority,
-      "IncomingVideoStreamThread");
+      IncomingVideoStreamThreadFun, this, "IncomingVideoStreamThread");
   if (!incoming_render_thread_) {
     WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, module_id_,
                  "%s: No thread", __FUNCTION__);
@@ -195,6 +194,7 @@
                  "%s: Could not start send thread", __FUNCTION__);
     return -1;
   }
+  incoming_render_thread_->SetPriority(kRealtimePriority);
   deliver_buffer_event_.StartTimer(false, KEventStartupTimeMS);
 
   running_ = true;

diff --git a/webrtc/modules/video_render/ios/video_render_ios_gles20.mm b/webrtc/modules/video_render/ios/video_render_ios_gles20.mm
index 1d61a09..35382ea 100644
--- a/webrtc/modules/video_render/ios/video_render_ios_gles20.mm
+++ b/webrtc/modules/video_render/ios/video_render_ios_gles20.mm

@@ -33,7 +33,7 @@
       gles_context_([view context]),
       is_rendering_(true) {
   screen_update_thread_ = ThreadWrapper::CreateThread(
-      ScreenUpdateThreadProc, this, kRealtimePriority);
+      ScreenUpdateThreadProc, this, "ScreenUpdateGles20");
   screen_update_event_ = EventWrapper::Create();
   GetWindowRect(window_rect_);
 }
@@ -83,6 +83,7 @@
   }
 
   screen_update_thread_->Start();
+  screen_update_thread_->SetPriority(kRealtimePriority);
 
   // Start the event triggering the render process
   unsigned int monitor_freq = 60;

diff --git a/webrtc/modules/video_render/mac/video_render_agl.cc b/webrtc/modules/video_render/mac/video_render_agl.cc
index ae8b7c3..6cd4173 100644
--- a/webrtc/modules/video_render/mac/video_render_agl.cc
+++ b/webrtc/modules/video_render/mac/video_render_agl.cc

@@ -395,7 +395,8 @@
 {
     //WEBRTC_TRACE(kTraceInfo, kTraceVideoRenderer, _id, "%s");
 
-    _screenUpdateThread = ThreadWrapper::CreateThread(ScreenUpdateThreadProc, this, kRealtimePriority);
+    _screenUpdateThread = ThreadWrapper::CreateThread(
+        ScreenUpdateThreadProc, this, "ScreenUpdate");
     _screenUpdateEvent = EventWrapper::Create();
 
     if(!IsValidWindowPtr(_windowRef))
@@ -511,7 +512,8 @@
     //WEBRTC_TRACE(kTraceDebug, "%s:%d Constructor", __FUNCTION__, __LINE__);
     //    _renderCritSec = CriticalSectionWrapper::CreateCriticalSection();
 
-    _screenUpdateThread = ThreadWrapper::CreateThread(ScreenUpdateThreadProc, this, kRealtimePriority);
+    _screenUpdateThread = ThreadWrapper::CreateThread(
+        ScreenUpdateThreadProc, this, "ScreenUpdateThread");
     _screenUpdateEvent = EventWrapper::Create();
 
     GetWindowRect(_windowRect);
@@ -737,6 +739,7 @@
         return -1;
     }
     _screenUpdateThread->Start();
+    _screenUpdateThread->SetPriority(kRealtimePriority);
 
     // Start the event triggering the render process
     unsigned int monitorFreq = 60;
@@ -1877,6 +1880,7 @@
             UnlockAGLCntx();
             return -1;
         }
+        _screenUpdateThread->SetPriority(kRealtimePriority);
         if(FALSE == _screenUpdateEvent->StartTimer(true, 1000/MONITOR_FREQ))
         {
             //WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s:%d Failed to start screenUpdateEvent", __FUNCTION__, __LINE__);
@@ -1887,7 +1891,8 @@
         return 0;
     }
 
-    _screenUpdateThread = ThreadWrapper::CreateThread(ScreenUpdateThreadProc, this, kRealtimePriority);
+    _screenUpdateThread = ThreadWrapper::CreateThread(ScreenUpdateThreadProc,
+        this, "ScreenUpdate");
     _screenUpdateEvent = EventWrapper::Create();
 
     if (!_screenUpdateThread)
@@ -1898,6 +1903,7 @@
     }
 
     _screenUpdateThread->Start();
+    _screenUpdateThread->SetPriority(kRealtimePriority);
     _screenUpdateEvent->StartTimer(true, 1000/MONITOR_FREQ);
 
     //WEBRTC_TRACE(kTraceInfo, kTraceVideoRenderer, _id, "%s:%d Started screenUpdateThread", __FUNCTION__, __LINE__);

diff --git a/webrtc/modules/video_render/mac/video_render_nsopengl.mm b/webrtc/modules/video_render/mac/video_render_nsopengl.mm
index 569dd26..556eee0 100644
--- a/webrtc/modules/video_render/mac/video_render_nsopengl.mm
+++ b/webrtc/modules/video_render/mac/video_render_nsopengl.mm

@@ -380,7 +380,8 @@
 _windowRefSuperView(NULL),
 _windowRefSuperViewFrame(NSMakeRect(0,0,0,0))
 {
-    _screenUpdateThread = ThreadWrapper::CreateThread(ScreenUpdateThreadProc, this, kRealtimePriority);
+    _screenUpdateThread = ThreadWrapper::CreateThread(ScreenUpdateThreadProc,
+            this, "ScreenUpdateNSOpenGL");
     _screenUpdateEvent = EventWrapper::Create();
 }
 
@@ -437,6 +438,8 @@
             return -1;
         }
 
+        _screenUpdateThread->SetPriority(kRealtimePriority);
+
         UnlockAGLCntx();
         return 0;
     }
@@ -716,6 +719,7 @@
     }
 
     _screenUpdateThread->Start();
+    _screenUpdateThread->SetPriority(kRealtimePriority);
 
     // Start the event triggering the render process
     unsigned int monitorFreq = 60;

diff --git a/webrtc/modules/video_render/windows/video_render_direct3d9.cc b/webrtc/modules/video_render/windows/video_render_direct3d9.cc
index 99dd494..e9c08df 100644
--- a/webrtc/modules/video_render/windows/video_render_direct3d9.cc
+++ b/webrtc/modules/video_render/windows/video_render_direct3d9.cc

@@ -295,8 +295,8 @@
     _totalMemory(0),
     _availableMemory(0)
 {
-    _screenUpdateThread = ThreadWrapper::CreateThread(ScreenUpdateThreadProc,
-                                                      this, kRealtimePriority);
+    _screenUpdateThread = ThreadWrapper::CreateThread(
+        ScreenUpdateThreadProc, this, "ScreenUpdateThread");
     _screenUpdateEvent = EventWrapper::Create();
     SetRect(&_originalHwndRect, 0, 0, 0, 0);
 }
@@ -547,6 +547,7 @@
         return -1;
     }
     _screenUpdateThread->Start();
+    _screenUpdateThread->SetPriority(kRealtimePriority);
 
     // Start the event triggering the render process
     unsigned int monitorFreq = 60;

diff --git a/webrtc/system_wrappers/interface/thread_wrapper.h b/webrtc/system_wrappers/interface/thread_wrapper.h
index 67ce866..7420561 100644
--- a/webrtc/system_wrappers/interface/thread_wrapper.h
+++ b/webrtc/system_wrappers/interface/thread_wrapper.h

@@ -16,6 +16,10 @@
 #ifndef WEBRTC_SYSTEM_WRAPPERS_INTERFACE_THREAD_WRAPPER_H_
 #define WEBRTC_SYSTEM_WRAPPERS_INTERFACE_THREAD_WRAPPER_H_
 
+#if defined(WEBRTC_WIN)
+#include <windows.h>
+#endif
+
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_types.h"
 #include "webrtc/typedefs.h"
@@ -28,11 +32,19 @@
 typedef bool(*ThreadRunFunction)(void*);
 
 enum ThreadPriority {
+#ifdef WEBRTC_WIN
+  kLowPriority = THREAD_PRIORITY_BELOW_NORMAL,
+  kNormalPriority = THREAD_PRIORITY_NORMAL,
+  kHighPriority = THREAD_PRIORITY_ABOVE_NORMAL,
+  kHighestPriority = THREAD_PRIORITY_HIGHEST,
+  kRealtimePriority = THREAD_PRIORITY_TIME_CRITICAL
+#else
   kLowPriority = 1,
   kNormalPriority = 2,
   kHighPriority = 3,
   kHighestPriority = 4,
   kRealtimePriority = 5
+#endif
 };
 
 // Represents a simple worker thread.  The implementation must be assumed
@@ -52,11 +64,8 @@
   // prio        Thread priority. May require root/admin rights.
   // thread_name  NULL terminated thread name, will be visable in the Windows
   //             debugger.
-  // TODO(tommi): Remove the priority argument and provide a setter instead.
-  // TODO(tommi): Make thread_name non-optional (i.e. no default value).
   static rtc::scoped_ptr<ThreadWrapper> CreateThread(ThreadRunFunction func,
-      void* obj, ThreadPriority prio = kNormalPriority,
-      const char* thread_name = 0);
+      void* obj, const char* thread_name);
 
   // Get the current thread's thread ID.
   // NOTE: This is a static method. It returns the id of the calling thread,
@@ -75,6 +84,10 @@
   // Multiple tries to Stop are allowed (e.g. to wait longer than 2 seconds).
   // It's ok to call Stop() even if the spawned thread has been reclaimed.
   virtual bool Stop() = 0;
+
+  // Set the priority of the worker thread.  Must be called when thread
+  // is running.
+  virtual bool SetPriority(ThreadPriority priority) = 0;
 };
 
 }  // namespace webrtc

diff --git a/webrtc/system_wrappers/source/condition_variable_unittest.cc b/webrtc/system_wrappers/source/condition_variable_unittest.cc
index d6907f6..c34c4ea 100644
--- a/webrtc/system_wrappers/source/condition_variable_unittest.cc
+++ b/webrtc/system_wrappers/source/condition_variable_unittest.cc

@@ -145,7 +145,7 @@
 
   virtual void SetUp() {
     thread_ = ThreadWrapper::CreateThread(&WaitingRunFunction,
-                                          &baton_);
+                                          &baton_, "CondVarTest");
     ASSERT_TRUE(thread_->Start());
   }
 

diff --git a/webrtc/system_wrappers/source/critical_section_unittest.cc b/webrtc/system_wrappers/source/critical_section_unittest.cc
index 9b497b4..ec639eb 100644
--- a/webrtc/system_wrappers/source/critical_section_unittest.cc
+++ b/webrtc/system_wrappers/source/critical_section_unittest.cc

@@ -79,7 +79,7 @@
       CriticalSectionWrapper::CreateCriticalSection();
   ProtectedCount count(crit_sect);
   rtc::scoped_ptr<ThreadWrapper> thread = ThreadWrapper::CreateThread(
-      &LockUnlockThenStopRunFunction, &count);
+      &LockUnlockThenStopRunFunction, &count, "ThreadWakesOnce");
   crit_sect->Enter();
   ASSERT_TRUE(thread->Start());
   SwitchProcess();
@@ -106,7 +106,7 @@
       CriticalSectionWrapper::CreateCriticalSection();
   ProtectedCount count(crit_sect);
   rtc::scoped_ptr<ThreadWrapper> thread = ThreadWrapper::CreateThread(
-      &LockUnlockRunFunction, &count);
+      &LockUnlockRunFunction, &count, "ThreadWakesTwice");
   crit_sect->Enter();  // Make sure counter stays 0 until we wait for it.
   ASSERT_TRUE(thread->Start());
   crit_sect->Leave();

diff --git a/webrtc/system_wrappers/source/data_log.cc b/webrtc/system_wrappers/source/data_log.cc
index 7c2a91b..653af65 100644
--- a/webrtc/system_wrappers/source/data_log.cc
+++ b/webrtc/system_wrappers/source/data_log.cc

@@ -349,13 +349,11 @@
 
 int DataLogImpl::Init() {
   file_writer_thread_ = ThreadWrapper::CreateThread(
-                          DataLogImpl::Run,
-                          instance_,
-                          kHighestPriority,
-                          "DataLog");
+      DataLogImpl::Run, instance_, "DataLog");
   bool success = file_writer_thread_->Start();
   if (!success)
     return -1;
+  file_writer_thread_->SetPriority(kHighestPriority);
   return 0;
 }
 

diff --git a/webrtc/system_wrappers/source/event_posix.cc b/webrtc/system_wrappers/source/event_posix.cc
index bbfb0b0..6833e0e 100644
--- a/webrtc/system_wrappers/source/event_posix.cc
+++ b/webrtc/system_wrappers/source/event_posix.cc

@@ -154,11 +154,11 @@
   // Start the timer thread
   timer_event_ = static_cast<EventPosix*>(EventWrapper::Create());
   const char* thread_name = "WebRtc_event_timer_thread";
-  timer_thread_ = ThreadWrapper::CreateThread(Run, this, kRealtimePriority,
-                                              thread_name);
+  timer_thread_ = ThreadWrapper::CreateThread(Run, this, thread_name);
   periodic_ = periodic;
   time_ = time;
   bool started = timer_thread_->Start();
+  timer_thread_->SetPriority(kRealtimePriority);
   pthread_mutex_unlock(&mutex_);
 
   return started;

diff --git a/webrtc/system_wrappers/source/thread.cc b/webrtc/system_wrappers/source/thread.cc
index 957388b..b469344 100644
--- a/webrtc/system_wrappers/source/thread.cc
+++ b/webrtc/system_wrappers/source/thread.cc

@@ -25,10 +25,9 @@
 #endif
 
 rtc::scoped_ptr<ThreadWrapper> ThreadWrapper::CreateThread(
-    ThreadRunFunction func, void* obj, ThreadPriority prio,
-    const char* thread_name) {
+    ThreadRunFunction func, void* obj, const char* thread_name) {
   return rtc::scoped_ptr<ThreadWrapper>(
-      new ThreadType(func, obj, prio, thread_name)).Pass();
+      new ThreadType(func, obj, thread_name)).Pass();
 }
 
 }  // namespace webrtc

diff --git a/webrtc/system_wrappers/source/thread_posix.cc b/webrtc/system_wrappers/source/thread_posix.cc
index c605411..dc95cbc 100644
--- a/webrtc/system_wrappers/source/thread_posix.cc
+++ b/webrtc/system_wrappers/source/thread_posix.cc

@@ -69,10 +69,9 @@
 }
 
 ThreadPosix::ThreadPosix(ThreadRunFunction func, void* obj,
-                         ThreadPriority prio, const char* thread_name)
+                         const char* thread_name)
     : run_function_(func),
       obj_(obj),
-      prio_(prio),
       stop_event_(false, false),
       name_(thread_name ? thread_name : "webrtc"),
       thread_(0) {
@@ -112,6 +111,38 @@
   return true;
 }
 
+bool ThreadPosix::SetPriority(ThreadPriority priority) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!thread_)
+    return false;
+
+#ifdef WEBRTC_THREAD_RR
+  const int policy = SCHED_RR;
+#else
+  const int policy = SCHED_FIFO;
+#endif
+  const int min_prio = sched_get_priority_min(policy);
+  const int max_prio = sched_get_priority_max(policy);
+  if (min_prio == -1 || max_prio == -1) {
+    WEBRTC_TRACE(kTraceError, kTraceUtility, -1,
+                 "unable to retreive min or max priority for threads");
+    return false;
+  }
+
+  if (max_prio - min_prio <= 2)
+    return false;
+
+  sched_param param;
+  param.sched_priority = ConvertToSystemPriority(priority, min_prio, max_prio);
+  if (pthread_setschedparam(thread_, policy, &param) != 0) {
+    WEBRTC_TRACE(
+        kTraceError, kTraceUtility, -1, "unable to set thread priority");
+    return false;
+  }
+
+  return true;
+}
+
 void ThreadPosix::Run() {
   if (!name_.empty()) {
     // Setting the thread name may fail (harmlessly) if running inside a
@@ -123,27 +154,6 @@
 #endif
   }
 
-#ifdef WEBRTC_THREAD_RR
-  const int policy = SCHED_RR;
-#else
-  const int policy = SCHED_FIFO;
-#endif
-  const int min_prio = sched_get_priority_min(policy);
-  const int max_prio = sched_get_priority_max(policy);
-  if ((min_prio == -1) || (max_prio == -1)) {
-    WEBRTC_TRACE(kTraceError, kTraceUtility, -1,
-                 "unable to retreive min or max priority for threads");
-  }
-
-  if (max_prio - min_prio > 2) {
-    sched_param param;
-    param.sched_priority = ConvertToSystemPriority(prio_, min_prio, max_prio);
-    if (pthread_setschedparam(pthread_self(), policy, &param) != 0) {
-      WEBRTC_TRACE(
-          kTraceError, kTraceUtility, -1, "unable to set thread priority");
-    }
-  }
-
   // It's a requirement that for successful thread creation that the run
   // function be called at least once (see RunFunctionIsCalled unit test),
   // so to fullfill that requirement, we use a |do| loop and not |while|.

diff --git a/webrtc/system_wrappers/source/thread_posix.h b/webrtc/system_wrappers/source/thread_posix.h
index ccc52b6..c726e48 100644
--- a/webrtc/system_wrappers/source/thread_posix.h
+++ b/webrtc/system_wrappers/source/thread_posix.h

@@ -25,14 +25,15 @@
 
 class ThreadPosix : public ThreadWrapper {
  public:
-  ThreadPosix(ThreadRunFunction func, void* obj, ThreadPriority prio,
-              const char* thread_name);
+  ThreadPosix(ThreadRunFunction func, void* obj, const char* thread_name);
   ~ThreadPosix() override;
 
   // From ThreadWrapper.
   bool Start() override;
   bool Stop() override;
 
+  bool SetPriority(ThreadPriority priority) override;
+
  private:
   static void* StartThread(void* param);
 
@@ -41,7 +42,6 @@
   rtc::ThreadChecker thread_checker_;
   ThreadRunFunction const run_function_;
   void* const obj_;
-  ThreadPriority prio_;
   rtc::Event stop_event_;
   const std::string name_;
 

diff --git a/webrtc/system_wrappers/source/thread_unittest.cc b/webrtc/system_wrappers/source/thread_unittest.cc
index f5de7d2..854f98b 100644
--- a/webrtc/system_wrappers/source/thread_unittest.cc
+++ b/webrtc/system_wrappers/source/thread_unittest.cc

@@ -24,7 +24,7 @@
 
 TEST(ThreadTest, StartStop) {
   rtc::scoped_ptr<ThreadWrapper> thread = ThreadWrapper::CreateThread(
-      &NullRunFunction, NULL);
+      &NullRunFunction, nullptr, "ThreadTest");
   ASSERT_TRUE(thread->Start());
   EXPECT_TRUE(thread->Stop());
 }
@@ -40,7 +40,7 @@
 TEST(ThreadTest, RunFunctionIsCalled) {
   bool flag = false;
   rtc::scoped_ptr<ThreadWrapper> thread = ThreadWrapper::CreateThread(
-      &SetFlagRunFunction, &flag);
+      &SetFlagRunFunction, &flag, "RunFunctionIsCalled");
   ASSERT_TRUE(thread->Start());
 
   // At this point, the flag may be either true or false.

diff --git a/webrtc/system_wrappers/source/thread_win.cc b/webrtc/system_wrappers/source/thread_win.cc
index 0c1a8f2..aa03b91 100644
--- a/webrtc/system_wrappers/source/thread_win.cc
+++ b/webrtc/system_wrappers/source/thread_win.cc

@@ -55,10 +55,9 @@
 }
 
 ThreadWindows::ThreadWindows(ThreadRunFunction func, void* obj,
-                             ThreadPriority prio, const char* thread_name)
+                             const char* thread_name)
     : run_function_(func),
       obj_(obj),
-      prio_(prio),
       stop_(false),
       thread_(NULL),
       name_(thread_name ? thread_name : "webrtc") {
@@ -98,28 +97,6 @@
     return false;
   }
 
-  if (prio_ != kNormalPriority) {
-    int priority = THREAD_PRIORITY_NORMAL;
-    switch (prio_) {
-      case kLowPriority:
-        priority = THREAD_PRIORITY_BELOW_NORMAL;
-        break;
-      case kHighPriority:
-        priority = THREAD_PRIORITY_ABOVE_NORMAL;
-        break;
-      case kHighestPriority:
-        priority = THREAD_PRIORITY_HIGHEST;
-        break;
-      case kRealtimePriority:
-        priority = THREAD_PRIORITY_TIME_CRITICAL;
-        break;
-      default:
-        break;
-    }
-
-    SetThreadPriority(thread_, priority);
-  }
-
   return true;
 }
 
@@ -136,6 +113,11 @@
   return true;
 }
 
+bool ThreadWindows::SetPriority(ThreadPriority priority) {
+  DCHECK(main_thread_.CalledOnValidThread());
+  return thread_ && SetThreadPriority(thread_, priority);
+}
+
 void ThreadWindows::Run() {
   if (!name_.empty())
     SetThreadName(static_cast<DWORD>(-1), name_.c_str());

diff --git a/webrtc/system_wrappers/source/thread_win.h b/webrtc/system_wrappers/source/thread_win.h
index 1652551..741ae1e 100644
--- a/webrtc/system_wrappers/source/thread_win.h
+++ b/webrtc/system_wrappers/source/thread_win.h

@@ -21,13 +21,14 @@
 
 class ThreadWindows : public ThreadWrapper {
  public:
-  ThreadWindows(ThreadRunFunction func, void* obj, ThreadPriority prio,
-                const char* thread_name);
+  ThreadWindows(ThreadRunFunction func, void* obj, const char* thread_name);
   ~ThreadWindows() override;
 
   bool Start() override;
   bool Stop() override;
 
+  bool SetPriority(ThreadPriority priority) override;
+
  protected:
   void Run();
 
@@ -37,8 +38,6 @@
   ThreadRunFunction const run_function_;
   void* const obj_;
   bool stop_;
-  // TODO(tommi): Consider having a SetPriority method instead of this variable.
-  ThreadPriority prio_;
   HANDLE thread_;
   const std::string name_;
   rtc::ThreadChecker main_thread_;

diff --git a/webrtc/test/channel_transport/udp_socket2_manager_win.cc b/webrtc/test/channel_transport/udp_socket2_manager_win.cc
index f5062b1..55ddaee 100644
--- a/webrtc/test/channel_transport/udp_socket2_manager_win.cc
+++ b/webrtc/test/channel_transport/udp_socket2_manager_win.cc

@@ -537,7 +537,11 @@
 {
     WEBRTC_TRACE(kTraceStateInfo,  kTraceTransport, -1,
                  "Start UdpSocket2WorkerWindows");
-    return _pThread->Start();
+    if (!_pThread->Start())
+        return false;
+
+    _pThread->SetPriority(kRealtimePriority);
+    return true;
 }
 
 bool UdpSocket2WorkerWindows::Stop()
@@ -552,8 +556,7 @@
     if(!_init)
     {
         const char* threadName = "UdpSocket2ManagerWindows_thread";
-        _pThread = ThreadWrapper::CreateThread(Run, this, kRealtimePriority,
-                                               threadName);
+        _pThread = ThreadWrapper::CreateThread(Run, this, threadName);
         _init = true;
     }
     return 0;

diff --git a/webrtc/test/channel_transport/udp_socket_manager_posix.cc b/webrtc/test/channel_transport/udp_socket_manager_posix.cc
index 5d7686e..9748400 100644
--- a/webrtc/test/channel_transport/udp_socket_manager_posix.cc
+++ b/webrtc/test/channel_transport/udp_socket_manager_posix.cc

@@ -189,7 +189,6 @@
 {
     _critSectList = CriticalSectionWrapper::CreateCriticalSection();
     _thread = ThreadWrapper::CreateThread(UdpSocketManagerPosixImpl::Run, this,
-                                          kRealtimePriority,
                                           "UdpSocketManagerPosixImplThread");
     FD_ZERO(&_readFds);
     WEBRTC_TRACE(kTraceMemory,  kTraceTransport, -1,
@@ -228,7 +227,10 @@
 
     WEBRTC_TRACE(kTraceStateInfo,  kTraceTransport, -1,
                  "Start UdpSocketManagerPosix");
-    return _thread->Start();
+    if (!_thread->Start())
+        return false;
+    _thread->SetPriority(kRealtimePriority);
+    return true;
 }
 
 bool UdpSocketManagerPosixImpl::Stop()

diff --git a/webrtc/test/direct_transport.cc b/webrtc/test/direct_transport.cc
index 4e7b9d0..871bcb0 100644
--- a/webrtc/test/direct_transport.cc
+++ b/webrtc/test/direct_transport.cc

@@ -20,7 +20,8 @@
 DirectTransport::DirectTransport()
     : lock_(CriticalSectionWrapper::CreateCriticalSection()),
       packet_event_(EventWrapper::Create()),
-      thread_(ThreadWrapper::CreateThread(NetworkProcess, this)),
+      thread_(ThreadWrapper::CreateThread(
+          NetworkProcess, this, "NetworkProcess")),
       clock_(Clock::GetRealTimeClock()),
       shutting_down_(false),
       fake_network_(FakeNetworkPipe::Config()) {
@@ -31,7 +32,8 @@
     const FakeNetworkPipe::Config& config)
     : lock_(CriticalSectionWrapper::CreateCriticalSection()),
       packet_event_(EventWrapper::Create()),
-      thread_(ThreadWrapper::CreateThread(NetworkProcess, this)),
+      thread_(ThreadWrapper::CreateThread(
+          NetworkProcess, this, "NetworkProcess")),
       clock_(Clock::GetRealTimeClock()),
       shutting_down_(false),
       fake_network_(config) {

diff --git a/webrtc/test/fake_audio_device.cc b/webrtc/test/fake_audio_device.cc
index 5f78eb4..a55be4a 100644
--- a/webrtc/test/fake_audio_device.cc
+++ b/webrtc/test/fake_audio_device.cc

@@ -55,14 +55,15 @@
 
   if (!tick_->StartTimer(true, 10))
     return -1;
-  thread_ = ThreadWrapper::CreateThread(
-      FakeAudioDevice::Run, this, webrtc::kHighPriority, "FakeAudioDevice");
+  thread_ = ThreadWrapper::CreateThread(FakeAudioDevice::Run, this,
+                                        "FakeAudioDevice");
   if (thread_.get() == NULL)
     return -1;
   if (!thread_->Start()) {
     thread_.reset();
     return -1;
   }
+  thread_->SetPriority(webrtc::kHighPriority);
   return 0;
 }
 

diff --git a/webrtc/test/frame_generator_capturer.cc b/webrtc/test/frame_generator_capturer.cc
index e956fd2..664ed6b 100644
--- a/webrtc/test/frame_generator_capturer.cc
+++ b/webrtc/test/frame_generator_capturer.cc

@@ -90,9 +90,7 @@
 
   if (!tick_->StartTimer(true, 1000 / target_fps_))
     return false;
-  thread_ = ThreadWrapper::CreateThread(FrameGeneratorCapturer::Run,
-                                        this,
-                                        webrtc::kHighPriority,
+  thread_ = ThreadWrapper::CreateThread(FrameGeneratorCapturer::Run, this,
                                         "FrameGeneratorCapturer");
   if (thread_.get() == NULL)
     return false;
@@ -100,6 +98,7 @@
     thread_.reset();
     return false;
   }
+  thread_->SetPriority(webrtc::kHighPriority);
   return true;
 }
 

diff --git a/webrtc/video/full_stack.cc b/webrtc/video/full_stack.cc
index 9913f3d..93e682a 100644
--- a/webrtc/video/full_stack.cc
+++ b/webrtc/video/full_stack.cc

@@ -108,7 +108,7 @@
 
     for (uint32_t i = 0; i < num_cores; ++i) {
       rtc::scoped_ptr<ThreadWrapper> thread =
-          ThreadWrapper::CreateThread(&FrameComparisonThread, this);
+          ThreadWrapper::CreateThread(&FrameComparisonThread, this, "Analyzer");
       EXPECT_TRUE(thread->Start());
       comparison_thread_pool_.push_back(thread.release());
     }

diff --git a/webrtc/video_engine/test/auto_test/source/vie_autotest_win.cc b/webrtc/video_engine/test/auto_test/source/vie_autotest_win.cc
index a5ef89c..6e2bac3 100755
--- a/webrtc/video_engine/test/auto_test/source/vie_autotest_win.cc
+++ b/webrtc/video_engine/test/auto_test/source/vie_autotest_win.cc

@@ -47,8 +47,7 @@
       _window2(NULL),
       _terminate(false),
       _eventThread(webrtc::ThreadWrapper::CreateThread(
-          EventProcess, this, webrtc::kNormalPriority,
-          "ViEAutotestEventThread")),
+          EventProcess, this, "ViEAutotestEventThread")),
       _crit(*webrtc::CriticalSectionWrapper::CreateCriticalSection()),
       _hwnd1(NULL),
       _hwnd2(NULL),

diff --git a/webrtc/video_engine/test/libvietest/helpers/vie_fake_camera.cc b/webrtc/video_engine/test/libvietest/helpers/vie_fake_camera.cc
index 5de0f9c..1c18d49 100644
--- a/webrtc/video_engine/test/libvietest/helpers/vie_fake_camera.cc
+++ b/webrtc/video_engine/test/libvietest/helpers/vie_fake_camera.cc

@@ -61,7 +61,8 @@
   // Set up a thread which runs the fake camera. The capturer object is
   // thread-safe.
   camera_thread_ = webrtc::ThreadWrapper::CreateThread(
-      StreamVideoFileRepeatedlyIntoCaptureDevice, file_capture_device_);
+      StreamVideoFileRepeatedlyIntoCaptureDevice, file_capture_device_,
+      "StreamVideoFileRepeatedlyIntoCaptureDevice");
   camera_thread_->Start();
 
   return true;

diff --git a/webrtc/video_engine/test/libvietest/helpers/vie_to_file_renderer.cc b/webrtc/video_engine/test/libvietest/helpers/vie_to_file_renderer.cc
index 640d9c6..d0aee84 100644
--- a/webrtc/video_engine/test/libvietest/helpers/vie_to_file_renderer.cc
+++ b/webrtc/video_engine/test/libvietest/helpers/vie_to_file_renderer.cc

@@ -37,8 +37,7 @@
       output_path_(),
       output_filename_(),
       thread_(webrtc::ThreadWrapper::CreateThread(
-          ViEToFileRenderer::RunRenderThread,
-          this, webrtc::kNormalPriority, "ViEToFileRendererThread")),
+          ViEToFileRenderer::RunRenderThread, this, "ViEToFileRendererThread")),
       frame_queue_cs_(webrtc::CriticalSectionWrapper::CreateCriticalSection()),
       frame_render_event_(webrtc::EventWrapper::Create()),
       render_queue_(),

diff --git a/webrtc/video_engine/test/libvietest/testbed/tb_external_transport.cc b/webrtc/video_engine/test/libvietest/testbed/tb_external_transport.cc
index f62c660..d406985 100644
--- a/webrtc/video_engine/test/libvietest/testbed/tb_external_transport.cc
+++ b/webrtc/video_engine/test/libvietest/testbed/tb_external_transport.cc

@@ -41,8 +41,7 @@
       receive_channels_(receive_channels),
       _vieNetwork(vieNetwork),
       _thread(webrtc::ThreadWrapper::CreateThread(
-          ViEExternalTransportRun, this, webrtc::kHighPriority,
-          "AutotestTransport")),
+          ViEExternalTransportRun, this, "AutotestTransport")),
       _event(*webrtc::EventWrapper::Create()),
       _crit(*webrtc::CriticalSectionWrapper::CreateCriticalSection()),
       _statCrit(*webrtc::CriticalSectionWrapper::CreateCriticalSection()),
@@ -77,6 +76,7 @@
     srand((int) webrtc::TickTime::MicrosecondTimestamp());
     memset(&network_parameters_, 0, sizeof(NetworkParameters));
     _thread->Start();
+    _thread->SetPriority(webrtc::kHighPriority);
 }
 
 TbExternalTransport::~TbExternalTransport()

diff --git a/webrtc/video_engine/vie_capturer.cc b/webrtc/video_engine/vie_capturer.cc
index 456d15de..8a48804 100644
--- a/webrtc/video_engine/vie_capturer.cc
+++ b/webrtc/video_engine/vie_capturer.cc

@@ -68,10 +68,8 @@
       module_process_thread_(module_process_thread),
       capture_id_(capture_id),
       incoming_frame_cs_(CriticalSectionWrapper::CreateCriticalSection()),
-      capture_thread_(ThreadWrapper::CreateThread(ViECaptureThreadFunction,
-                                                  this,
-                                                  kHighPriority,
-                                                  "ViECaptureThread")),
+      capture_thread_(ThreadWrapper::CreateThread(
+          ViECaptureThreadFunction, this, "ViECaptureThread")),
       capture_event_(*EventWrapper::Create()),
       deliver_event_(*EventWrapper::Create()),
       stop_(0),
@@ -93,6 +91,7 @@
           new OveruseFrameDetector(Clock::GetRealTimeClock(),
                                    cpu_overuse_metrics_observer_.get())) {
   capture_thread_->Start();
+  capture_thread_->SetPriority(kHighPriority);
   module_process_thread_.RegisterModule(overuse_detector_.get());
 }
 

diff --git a/webrtc/video_engine/vie_channel.cc b/webrtc/video_engine/vie_channel.cc
index ee23dcc..a6d075f 100644
--- a/webrtc/video_engine/vie_channel.cc
+++ b/webrtc/video_engine/vie_channel.cc

@@ -1839,9 +1839,9 @@
     return 0;
   }
   decode_thread_ = ThreadWrapper::CreateThread(ChannelDecodeThreadFunction,
-                                                   this, kHighestPriority,
-                                                   "DecodingThread");
+                                               this, "DecodingThread");
   decode_thread_->Start();
+  decode_thread_->SetPriority(kHighestPriority);
   return 0;
 }
 

diff --git a/webrtc/voice_engine/test/android/android_test/jni/android_test.cc b/webrtc/voice_engine/test/android/android_test/jni/android_test.cc
index 1efe075..b0a26e0 100644
--- a/webrtc/voice_engine/test/android/android_test/jni/android_test.cc
+++ b/webrtc/voice_engine/test/android/android_test/jni/android_test.cc

@@ -188,8 +188,7 @@
 
 ThreadTest::ThreadTest()
 {
-    _thread = ThreadWrapper::CreateThread(Run, this, kNormalPriority,
-                                          "ThreadTest thread");
+    _thread = ThreadWrapper::CreateThread(Run, this, "ThreadTest thread");
 }
 
 bool ThreadTest::Run(void* ptr)

diff --git a/webrtc/voice_engine/test/auto_test/fakes/fake_external_transport.cc b/webrtc/voice_engine/test/auto_test/fakes/fake_external_transport.cc
index 29156cd..c825ea5 100644
--- a/webrtc/voice_engine/test/auto_test/fakes/fake_external_transport.cc
+++ b/webrtc/voice_engine/test/auto_test/fakes/fake_external_transport.cc

@@ -27,10 +27,10 @@
   const char* thread_name = "external_thread";
   lock_ = webrtc::CriticalSectionWrapper::CreateCriticalSection();
   event_ = webrtc::EventWrapper::Create();
-  thread_ = webrtc::ThreadWrapper::CreateThread(
-      Run, this, webrtc::kHighPriority, thread_name);
+  thread_ = webrtc::ThreadWrapper::CreateThread(Run, this, thread_name);
   if (thread_) {
     thread_->Start();
+    thread_->SetPriority(webrtc::kHighPriority);
   }
 }
 

diff --git a/webrtc/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h b/webrtc/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h
index 3383a53..cee5a58 100644
--- a/webrtc/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h
+++ b/webrtc/voice_engine/test/auto_test/fixtures/after_initialization_fixture.h

@@ -29,7 +29,8 @@
   LoopBackTransport(webrtc::VoENetwork* voe_network)
       : crit_(webrtc::CriticalSectionWrapper::CreateCriticalSection()),
         packet_event_(webrtc::EventWrapper::Create()),
-        thread_(webrtc::ThreadWrapper::CreateThread(NetworkProcess, this)),
+        thread_(webrtc::ThreadWrapper::CreateThread(
+            NetworkProcess, this, "LoopBackTransport")),
         voe_network_(voe_network), transmitted_packets_(0) {
     thread_->Start();
   }

diff --git a/webrtc/voice_engine/test/auto_test/voe_stress_test.cc b/webrtc/voice_engine/test/auto_test/voe_stress_test.cc
index 38329eb..ab8fffe 100644
--- a/webrtc/voice_engine/test/auto_test/voe_stress_test.cc
+++ b/webrtc/voice_engine/test/auto_test/voe_stress_test.cc

@@ -334,9 +334,8 @@
   int rnd(0);
 
   // Start extra thread
-  const char* threadName = "StressTest Extra API Thread";
   _ptrExtraApiThread = ThreadWrapper::CreateThread(RunExtraApi, this,
-                                                   kNormalPriority, threadName);
+                                                   "StressTestExtraApiThread");
   VALIDATE_STRESS(!_ptrExtraApiThread->Start());
 
   //       Some possible extensions include: