This adds some plumbing for propagating the reason for a renderer's death

chrome/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2010 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/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 318 matching lines @@
       registrar_(),
       ALLOW_THIS_IN_INITIALIZER_LIST(printing_(
           new printing::PrintViewManager(*this))),
       save_package_(),
       autocomplete_history_manager_(),
       autofill_manager_(),
       plugin_installer_(),
       bookmark_drag_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(fav_icon_helper_(this)),
       is_loading_(false),
-      is_crashed_(false),
+      crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
+      crashed_error_code_(0),
       waiting_for_response_(false),
       max_page_id_(-1),
       current_load_start_(),
       load_state_(net::LOAD_STATE_IDLE),
       load_state_host_(),
       upload_size_(0),
       upload_position_(0),
       received_page_title_(false),
       is_starred_(false),
       contents_mime_type_(),
@@ skipping 410 matching lines @@
 }
 
 void TabContents::AddNavigationObserver(WebNavigationObserver* observer) {
   web_navigation_observers_.AddObserver(observer);
 }
 
 void TabContents::RemoveNavigationObserver(WebNavigationObserver* observer) {
   web_navigation_observers_.RemoveObserver(observer);
 }
 
-void TabContents::SetIsCrashed(bool state) {
-  if (state == is_crashed_)
+void TabContents::SetIsCrashed(base::TerminationStatus status, int error_code) {
+  if (status == crashed_status_)
     return;
 
-  is_crashed_ = state;
+  crashed_status_ = status;
+  crashed_error_code_ = error_code;
   NotifyNavigationStateChanged(INVALIDATE_TAB);
 }
 
 void TabContents::PageActionStateChanged() {
   NotifyNavigationStateChanged(TabContents::INVALIDATE_PAGE_ACTIONS);
 }
 
 void TabContents::NotifyNavigationStateChanged(unsigned changed_flags) {
   if (delegate_)
     delegate_->NavigationStateChanged(this, changed_flags);
@@ skipping 1616 matching lines @@
 
 void TabContents::RenderViewReady(RenderViewHost* rvh) {
   if (rvh != render_view_host()) {
     // Don't notify the world, since this came from a renderer in the
     // background.
     return;
   }
 
   NotifyConnected();
   bool was_crashed = is_crashed();
-  SetIsCrashed(false);
+  SetIsCrashed(base::TERMINATION_STATUS_STILL_RUNNING, 0);
 
   // Restore the focus to the tab (otherwise the focus will be on the top
   // window).
   if (was_crashed && !FocusLocationBarByDefault() &&
       (!delegate_ || delegate_->ShouldFocusPageAfterCrash())) {
     Focus();
   }
 }
 
-void TabContents::RenderViewGone(RenderViewHost* rvh) {
+void TabContents::RenderViewGone(RenderViewHost* rvh,
+                                 base::TerminationStatus status,
+                                 int error_code) {
   // Ask the print preview if this renderer was valuable.
   if (!printing_->OnRenderViewGone(rvh))
     return;
   if (rvh != render_view_host()) {
     // The pending page's RenderViewHost is gone.
     return;
   }
 
   SetIsLoading(false, NULL);
   NotifyDisconnected();
-  SetIsCrashed(true);
+  SetIsCrashed(status, error_code);
 
   // Remove all infobars.
   for (int i = infobar_delegate_count() - 1; i >=0 ; --i)
     RemoveInfoBar(GetInfoBarDelegateAt(i));
 
   // Tell the view that we've crashed so it can prepare the sad tab page.
   // Only do this if we're not in browser shutdown, so that TabContents
   // objects that are not in a browser (e.g., HTML dialogs) and thus are
   // visible do not flash a sad tab page.
   if (browser_shutdown::GetShutdownType() == browser_shutdown::NOT_VALID)
@@ skipping 622 matching lines @@
     delegate()->BeforeUnloadFired(this, proceed, proceed_to_fire_unload);
 }
 
 void TabContents::DidStartLoadingFromRenderManager(
       RenderViewHost* render_view_host) {
   DidStartLoading();
 }
 
 void TabContents::RenderViewGoneFromRenderManager(
     RenderViewHost* render_view_host) {
-  RenderViewGone(render_view_host);
+  DCHECK(crashed_status_ != base::TERMINATION_STATUS_STILL_RUNNING);
+  RenderViewGone(render_view_host, crashed_status_, crashed_error_code_);
 }
 
 void TabContents::UpdateRenderViewSizeForRenderManager() {
   // TODO(brettw) this is a hack. See TabContentsView::SizeContents.
   gfx::Size size = view_->GetContainerSize();
   // 0x0 isn't a valid window size (minimal window size is 1x1) but it may be
   // here during container initialization and normal window size will be set
   // later. In case of tab duplication this resizing to 0x0 prevents setting
   // normal size later so just ignore it.
   if (!size.IsEmpty())
@@ skipping 196 matching lines @@
 }
 
 void TabContents::SwapInRenderViewHost(RenderViewHost* rvh) {
   render_manager_.SwapInRenderViewHost(rvh);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }