Stop spamming delayed tasks on each input event.

chrome/browser/render_widget_host.h

 // Copyright (c) 2006-2008 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_BROWSER_RENDER_WIDGET_HOST_H__
-#define CHROME_BROWSER_RENDER_WIDGET_HOST_H__
+#ifndef CHROME_BROWSER_RENDER_WIDGET_HOST_H_
+#define CHROME_BROWSER_RENDER_WIDGET_HOST_H_
 
 #include <windows.h>
 
-#include "base/task.h"
 #include "base/gfx/size.h"
+#include "base/timer.h"
 #include "chrome/common/ipc_channel.h"
 
 namespace gfx {
 class Rect;
 }
 
 class BackingStore;
 class PaintObserver;
 class RenderProcessHost;
 class RenderWidgetHostView;
@@ skipping 151 matching lines @@
   class PaintObserver;
   // Set the PaintObserver on this object.  Takes ownership.
   void SetPaintObserver(PaintObserver* paint_observer) {
     paint_observer_.reset(paint_observer);
   }
 
   // Checks to see if we can give  up focus to this  widget through a
   // javascript call.
   virtual bool CanBlur() const { return true; }
 
-  // Restart the active hang monitor timeout. Clears all existing timeouts
-  // and starts with a new one.
-  // This can be because the renderer has become active, the tab is being
-  // hidden, or the user has chosen to wait some more to give the tab a chance
-  // to become active and we don't want to display a warning too soon.
+  // Restart the active hang monitor timeout. Clears all existing timeouts and
+  // starts with a new one.  This can be because the renderer has become
+  // active, the tab is being hidden, or the user has chosen to wait some more
+  // to give the tab a chance to become active and we don't want to display a
+  // warning too soon.
   void RestartHangMonitorTimeout();
   
   // Stops all existing hang monitor timeouts and assumes the renderer is
   // responsive.
   void StopHangMonitorTimeout();
 
   // Starts a hang monitor timeout. If there's already a hang monitor timeout
   // the new one will only fire if it has a shorter delay than the time
   // left on the existing timeouts.
-  void StartHangMonitorTimeout(int delay);
+  void StartHangMonitorTimeout(TimeDelta delay);
 
   // Called when we receive a notification indicating that the renderer
   // process has gone.
   void RendererExited();
 
   // Called when the system theme changes. At this time all existing native
   // theme handles are invalid and the renderer must obtain new ones and
   // repaint.
   void SystemThemeChanged();
 
@@ skipping 35 matching lines @@
   // Called to scroll a region of the backing store
   void ScrollRect(HANDLE bitmap, const gfx::Rect& bitmap_rect, int dx, int dy,
                   const gfx::Rect& clip_rect, const gfx::Size& view_size);
 
   // Tell this object to destroy itself.
   void Destroy();
 
   // Callbacks for notification when the renderer becomes unresponsive to user
   // input events, and subsequently responsive again. The delegate can use
   // these notifications to show a warning.
-  void RendererIsUnresponsive();
+  void CheckRendererIsUnresponsive();
   virtual void NotifyRendererUnresponsive() {}
   void RendererIsResponsive();
   virtual void NotifyRendererResponsive() {}
 
   // Created during construction but initialized during Init*(). Therefore, it
   // is guaranteed never to be NULL, but its channel may be NULL if the
   // renderer crashed, so you must always check that.
   RenderProcessHost* process_;
 
   // The ID of the corresponding object in the Renderer Instance.
@@ skipping 27 matching lines @@
   // If true, then we should not ask our view to repaint when our backingstore
   // is updated.
   bool suppress_view_updating_;
 
   // If true, then we should repaint when restoring even if we have a
   // backingstore.  This flag is set to true if we receive a paint message
   // while is_hidden_ to true.  Even though we tell the render widget to hide
   // itself, a paint message could already be in flight at that point.
   bool needs_repainting_on_restore_;
 
-  // The following factory is used to detect a hung renderer
-  ScopedRunnableMethodFactory<RenderWidgetHost> hung_renderer_factory_;
+  // The following value indicates a time in the future when we would consider
+  // the renderer hung if it does not generate an appropriate response message.
+  Time time_when_considered_hung_;
+
+  // This timer runs to check if time_when_considered_hung_ has past.
+  base::OneShotTimer<RenderWidgetHost> hung_renderer_timer_;
 
   // This is true if the renderer is currently unresponsive.
   bool is_unresponsive_;
 
   // Optional observer that listens for notifications of painting.
   scoped_ptr<PaintObserver> paint_observer_;
 
   // Set when we call DidPaintRect/DidScrollRect on the view.
   bool view_being_painted_;
 
@@ skipping 39 matching lines @@
 };
 
 class RenderWidgetHost::PaintObserver {
  public:
   virtual ~PaintObserver() {}
 
   // Called each time the RenderWidgetHost paints.
   virtual void RenderWidgetHostDidPaint(RenderWidgetHost* rwh) = 0;
 };
 
-#endif  // #ifndef CHROME_BROWSER_RENDER_WIDGET_HOST_H__
-
+#endif  // #ifndef CHROME_BROWSER_RENDER_WIDGET_HOST_H_