Add support for priorities to TaskQueue.

webrtc/base/task_queue_win.cc

 /*
  *  Copyright 2016 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.
  */
 
 #include "webrtc/base/task_queue.h"
 
 #include <mmsystem.h>
 #include <string.h>
 
 #include <algorithm>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 
 namespace rtc {
 namespace {
 #define WM_RUN_TASK WM_USER + 1
 #define WM_QUEUE_DELAYED_TASK WM_USER + 2
 
+using Priority = TaskQueue::Priority;
+
 DWORD g_queue_ptr_tls = 0;
 
 BOOL CALLBACK InitializeTls(PINIT_ONCE init_once, void* param, void** context) {
   g_queue_ptr_tls = TlsAlloc();
   return TRUE;
 }
 
 DWORD GetQueuePtrTls() {
   static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
   ::InitOnceExecuteOnce(&init_once, InitializeTls, nullptr, nullptr);
   return g_queue_ptr_tls;
 }
 
 struct ThreadStartupData {
   Event* started;
   void* thread_context;
 };
 
 void CALLBACK InitializeQueueThread(ULONG_PTR param) {
   MSG msg;
   ::PeekMessage(&msg, nullptr, WM_USER, WM_USER, PM_NOREMOVE);
   ThreadStartupData* data = reinterpret_cast<ThreadStartupData*>(param);
   ::TlsSetValue(GetQueuePtrTls(), data->thread_context);
   data->started->Set();
 }
+
+ThreadPriority TaskQueuePriorityToThreadPriority(Priority priority) {
+  switch (priority) {
+    case Priority::HIGH:
+      return kRealtimePriority;
+    case Priority::LOW:
+      return kLowPriority;
+    case Priority::NORMAL:
+      return kNormalPriority;
+    default:
+      RTC_NOTREACHED();
+      break;
+  }
+  return kNormalPriority;
+}
 }  // namespace
 
 class TaskQueue::MultimediaTimer {
  public:
   // kMaxTimers defines the limit of how many MultimediaTimer instances should
   // be created.
   // Background: The maximum number of supported handles for Wait functions, is
   // MAXIMUM_WAIT_OBJECTS - 1 (63).
   // There are some ways to work around the limitation but as it turns out, the
   // limit of concurrently active multimedia timers per process, is much lower,
@@ skipping 76 matching lines @@
     }
   }
 
   HANDLE event_ = nullptr;
   MMRESULT timer_id_ = 0;
   std::unique_ptr<QueuedTask> task_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(MultimediaTimer);
 };
 
-TaskQueue::TaskQueue(const char* queue_name)
-    : thread_(&TaskQueue::ThreadMain, this, queue_name) {
+TaskQueue::TaskQueue(const char* queue_name, Priority priority /*= NORMAL*/)
+    : thread_(&TaskQueue::ThreadMain,
+              this,
+              queue_name,
+              TaskQueuePriorityToThreadPriority(priority)) {
   RTC_DCHECK(queue_name);
   thread_.Start();
   Event event(false, false);
   ThreadStartupData startup = {&event, this};
   RTC_CHECK(thread_.QueueAPC(&InitializeQueueThread,
                              reinterpret_cast<ULONG_PTR>(&startup)));
   event.Wait(Event::kForever);
 }
 
 TaskQueue::~TaskQueue() {
@@ skipping 195 matching lines @@
       }
     } else {
       ::TranslateMessage(&msg);
       ::DispatchMessage(&msg);
     }
   }
   return msg.message != WM_QUIT;
 }
 
 }  // namespace rtc