Ensure that before creating proxy of site A, RVH of site A is initialized.

content/browser/frame_host/render_frame_host_manager.cc

 // Copyright 2013 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/frame_host/render_frame_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 484 matching lines @@
     pending_render_frame_host_->DisownOpener();
   }
 }
 
 void RenderFrameHostManager::RendererProcessClosing(
     RenderProcessHost* render_process_host) {
   // Remove any swapped out RVHs from this process, so that we don't try to
   // swap them back in while the process is exiting.  Start by finding them,
   // since there could be more than one.
   std::list<int> ids_to_remove;
+  // Do not remove proxies in the dead process that still have active frame
+  // count though, we just reset them to be uninitialized.
+  std::list<int> ids_to_keep;
   for (RenderFrameProxyHostMap::iterator iter = proxy_hosts_.begin();
        iter != proxy_hosts_.end();
        ++iter) {
-    if (iter->second->GetProcess() == render_process_host)
+    RenderFrameProxyHost* proxy = iter->second;
+    if (proxy->GetProcess() != render_process_host)
+      continue;
+
+    if (static_cast<SiteInstanceImpl*>(proxy->GetSiteInstance())
+            ->active_frame_count() >= 1U) {
+      ids_to_keep.push_back(iter->first);
+    } else {
       ids_to_remove.push_back(iter->first);
+    }
   }
 
   // Now delete them.
   while (!ids_to_remove.empty()) {
     delete proxy_hosts_[ids_to_remove.back()];
     proxy_hosts_.erase(ids_to_remove.back());
     ids_to_remove.pop_back();
   }
+
+  while (!ids_to_keep.empty()) {
+    frame_tree_node_->frame_tree()->ForEach(
+        base::Bind(
+            &RenderFrameHostManager::ResetProxiesInSiteInstanceForNewProcess,
+            ids_to_keep.back()));
+    ids_to_keep.pop_back();
+  }
 }
 
 void RenderFrameHostManager::SwapOutOldFrame(
     scoped_ptr<RenderFrameHostImpl> old_render_frame_host) {
   TRACE_EVENT1("navigation", "RenderFrameHostManager::SwapOutOldFrame",
                "FrameTreeNode id", frame_tree_node_->frame_tree_node_id());
 
   // Tell the renderer to suppress any further modal dialogs so that we can swap
   // it out.  This must be done before canceling any current dialog, in case
   // there is a loop creating additional dialogs.
@@ skipping 34 matching lines @@
   // Otherwise there are active views and we need a proxy for the old RFH.
   // (There should not be one yet.)
   CHECK(!GetRenderFrameProxyHost(old_render_frame_host->GetSiteInstance()));
   RenderFrameProxyHost* proxy = new RenderFrameProxyHost(
       old_render_frame_host->GetSiteInstance(), frame_tree_node_);
   CHECK(proxy_hosts_.insert(std::make_pair(old_site_instance_id, proxy)).second)
       << "Inserting a duplicate item.";
 
   // Tell the old RenderFrameHost to swap out and be replaced by the proxy.
   old_render_frame_host->SwapOut(proxy, true);
+  // SwapOut creates a RenderFrameProxy, so set the proxy to be initialized.
+  proxy->set_render_frame_proxy_created(true);
 
   bool is_main_frame = frame_tree_node_->IsMainFrame();
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSitePerProcess) &&
       !is_main_frame) {
     // In --site-per-process, subframes delete their RFH rather than storing it
     // in the proxy.  Schedule it for deletion once the SwapOutACK comes in.
     // TODO(creis): This will be the default when we remove swappedout://.
     MoveToPendingDeleteHosts(old_render_frame_host.Pass());
   } else {
@@ skipping 224 matching lines @@
           proxy->PassFrameHostOwnership();
       node->render_manager()->MoveToPendingDeleteHosts(swapped_out_rfh.Pass());
     }
     delete proxy;
     node->render_manager()->proxy_hosts_.erase(site_instance_id);
   }
 
   return true;
 }
 
