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 199 matching lines @@
 using base::TimeDelta;
 
 namespace content {
 
 namespace {
 
 const char kDefaultAcceptHeader[] =
     "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/"
     "*;q=0.8";
 const char kAcceptHeader[] = "Accept";
+const char kHtmlMimeType[] = "text/html";
 
 const size_t kExtraCharsBeforeAndAfterSelection = 100;
 
 typedef std::map<int, RenderFrameImpl*> RoutingIDFrameMap;
 static base::LazyInstance<RoutingIDFrameMap> g_routing_id_frame_map =
     LAZY_INSTANCE_INITIALIZER;
 
 typedef std::map<blink::WebFrame*, RenderFrameImpl*> FrameMap;
 base::LazyInstance<FrameMap> g_frame_map = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 855 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 2761 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)) {

[Charlie Reis, 2015/02/26 20:49:01]

This case passes data URLs without base_url_data_urls to LoadDataURL, which
would fail the new CHECK.

[clamy, 2015/02/27 12:53:59]

I removed the CHECK.

+    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)) {
+    CHECK(mime_type != kHtmlMimeType ||
+          !params.base_url_for_data_url.is_empty());

[Charlie Reis, 2015/02/26 20:49:01]

I don't understand why this would be true.  It's possible to navigate to data
URLs without specifying base_url_for_data_url.

If this function doesn't handle that case, can you elaborate in the comment
above to say where data URLs without base URLs are handled?

[clamy, 2015/02/27 12:53:59]

I removed the CHECK. It was introduced because the current logic only calls
LoadDataURL when there is a base_url_for_data_url, and the last one may be
important for html data. Note that trying to do a browser-initiated navigation
to a data url currently does not seem to work in content shell.

+    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();
 }
 
 #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