Increase tick precision in TaskQueue on Windows 64.

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.
  */
 
@@ skipping 48 matching lines @@
     case Priority::LOW:
       return kLowPriority;
     case Priority::NORMAL:
       return kNormalPriority;
     default:
       RTC_NOTREACHED();
       break;
   }
   return kNormalPriority;
 }
+
+#if defined(_WIN64)
+DWORD GetTick() {
+  static const UINT kPeriod = 1;
+  bool high_res = (timeBeginPeriod(kPeriod) == TIMERR_NOERROR);
+  DWORD ret = timeGetTime();
+  if (high_res)
+    timeEndPeriod(kPeriod);
+  return ret;
+}
+#endif
 }  // namespace
 
 class TaskQueue::MultimediaTimer {
  public:
   // kMaxTimers defines the limit of how many MultimediaTimer instances should
   // be created.
   // Background: The maximum number of supported handles for Wait functions, is
   // MAXIMUM_WAIT_OBJECTS - 1 (63).
   // There are some ways to work around the limitation but as it turns out, the
   // limit of concurrently active multimedia timers per process, is much lower,
@@ skipping 128 matching lines @@
   }
 }
 
 void TaskQueue::PostDelayedTask(std::unique_ptr<QueuedTask> task,
                                 uint32_t milliseconds) {
   WPARAM wparam;
 #if defined(_WIN64)
   // GetTickCount() returns a fairly coarse tick count (resolution or about 8ms)
   // so this compensation isn't that accurate, but since we have unused 32 bits
   // on Win64, we might as well use them.
-  wparam = (static_cast<WPARAM>(::GetTickCount()) << 32) | milliseconds;
+  wparam = (static_cast<WPARAM>(GetTick()) << 32) | milliseconds;
 #else
   wparam = milliseconds;
 #endif
   if (::PostThreadMessage(thread_.GetThreadRef(), WM_QUEUE_DELAYED_TASK, wparam,
                           reinterpret_cast<LPARAM>(task.get()))) {
     task.release();
   }
 }
 
 void TaskQueue::PostTaskAndReply(std::unique_ptr<QueuedTask> task,
@@ skipping 90 matching lines @@
           if (task->Run())
             delete task;
           break;
         }
         case WM_QUEUE_DELAYED_TASK: {
           std::unique_ptr<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();
+          const DWORD now = GetTick();
           DWORD post_time = now - (msg.wParam >> 32);
           milliseconds =
               post_time > milliseconds ? 0 : milliseconds - post_time;
 #endif
           bool timer_queued = false;
           if (timers->size() < MultimediaTimer::kMaxTimers) {
             MultimediaTimer* timer = nullptr;
             auto available = std::find_if(
                 timers->begin(), timers->end(),
                 [](const MultimediaTimer& t) { return !t.is_active(); });
@@ skipping 36 matching lines @@
       }
     } else {
       ::TranslateMessage(&msg);
       ::DispatchMessage(&msg);
     }
   }
   return msg.message != WM_QUIT;
 }
 
 }  // namespace rtc