data_with_base_url

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 4808 matching lines @@
     CHECK_EQ(request_params.page_id, -1);
 
     should_load_request = true;
   }
 
   if (should_load_request) {
     // Sanitize navigation start now that we know the load_type.
     pending_navigation_params_->common_params.navigation_start =
         SanitizeNavigationTiming(load_type, common_params.navigation_start,
                                  renderer_navigation_start);
-    // Perform a navigation to a data url if needed.
-    if (!common_params.base_url_for_data_url.is_empty() ||
-        (browser_side_navigation &&
-         common_params.url.SchemeIs(url::kDataScheme))) {
+    if (!common_params.data_url_with_base_url.is_empty()) {
+      LoadDataWithBaseURL(common_params, frame_);
+    } else if (browser_side_navigation &&
+               common_params.url.SchemeIs(url::kDataScheme)) {
+      // Perform a navigation to a data url if needed.
       LoadDataURL(common_params, frame_);
     } else {
       // Load the request.
       frame_->toWebLocalFrame()->load(request, load_type,
                                       item_for_history_navigation);
     }
   }
 
   // In case LoadRequest failed before didCreateDataSource was called.
   pending_navigation_params_.reset();
@@ skipping 224 matching lines @@
           request->skipServiceWorker(),
           GetRequestContextTypeForWebURLRequest(*request)),
       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() ?
-        params.url : params.base_url_for_data_url;
+    const GURL base_url;
+    frame->loadData(WebData(data.c_str(), data.length()),
+                    WebString::fromUTF8(mime_type),
+                    WebString::fromUTF8(charset),
+                    GURL(),  // base_url
+                    GURL(),  // history_url
+                    false);
+  } else {
+    CHECK(false) << "Invalid URL passed: "
+                 << params.url.possibly_invalid_spec();
+  }
+}
+
+void RenderFrameImpl::LoadDataWithBaseURL(const CommonNavigationParams& params,
+                                          WebFrame* frame) {
+  std::string mime_type, charset, data;
+  if (net::DataURL::Parse(params.data_url_with_base_url, &mime_type, &charset,
+                          &data)) {
     frame->loadData(
         WebData(data.c_str(), data.length()),
         WebString::fromUTF8(mime_type),
         WebString::fromUTF8(charset),
-        base_url,
+        params.url,  // base_url
+        // Needed to not identify only changing history url as reload.
         params.history_url_for_data_url,
         false);
   } else {
     CHECK(false) << "Invalid URL passed: "
                  << params.url.possibly_invalid_spec();
   }
 }
 
 void RenderFrameImpl::SendUpdateState() {
   DCHECK(SiteIsolationPolicy::UseSubframeNavigationEntries());
@@ skipping 45 matching lines @@
   if (RenderThreadImpl::current() &&
       RenderThreadImpl::current()->layout_test_mode()) {
     return false;
   }
 
   return true;
 }
 
 GURL RenderFrameImpl::GetLoadingUrl() const {
   WebDataSource* ds = frame_->dataSource();
+
   if (ds->hasUnreachableURL())
     return ds->unreachableURL();
 
   const WebURLRequest& request = ds->request();
   return request.url();
 }
 
 void RenderFrameImpl::PopulateDocumentStateFromPending(
     DocumentState* document_state) {
   document_state->set_request_time(
@@ skipping 214 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