Add support for priorities to TaskQueue.

webrtc/base/task_queue_gcd.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.
  */
 
 // This file contains the implementation of TaskQueue for Mac and iOS.
 // The implementation uses Grand Central Dispatch queues (GCD) to
 // do the actual task queuing.
 
 #include "webrtc/base/task_queue.h"
 
 #include <string.h>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/task_queue_posix.h"
 
 namespace rtc {
+namespace {
+
+using Priority = TaskQueue::Priority;
+
+int TaskQueuePriorityToGCD(Priority priority) {
+  switch (priority) {
+    case Priority::NORMAL:
+      return DISPATCH_QUEUE_PRIORITY_DEFAULT;
+    case Priority::HIGH:
+      return DISPATCH_QUEUE_PRIORITY_HIGH;
+    case Priority::LOW:
+      return DISPATCH_QUEUE_PRIORITY_LOW;
+  }
+}
+}
+
 using internal::GetQueuePtrTls;
 using internal::AutoSetCurrentQueuePtr;
 
 struct TaskQueue::QueueContext {
   explicit QueueContext(TaskQueue* q) : queue(q), is_active(true) {}
 
   static void SetNotActive(void* context) {
     QueueContext* qc = static_cast<QueueContext*>(context);
     qc->is_active = false;
   }
@@ skipping 53 matching lines @@
     // Post the reply task.  This hands the work over to the parent struct.
     // This task will eventually delete |this|.
     dispatch_async_f(rc->reply_queue_, rc, &TaskContext::RunTask);
   }
 
   QueueContext* const first_queue_ctx;
   std::unique_ptr<QueuedTask> first_task;
   dispatch_queue_t reply_queue_;
 };
 
-TaskQueue::TaskQueue(const char* queue_name)
+TaskQueue::TaskQueue(const char* queue_name, Priority priority /*= NORMAL*/)
     : queue_(dispatch_queue_create(queue_name, DISPATCH_QUEUE_SERIAL)),
       context_(new QueueContext(this)) {
   RTC_DCHECK(queue_name);
   RTC_CHECK(queue_);
   dispatch_set_context(queue_, context_);
   // Assign a finalizer that will delete the context when the last reference
   // to the queue is released.  This may run after the TaskQueue object has
   // been deleted.
   dispatch_set_finalizer_f(queue_, &QueueContext::DeleteContext);
+
+  dispatch_set_target_queue(
+      queue_, dispatch_get_global_queue(TaskQueuePriorityToGCD(priority), 0));
 }
 
 TaskQueue::~TaskQueue() {
   RTC_DCHECK(!IsCurrent());
   // Implementation/behavioral note:
   // Dispatch queues are reference counted via calls to dispatch_retain and
   // dispatch_release. Pending blocks submitted to a queue also hold a
   // reference to the queue until they have finished. Once all references to a
   // queue have been released, the queue will be deallocated by the system.
   // This is why we check the context before running tasks.
@@ skipping 41 matching lines @@
       context_, std::move(task), reply_queue->context_, std::move(reply));
   dispatch_async_f(queue_, context, &PostTaskAndReplyContext::RunTask);
 }
 
 void TaskQueue::PostTaskAndReply(std::unique_ptr<QueuedTask> task,
                                  std::unique_ptr<QueuedTask> reply) {
   return PostTaskAndReply(std::move(task), std::move(reply), Current());
 }
 
 }  // namespace rtc