Remove ChildProcess.HangRendererType.

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 270 matching lines @@
       has_touch_handler_(false),
       is_in_touchpad_gesture_scroll_(false),
       is_in_touchscreen_gesture_scroll_(false),
       received_paint_after_load_(false),
       latency_tracker_(),
       next_browser_snapshot_id_(1),
       owned_by_render_frame_host_(false),
       is_focused_(false),
       hung_renderer_delay_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
-      hang_monitor_reason_(
-          RendererUnresponsiveType::RENDERER_UNRESPONSIVE_UNKNOWN),
       hang_monitor_event_type_(blink::WebInputEvent::Undefined),
       last_event_type_(blink::WebInputEvent::Undefined),
       new_content_rendering_delay_(
           base::TimeDelta::FromMilliseconds(kNewContentRenderingDelayMs)),
       current_content_source_id_(0),
       weak_factory_(this) {
   CHECK(delegate_);
   CHECK_NE(MSG_ROUTING_NONE, routing_id_);
   latency_tracker_.SetDelegate(delegate_);
 
@@ skipping 638 matching lines @@
   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,
-    blink::WebInputEvent::Type event_type,
-    RendererUnresponsiveType hang_monitor_reason) {
+    blink::WebInputEvent::Type event_type) {
   if (!hang_monitor_timeout_)
     return;
   if (!hang_monitor_timeout_->IsRunning())
     hang_monitor_event_type_ = event_type;
   last_event_type_ = event_type;
   hang_monitor_timeout_->Start(delay);
-  hang_monitor_reason_ = hang_monitor_reason;
 }
 
 void RenderWidgetHostImpl::RestartHangMonitorTimeoutIfNecessary() {
   if (!hang_monitor_timeout_)
     return;
-  if (in_flight_event_count_ > 0 && !is_hidden_) {
-    if (hang_monitor_reason_ ==
-        RendererUnresponsiveType::RENDERER_UNRESPONSIVE_UNKNOWN) {
-      hang_monitor_reason_ =
-          RendererUnresponsiveType::RENDERER_UNRESPONSIVE_IN_FLIGHT_EVENTS;
-    }
+  if (in_flight_event_count_ > 0 && !is_hidden_)
     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_ =
-        RendererUnresponsiveType::RENDERER_UNRESPONSIVE_UNKNOWN;
-  }
   RendererIsResponsive();
 }
 
 void RenderWidgetHostImpl::StartNewContentRenderingTimeout(
     uint32_t next_source_id) {
   current_content_source_id_ = next_source_id;
   // 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_) {
@@ skipping 701 matching lines @@
     delete this;
   }
 }
 
 void RenderWidgetHostImpl::RendererIsUnresponsive() {
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_HANG,
       Source<RenderWidgetHost>(this),
       NotificationService::NoDetails());
   is_unresponsive_ = true;
-  RendererUnresponsiveType reason = hang_monitor_reason_;
-  hang_monitor_reason_ =
-      RendererUnresponsiveType::RENDERER_UNRESPONSIVE_UNKNOWN;
 
   if (delegate_)
-    delegate_->RendererUnresponsive(this, reason);
+    delegate_->RendererUnresponsive(this);
 
   // 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 382 matching lines @@
     }
   }
 
   return view_ ? view_->FilterInputEvent(event)
                : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
 }
 
 void RenderWidgetHostImpl::IncrementInFlightEventCount(
     blink::WebInputEvent::Type event_type) {
   increment_in_flight_event_count();
-  if (!is_hidden_) {
-    StartHangMonitorTimeout(
-        hung_renderer_delay_, event_type,
-        RendererUnresponsiveType::RENDERER_UNRESPONSIVE_IN_FLIGHT_EVENTS);
-  }
+  if (!is_hidden_)
+    StartHangMonitorTimeout(hung_renderer_delay_, event_type);
 }
 
 void RenderWidgetHostImpl::DecrementInFlightEventCount(
     InputEventAckSource ack_source) {
   if (decrement_in_flight_event_count() <= 0) {
     // Cancel pending hung renderer checks since the renderer is responsive.
     StopHangMonitorTimeout();
   } else {
     // Only restart the hang monitor timer if we got a response from the
     // main thread.
@@ skipping 384 matching lines @@
     // different from the receiver's.
     file_system_file.url =
         GURL(storage::GetIsolatedFileSystemRootURIString(
                  file_system_url.origin(), filesystem_id, std::string())
                  .append(register_name));
     file_system_file.filesystem_id = filesystem_id;
   }
 }
 
 }  // namespace content