[DevTools] Preserve DevTools for crashed page.

content/browser/devtools/render_frame_devtools_agent_host.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/devtools/render_frame_devtools_agent_host.h"
 
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/child_process_security_policy_impl.h"
@@ skipping 288 matching lines @@
       security_handler_(nullptr),
       service_worker_handler_(
           new devtools::service_worker::ServiceWorkerHandler()),
       tracing_handler_(new devtools::tracing::TracingHandler(
           devtools::tracing::TracingHandler::Renderer)),
       emulation_handler_(nullptr),
       frame_trace_recorder_(nullptr),
       protocol_handler_(new DevToolsProtocolHandler(
           this,
           base::Bind(&RenderFrameDevToolsAgentHost::SendMessageToClient,
-                     base::Unretained(this)))) {
+                     base::Unretained(this)))),
+      current_frame_crashed_(false) {
   DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
   dispatcher->SetDOMHandler(dom_handler_.get());
   dispatcher->SetInputHandler(input_handler_.get());
   dispatcher->SetInspectorHandler(inspector_handler_.get());
   dispatcher->SetNetworkHandler(network_handler_.get());
   dispatcher->SetPowerHandler(power_handler_.get());
   dispatcher->SetServiceWorkerHandler(service_worker_handler_.get());
   dispatcher->SetTracingHandler(tracing_handler_.get());
 
   if (!host->GetParent()) {
     security_handler_.reset(new devtools::security::SecurityHandler());
     page_handler_.reset(new devtools::page::PageHandler());
     emulation_handler_.reset(
         new devtools::emulation::EmulationHandler(page_handler_.get()));
     dispatcher->SetSecurityHandler(security_handler_.get());
     dispatcher->SetPageHandler(page_handler_.get());
     dispatcher->SetEmulationHandler(emulation_handler_.get());
   }
 
   SetPending(host);
   CommitPending();
   WebContentsObserver::Observe(WebContents::FromRenderFrameHost(host));
 
   g_instances.Get().push_back(this);
   AddRef();  // Balanced in RenderFrameHostDestroyed.
 }
 
 void RenderFrameDevToolsAgentHost::SetPending(RenderFrameHostImpl* host) {
   DCHECK(!pending_);
+  current_frame_crashed_ = false;
   pending_.reset(new FrameHostHolder(this, host));
   if (IsAttached())
     pending_->Reattach(current_.get());
 
   // Can only be null in constructor.
   if (current_)
     current_->Suspend();
   pending_->Suspend();
 
   UpdateProtocolHandlers(host);
 }
 
 void RenderFrameDevToolsAgentHost::CommitPending() {
   DCHECK(pending_);
+  current_frame_crashed_ = false;
 
   if (!ShouldCreateDevToolsFor(pending_->host())) {
     DestroyOnRenderFrameGone();
     // |this| may be deleted at this point.
     return;
   }
 
   current_ = pending_.Pass();
   UpdateProtocolHandlers(current_->host());
   current_->Resume();
@@ skipping 97 matching lines @@
     g_instances.Get().erase(it);
 }
 
 // TODO(creis): Consider removing this in favor of RenderFrameHostChanged.
 void RenderFrameDevToolsAgentHost::AboutToNavigateRenderFrame(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
   DCHECK(!pending_ || pending_->host() != old_host);
   if (!current_ || current_->host() != old_host)
     return;
-  if (old_host == new_host)
+  if (old_host == new_host && !current_frame_crashed_)

[nasko, 2015/06/15 22:25:49]

Will it really make a difference whether the current frame has crashed or not?

[dgozman, 2015/06/16 13:30:36]

Yes, because if the current frame has crashed, renderer will be recreated on the
navigation and we should reattach there.

     return;
   DCHECK(!pending_);
   SetPending(static_cast<RenderFrameHostImpl*>(new_host));
 }
 
 void RenderFrameDevToolsAgentHost::RenderFrameHostChanged(
     RenderFrameHost* old_host,
     RenderFrameHost* new_host) {
   DCHECK(!pending_ || pending_->host() != old_host);
   if (!current_ || current_->host() != old_host)
@@ skipping 11 matching lines @@
   if (pending_ && pending_->host() == rfh) {
     DiscardPending();
     return;
   }
 
   if (current_ && current_->host() == rfh)
     DestroyOnRenderFrameGone();  // |this| may be deleted at this point.
 }
 
 void RenderFrameDevToolsAgentHost::RenderFrameDeleted(RenderFrameHost* rfh) {
-  FrameDeleted(rfh);
+  if (!current_frame_crashed_)
+    FrameDeleted(rfh);
 }
 
 void RenderFrameDevToolsAgentHost::DestroyOnRenderFrameGone() {
   DCHECK(current_);
   scoped_refptr<RenderFrameDevToolsAgentHost> protect(this);
   if (IsAttached())
     OnClientDetached();
   HostClosed();
   pending_.reset();
   current_.reset();
   Release();
 }
 
 void RenderFrameDevToolsAgentHost::RenderProcessGone(
     base::TerminationStatus status) {
   switch(status) {
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
 #if defined(OS_CHROMEOS)
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM:
 #endif
     case base::TERMINATION_STATUS_PROCESS_CRASHED:
 #if defined(OS_ANDROID)
     case base::TERMINATION_STATUS_OOM_PROTECTED:
 #endif
       inspector_handler_->TargetCrashed();
+      current_frame_crashed_ = true;
       break;
     default:
       break;
   }
 }
 
 bool RenderFrameDevToolsAgentHost::OnMessageReceived(
     const IPC::Message& message) {
   if (!current_)
     return false;
@@ skipping 39 matching lines @@
 
 void RenderFrameDevToolsAgentHost::DidDetachInterstitialPage() {
   if (page_handler_)
     page_handler_->DidDetachInterstitialPage();
 }
 
 void RenderFrameDevToolsAgentHost::DidCommitProvisionalLoadForFrame(
     RenderFrameHost* render_frame_host,
     const GURL& url,
     ui::PageTransition transition_type) {
+  if (pending_ && pending_->host() == render_frame_host)
+    CommitPending();
   service_worker_handler_->UpdateHosts();
 }
 
 void RenderFrameDevToolsAgentHost::DidFailProvisionalLoad(
     RenderFrameHost* render_frame_host,
     const GURL& validated_url,
     int error_code,
     const base::string16& error_description) {
   if (pending_ && pending_->host() == render_frame_host)
     DiscardPending();
@@ skipping 106 matching lines @@
     RenderFrameHost* host) {
   return (current_ && current_->host() == host) ||
       (pending_ && pending_->host() == host);
 }
 
 bool RenderFrameDevToolsAgentHost::IsChildFrame() {
   return current_ && current_->host()->GetParent();
 }
 
 }  // namespace content