Stop spamming delayed tasks on each input event.

chrome/browser/render_widget_host.cc

 // 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.
 
 #include "chrome/browser/render_widget_host.h"
 
 #include "base/gfx/bitmap_header.h"
 #include "base/message_loop.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/render_process_host.h"
@@ skipping 255 matching lines @@
 RenderWidgetHost::RenderWidgetHost(RenderProcessHost* process, int routing_id)
     : process_(process),
       routing_id_(routing_id),
       resize_ack_pending_(false),
       mouse_move_pending_(false),
       view_(NULL),
       is_loading_(false),
       is_hidden_(false),
       suppress_view_updating_(false),
       needs_repainting_on_restore_(false),
-      hung_renderer_factory_(this),
       is_unresponsive_(false),
       view_being_painted_(false),
       repaint_ack_pending_(false) {
   if (routing_id_ == MSG_ROUTING_NONE)
     routing_id_ = process_->widget_helper()->GetNextRoutingID();
 
   process_->Attach(this, routing_id_);
   // Because the widget initializes as is_hidden_ == false,
   // tell the process host that we're alive.
   process_->WidgetRestored();
@@ skipping 336 matching lines @@
 
   IPC::Message* message = new ViewMsg_HandleInputEvent(routing_id_);
   message->WriteData(
       reinterpret_cast<const char*>(&input_event), event_size);
   input_event_start_time_ = TimeTicks::Now();
   Send(message);
 
   // any input event cancels a pending mouse move event
   next_mouse_move_.reset();
 
-  StartHangMonitorTimeout(kHungRendererDelayMs);
+  StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kHungRendererDelayMs));
 }
 
 void RenderWidgetHost::Shutdown() {
   if (process_->channel()) {
     // Tell the renderer object to close.
     process_->ReportExpectingClose(routing_id_);
     bool rv = Send(new ViewMsg_Close(routing_id_));
     DCHECK(rv);
   }
 
@@ skipping 22 matching lines @@
   // Tell the view to die.
   // Note that in the process of the view shutting down, it can call a ton
   // of other messages on us.  So if you do any other deinitialization here,
   // do it after this call to view_->Destroy().
   if (view_)
     view_->Destroy();
 
   delete this;
 }
 
-void RenderWidgetHost::RendererIsUnresponsive() {
+void RenderWidgetHost::CheckRendererIsUnresponsive() {
+  // If we received a call to StopHangMonitorTimeout.
+  if (time_when_considered_hung_.is_null())
+    return;
+
+  // If we have not waited long enough, then wait some more.
+  Time now = Time::Now();
+  if (now < time_when_considered_hung_) {
+    StartHangMonitorTimeout(time_when_considered_hung_ - now);
+    return;
+  }
+
+  // OK, looks like we have a hung renderer!
   NotificationService::current()->Notify(NOTIFY_RENDERER_PROCESS_HANG,
                                          Source<RenderWidgetHost>(this),
                                          NotificationService::NoDetails());
   is_unresponsive_ = true;
   NotifyRendererUnresponsive();
 }
 
 void RenderWidgetHost::RendererIsResponsive() {
   if (is_unresponsive_) {
     is_unresponsive_ = false;
@@ skipping 94 matching lines @@
   // TODO(darin): this doesn't work if dx and dy are both non-zero!
   DCHECK(dx == 0 || dy == 0);
 
   // We expect that damaged_rect should equal bitmap_rect.
   DCHECK(gfx::Rect(damaged_rect) == bitmap_rect);
 
   backing_store->Refresh(process_->process(), bitmap, bitmap_rect);
 }
 
 void RenderWidgetHost::RestartHangMonitorTimeout() {
-  hung_renderer_factory_.RevokeAll();
-  StartHangMonitorTimeout(kHungRendererDelayMs);
+  StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kHungRendererDelayMs));
 }
 
 void RenderWidgetHost::StopHangMonitorTimeout() {
-  hung_renderer_factory_.RevokeAll();
+  time_when_considered_hung_ = Time();
   RendererIsResponsive();
+
+  // We do not bother to stop the hung_renderer_timer_ here in case it will be
+  // started again shortly, which happens to be the common use case.
 }
 
-void RenderWidgetHost::StartHangMonitorTimeout(int delay) {
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
-        hung_renderer_factory_.NewRunnableMethod(
-            &RenderWidgetHost::RendererIsUnresponsive), delay);
+void RenderWidgetHost::StartHangMonitorTimeout(TimeDelta delay) {
+  time_when_considered_hung_ = Time::Now() + delay;
+
+  // If we already have a timer that will expire at or before the given delay,
+  // then we have nothing more to do now.
+  if (hung_renderer_timer_.IsRunning() &&
+      hung_renderer_timer_.GetCurrentDelay() <= delay)
+    return;
+
+  // We need to adjust the timer to fire sooner. 

[Mike Belshe, 2008/09/25 16:01:05]

// Either the timer is not yet running, or we need
// to adjust the timer to fire sooner.

+  hung_renderer_timer_.Stop();
+  hung_renderer_timer_.Start(delay, this,
+      &RenderWidgetHost::CheckRendererIsUnresponsive);
 }
 
 void RenderWidgetHost::RendererExited() {
   BackingStoreManager::RemoveBackingStore(this);
 }
 
 void RenderWidgetHost::SystemThemeChanged() {
   Send(new ViewMsg_ThemeChanged(routing_id_));
 }