Ensure that the wake up timer set by the UI worker thread in the UI message pump on Windows is set …

base/message_loop/message_pump_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/message_loop/message_pump_win.h"
 
 #include <limits>
 #include <math.h>
 
 #include "base/message_loop/message_loop.h"
@@ skipping 75 matching lines @@
   // super-long delay.
   return timeout < 0 ? 0 :
       (timeout > std::numeric_limits<int>::max() ?
        std::numeric_limits<int>::max() : static_cast<int>(timeout));
 }
 
 //-----------------------------------------------------------------------------
 // MessagePumpForUI public:
 
 MessagePumpForUI::MessagePumpForUI()
-    : atom_(0) {
+    : atom_(0),
+      force_fallback_timer_for_tasks_(0) {
   InitMessageWnd();
 
   ui_worker_thread_timer_.Set(::CreateWaitableTimer(NULL, FALSE, NULL));
   ui_worker_thread_.reset(new base::Thread("UI Pump Worker thread"));
   ui_worker_thread_->Start();
   ui_worker_thread_->WaitUntilThreadStarted();
   ui_worker_thread_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&MessagePumpForUI::DoWorkerThreadRunLoop,
                  base::Unretained(this)));
@@ skipping 11 matching lines @@
 }
 
 void MessagePumpForUI::ScheduleWork() {
   // If we have a regular posted task at the head of queue then we need to
   // process it quickly.
   if (state_ && state_->delegate->GetNewlyAddedTaskDelay().is_null()) {
     // Make sure the MessagePump does some work for us.
     PostWorkMessage();
     return;
   }
+
+  ::InterlockedExchange(&force_fallback_timer_for_tasks_, 1);
   // Set a one shot timer to fire after 3 milliseconds. The actual resolution
   // of the timer is dependent on timeBeginPeriod being called.
   SetWakeupTimer(kDefaultUIWorkerThreadWakeupTimerMs);
 }
 
 void MessagePumpForUI::ScheduleDelayedWork(const TimeTicks& delayed_work_time) {
   delayed_work_time_ = delayed_work_time;
   RescheduleTimer();
 }
 
@@ skipping 280 matching lines @@
 }
 
 bool MessagePumpForUI::ProcessPumpReplacementMessage() {
   // Since we discarded a kMsgHaveWork message, we must update the flag.
   InterlockedExchange(&have_work_, 0);
   return true;
 }
 
 void MessagePumpForUI::DoWorkerThreadRunLoop() {
   DCHECK(ui_worker_thread_timer_.Get());
+
   while (TRUE) {
     DWORD ret = WaitForSingleObjectEx(
         ui_worker_thread_timer_.Get(), INFINITE, TRUE);
     // The only APC this thread could receive is the Shutdown APC.
     if (ret == WAIT_IO_COMPLETION)
       return;
 
     // Make sure the MessagePump does some work for us.
     PostWorkMessage();
 
     // Set a one shot timer to process pending delayed tasks if any in the
     // queue. The actual resolution of the timer is dependent on the
     // timeBeginPeriod API being called.

[brucedawson, 2015/06/19 21:09:01]

"is dependent on the current global timer precision and therefore depends on
whether Chrome or any other process has raised the timer frequency with
timeBeginPeriod."

[ananta, 2015/06/19 22:19:10]

Done.

-    SetWakeupTimer(kDefaultUIWorkerThreadWakeupTimerMs);
+    if (::InterlockedExchange(&force_fallback_timer_for_tasks_, 0))
+      SetWakeupTimer(kDefaultUIWorkerThreadWakeupTimerMs);
   }
 }
 
 // static
 void CALLBACK MessagePumpForUI::ShutdownWorkerThread(ULONG_PTR param) {
   // This function is empty because we only use the fact that an APC was posted
   // to the worker thread to shut it down.
   return;
 }
 
@@ skipping 249 matching lines @@
 
 // static
 MessagePumpForIO::IOHandler* MessagePumpForIO::KeyToHandler(
     ULONG_PTR key,
     bool* has_valid_io_context) {
   *has_valid_io_context = ((key & 1) == 0);
   return reinterpret_cast<IOHandler*>(key & ~static_cast<ULONG_PTR>(1));
 }
 
 }  // namespace base