Fix CPM casting issue; refactor renderer crash events

chrome/browser/performance_monitor/performance_monitor.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 "chrome/browser/performance_monitor/performance_monitor.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/test/base/chrome_process_util.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/load_notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 
 namespace {
 const uint32 kAccessFlags = base::kProcessAccessDuplicateHandle |
                             base::kProcessAccessQueryInformation |
                             base::kProcessAccessTerminate |
@@ skipping 436 matching lines @@
                           content::Details<Extension>(details).ptr());
       }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNINSTALLED: {
       AddExtensionEvent(EVENT_EXTENSION_UNINSTALL,
                         content::Details<Extension>(details).ptr());
       break;
     }
     case content::NOTIFICATION_RENDERER_PROCESS_HANG: {
-      content::WebContents* contents =
-          content::Source<content::WebContents>(source).ptr();
-      AddEvent(util::CreateRendererFreezeEvent(base::Time::Now(),
-                                               contents->GetURL().spec()));
+      std::string url;
+      content::RenderWidgetHost* widget =
+          content::Source<content::RenderWidgetHost>(source).ptr();
+      if (widget->IsRenderView()) {
+        url = content::WebContents::FromRenderViewHost(
+            content::RenderViewHost::From(widget))->GetURL().spec();
+      }
+      AddEvent(util::CreateRendererFailureEvent(base::Time::Now(),
+                                                EVENT_RENDERER_HANG,
+                                                url));
       break;
     }
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
-      AddCrashEvent(*content::Details<
-          content::RenderProcessHost::RendererClosedDetails>(details).ptr());
+      AddRendererClosedEvent(
+          content::Source<content::RenderProcessHost>(source).ptr(),
+          *content::Details<content::RenderProcessHost::RendererClosedDetails>(
+              details).ptr());
       break;
     }
     case chrome::NOTIFICATION_PROFILE_ADDED: {
       Profile* profile = content::Source<Profile>(source).ptr();
       if (!profile->DidLastSessionExitCleanly()) {
         BrowserThread::PostBlockingPoolSequencedTask(
             Database::kDatabaseSequenceToken,
             FROM_HERE,
             base::Bind(
                 &PerformanceMonitor::AddUncleanExitEventOnBackgroundThread,
@@ skipping 36 matching lines @@
   AddEvent(util::CreateExtensionEvent(type,
                                       base::Time::Now(),
                                       extension->id(),
                                       extension->name(),
                                       extension->url().spec(),
                                       extension->location(),
                                       extension->VersionString(),
                                       extension->description()));
 }
 
-void PerformanceMonitor::AddCrashEvent(
+void PerformanceMonitor::AddRendererClosedEvent(
+    content::RenderProcessHost* host,
     const content::RenderProcessHost::RendererClosedDetails& details) {
   // We only care if this is an invalid termination.
   if (details.status == base::TERMINATION_STATUS_NORMAL_TERMINATION ||
       details.status == base::TERMINATION_STATUS_STILL_RUNNING)
     return;
 
   // Determine the type of crash.
   EventType type =
       details.status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED ?
-      EVENT_KILLED_BY_OS_CRASH : EVENT_RENDERER_CRASH;
+      EVENT_RENDERER_KILLED : EVENT_RENDERER_CRASH;
 
-  AddEvent(util::CreateCrashEvent(base::Time::Now(), type));
+  content::RenderProcessHost::RenderWidgetHostsIterator iter =
+      host->GetRenderWidgetHostsIterator();
+
+  // A RenderProcessHost may contain multiple render views - for each valid
+  // render view, extract the url, and append it to the string, comma-separating
+  // the entries.
+  std::string url;
+  for (; !iter.IsAtEnd(); iter.Advance()) {
+    const content::RenderWidgetHost* widget = iter.GetCurrentValue();
+    DCHECK(widget);
+    if (!widget || !widget->IsRenderView())
+      continue;
+
+    content::RenderViewHost* view =
+        content::RenderViewHost::From(
+            const_cast<content::RenderWidgetHost*>(widget));
+
+    if (!url.empty())
+      url += ", ";
+
+    url += content::WebContents::FromRenderViewHost(view)->GetURL().spec();
+  }
+
+  AddEvent(util::CreateRendererFailureEvent(base::Time::Now(), type, url));
 }
 
 }  // namespace performance_monitor