+// static.
+bool RenderFrameHostManager::ResetProxiesInSiteInstanceForNewProcess(
+    int32 site_instance_id,
+    FrameTreeNode* node) {
+  RenderFrameProxyHostMap::iterator iter =
+      node->render_manager()->proxy_hosts_.find(site_instance_id);
+  if (iter != node->render_manager()->proxy_hosts_.end())
+    iter->second->set_render_frame_proxy_created(false);
+
+  return true;
+}
+
 bool RenderFrameHostManager::ShouldTransitionCrossSite() {
   // False in the single-process mode, as it makes RVHs to accumulate
   // in swapped_out_hosts_.
   // True if we are using process-per-site-instance (default) or
   // process-per-site (kProcessPerSite).
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kSingleProcess) &&
          !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kProcessPerTab);
 }
@@ skipping 547 matching lines @@
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
   if (proxy)
     return proxy->GetRoutingID();
 
   proxy = new RenderFrameProxyHost(instance, frame_tree_node_);
   proxy_hosts_[instance->GetId()] = proxy;
   proxy->InitRenderFrameProxy();
   return proxy->GetRoutingID();
 }
 
+void RenderFrameHostManager::EnsureRenderViewInitialized(
+    FrameTreeNode* source,
+    RenderViewHostImpl* render_view_host,
+    SiteInstance* instance) {
+  DCHECK(frame_tree_node_->IsMainFrame());
+
+  if (render_view_host->IsRenderViewLive())
+    return;
+
+  // Recreate the opener chain.
+  int opener_route_id =
+      delegate_->CreateOpenerRenderViewsForRenderManager(instance);
+  RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
+  DCHECK(proxy);

[nasko, 2015/01/20 23:51:23]

nit: no need for DCHECK, it will crash on the next line.

[lazyboy, 2015/01/21 18:52:14]

Done.

+  InitRenderView(render_view_host, opener_route_id, proxy->GetRoutingID(),
+                 source->IsMainFrame());
+}
+
 bool RenderFrameHostManager::InitRenderView(
     RenderViewHostImpl* render_view_host,
     int opener_route_id,
     int proxy_routing_id,
     bool for_main_frame_navigation) {
   // We may have initialized this RenderViewHost for another RenderFrameHost.
   if (render_view_host->IsRenderViewLive())
     return true;
 
   // If the ongoing navigation is to a WebUI and the RenderView is not in a
@@ skipping 41 matching lines @@
   // the proxy it is replacing, so that it can fully initialize itself.
   // NOTE: This is the only time that a RenderFrameProxyHost can be in the same
   // SiteInstance as its RenderFrameHost. This is only the case until the
   // RenderFrameHost commits, at which point it will replace and delete the
   // RenderFrameProxyHost.
   RenderFrameProxyHost* existing_proxy =
       GetRenderFrameProxyHost(render_frame_host->GetSiteInstance());
   if (existing_proxy) {
     proxy_routing_id = existing_proxy->GetRoutingID();
     CHECK_NE(proxy_routing_id, MSG_ROUTING_NONE);
+    if (!existing_proxy->IsRenderFrameProxyLive())
+      existing_proxy->InitRenderFrameProxy();
   }
   return delegate_->CreateRenderFrameForRenderManager(render_frame_host,
                                                       parent_routing_id,
                                                       proxy_routing_id);
 }
 
 int RenderFrameHostManager::GetRoutingIdForSiteInstance(
     SiteInstance* site_instance) {
   if (render_frame_host_->GetSiteInstance() == site_instance)
     return render_frame_host_->GetRoutingID();
@@ skipping 416 matching lines @@
 void RenderFrameHostManager::DeleteRenderFrameProxyHost(
     SiteInstance* instance) {
   RenderFrameProxyHostMap::iterator iter = proxy_hosts_.find(instance->GetId());
   if (iter != proxy_hosts_.end()) {
     delete iter->second;
     proxy_hosts_.erase(iter);
   }
 }
 
 }  // namespace content