Fixing a problem, where a hung renderer process is not killed when navigating away

content/browser/renderer_host/render_widget_host_impl.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_impl.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 610 matching lines @@
     Send(new ViewMsg_Repaint(routing_id_, current_size_));
   }
 }
 
 void RenderWidgetHostImpl::StartHangMonitorTimeout(TimeDelta delay) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableHangMonitor)) {
     return;
   }
 
-  // Set time_when_considered_hung_ if it's null.
+  // Set time_when_considered_hung_ if it's null, or if it is further in the

[Charlie Reis, 2012/04/06 22:34:14]

nit: Split this into a separate sentence to make it easier to read.  Something
like "Otherwise, update time_when_considered_hung_ if the requested end time is
now sooner than before."

I don't suppose we have any unit tests for this logic, do we?  If we do, it
would be nice to add one for this case.

[nasko, 2012/04/10 00:16:37]

No, there is no unit test for this particular case. I will add one, as there is
an existing unit test for that timer.

+  // future than the current request, update it to the shorter duration. This
+  // will have the side effect that the existing timeout will be forgotten.
   Time requested_end_time = Time::Now() + delay;
-  if (time_when_considered_hung_.is_null())
+  if (time_when_considered_hung_.is_null() ||
+      time_when_considered_hung_ > requested_end_time)
     time_when_considered_hung_ = requested_end_time;
 
   // If we already have a timer with the same or shorter duration, then we can
   // wait for it to finish.
   if (hung_renderer_timer_.IsRunning() &&
       hung_renderer_timer_.GetCurrentDelay() <= delay) {
     // If time_when_considered_hung_ was null, this timer may fire early.
     // CheckRendererIsUnresponsive handles that by calling
     // StartHangMonitorTimeout with the remaining time.
     // If time_when_considered_hung_ was non-null, it means we still haven't
@@ skipping 194 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();
 
-  in_flight_event_count_++;
+  IncrementInFlightEventCount();
   StartHangMonitorTimeout(
       TimeDelta::FromMilliseconds(hung_renderer_delay_ms_));
 }
 
 void RenderWidgetHostImpl::ForwardTouchEvent(
     const WebKit::WebTouchEvent& touch_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardTouchEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
@@ skipping 421 matching lines @@
 
 void RenderWidgetHostImpl::OnMsgInputEventAck(WebInputEvent::Type event_type,
                                               bool processed) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::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.
-  if (--in_flight_event_count_ == 0)
+  if (DecrementInFlightEventCount() == 0)
     StopHangMonitorTimeout();
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
     RecordAction(UserMetricsAction("BadMessageTerminate_RWH2"));
     process_->ReceivedBadMessage();
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
@@ skipping 408 matching lines @@
   // indicate that no callback is in progress (i.e. without this line
   // DelayedAutoResized will not get called again).
   new_auto_size_.SetSize(0, 0);
   if (!should_auto_resize_)
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 }  // namespace content