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 1074 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 2754 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)) {
+    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 475 matching lines @@
   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)));
 }
 
+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() ?

[Charlie Reis, 2015/02/20 22:11:50]

We didn't have this case before (i.e., passing a data: URL without having
base_url_for_data_url), so I'm not sure whether the loadData method expects
params.url or an empty URL.  I assume you've verified this is the right thing to
pass?

[clamy, 2015/02/26 15:28:36]

We cannot pass an empty URL here as this will cause the subsequent
ResourceRequest in Blink to have an empty url (and fail checks). Since it seems
that the base url is used for security purposes when the data mime type is html,
I added a CHECK for that.

+        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();
 }
 
 #if defined(OS_ANDROID)
@@ skipping 51 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