Fix for crbug.com/111185.

content/browser/renderer_host/render_widget_host.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 "content/browser/renderer_host/render_widget_host.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 59 matching lines @@
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHost
 
 RenderWidgetHost::RenderWidgetHost(content::RenderProcessHost* process,
                                    int routing_id)
     : renderer_initialized_(false),
+      hung_renderer_delay_ms_(kHungRendererDelayMs),
       renderer_accessible_(false),
       view_(NULL),
       process_(process),
       routing_id_(routing_id),
       surface_id_(0),
       is_loading_(false),
       is_hidden_(false),
       is_accelerated_compositing_active_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
       should_auto_resize_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       touch_move_pending_(false),
       touch_event_is_queued_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
+      event_count_(0),
       in_get_backing_store_(false),
       view_being_painted_(false),
       ignore_input_events_(false),
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_next_char_events_(false),
       pending_mouse_lock_request_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   if (routing_id_ == MSG_ROUTING_NONE) {
@@ skipping 424 matching lines @@
   // fire sooner.
   time_when_considered_hung_ = requested_end_time;
   hung_renderer_timer_.Stop();
   hung_renderer_timer_.Start(FROM_HERE, delay, this,
       &RenderWidgetHost::CheckRendererIsUnresponsive);
 }
 
 void RenderWidgetHost::RestartHangMonitorTimeout() {
   // Setting to null will cause StartHangMonitorTimeout to restart the timer.
   time_when_considered_hung_ = Time();
-  StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kHungRendererDelayMs));
+  StartHangMonitorTimeout(
+      TimeDelta::FromMilliseconds(hung_renderer_delay_ms_));
 }
 
 void RenderWidgetHost::StopHangMonitorTimeout() {
   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::ForwardMouseEvent(const WebMouseEvent& mouse_event) {
   TRACE_EVENT2("renderer_host", "RenderWidgetHost::ForwardMouseEvent",
                "x", mouse_event.x, "y", mouse_event.y);
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
@@ skipping 154 matching lines @@
 
   // Any non-wheel input event cancels pending wheel events.
   if (input_event.type != WebInputEvent::MouseWheel)
     coalesced_mouse_wheel_events_.clear();
 
   // Any input event cancels a pending mouse move event. Note that
   // |next_mouse_move_| possibly owns |input_event|, so don't use |input_event|
   // after this line.
   next_mouse_move_.reset();
 
-  StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kHungRendererDelayMs));
+  RecordInputEvent();
+  StartHangMonitorTimeout(
+      TimeDelta::FromMilliseconds(hung_renderer_delay_ms_));
 }
 
 void RenderWidgetHost::ForwardTouchEvent(
     const WebKit::WebTouchEvent& touch_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::ForwardTouchEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   if (touch_event.type == WebInputEvent::TouchMove &&
       touch_move_pending_) {
@@ skipping 409 matching lines @@
 
 void RenderWidgetHost::OnMsgInputEventAck(WebInputEvent::Type event_type,
                                           bool processed) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHost::OnMsgInputEventAck");
 
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_InputEventDelta", delta);
 
   // Cancel pending hung renderer checks since the renderer is responsive.
-  StopHangMonitorTimeout();
+  if (RecordInputEventAck())
+    StopHangMonitorTimeout();
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
     content::RecordAction(UserMetricsAction("BadMessageTerminate_RWH2"));
     process()->ReceivedBadMessage();
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
     if (next_mouse_move_.get()) {
@@ skipping 355 matching lines @@
     if (!view_ || !view_->HasFocus()|| !view_->LockMouse()) {
       Send(new ViewMsg_LockMouse_ACK(routing_id_, false));
       return false;
     } else {
       Send(new ViewMsg_LockMouse_ACK(routing_id_, true));
       return true;
     }
   }
 }
 
+void RenderWidgetHost::RecordInputEvent() {
+  // TODO: remove this check once the compositor thread
+  // is used by default.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(

[darin (slow to review), 2012/01/24 17:58:01]

I'm not sure it is a good idea to check command line flags on each input event. 
That seems wasteful.  Also, why conditionalize this at all?

+          switches::kEnableThreadedCompositing)) {
+    return;
+  }
+  event_count_++;
+}
+
+bool RenderWidgetHost::RecordInputEventAck() {
+  // TODO: remove this check once the compositor thread
+  // is used by default.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableThreadedCompositing)) {
+    return true;
+  }
+  return --event_count_ == 0;

[darin (slow to review), 2012/01/24 17:58:01]

The name of this function, RecordInputEventAck, doesn't make its return value
immediately obvious.  It makes me think that you should just have the caller
check event_count_ directly.

It may also be nice to give this variable a slightly more descriptive name. 
Maybe: in_flight_event_count_

You should also take care to reset this event counter when we recover from a
crash.

+}
+
+
 // static
 void RenderWidgetHost::AcknowledgeSwapBuffers(int32 route_id, int gpu_host_id) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim)
     ui_shim->Send(new AcceleratedSurfaceMsg_BuffersSwappedACK(route_id));
 }
 
 // static
 void RenderWidgetHost::AcknowledgePostSubBuffer(int32 route_id,
                                                 int gpu_host_id) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim)
     ui_shim->Send(new AcceleratedSurfaceMsg_PostSubBufferACK(route_id));
 }