[content shell] report the PID of a crashed renderer, and always report crashes

content/shell/webkit_test_controller.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/shell/webkit_test_controller.h"
 
 #include <iostream>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
+#include "base/process_util.h"
 #include "base/run_loop.h"
+#include "base/string_number_conversions.h"
 #include "content/public/browser/navigation_controller.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/shell/shell.h"
 #include "content/shell/shell_browser_context.h"
 #include "content/shell/shell_content_browser_client.h"
 #include "content/shell/shell_messages.h"
 #include "content/shell/shell_switches.h"
 #include "content/shell/webkit_test_helpers.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/support/webkit_support_gfx.h"
@@ skipping 99 matching lines @@
 // static
 WebKitTestController* WebKitTestController::Get() {
   DCHECK(instance_);
   return instance_;
 }
 
 WebKitTestController::WebKitTestController() {
   CHECK(!instance_);
   instance_ = this;
   printer_.reset(new WebKitTestResultPrinter(&std::cout, &std::cerr));
+  registrar_.Add(this,
+                 NOTIFICATION_RENDERER_PROCESS_CREATED,
+                 NotificationService::AllSources());
   ResetAfterLayoutTest();
 }
 
 WebKitTestController::~WebKitTestController() {
   DCHECK(CalledOnValidThread());
   CHECK(instance_ == this);
   if (main_window_)
     main_window_->Close();
   instance_ = NULL;
 }
@@ skipping 11 matching lines @@
   printer_->PrintTextHeader();
   content::ShellBrowserContext* browser_context =
       static_cast<content::ShellContentBrowserClient*>(
           content::GetContentClient()->browser())->browser_context();
   main_window_ = content::Shell::CreateNewWindow(
       browser_context,
       GURL(),
       NULL,
       MSG_ROUTING_NONE,
       NULL);
-  Observe(main_window_->web_contents());
+  WebContentsObserver::Observe(main_window_->web_contents());
   main_window_->LoadURL(test_url);
   if (test_url.spec().find("/dumpAsText/") != std::string::npos ||
       test_url.spec().find("\\dumpAsText\\") != std::string::npos) {
     dump_as_text_ = true;
     enable_pixel_dumping_ = false;
   }
   if (test_url.spec().find("/inspector/") != std::string::npos ||
       test_url.spec().find("\\inspector\\") != std::string::npos) {
     main_window_->ShowDevTools();
   }
@@ skipping 16 matching lines @@
   wait_until_done_ = false;
   did_finish_load_ = false;
   prefs_ = webkit_glue::WebPreferences();
   should_override_prefs_ = false;
   {
     base::AutoLock lock(lock_);
     can_open_windows_ = false;
   }
   watchdog_.Cancel();
   if (main_window_) {
-    Observe(NULL);
+    WebContentsObserver::Observe(NULL);
     main_window_ = NULL;
   }
   Shell::CloseAllWindows();
   Send(new ShellViewMsg_ResetAll);
+  current_pid_ = base::kNullProcessId;
   return true;
 }
 
 void WebKitTestController::RendererUnresponsive() {
   DCHECK(CalledOnValidThread());
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoTimeout))
     printer_->AddErrorMessage("#PROCESS UNRESPONSIVE - renderer");
 }
 
 void WebKitTestController::OverrideWebkitPrefs(
@@ skipping 41 matching lines @@
   return handled;
 }
 
 void WebKitTestController::PluginCrashed(const FilePath& plugin_path) {
   DCHECK(CalledOnValidThread());
   printer_->AddErrorMessage("#CRASHED - plugin");
 }
 
 void WebKitTestController::RenderViewCreated(RenderViewHost* render_view_host) {
   DCHECK(CalledOnValidThread());
+  // Might be kNullProcessId, in which case we will receive a notification later
+  // when the RenderProcessHost was created.
+  current_pid_ = base::GetProcId(render_view_host->GetProcess()->GetHandle());
   render_view_host->Send(new ShellViewMsg_SetCurrentWorkingDirectory(
       render_view_host->GetRoutingID(), current_working_directory_));
 }
 
 void WebKitTestController::RenderViewGone(base::TerminationStatus status) {
   DCHECK(CalledOnValidThread());
-  if (status == base::TERMINATION_STATUS_PROCESS_CRASHED ||
-      status == base::TERMINATION_STATUS_ABNORMAL_TERMINATION) {
+  if (current_pid_ != base::kNullProcessId) {
+    printer_->AddErrorMessage(std::string("#CRASHED - renderer (pid ") +
+                              base::IntToString(current_pid_) + ")");
+  } else {
     printer_->AddErrorMessage("#CRASHED - renderer");
   }
 }
 
 void WebKitTestController::WebContentsDestroyed(WebContents* web_contents) {
   DCHECK(CalledOnValidThread());
   main_window_ = NULL;
   printer_->AddErrorMessage("FAIL: main window was destroyed");
 }
 
+void WebKitTestController::Observe(int type,
+                                   const NotificationSource& source,
+                                   const NotificationDetails& details) {
+  DCHECK(CalledOnValidThread());
+  switch (type) {
+    case NOTIFICATION_RENDERER_PROCESS_CREATED: {
+      if (!main_window_)
+        return;
+      RenderViewHost* render_view_host =
+          main_window_->web_contents()->GetRenderViewHost();
+      if (!render_view_host)
+        return;
+      RenderProcessHost* render_process_host =
+          Source<RenderProcessHost>(source).ptr();
+      if (render_process_host != render_view_host->GetProcess())
+        return;
+      current_pid_ = base::GetProcId(render_process_host->GetHandle());
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+}
+
 void WebKitTestController::CaptureDump() {
   if (captured_dump_ || !main_window_ || !printer_->in_text_block())
     return;
   captured_dump_ = true;
 
   if (main_window_->web_contents()->GetContentsMimeType() == "text/plain") {
     dump_as_text_ = true;
     enable_pixel_dumping_ = false;
   }
 
@@ skipping 162 matching lines @@
 
 void WebKitTestController::OnNotImplemented(
     const std::string& object_name,
     const std::string& property_name) {
   printer_->AddErrorMessage(
       std::string("FAIL: NOT IMPLEMENTED: ") +
       object_name + "." + property_name);
 }
 
 }  // namespace content