Throttle GpuWatchdogThread task posting

gpu/ipc/service/gpu_watchdog_thread.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 "gpu/ipc/service/gpu_watchdog_thread.h"
 
 #include <errno.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 48 matching lines @@
       arm_cpu_time_(),
 #endif
       suspended_(false),
 #if defined(USE_X11)
       display_(NULL),
       window_(0),
       atom_(None),
       host_tty_(-1),
 #endif
       weak_factory_(this) {
+  base::subtle::NoBarrier_Store(&awaiting_acknowledge_, false);
+
 #if defined(OS_WIN)
   // GetCurrentThread returns a pseudo-handle that cannot be used by one thread
   // to identify another. DuplicateHandle creates a "real" handle that can be
   // used for this purpose.
   BOOL result = DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
                                 GetCurrentProcess(), &watched_thread_handle_,
                                 THREAD_QUERY_INFORMATION, FALSE, 0);
   DCHECK(result);
 #endif
 
@@ skipping 14 matching lines @@
 }
 
 void GpuWatchdogThread::PostAcknowledge() {
   // Called on the monitored thread. Responds with OnAcknowledge. Cannot use
   // the method factory. Rely on reference counting instead.
   task_runner()->PostTask(FROM_HERE,
                           base::Bind(&GpuWatchdogThread::OnAcknowledge, this));
 }
 
 void GpuWatchdogThread::CheckArmed() {
-  // Acknowledge the watchdog if it has armed itself. The watchdog will not
-  // change its armed state until it is acknowledged.
-  if (armed()) {
+  // If the watchdog is |awaiting_acknowledge_|, reset this variable to false
+  // and post an acknowledge task now. No barrier is needed as
+  // |awaiting_acknowledge_| is only ever read from this thread.
+  if (base::subtle::NoBarrier_CompareAndSwap(&awaiting_acknowledge_, true,
+                                             false))
     PostAcknowledge();
-  }
 }
 
 void GpuWatchdogThread::Init() {
   // Schedule the first check.
   OnCheck(false);
 }
 
 void GpuWatchdogThread::CleanUp() {
   weak_factory_.InvalidateWeakPtrs();
 }
@@ skipping 84 matching lines @@
 }
 
 void GpuWatchdogThread::OnCheck(bool after_suspend) {
   CHECK(base::PlatformThread::CurrentId() == GetThreadId());
 
   // Do not create any new termination tasks if one has already been created
   // or the system is suspended.
   if (armed_ || suspended_)
     return;
 
-  // Must set armed before posting the task. This task might be the only task
-  // that will activate the TaskObserver on the watched thread and it must not
-  // miss the false -> true transition.
   armed_ = true;
 
+  // Must set |awaiting_acknowledge_| before posting the task.  This task might
+  // be the only task that will activate the TaskObserver on the watched thread
+  // and it must not miss the false -> true transition. No barrier is needed
+  // here, as the PostTask which follows contains a barrier.
+  base::subtle::NoBarrier_Store(&awaiting_acknowledge_, true);
+
 #if defined(OS_WIN)
   arm_cpu_time_ = GetWatchedThreadTime();
 
   QueryUnbiasedInterruptTime(&arm_interrupt_time_);
 #endif
 
   check_time_ = base::Time::Now();
   check_timeticks_ = base::TimeTicks::Now();
   // Immediately after the computer is woken up from being suspended it might
   // be pretty sluggish, so allow some extra time before the next timeout.
@@ skipping 248 matching lines @@
     int tty_number;
     size_t num_res = sscanf(tty_string, "tty%d\n", &tty_number);
     if (num_res == 1)
       return tty_number;
   }
   return -1;
 }
 #endif
 
 }  // namespace gpu