Handle initialization race in TaskQueue on Windows, discovered by drmemory

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 <string.h>
-#include <unordered_map>
 
 #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
 
 DWORD g_queue_ptr_tls = 0;
@@ skipping 100 matching lines @@
   });
 }
 
 void TaskQueue::PostTaskAndReply(std::unique_ptr<QueuedTask> task,
                                  std::unique_ptr<QueuedTask> reply) {
   return PostTaskAndReply(std::move(task), std::move(reply), Current());
 }
 
 // static
 bool TaskQueue::ThreadMain(void* context) {
-  std::unordered_map<UINT_PTR, std::unique_ptr<QueuedTask>> delayed_tasks;
+  DelayedTasks delayed_tasks;
+  while (true) {
+    DWORD result = ::MsgWaitForMultipleObjectsEx(0, nullptr, INFINITE,
+                                                 QS_ALLEVENTS, MWMO_ALERTABLE);
+    RTC_CHECK_NE(WAIT_FAILED, result);
+    if (result == WAIT_OBJECT_0) {
+      if (!ProcessQueuedMessages(&delayed_tasks))
+        break;
+    } else {
+      RTC_DCHECK_EQ(WAIT_IO_COMPLETION, result);
+    }
+  }
+  return false;
+}
 
-  BOOL ret;
-  MSG msg;
-
-  while ((ret = GetMessage(&msg, nullptr, 0, 0)) != 0 && ret != -1) {
+// static
+bool TaskQueue::ProcessQueuedMessages(DelayedTasks* delayed_tasks) {
+  MSG msg = {};
+  while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE) &&
+         msg.message != WM_QUIT) {
     if (!msg.hwnd) {
       switch (msg.message) {
         case WM_RUN_TASK: {
           QueuedTask* task = reinterpret_cast<QueuedTask*>(msg.lParam);
           if (task->Run())
             delete task;
           break;
         }
         case WM_QUEUE_DELAYED_TASK: {
           QueuedTask* task = reinterpret_cast<QueuedTask*>(msg.lParam);
           uint32_t milliseconds = msg.wParam & 0xFFFFFFFF;
 #if defined(_WIN64)
           // Subtract the time it took to queue the timer.
           const DWORD now = GetTickCount();
           DWORD post_time = now - (msg.wParam >> 32);
           milliseconds =
               post_time > milliseconds ? 0 : milliseconds - post_time;
 #endif
           UINT_PTR timer_id = SetTimer(nullptr, 0, milliseconds, nullptr);
-          delayed_tasks.insert(std::make_pair(timer_id, task));
+          delayed_tasks->insert(std::make_pair(timer_id, task));
           break;
         }
         case WM_TIMER: {
           KillTimer(nullptr, msg.wParam);
-          auto found = delayed_tasks.find(msg.wParam);
-          RTC_DCHECK(found != delayed_tasks.end());
+          auto found = delayed_tasks->find(msg.wParam);
+          RTC_DCHECK(found != delayed_tasks->end());
           if (!found->second->Run())
             found->second.release();
-          delayed_tasks.erase(found);
+          delayed_tasks->erase(found);
           break;
         }
         default:
           RTC_NOTREACHED();
           break;
       }
     } else {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
     }
   }
+  return msg.message != WM_QUIT;
+}
 
-  return false;
-}
 }  // namespace rtc