Add support for priorities to TaskQueue.

webrtc/base/task_queue_libevent.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.
  */
 
@@ skipping 66 matching lines @@
                  short events,
                  void (*callback)(int, short, void*),
                  void* arg) {
 #if defined(_EVENT2_EVENT_H_)
   RTC_CHECK_EQ(0, event_assign(ev, base, fd, events, callback, arg));
 #else
   event_set(ev, fd, events, callback, arg);
   RTC_CHECK_EQ(0, event_base_set(base, ev));
 #endif
 }
+
+ThreadPriority TaskQueuePriorityToThreadPriority(TaskQueue::Priority priority) {
+  switch (priority) {
+    case TaskQueue::HIGH:
+      return kRealtimePriority;
+    case TaskQueue::LOW:
+      return kLowPriority;
+    case TaskQueue::NORMAL:
+    default:

[the sun, 2017/02/24 09:03:43]

If compiler won't warn about an unhandled "case", you should instead of silently
resorting to default:

...
case TaskQueue::NORMAL:
  return kNormalPriority;
default:
  RTC_NOTREACHED();
  return kNormalPriority;
...

[tommi, 2017/02/24 17:34:41]

Done.

+      break;
+  }
+  return kNormalPriority;
+}
 }  // namespace
 
 struct TaskQueue::QueueContext {
   explicit QueueContext(TaskQueue* q) : queue(q), is_active(true) {}
   TaskQueue* queue;
   bool is_active;
   // Holds a list of events pending timers for cleanup when the loop exits.
   std::list<TimerEvent*> pending_timers_;
 };
 
@@ skipping 97 matching lines @@
         std::move(task_),
         post_time > milliseconds_ ? 0 : milliseconds_ - post_time);
     return true;
   }
 
   std::unique_ptr<QueuedTask> task_;
   const uint32_t milliseconds_;
   const uint32_t posted_;
 };
 
-TaskQueue::TaskQueue(const char* queue_name)
+TaskQueue::TaskQueue(const char* queue_name, Priority priority /*= NORMAL*/)
     : event_base_(event_base_new()),
       wakeup_event_(new event()),
-      thread_(&TaskQueue::ThreadMain, this, queue_name) {
+      thread_(&TaskQueue::ThreadMain,
+              this,
+              queue_name,
+              TaskQueuePriorityToThreadPriority(priority)) {
   RTC_DCHECK(queue_name);
   int fds[2];
   RTC_CHECK(pipe(fds) == 0);
   SetNonBlocking(fds[0]);
   SetNonBlocking(fds[1]);
   wakeup_pipe_out_ = fds[0];
   wakeup_pipe_in_ = fds[1];
 
   EventAssign(wakeup_event_.get(), event_base_, wakeup_pipe_out_,
               EV_READ | EV_PERSIST, OnWakeup, this);
@@ skipping 182 matching lines @@
   delete timer;
 }
 
 void TaskQueue::PrepareReplyTask(scoped_refptr<ReplyTaskOwnerRef> reply_task) {
   RTC_DCHECK(reply_task);
   CritScope lock(&pending_lock_);
   pending_replies_.push_back(std::move(reply_task));
 }
 
 }  // namespace rtc