Throttle GpuWatchdogThread task posting

gpu/ipc/service/gpu_watchdog_thread.h

 // 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.
 
 #ifndef GPU_IPC_SERVICE_GPU_WATCHDOG_THREAD_H_
 #define GPU_IPC_SERVICE_GPU_WATCHDOG_THREAD_H_
 
+#include "base/atomicops.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/power_monitor/power_observer.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "gpu/gpu_export.h"
 #include "ui/gfx/native_widget_types.h"
@@ skipping 12 matching lines @@
 
 // A thread that intermitently sends tasks to a group of watched message loops
 // and deliberately crashes if one of them does not respond after a timeout.
 class GPU_EXPORT GpuWatchdogThread
     : public base::Thread,
       public base::PowerObserver,
       public base::RefCountedThreadSafe<GpuWatchdogThread> {
  public:
   static scoped_refptr<GpuWatchdogThread> Create();
 
-  // Accessible on watched thread but only modified by watchdog thread.
-  bool armed() const { return armed_; }
   void PostAcknowledge();
-
   void CheckArmed();
 
   // Must be called after a PowerMonitor has been created. Can be called from
   // any thread.
   void AddPowerObserver();
 
  protected:
   void Init() override;
   void CleanUp() override;
 
@@ skipping 36 matching lines @@
 #if defined(OS_WIN)
   base::ThreadTicks GetWatchedThreadTime();
 #endif
 
 #if defined(USE_X11)
   int GetActiveTTY() const;
 #endif
 
   base::MessageLoop* watched_message_loop_;
   base::TimeDelta timeout_;
-  volatile bool armed_;
+  bool armed_;
   GpuWatchdogTaskObserver task_observer_;
 
+  // |awaiting_acknowledge_| is only ever read on the watched thread, but may
+  // be modified on either the watched or watchdog thread. Reads/writes should
+  // be careful to ensure that appropriate synchronization is used.
+  base::subtle::Atomic32 awaiting_acknowledge_;
+
   // True if the watchdog should wait for a certain amount of CPU to be used
   // before killing the process.
   bool use_thread_cpu_time_;
 
   // The number of consecutive acknowledgements that had a latency less than
   // 50ms.
   int responsive_acknowledge_count_;
 
 #if defined(OS_WIN)
   void* watched_thread_handle_;
@@ skipping 27 matching lines @@
 #endif
 
   base::WeakPtrFactory<GpuWatchdogThread> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuWatchdogThread);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_IPC_SERVICE_GPU_WATCHDOG_THREAD_H_