PlzNavigate: Support data urls

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 1073 matching lines @@
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(params.page_id, -1);
     scoped_ptr<HistoryEntry> entry =
         PageStateToHistoryEntry(params.commit_params.page_state);
     if (entry) {
       // Ensure we didn't save the swapped out URL in UpdateState, since the
       // browser should never be telling us to navigate to swappedout://.
       CHECK(entry->root().urlString() != WebString::fromUTF8(kSwappedOutURL));
       render_view_->history_controller()->GoToEntry(entry.Pass(), cache_policy);
     }
-  } else if (!params.base_url_for_data_url.is_empty()) {
-    // A loadData request with a specified base URL.
-    std::string mime_type, charset, data;
-    if (net::DataURL::Parse(
-            params.common_params.url, &mime_type, &charset, &data)) {
-      frame->loadData(
-          WebData(data.c_str(), data.length()),
-          WebString::fromUTF8(mime_type),
-          WebString::fromUTF8(charset),
-          params.base_url_for_data_url,
-          params.history_url_for_data_url,
-          false);
-    } else {
-      CHECK(false) << "Invalid URL passed: "
-                   << params.common_params.url.possibly_invalid_spec();
-    }
+  } else if (!params.common_params.base_url_for_data_url.is_empty()) {
+    LoadDataURL(params.common_params, frame);
   } else {
     // Navigate to the given URL.
     WebURLRequest request =
         CreateURLRequestForNavigation(params.common_params,
                                       scoped_ptr<StreamOverrideParameters>(),
                                       frame->isViewSourceModeEnabled());
 
     if (!params.extra_headers.empty()) {
       for (net::HttpUtil::HeadersIterator i(params.extra_headers.begin(),
                                             params.extra_headers.end(),
@@ skipping 2756 matching lines @@
       WebURLRequest::UseProtocolCachePolicy;
   if (!RenderFrameImpl::PrepareRenderViewForNavigation(
       common_params.url, false /* check_for_stale_navigation */,
       is_history_navigation, -1 /* current_history_list_offset; TODO(clamy)*/,
       &is_reload, &cache_policy)) {
     return;
   }
 
   GetContentClient()->SetActiveURL(common_params.url);
 
+  if (!common_params.base_url_for_data_url.is_empty() ||
+      common_params.url.SchemeIs(url::kDataScheme)) {

[carlosk, 2015/02/17 12:35:09]

Shouldn't this be a call to ShouldMakeNetworkRequestForNavigation?

[clamy, 2015/02/17 12:54:28]

The goal is for ShouldMakeNetworkRequestForNavigation to be extended to also
cover the same document navigation case (where we should not be making a network
request). Here we specifically only handle data urls.

[carlosk, 2015/02/17 14:11:23]

Acknowledged.

+    LoadDataURL(common_params, frame_);
+    return;
+  }
+
   // Create a WebURLRequest that blink can use to get access to the body of the
   // response through a stream in the browser. Blink will then commit the
   // navigation.
   // TODO(clamy): Have the navigation commit directly, without going through
   // loading a WebURLRequest.
   scoped_ptr<StreamOverrideParameters> stream_override(
       new StreamOverrideParameters());
   stream_override->stream_url = stream_url;
   stream_override->response = response;
   WebURLRequest request =
@@ skipping 231 matching lines @@
   if (is_fork) {
     // Open the URL via the browser, not via WebKit.
     OpenURL(info.frame, url, Referrer(), info.defaultPolicy);
     return blink::WebNavigationPolicyIgnore;
   }
 
   // PlzNavigate: send the request to the browser if needed.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableBrowserSideNavigation) &&
       info.urlRequest.checkForBrowserSideNavigation()) {
-    BeginNavigation(&info.urlRequest);
-    return blink::WebNavigationPolicyIgnore;
+    if (BeginNavigation(&info.urlRequest))
+      return blink::WebNavigationPolicyIgnore;

[Charlie Reis, 2015/02/18 00:43:25]

What if we're navigating a RemoteFrame and it needs to be pulled back in
process?  I'm not sure we can skip the browser process on all data URL
navigations.

[clamy, 2015/02/20 17:05:59]

Done.

   }
 
   return info.defaultPolicy;
 }
 
 void RenderFrameImpl::OpenURL(WebFrame* frame,
                               const GURL& url,
                               const Referrer& referrer,
                               WebNavigationPolicy policy) {
   DCHECK_EQ(frame_, frame);
@@ skipping 191 matching lines @@
   // We refresh timezone when a view is swapped in since timezone
   // can get out of sync when the system timezone is updated while
   // the view is swapped out.
   RenderThreadImpl::NotifyTimezoneChange();
 
   render_view_->SetSwappedOut(false);
   is_swapped_out_ = false;
   return true;
 }
 
-void RenderFrameImpl::BeginNavigation(blink::WebURLRequest* request) {
+bool RenderFrameImpl::BeginNavigation(blink::WebURLRequest* request) {
   CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableBrowserSideNavigation));
   DCHECK(request);
   // TODO(clamy): Execute the beforeunload event.
 
   // Note: At this stage, the goal is to apply all the modifications the
   // renderer wants to make to the request, and then send it to the browser, so
   // that the actual network request can be started. Ideally, all such
   // modifications should take place in willSendRequest, and in the
   // implementation of willSendRequest for the various InspectorAgents
   // (devtools).
   //
   // TODO(clamy): Apply devtools override.
   // TODO(clamy): Make sure that navigation requests are not modified somewhere
   // else in blink.
   willSendRequest(frame_, 0, *request, blink::WebURLResponse());
 
   // TODO(clamy): Same-document navigations should not be sent back to the
   // browser.
   // TODO(clamy): Data urls should not be sent back to the browser either.
   Send(new FrameHostMsg_DidStartLoading(routing_id_, true));
   Send(new FrameHostMsg_BeginNavigation(
         routing_id_, MakeCommonNavigationParams(request),
         BeginNavigationParams(request->httpMethod().latin1(),
                               GetWebURLRequestHeaders(*request),
                               GetLoadFlagsForWebURLRequest(*request),
                               request->hasUserGesture()),
         GetRequestBodyForWebURLRequest(*request)));
+  return ShouldMakeNetworkRequestForNavigation(request->url());
+}
+
+void RenderFrameImpl::LoadDataURL(const CommonNavigationParams& params,
+                                  WebFrame* frame) {
+  // A loadData request with a specified base URL.
+  std::string mime_type, charset, data;
+  if (net::DataURL::Parse(params.url, &mime_type, &charset, &data)) {
+    const GURL base_url = params.base_url_for_data_url.is_empty() ?
+        params.url : params.base_url_for_data_url;
+    frame->loadData(
+        WebData(data.c_str(), data.length()),
+        WebString::fromUTF8(mime_type),
+        WebString::fromUTF8(charset),
+        base_url,
+        params.history_url_for_data_url,
+        false);
+  } else {
+    CHECK(false) << "Invalid URL passed: "
+                 << params.url.possibly_invalid_spec();
+  }
 }
 
 GURL RenderFrameImpl::GetLoadingUrl() const {
   WebDataSource* ds = frame_->dataSource();
   if (ds->hasUnreachableURL())
     return ds->unreachableURL();
 
   const WebURLRequest& request = ds->request();
   return request.url();
 }
@@ skipping 53 matching lines @@
 
 #if defined(ENABLE_BROWSER_CDMS)
 RendererCdmManager* RenderFrameImpl::GetCdmManager() {
   if (!cdm_manager_)
     cdm_manager_ = new RendererCdmManager(this);
   return cdm_manager_;
 }
 #endif  // defined(ENABLE_BROWSER_CDMS)
 
 }  // namespace content