Support cross-process navigations in a single subframe RenderFrameHost.

content/browser/web_contents/web_contents_impl.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/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 1720 matching lines @@
   TRACE_EVENT0("browser", "WebContentsImpl::NavigateToEntry");
 
   // The renderer will reject IPC messages with URLs longer than
   // this limit, so don't attempt to navigate with a longer URL.
   if (entry.GetURL().spec().size() > GetMaxURLChars()) {
     LOG(WARNING) << "Refusing to load URL as it exceeds " << GetMaxURLChars()
                  << " characters.";
     return false;
   }
 
-  // TODO(creis): Use entry->frame_tree_node_id() to pick which
-  // RenderFrameHostManager to use.
+  // Use entry->frame_tree_node_id() to pick which RenderFrameHostManager to
+  // use when --site-per-process is used.
+  RenderFrameHostManager* manager = GetRenderManager();
+  if (entry.frame_tree_node_id() != -1 &&
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess)) {
+    int64 frame_tree_node_id = entry.frame_tree_node_id();
+    manager = frame_tree_.FindByID(frame_tree_node_id)->render_manager();
+  }
+
   RenderViewHostImpl* dest_render_view_host =
-      static_cast<RenderViewHostImpl*>(GetRenderManager()->Navigate(entry));
+      static_cast<RenderViewHostImpl*>(manager->Navigate(entry));
   if (!dest_render_view_host)
     return false;  // Unable to create the desired render view host.
 
   // For security, we should never send non-Web-UI URLs to a Web UI renderer.
   // Double check that here.
   int enabled_bindings = dest_render_view_host->GetEnabledBindings();
   bool data_urls_allowed = delegate_ && delegate_->CanLoadDataURLsInWebUI();
   bool is_allowed_in_web_ui_renderer =
       WebUIControllerFactoryRegistry::GetInstance()->IsURLAcceptableForWebUI(
           GetBrowserContext(), entry.GetURL(), data_urls_allowed);
   if ((enabled_bindings & BINDINGS_POLICY_WEB_UI) &&
       !is_allowed_in_web_ui_renderer) {
     // Log the URL to help us diagnose any future failures of this CHECK.
     GetContentClient()->SetActiveURL(entry.GetURL());
     CHECK(0);
   }
 
   // Notify observers that we will navigate in this RV.
   FOR_EACH_OBSERVER(WebContentsObserver,
                     observers_,
                     AboutToNavigateRenderView(dest_render_view_host));
 
   // Used for page load time metrics.
   current_load_start_ = base::TimeTicks::Now();
 
   // Navigate in the desired RenderViewHost.
+  // TODO(creis): As a temporary hack, we currently do cross-process subframe
+  // navigations in a top-level frame of the new process.  Thus, we don't yet
+  // need to store the correct frame ID in ViewMsg_Navigate_Params.
   ViewMsg_Navigate_Params navigate_params;
   MakeNavigateParams(entry, controller_, delegate_, reload_type,
                      &navigate_params);
   dest_render_view_host->Navigate(navigate_params);
 
   if (entry.GetPageID() == -1) {
     // HACK!!  This code suppresses javascript: URLs from being added to
     // session history, which is what we want to do for javascript: URLs that
     // do not generate content.  What we really need is a message from the
     // renderer telling us that a new page was not created.  The same message
@@ skipping 504 matching lines @@
   FOR_EACH_OBSERVER(
       WebContentsObserver, observers_,
       DocumentLoadedInFrame(frame_id, render_view_message_source_));
 }
 
 void WebContentsImpl::OnDidFinishLoad(
     int64 frame_id,
     const GURL& url,
     bool is_main_frame) {
   GURL validated_url(url);
+
+  // --site-per-process mode has a short-term hack allowing cross-process
+  // subframe pages to commit thinking they are top-level.  Correct it here to
+  // avoid confusing the observers.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess) &&
+      render_view_message_source_ != GetRenderViewHost())
+    is_main_frame = false;

