Proposed ~TaskQueue() solution - GCD

webrtc/rtc_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/rtc_base/task_queue.h"
 
 #include <string.h>
 
+#include <atomic>
+
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/task_queue_posix.h"
 
 namespace rtc {
 namespace {
 
 using Priority = TaskQueue::Priority;
 
 int TaskQueuePriorityToGCD(Priority priority) {
@@ skipping 17 matching lines @@
   static void SetNotActive(void* context) {
     QueueContext* qc = static_cast<QueueContext*>(context);
     qc->is_active = false;
   }
 
   static void DeleteContext(void* context) {
     QueueContext* qc = static_cast<QueueContext*>(context);
     delete qc;
   }
 
+  // By posting this function synchronously, one can wait until the queue
+  // has been emptied.
+  static void VoidFunction(void* context) {}  // TODO(eladalon): !!! Rename?
+
   TaskQueue* const queue;
-  bool is_active;
+  std::atomic<bool> is_active;
 };
 
 struct TaskQueue::TaskContext {
   TaskContext(QueueContext* queue_ctx, std::unique_ptr<QueuedTask> task)
       : queue_ctx(queue_ctx), task(std::move(task)) {}
   virtual ~TaskContext() {}
 
   static void RunTask(void* context) {
     std::unique_ptr<TaskContext> tc(static_cast<TaskContext*>(context));
     if (tc->queue_ctx->is_active) {
@@ skipping 59 matching lines @@
 
 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.
 
-  // Use dispatch_sync to set the context to null to guarantee that there's not
-  // a race between checking the context and using it from a task.
-  dispatch_sync_f(queue_, context_, &QueueContext::SetNotActive);
+  // Prevent pending tasks from running.
+  QueueContext::SetNotActive(context_);
+
+  // Wait until all previous tasks' destructors have been invoked.
+  dispatch_sync_f(queue_, context_, &QueueContext::VoidFunction);
+
+  // TODO(eladalon): !!! It would be good to also RTC_DCHECK here to make sure
+  // no additional tasks were posted in the meantime. Posting tasks during
+  // tear-down would be an error of poster. Additionally, the tasks' destructors
+  // would not get called.
+
   dispatch_release(queue_);
 }
 
 // static
 TaskQueue* TaskQueue::Current() {
   return static_cast<TaskQueue*>(pthread_getspecific(GetQueuePtrTls()));
 }
 
 // static
 bool TaskQueue::IsCurrent(const char* queue_name) {
@@ skipping 27 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