Refactor Windows TaskQueue code to only need a single high res timer.

webrtc/base/task_queue_unittest.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.
  */
 
+#if defined(WEBRTC_WIN)
+// clang-format off
+#include <windows.h>  // Must come first.
+#include <mmsystem.h>
+// clang-format on
+#endif
+
 #include <memory>
 #include <vector>
 
 #include "webrtc/base/bind.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/base/timeutils.h"
 
 namespace rtc {
+namespace {
+// Noop on all platforms except Windows, where it turns on high precision
+// multimedia timers which increases the precision of TimeMillis() while in
+// scope.
+class EnableHighResTimers {
+ public:
+#if !defined(WEBRTC_WIN)
+  EnableHighResTimers() {}
+#else
+  EnableHighResTimers() : enabled_(timeBeginPeriod(1) == TIMERR_NOERROR) {}
+  ~EnableHighResTimers() {
+    if (enabled_)
+      timeEndPeriod(1);
+  }
+
+ private:
+  const bool enabled_;
+#endif
+};
+}
 
 namespace {
 void CheckCurrent(const char* expected_queue, Event* signal, TaskQueue* queue) {
   EXPECT_TRUE(TaskQueue::IsCurrent(expected_queue));
   EXPECT_TRUE(queue->IsCurrent());
   if (signal)
     signal->Set();
 }
 
 }  // namespace
@@ skipping 77 matching lines @@
   queue.PostDelayedTask(Bind(&CheckCurrent, kQueueName, &event, &queue), 100);
   EXPECT_TRUE(event.Wait(1000));
   uint32_t end = Time();
   // These tests are a little relaxed due to how "powerful" our test bots can
   // be.  Most recently we've seen windows bots fire the callback after 94-99ms,
   // which is why we have a little bit of leeway backwards as well.
   EXPECT_GE(end - start, 90u);
   EXPECT_NEAR(end - start, 190u, 100u);  // Accept 90-290.
 }
 
+// This task needs to be run manually due to the slowness of some of our bots.
+// TODO(tommi): Can we run this on the perf bots?
+TEST(TaskQueueTest, DISABLED_PostDelayedHighRes) {
+  EnableHighResTimers high_res_scope;
+
+  static const char kQueueName[] = "PostDelayedHighRes";
+  Event event(false, false);
+  TaskQueue queue(kQueueName, TaskQueue::Priority::HIGH);
+
+  uint32_t start = Time();
+  queue.PostDelayedTask(Bind(&CheckCurrent, kQueueName, &event, &queue), 3);
+  EXPECT_TRUE(event.Wait(1000));
+  uint32_t end = TimeMillis();
+  // These tests are a little relaxed due to how "powerful" our test bots can
+  // be.  Most recently we've seen windows bots fire the callback after 94-99ms,
+  // which is why we have a little bit of leeway backwards as well.
+  EXPECT_GE(end - start, 3u);
+  EXPECT_NEAR(end - start, 3, 3u);
+}
+
 TEST(TaskQueueTest, PostMultipleDelayed) {
   static const char kQueueName[] = "PostMultipleDelayed";
   TaskQueue queue(kQueueName);
 
   std::vector<std::unique_ptr<Event>> events;
   for (int i = 0; i < 100; ++i) {
     events.push_back(std::unique_ptr<Event>(new Event(false, false)));
     queue.PostDelayedTask(
-        Bind(&CheckCurrent, kQueueName, events.back().get(), &queue), 10);
+        Bind(&CheckCurrent, kQueueName, events.back().get(), &queue), i);
   }
 
   for (const auto& e : events)
     EXPECT_TRUE(e->Wait(1000));
 }
 
 TEST(TaskQueueTest, PostDelayedAfterDestruct) {
   static const char kQueueName[] = "PostDelayedAfterDestruct";
   Event event(false, false);
   {
@@ skipping 138 matching lines @@
       queue.PostTask(NewClosure([&tasks_executed]() { ++tasks_executed; },
                                 [&tasks_cleaned_up]() { ++tasks_cleaned_up; }));
     event.Set();  // Unblock the first task.
   }
 
   EXPECT_GE(tasks_cleaned_up, tasks_executed);
   EXPECT_EQ(kTaskCount, tasks_cleaned_up);
 }
 
 }  // namespace rtc