[Charlie Reis, 2013/12/20 23:20:08]

This eliminates the need for the web_navigation_api.cc change from the draft CL:
https://codereview.chromium.org/30323002/diff/720001/chrome/browser/extension...

+
   RenderProcessHost* render_process_host =
       render_view_message_source_->GetProcess();
   RenderViewHost::FilterURL(render_process_host, false, &validated_url);
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidFinishLoad(frame_id, validated_url, is_main_frame,
                                   render_view_message_source_));
 }
 
 void WebContentsImpl::OnDidFailLoadWithError(
     int64 frame_id,
@@ skipping 656 matching lines @@
 
   // TODO(avi): Remove. http://crbug.com/170921
   NotificationService::current()->Notify(
       NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
       Source<WebContents>(this),
       Details<const ResourceRedirectDetails>(&details));
 }
 
 void WebContentsImpl::DidNavigate(
     RenderViewHost* rvh,
-    const ViewHostMsg_FrameNavigate_Params& params) {
+    const ViewHostMsg_FrameNavigate_Params& orig_params) {
+  ViewHostMsg_FrameNavigate_Params params(orig_params);
+  bool use_site_per_process =
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess);
   if (frame_tree_.IsFirstNavigationAfterSwap()) {
     // First navigation should be a main frame navigation.
-    DCHECK(PageTransitionIsMainFrame(params.transition));
+    // TODO(creis): This DCHECK is currently disabled for --site-per-process
+    // because cross-process subframe navigations still have a main frame
+    // PageTransition.
+    if (!use_site_per_process)
+      DCHECK(PageTransitionIsMainFrame(params.transition));
     frame_tree_.OnFirstNavigationAfterSwap(params.frame_id);
   }
 
+  // When using --site-per-process, look up the FrameTreeNode ID that the
+  // renderer-specific frame ID corresponds to.
+  int64 frame_tree_node_id = frame_tree_.root()->frame_tree_node_id();
+  if (use_site_per_process) {
+    FrameTreeNode* source_node = frame_tree_.FindByFrameID(params.frame_id);
+    if (source_node)
+      frame_tree_node_id = source_node->frame_tree_node_id();
+
+    // TODO(creis): In the short term, cross-process subframe navigations are
+    // happening in the pending RenderViewHost's top-level frame.  (We need to
+    // both mirror the frame tree and get the navigation to occur in the correct
+    // subframe to fix this.)  Until then, we should check whether we have a
+    // pending NavigationEntry with a frame ID and if so, treat the
+    // cross-process "main frame" navigation as a subframe navigation.  This
+    // limits us to a single cross-process subframe per RVH, and it affects
+    // NavigateToEntry, NavigatorImpl::DidStartProvisionalLoad, and
+    // OnDidFinishLoad.
+    NavigationEntryImpl* pending_entry =
+        NavigationEntryImpl::FromNavigationEntry(controller_.GetPendingEntry());
+    int root_ftn_id = frame_tree_.root()->frame_tree_node_id();
+    if (pending_entry &&
+        pending_entry->frame_tree_node_id() != -1 &&
+        pending_entry->frame_tree_node_id() != root_ftn_id) {
+      params.transition = PAGE_TRANSITION_AUTO_SUBFRAME;
+      frame_tree_node_id = pending_entry->frame_tree_node_id();
+    }
+  }
+
   if (PageTransitionIsMainFrame(params.transition)) {
     // When overscroll navigation gesture is enabled, a screenshot of the page
     // in its current state is taken so that it can be used during the
     // nav-gesture. It is necessary to take the screenshot here, before calling
     // RenderFrameHostManager::DidNavigateMainFrame, because that can change
     // WebContents::GetRenderViewHost to return the new host, instead of the one
     // that may have just been swapped out.
     if (delegate_ && delegate_->CanOverscrollContent())
       controller_.TakeScreenshot();
 
-    GetRenderManager()->DidNavigateMainFrame(rvh);
+    if (!use_site_per_process)
+      GetRenderManager()->DidNavigateMainFrame(rvh);
+  }
+
+  // When using --site-per-process, we notify the RFHM for all navigations,
+  // not just main frame navigations.
+  if (use_site_per_process) {
+    FrameTreeNode* frame = frame_tree_.FindByID(frame_tree_node_id);
+    // TODO(creis): Rename to DidNavigateFrame.
+    frame->render_manager()->DidNavigateMainFrame(rvh);
   }
 
   // Update the site of the SiteInstance if it doesn't have one yet, unless
   // assigning a site is not necessary for this URL.  In that case, the
   // SiteInstance can still be considered unused until a navigation to a real
   // page.
   if (!static_cast<SiteInstanceImpl*>(GetSiteInstance())->HasSite() &&
       ShouldAssignSiteForURL(params.url)) {
     static_cast<SiteInstanceImpl*>(GetSiteInstance())->SetSite(params.url);
   }
 
   // Need to update MIME type here because it's referred to in
   // UpdateNavigationCommands() called by RendererDidNavigate() to
   // determine whether or not to enable the encoding menu.
   // It's updated only for the main frame. For a subframe,
   // RenderView::UpdateURL does not set params.contents_mime_type.
   // (see http://code.google.com/p/chromium/issues/detail?id=2929 )
   // TODO(jungshik): Add a test for the encoding menu to avoid
   // regressing it again.
   if (PageTransitionIsMainFrame(params.transition))
     contents_mime_type_ = params.contents_mime_type;
 
   LoadCommittedDetails details;
