Disable support for swapped out RenderFrame(Host) on desktop.

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/logging.h"
@@ skipping 33 matching lines @@
 
 namespace content {
 
 // static
 bool RenderFrameHostManager::ClearRFHsPendingShutdown(FrameTreeNode* node) {
   node->render_manager()->pending_delete_hosts_.clear();
   return true;
 }
 
 // static
 bool RenderFrameHostManager::IsSwappedOutStateForbidden() {

[Avi (use Gerrit), 2015/06/24 14:59:43]

Looking forward to this function going away. :)

-  return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kSitePerProcess);
+  return true;
 }
 
 RenderFrameHostManager::RenderFrameHostManager(
     FrameTreeNode* frame_tree_node,
     RenderFrameHostDelegate* render_frame_delegate,
     RenderViewHostDelegate* render_view_delegate,
     RenderWidgetHostDelegate* render_widget_delegate,
     Delegate* delegate)
     : frame_tree_node_(frame_tree_node),
       delegate_(delegate),
       render_frame_delegate_(render_frame_delegate),
       render_view_delegate_(render_view_delegate),
       render_widget_delegate_(render_widget_delegate),
       interstitial_page_(nullptr),
       should_reuse_web_ui_(false),
       weak_factory_(this) {
   DCHECK(frame_tree_node_);
+  LOG(ERROR) << "RFHM[" << this << "]::RFHM:"
+    << " parent:" << frame_tree_node_->parent();
 }
 
 RenderFrameHostManager::~RenderFrameHostManager() {
   if (pending_render_frame_host_) {
     scoped_ptr<RenderFrameHostImpl> relic = UnsetPendingRenderFrameHost();
     ShutdownProxiesIfLastActiveFrameInSiteInstance(relic.get());
   }
 
   if (speculative_render_frame_host_) {
     scoped_ptr<RenderFrameHostImpl> relic = UnsetSpeculativeRenderFrameHost();
@@ skipping 114 matching lines @@
       frame_entry.url(),
       // TODO(creis): Move source_site_instance to FNE.
       entry.source_site_instance(), frame_entry.site_instance(),
       entry.GetTransitionType(),
       entry.restore_type() != NavigationEntryImpl::RESTORE_NONE,
       entry.IsViewSourceMode(), entry.transferred_global_request_id(),
       entry.bindings());
   if (!dest_render_frame_host)
     return NULL;  // We weren't able to create a pending render frame host.
 
+  LOG(ERROR) << "RFHM[" << this << "]::Navigate:"
+    << " rfh:" << render_frame_host_
+    << " dest_rfh:" << dest_render_frame_host;
+
   // If the current render_frame_host_ isn't live, we should create it so
   // that we don't show a sad tab while the dest_render_frame_host fetches
   // its first page.  (Bug 1145340)
   if (dest_render_frame_host != render_frame_host_ &&
       !render_frame_host_->IsRenderFrameLive()) {
+    LOG(ERROR) << "RFHM[" << this << "]::Navigate:"
+      << " dest rfh != rfh and rfh not live";
     // Note: we don't call InitRenderView here because we are navigating away
     // soon anyway, and we don't have the NavigationEntry for this host.
     delegate_->CreateRenderViewForRenderManager(
         render_frame_host_->render_view_host(), MSG_ROUTING_NONE,
         MSG_ROUTING_NONE, frame_tree_node_->current_replication_state(),
         frame_tree_node_->IsMainFrame());
   }
 
   // If the renderer crashed, then try to create a new one to satisfy this
   // navigation request.
   if (!dest_render_frame_host->IsRenderFrameLive()) {
+    LOG(ERROR) << "RFHM[" << this << "]::Navigate:"
+      << " dest rfh not live";
     // Instruct the destination render frame host to set up a Mojo connection
     // with the new render frame if necessary.  Note that this call needs to
     // occur before initializing the RenderView; the flow of creating the
     // RenderView can cause browser-side code to execute that expects the this
     // RFH's ServiceRegistry to be initialized (e.g., if the site is a WebUI
     // site that is handled via Mojo, then Mojo WebUI code in //chrome will
     // add a service to this RFH's ServiceRegistry).
     dest_render_frame_host->SetUpMojoIfNeeded();
 
     // Recreate the opener chain.
@@ skipping 25 matching lines @@
 
   // If entry includes the request ID of a request that is being transferred,
   // the destination render frame will take ownership, so release ownership of
   // the request.
   if (cross_site_transferring_request_.get() &&
       cross_site_transferring_request_->request_id() ==
           entry.transferred_global_request_id()) {
     cross_site_transferring_request_->ReleaseRequest();
   }
 
+  LOG(ERROR) << "RFHM[" << this << "]::Navigate: " << dest_render_frame_host;
   return dest_render_frame_host;
 }
 
 void RenderFrameHostManager::Stop() {
   render_frame_host_->Stop();
 
   // If we are navigating cross-process, we should stop the pending renderers.
   // This will lead to a DidFailProvisionalLoad, which will properly destroy
   // them.
   if (pending_render_frame_host_) {
@@ skipping 240 matching lines @@
     if (pair.second->GetSiteInstance() != parent_site_instance) {
       pair.second->Send(new FrameMsg_DidUpdateSandboxFlags(
           pair.second->GetRoutingID(),
           frame_tree_node_->current_replication_state().sandbox_flags));
     }
   }
 }
 
 void RenderFrameHostManager::RendererProcessClosing(
     RenderProcessHost* render_process_host) {
+  LOG(ERROR) << "RFHM[" << this << "]::RendererProcessClosing:";
+
   // 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) {
@@ skipping 67 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(),
       old_render_frame_host->render_view_host(), frame_tree_node_);
   CHECK(proxy_hosts_.insert(std::make_pair(old_site_instance_id, proxy)).second)
       << "Inserting a duplicate item.";
+  LOG(ERROR) << "RFHM[" << this << "]::SwapOutOldFrame: "
+    << " created proxy for SI:" << proxy->GetSiteInstance()->GetId()
+    << "," << proxy->GetSiteInstance()->GetSiteURL();
 
   // 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);
 
   if (RenderFrameHostManager::IsSwappedOutStateForbidden()) {
     // In --site-per-process, frames delete their RFH rather than storing it
     // in the proxy.  Schedule it for deletion once the SwapOutACK comes in.
@@ skipping 911 matching lines @@
       if (swapped_out)
         proxy->set_render_frame_proxy_created(true);
       if (frame_tree_node_->IsMainFrame()) {
         // Don't show the main frame's view until we get a DidNavigate from it.
         // Only the RenderViewHost for the top-level RenderFrameHost has a
         // RenderWidgetHostView; RenderWidgetHosts for out-of-process iframes
         // will be created later and hidden.
         if (render_view_host->GetView())
           render_view_host->GetView()->Hide();
       }
-      // With --site-per-process, RenderViewHost for |instance| might exist
-      // prior to calling CreateRenderFrame, due to a subframe in
-      // |instance|. In such a case, InitRenderView will not create the
+      // RenderViewHost for |instance| might exist prior to calling
+      // CreateRenderFrame. In such a case, InitRenderView will not create the
       // RenderFrame in the renderer process and it needs to be done
       // explicitly.
-      if (is_site_per_process) {
+      if (swapped_out_forbidden) {
         // Init the RFH, so a RenderFrame is created in the renderer.
         DCHECK(new_render_frame_host);
         success = InitRenderFrame(new_render_frame_host.get());
       }
     }
 
     if (success) {
       if (view_routing_id_ptr)
         *view_routing_id_ptr = render_view_host->GetRoutingID();
     }
@@ skipping 25 matching lines @@
 int RenderFrameHostManager::CreateRenderFrameProxy(SiteInstance* instance) {
   // A RenderFrameProxyHost should never be created in the same SiteInstance as
   // the current RFH.
   CHECK(instance);
   CHECK_NE(instance, render_frame_host_->GetSiteInstance());
 
   RenderViewHostImpl* render_view_host = nullptr;
 
   // Ensure a RenderViewHost exists for |instance|, as it creates the page
   // level structure in Blink.
+  LOG(ERROR) << "RFHM[" << this << "]::CreateRenderFrameProxy:"
+    << " main_frame:" << frame_tree_node_->IsMainFrame()
+    << " site:" << instance->GetId() << "," << instance->GetSiteURL()
+    << " ft:" << frame_tree_node_->frame_tree();
+
   if (RenderFrameHostManager::IsSwappedOutStateForbidden()) {
     render_view_host =
         frame_tree_node_->frame_tree()->GetRenderViewHost(instance);
+    LOG(ERROR) << "RFHM[" << this << "]::CreateRenderFrameProxy:"
+      << " rvh:" << render_view_host;
     if (!render_view_host) {
       CHECK(frame_tree_node_->IsMainFrame());
       render_view_host = frame_tree_node_->frame_tree()->CreateRenderViewHost(
           instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE, true, true);
     }
   }
 
   RenderFrameProxyHost* proxy = GetRenderFrameProxyHost(instance);
-  if (proxy && proxy->is_render_frame_proxy_live())
+  if (proxy && proxy->is_render_frame_proxy_live()) {
+    LOG(ERROR) << "RFHM[" << this << "]::CreateRenderFrameProxy:"
+      << " proxy exists and live:" << proxy;
     return proxy->GetRoutingID();
+  }
 
   if (!proxy) {
     proxy = new RenderFrameProxyHost(
         instance, render_view_host, frame_tree_node_);
     proxy_hosts_[instance->GetId()] = proxy;
   }
 
   if (RenderFrameHostManager::IsSwappedOutStateForbidden() &&
       frame_tree_node_->IsMainFrame()) {
-    InitRenderView(
+    LOG(ERROR) << "RFHM[" << this << "]::CreateRenderFrameProxy:"
+      << " init rv";
+    bool success = InitRenderView(
         render_view_host, MSG_ROUTING_NONE, proxy->GetRoutingID(), true);
+    LOG(ERROR) << "RFHM[" << this << "]::CreateRenderFrameProxy:"
+      << " init rv:" << success;
     proxy->set_render_frame_proxy_created(true);
   } else {
+    LOG(ERROR) << "RFHM[" << this << "]::CreateRenderFrameProxy:"
+      << " init proxy";
     proxy->InitRenderFrameProxy();
   }
 
   return proxy->GetRoutingID();
 }
 
 void RenderFrameHostManager::CreateProxiesForChildFrame(FrameTreeNode* child) {
   for (const auto& pair : proxy_hosts_) {
     child->render_manager()->CreateRenderFrameProxy(
         pair.second->GetSiteInstance());
@@ skipping 16 matching lines @@
   proxy->set_render_frame_proxy_created(true);
 }
 
 bool RenderFrameHostManager::InitRenderView(
     RenderViewHostImpl* render_view_host,
     int opener_route_id,
     int proxy_routing_id,
     bool for_main_frame_navigation) {
   // Ensure the renderer process is initialized before creating the
   // RenderView.
+  LOG(ERROR) << "RFHM[" << this << "]::InitRenderView: "
+    << " rvh:" << render_view_host;
   if (!render_view_host->GetProcess()->Init())
     return false;
 
   // We may have initialized this RenderViewHost for another RenderFrameHost.
-  if (render_view_host->IsRenderViewLive())
+  if (render_view_host->IsRenderViewLive()) {
+    LOG(ERROR) << "RFHM[" << this << "]::InitRenderView: "
+      << " rvh already live.";
     return true;
+  }
 
   // If the ongoing navigation is to a WebUI and the RenderView is not in a
   // guest process, tell the RenderViewHost about any bindings it will need
   // enabled.
   WebUIImpl* dest_web_ui = nullptr;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation)) {
     dest_web_ui =
         should_reuse_web_ui_ ? web_ui_.get() : speculative_web_ui_.get();
   } else {
@@ skipping 13 matching lines @@
   return delegate_->CreateRenderViewForRenderManager(
       render_view_host,
       opener_route_id,
       proxy_routing_id,
       frame_tree_node_->current_replication_state(),
       for_main_frame_navigation);
 }
 
 bool RenderFrameHostManager::InitRenderFrame(
     RenderFrameHostImpl* render_frame_host) {
-  if (render_frame_host->IsRenderFrameLive())
+  LOG(ERROR) << "RFHM[" << this << "]::InitRenderFrame: "
+    << " rfh:" << render_frame_host;
+
+  if (render_frame_host->IsRenderFrameLive()) {
+    LOG(ERROR) << "RFHM[" << this << "]::InitRenderFrame: "
+      << " rfh already live.";
     return true;
+  }
 
   int parent_routing_id = MSG_ROUTING_NONE;
   int previous_sibling_routing_id = MSG_ROUTING_NONE;
   int proxy_routing_id = MSG_ROUTING_NONE;
 
   if (frame_tree_node_->parent()) {
     parent_routing_id = frame_tree_node_->parent()->render_manager()->
         GetRoutingIdForSiteInstance(render_frame_host->GetSiteInstance());
     CHECK_NE(parent_routing_id, MSG_ROUTING_NONE);
   }
@@ skipping 102 matching lines @@
   if (!browser_side_navigation) {
     DCHECK(!speculative_render_frame_host_);
     old_render_frame_host =
         SetRenderFrameHost(pending_render_frame_host_.Pass());
   } else {
     // PlzNavigate
     DCHECK(speculative_render_frame_host_);
     old_render_frame_host =
         SetRenderFrameHost(speculative_render_frame_host_.Pass());
   }
+  LOG(ERROR) << "RFHM[" << this << "]::CommitPending:"
+    << " old:" << old_render_frame_host.get()
+    << "," << old_render_frame_host->GetSiteInstance()->GetSiteURL()
+    << " new:" << render_frame_host_.get()
+    << "," << render_frame_host_->GetSiteInstance()->GetSiteURL();
 
   // Remove the children of the old frame from the tree.
   frame_tree_node_->ResetForNewProcess();
 
   // The process will no longer try to exit, so we can decrement the count.
   render_frame_host_->GetProcess()->RemovePendingView();
 
   // Show the new view (or a sad tab) if necessary.
   bool new_rfh_has_view = !!render_frame_host_->GetView();
   if (!delegate_->IsHidden() && new_rfh_has_view) {
@@ skipping 145 matching lines @@
   scoped_refptr<SiteInstance> new_instance = GetSiteInstanceForNavigation(
       dest_url, source_instance, dest_instance, nullptr, transition,
       dest_is_restore, dest_is_view_source_mode);
 
   const NavigationEntry* current_entry =
       delegate_->GetLastCommittedNavigationEntryForRenderManager();
 
   DCHECK(!pending_render_frame_host_);
 
   if (new_instance.get() != current_instance) {
+    LOG(ERROR) << "RFHM[" << this << "]::UpdateStateForNavigate:"
+      << " navigating from:" << current_instance->GetSiteURL()
+      << " to:" << new_instance->GetSiteURL();
+
     TRACE_EVENT_INSTANT2(
         "navigation",
         "RenderFrameHostManager::UpdateStateForNavigate:New SiteInstance",
         TRACE_EVENT_SCOPE_THREAD,
         "current_instance id", current_instance->GetId(),
         "new_instance id", new_instance->GetId());
 
     // New SiteInstance: create a pending RFH to navigate.
 
     // This will possibly create (set to nullptr) a Web UI object for the
@@ skipping 48 matching lines @@
       // Unless we are transferring an existing request, we should now tell the
       // old render view to run its beforeunload handler, since it doesn't
       // otherwise know that the cross-site request is happening.  This will
       // trigger a call to OnBeforeUnloadACK with the reply.
       render_frame_host_->DispatchBeforeUnload(true);
     }
 
     return pending_render_frame_host_.get();
   }
 
+  LOG(ERROR) << "RFHM[" << this << "]::UpdateStateForNavigate:"
+    << " to:" << new_instance->GetSiteURL();
+
   // Otherwise the same SiteInstance can be used.  Navigate render_frame_host_.
 
   // It's possible to swap out the current RFH and then decide to navigate in it
   // anyway (e.g., a cross-process navigation that redirects back to the
   // original site).  In that case, we have a proxy for the current RFH but
   // haven't deleted it yet.  The new navigation will swap it back in, so we can
   // delete the proxy.
   DeleteRenderFrameProxyHost(new_instance.get());
 
   if (ShouldReuseWebUI(current_entry, dest_url)) {
@@ skipping 165 matching lines @@
     // Ensure that all the nodes in the opener's frame tree have
     // RenderFrameProxyHosts for the new SiteInstance.
     frame_tree->CreateProxiesForSiteInstance(nullptr, instance);
     rvh = frame_tree->GetRenderViewHost(instance);
     render_view_routing_id = rvh->GetRoutingID();
   } else {
     // Create a swapped out RenderView in the given SiteInstance if none exists,
     // setting its opener to the given route_id.  Since the opener can point to
     // a subframe, do this on the root frame of the opener's frame tree.
     // Return the new view's route_id.
-    frame_tree->root()->render_manager()->
-        CreateRenderFrame(instance, nullptr, opener_route_id,
-                          CREATE_RF_FOR_MAIN_FRAME_NAVIGATION |
-                          CREATE_RF_SWAPPED_OUT | CREATE_RF_HIDDEN,
-                          &render_view_routing_id);
+    frame_tree->root()->render_manager()->CreateRenderFrameProxy(instance);
   }
   return render_view_routing_id;
 }
 
 }  // namespace content