OOPIF: History navigations for new child frames.

content/renderer/render_frame_impl.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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 2581 matching lines @@
                                         blink::WebNavigationPolicy policy,
                                         const blink::WebString& suggested_name,
                                         bool should_replace_current_entry) {
   Referrer referrer(RenderViewImpl::GetReferrerFromRequest(frame_, request));
   if (policy == blink::WebNavigationPolicyDownload) {
     render_view_->Send(new ViewHostMsg_DownloadUrl(render_view_->GetRoutingID(),
                                                    GetRoutingID(),
                                                    request.url(), referrer,
                                                    suggested_name));
   } else {
-    OpenURL(request.url(), referrer, policy, should_replace_current_entry);
+    OpenURL(request.url(), referrer, policy, should_replace_current_entry,
+            false);
   }
 }
 
-blink::WebHistoryItem RenderFrameImpl::historyItemForNewChildFrame(
-    blink::WebFrame* frame) {
-  DCHECK(!frame_ || frame_ == frame);
-
-  // TODO(creis): In OOPIF enabled modes, send an IPC to the browser process
-  // telling it to navigate the new frame.  See https://crbug.com/502317.
+blink::WebHistoryItem RenderFrameImpl::historyItemForNewChildFrame() {
+  // OOPIF enabled modes will punt this navigation to the browser in
+  // decidePolicyForNavigation.
   if (SiteIsolationPolicy::UseSubframeNavigationEntries())
     return WebHistoryItem();
 
   return render_view_->history_controller()->GetItemForNewChildFrame(this);
 }
 
 void RenderFrameImpl::willSendSubmitEvent(blink::WebLocalFrame* frame,
                                           const blink::WebFormElement& form) {
   DCHECK(!frame_ || frame_ == frame);
 
@@ skipping 1880 matching lines @@
       if (info.urlRequest.url() != GURL(kSwappedOutURL)) {
         // Targeted links may try to navigate a swapped out frame.  Allow the
         // browser process to navigate the tab instead.  Note that it is also
         // possible for non-targeted navigations (from this view) to arrive
         // here just after we are swapped out.  It's ok to send them to the
         // browser, as long as they're for the top level frame.
         // TODO(creis): Ensure this supports targeted form submissions when
         // fixing http://crbug.com/101395.
         if (frame_->parent() == NULL) {
           OpenURL(info.urlRequest.url(), referrer, info.defaultPolicy,
-                  info.replacesCurrentHistoryItem);
+                  info.replacesCurrentHistoryItem, false);
           return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
         }
 
         // We should otherwise ignore in-process iframe navigations, if they
         // arrive just after we are swapped out.
         return blink::WebNavigationPolicyIgnore;
       }
 
       // Allow kSwappedOutURL to complete.
       return info.defaultPolicy;
     }
   }
 
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = info.urlRequest.url();
 
   // If the browser is interested, then give it a chance to look at the request.
   if (is_content_initiated && IsTopLevelNavigation(frame_) &&
       render_view_->renderer_preferences_
           .browser_handles_all_top_level_requests) {
-    OpenURL(url, referrer, info.defaultPolicy, info.replacesCurrentHistoryItem);
+    OpenURL(url, referrer, info.defaultPolicy, info.replacesCurrentHistoryItem,
+            false);
     return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
   }
 
+  // In OOPIF-enabled modes, back/forward navigations in newly created subframes
+  // should be sent to the browser in case there is a matching
+  // FrameNavigationEntry.  If none is found, fall back to the default url.
+  if (SiteIsolationPolicy::UseSubframeNavigationEntries() &&
+      info.isHistoryNavigationInNewChildFrame && is_content_initiated) {
+    OpenURL(url, referrer, info.defaultPolicy, info.replacesCurrentHistoryItem,
+            true);
+    // Suppress the load in Blink but mark the frame as loading.
+    return blink::WebNavigationPolicyHandledByClient;
+  }
+
   // Use the frame's original request's URL rather than the document's URL for
   // subsequent checks.  For a popup, the document's URL may become the opener
   // window's URL if the opener has called document.write().
   // See http://crbug.com/93517.
   GURL old_url(frame_->dataSource()->request().url());
 
   // Detect when we're crossing a permission-based boundary (e.g. into or out of
   // an extension or app origin, leaving a WebUI page, etc). We only care about
   // top-level navigations (not iframes). But we sometimes navigate to
   // about:blank to clear a tab, and we want to still allow that.
@@ skipping 39 matching lines @@
 
     if (!should_fork) {
       // Give the embedder a chance.
       should_fork = GetContentClient()->renderer()->ShouldFork(
           frame_, url, info.urlRequest.httpMethod().utf8(),
           is_initial_navigation, is_redirect, &send_referrer);
     }
 
     if (should_fork) {
       OpenURL(url, send_referrer ? referrer : Referrer(), info.defaultPolicy,
-              info.replacesCurrentHistoryItem);
+              info.replacesCurrentHistoryItem, false);
       return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
     }
   }
 
   // Detect when a page is "forking" a new tab that can be safely rendered in
   // its own process.  This is done by sites like Gmail that try to open links
   // in new windows without script connections back to the original page.  We
   // treat such cases as browser navigations (in which we will create a new
   // renderer for a cross-site navigation), rather than WebKit navigations.
   //