-  bool did_navigate = controller_.RendererDidNavigate(params, &details);
+  bool did_navigate = controller_.RendererDidNavigate(rvh, params, &details);
 
   // For now, keep track of each frame's URL in its FrameTreeNode.  This lets
   // us estimate our process count for implementing OOP iframes.
   // TODO(creis): Remove this when we track which pages commit in each frame.
   frame_tree_.SetFrameUrl(params.frame_id, params.url);
 
   // Send notification about committed provisional loads. This notification is
   // different from the NAV_ENTRY_COMMITTED notification which doesn't include
   // the actual URL navigated to and isn't sent for AUTO_SUBFRAME navigations.
   if (details.type != NAVIGATION_TYPE_NAV_IGNORE) {
@@ skipping 254 matching lines @@
     int64 source_frame_id,
     const GlobalRequestID& old_request_id,
     bool should_replace_current_entry,
     bool user_gesture) {
   WebContents* new_contents = NULL;
   GURL dest_url(url);
   if (!GetContentClient()->browser()->ShouldAllowOpenURL(
           GetSiteInstance(), url))
     dest_url = GURL(kAboutBlankURL);
 
-  // TODO(creis): Look up the FrameTreeNode ID corresponding to source_frame_id.
-  int frame_tree_node_id = -1;
+  // Look up the FrameTreeNode ID corresponding to source_frame_id.
+  int64 frame_tree_node_id = -1;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess) &&
+      source_frame_id != -1) {
+    FrameTreeNode* source_node = frame_tree_.FindByFrameID(source_frame_id);
+    if (source_node)
+      frame_tree_node_id = source_node->frame_tree_node_id();
+  }
   OpenURLParams params(dest_url, referrer, source_frame_id,
       frame_tree_node_id, disposition,
       page_transition, true /* is_renderer_initiated */);
   if (redirect_chain.size() > 0)
     params.redirect_chain = redirect_chain;
   params.transferred_global_request_id = old_request_id;
   params.should_replace_current_entry = should_replace_current_entry;
   params.user_gesture = user_gesture;
 
   if (GetRenderManager()->web_ui()) {
@@ skipping 525 matching lines @@
 }
 
 void WebContentsImpl::OnFrameRemoved(
     RenderViewHostImpl* render_view_host,
     int64 frame_id) {
    FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                      FrameDetached(render_view_host, frame_id));
 }
 
 }  // namespace content