GPU thread acknowledges an armed watchdog every time it returns to the messag...

chrome/gpu/gpu_watchdog_thread.h

 // Copyright (c) 2010 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 CHROME_GPU_GPU_WATCHDOG_THREAD_H_
 #define CHROME_GPU_GPU_WATCHDOG_THREAD_H_
 
+#include "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "base/thread.h"
 
 // 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 GpuWatchdogThread : public base::Thread,
                           public base::RefCountedThreadSafe<GpuWatchdogThread> {
  public:
   GpuWatchdogThread(MessageLoop* watched_message_loop, int timeout);
   virtual ~GpuWatchdogThread();
 
+  // Accessible on watched thread but only modified by watchdog thread.
+  bool armed() const { return armed_; }
+  void PostAcknowledge();
+
  protected:
   virtual void Init();
   virtual void CleanUp();
 
  private:
+
+  // An object of this type intercepts the reception and completion of all tasks
+  // on the watched thread and checks whether the watchdog is armed.
+  class GpuWatchdogTaskObserver : public MessageLoop::TaskObserver {
+   public:
+    explicit GpuWatchdogTaskObserver(GpuWatchdogThread* watchdog);
+    virtual ~GpuWatchdogTaskObserver();
+
+    // Implements MessageLoop::TaskObserver.
+    virtual void WillProcessTask(const Task* task);
+    virtual void DidProcessTask(const Task* task);
+
+   private:
+    void CheckArmed();
+    GpuWatchdogThread* watchdog_;
+  };
+
   void OnAcknowledge();
   void OnCheck();
-  void PostAcknowledge();
   void OnExit();
   void Disable();
 
   MessageLoop* watched_message_loop_;
   int timeout_;
+  bool armed_;

[Ken Russell (switch to Gerrit), 2010/11/23 23:03:12]

This should probably be volatile.

+  GpuWatchdogTaskObserver task_observer_;
 
   typedef ScopedRunnableMethodFactory<GpuWatchdogThread> MethodFactory;
   scoped_ptr<MethodFactory> method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuWatchdogThread);
 };
 
 #endif  // CHROME_GPU_GPU_WATCHDOG_THREAD_H_