@@ skipping 19 matching lines @@
       // Must not have issued the request from this page.
       is_content_initiated &&
       // Must be targeted at the current tab.
       info.defaultPolicy == blink::WebNavigationPolicyCurrentTab &&
       // Must be a JavaScript navigation, which appears as "other".
       info.navigationType == blink::WebNavigationTypeOther;
 
   if (is_fork) {
     // Open the URL via the browser, not via WebKit.
     OpenURL(url, Referrer(), info.defaultPolicy,
-            info.replacesCurrentHistoryItem);
+            info.replacesCurrentHistoryItem, false);
     return blink::WebNavigationPolicyIgnore;
   }
 
   // PlzNavigate: if the navigation is not synchronous, send it to the browser.
   // This includes navigations with no request being sent to the network stack.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation) &&
       info.urlRequest.checkForBrowserSideNavigation() &&
       ShouldMakeNetworkRequestForURL(url)) {
     BeginNavigation(&info.urlRequest);
@@ skipping 39 matching lines @@
   // Serialize the frame (without recursing into subframes).
   WebPageSerializer::serialize(GetWebFrame(),
                                this,   // WebPageSerializerClient.
                                weburl_links, webstring_paths,
                                local_directory_path.AsUTF16Unsafe());
 }
 
 void RenderFrameImpl::OpenURL(const GURL& url,
                               const Referrer& referrer,
                               WebNavigationPolicy policy,
-                              bool should_replace_current_entry) {
+                              bool should_replace_current_entry,
+                              bool is_history_navigation_in_new_child) {
   FrameHostMsg_OpenURL_Params params;
   params.url = url;
   params.referrer = referrer;
   params.disposition = RenderViewImpl::NavigationPolicyToDisposition(policy);
 
   if (IsBrowserInitiated(pending_navigation_params_.get())) {
     // This is necessary to preserve the should_replace_current_entry value on
     // cross-process redirects, in the event it was set by a previous process.
     //
     // TODO(davidben): Avoid this awkward duplication of state. See comment on
     // NavigationState::should_replace_current_entry().
     params.should_replace_current_entry =
         pending_navigation_params_->common_params.should_replace_current_entry;
   } else {
     params.should_replace_current_entry =
         should_replace_current_entry && render_view_->history_list_length_;
   }
   params.user_gesture = WebUserGestureIndicator::isProcessingUserGesture();
   if (GetContentClient()->renderer()->AllowPopup())
     params.user_gesture = true;
 
   if (policy == blink::WebNavigationPolicyNewBackgroundTab ||
       policy == blink::WebNavigationPolicyNewForegroundTab ||
       policy == blink::WebNavigationPolicyNewWindow ||
       policy == blink::WebNavigationPolicyNewPopup) {
     WebUserGestureIndicator::consumeUserGesture();
   }
 
+  if (is_history_navigation_in_new_child) {
+    DCHECK(SiteIsolationPolicy::UseSubframeNavigationEntries());
+    params.is_history_navigation_in_new_child = true;
+    params.frame_unique_name = frame_->uniqueName().utf8();
+  }
+
   Send(new FrameHostMsg_OpenURL(routing_id_, params));
 }
 
 void RenderFrameImpl::NavigateInternal(
     const CommonNavigationParams& common_params,
     const StartNavigationParams& start_params,
     const RequestNavigationParams& request_params,
     scoped_ptr<StreamOverrideParameters> stream_params) {
   bool browser_side_navigation =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 112 matching lines @@
           // store the relevant frame's WebHistoryItem in the root of the
           // PageState.
           SetPendingNavigationParams(navigation_params.Pass());
           blink::WebHistoryItem history_item = entry->root();
           blink::WebHistoryLoadType load_type =
               request_params.is_same_document_history_load
                   ? blink::WebHistorySameDocumentLoad
                   : blink::WebHistoryDifferentDocumentLoad;
 
           // Navigate the frame directly.
+          // TODO(creis): Use InitialHistoryLoad rather than BackForward for a
+          // history navigation in a newly created subframe.
           WebURLRequest request =
               frame_->requestFromHistoryItem(history_item, cache_policy);
           frame_->load(request, blink::WebFrameLoadType::BackForward,
                        history_item, load_type);
         }
       } else {
         // TODO(clamy): this should be set to the HistoryItem sent by the
         // browser once the HistoryController has moved to the browser.
         // TODO(clamy): distinguish between different document and same document
         // loads.
@@ skipping 604 matching lines @@
       media::ConvertToSwitchOutputDeviceCB(web_callbacks);
   scoped_refptr<media::AudioOutputDevice> device =
       AudioDeviceFactory::NewOutputDevice(routing_id_, 0, sink_id.utf8(),
                                           security_origin);
   media::OutputDeviceStatus status = device->GetDeviceStatus();
   device->Stop();
   callback.Run(status);
 }
 
 }  // namespace content