Add an histogram to differentiate between hang types of the renderer

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 <math.h>
 
 #include <set>
 #include <tuple>
@@ skipping 28 matching lines @@
 #include "content/browser/renderer_host/input/input_router_config_helper.h"
 #include "content/browser/renderer_host/input/input_router_impl.h"
 #include "content/browser/renderer_host/input/synthetic_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_controller.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
 #include "content/browser/renderer_host/input/touch_emulator.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
-#include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_input_event_router.h"
 #include "content/browser/renderer_host/render_widget_host_owner_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/cursors/webcursor.h"
 #include "content/common/frame_messages.h"
 #include "content/common/host_shared_bitmap_manager.h"
 #include "content/common/input_messages.h"
 #include "content/common/resize_params.h"
@@ skipping 144 matching lines @@
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
       is_in_touchpad_gesture_scroll_(false),
       is_in_touchscreen_gesture_scroll_(false),
       received_paint_after_load_(false),
       next_browser_snapshot_id_(1),
       owned_by_render_frame_host_(false),
       is_focused_(false),
       hung_renderer_delay_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
+      hang_monitor_reason_(
+          RenderWidgetHostDelegate::RENDERER_UNRESPONSIVE_UNKNOWN),
       new_content_rendering_delay_(
           base::TimeDelta::FromMilliseconds(kNewContentRenderingDelayMs)),
       weak_factory_(this) {
   CHECK(delegate_);
   CHECK_NE(MSG_ROUTING_NONE, routing_id_);
 
 #if defined(OS_WIN)
   // Update the display color profile cache so that it is likely to be up to
   // date when the renderer process requests the color profile.
   if (gfx::ColorSpace::CachedProfilesNeedUpdate()) {
@@ skipping 306 matching lines @@
   if (!is_hidden_)
     return;
 
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::WasShown");
   is_hidden_ = false;
 
   SendScreenRects();
 
   // When hidden, timeout monitoring for input events is disabled. Restore it
   // now to ensure consistent hang detection.
-  if (in_flight_event_count_)
+  if (in_flight_event_count_) {
     RestartHangMonitorTimeout();
+    hang_monitor_reason_ =
+        RenderWidgetHostDelegate::RENDERER_UNRESPONSIVE_IN_FLIGHT_EVENTS;
+  }
 
   // Always repaint on restore.
   bool needs_repainting = true;
   needs_repainting_on_restore_ = false;
   Send(new ViewMsg_WasShown(routing_id_, needs_repainting, latency_info));
 
   process_->WidgetRestored();
 
   bool is_visible = true;
   NotificationService::current()->Notify(
@@ skipping 317 matching lines @@
 
   // Send out a request to the renderer to paint the view if required.
   repaint_start_time_ = TimeTicks::Now();
   repaint_ack_pending_ = true;
   TRACE_EVENT_ASYNC_BEGIN0(
       "renderer_host", "RenderWidgetHostImpl::repaint_ack_pending_", this);
   Send(new ViewMsg_Repaint(routing_id_, current_size_));
   return true;
 }
 
-void RenderWidgetHostImpl::StartHangMonitorTimeout(base::TimeDelta delay) {
-  if (hang_monitor_timeout_)
-    hang_monitor_timeout_->Start(delay);
+void RenderWidgetHostImpl::StartHangMonitorTimeout(
+    base::TimeDelta delay,
+    RenderWidgetHostDelegate::RendererUnresponsiveType hang_monitor_reason) {
+  if (!hang_monitor_timeout_)
+    return;
+  hang_monitor_timeout_->Start(delay);
+  hang_monitor_reason_ = hang_monitor_reason;
 }
 
 void RenderWidgetHostImpl::RestartHangMonitorTimeout() {
   if (hang_monitor_timeout_)
     hang_monitor_timeout_->Restart(hung_renderer_delay_);
 }
 
 void RenderWidgetHostImpl::DisableHangMonitorForTesting() {
   StopHangMonitorTimeout();
   hang_monitor_timeout_.reset();
 }
 
 void RenderWidgetHostImpl::StopHangMonitorTimeout() {
-  if (hang_monitor_timeout_)
+  if (hang_monitor_timeout_) {
     hang_monitor_timeout_->Stop();
+    hang_monitor_reason_ =
+        RenderWidgetHostDelegate::RENDERER_UNRESPONSIVE_UNKNOWN;
+  }
   RendererIsResponsive();
 }
 
 void RenderWidgetHostImpl::StartNewContentRenderingTimeout() {
   // It is possible for a compositor frame to arrive before the browser is
   // notified about the page being committed, in which case no timer is
   // necessary.
   if (received_paint_after_load_) {
     received_paint_after_load_ = false;
     return;
@@ skipping 529 matching lines @@
     delete this;
   }
 }
 
 void RenderWidgetHostImpl::RendererIsUnresponsive() {
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_HANG,
       Source<RenderWidgetHost>(this),
       NotificationService::NoDetails());
   is_unresponsive_ = true;
+  RenderWidgetHostDelegate::RendererUnresponsiveType reason =
+      hang_monitor_reason_;
+  hang_monitor_reason_ =
+      RenderWidgetHostDelegate::RENDERER_UNRESPONSIVE_UNKNOWN;
+
   if (delegate_)
-    delegate_->RendererUnresponsive(this);
+    delegate_->RendererUnresponsive(this, reason);
+
+  // Do not add code after this since the Delegate may delete this
+  // RenderWidgetHostImpl in RendererUnresponsive.
 }
 
 void RenderWidgetHostImpl::RendererIsResponsive() {
   if (is_unresponsive_) {
     is_unresponsive_ = false;
     if (delegate_)
       delegate_->RendererResponsive(this);
   }
 }
 
@@ skipping 367 matching lines @@
                     event.type == WebInputEvent::RawKeyDown)) {
     delegate_->OnUserInteraction(this, event.type);
   }
 
   return view_ ? view_->FilterInputEvent(event)
                : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
 }
 
 void RenderWidgetHostImpl::IncrementInFlightEventCount() {
   increment_in_flight_event_count();
-  if (!is_hidden_)
-    StartHangMonitorTimeout(hung_renderer_delay_);
+  if (!is_hidden_) {
+    StartHangMonitorTimeout(
+        hung_renderer_delay_,
+        RenderWidgetHostDelegate::RENDERER_UNRESPONSIVE_IN_FLIGHT_EVENTS);
+  }
 }
 
 void RenderWidgetHostImpl::DecrementInFlightEventCount() {
   if (decrement_in_flight_event_count() <= 0) {
     // Cancel pending hung renderer checks since the renderer is responsive.
     StopHangMonitorTimeout();
   } else {
     // The renderer is responsive, but there are in-flight events to wait for.
-    if (!is_hidden_)
+    if (!is_hidden_) {
       RestartHangMonitorTimeout();
+      hang_monitor_reason_ =
+          RenderWidgetHostDelegate::RENDERER_UNRESPONSIVE_IN_FLIGHT_EVENTS;
+    }
   }
 }
 
 void RenderWidgetHostImpl::OnHasTouchEventHandlers(bool has_handlers) {
   has_touch_handler_ = has_handlers;
 }
 
 void RenderWidgetHostImpl::DidFlush() {
   if (synthetic_gesture_controller_)
     synthetic_gesture_controller_->OnDidFlushInput();
@@ skipping 284 matching lines @@
   return delegate_ ? delegate_->GetRootBrowserAccessibilityManager() : NULL;
 }
 
 BrowserAccessibilityManager*
     RenderWidgetHostImpl::GetOrCreateRootBrowserAccessibilityManager() {
   return delegate_ ?
       delegate_->GetOrCreateRootBrowserAccessibilityManager() : NULL;
 }
 
 }  // namespace content