Browser test for LoadDataWithBaseURL reload

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 289 matching lines @@
   ds->redirectChain(urls);
   result->reserve(urls.size());
   for (size_t i = 0; i < urls.size(); ++i) {
     if (urls[i] != GURL(kSwappedOutURL))
       result->push_back(urls[i]);
     else
       result->push_back(blank_url);
   }
 }
 
+// Gets URL that should override the default getter for this data source
+// (if any), storing it in |output|. Returns true if there is an override URL.
+bool MaybeGetOverriddenURL(WebDataSource* ds, GURL* output) {
+  DocumentState* document_state = DocumentState::FromDataSource(ds);
+
+  // If load was from a data URL, then the saved data URL, not the history
+  // URL, should be the URL of the data source.
+  if (document_state->was_load_data_with_base_url_request()) {
+    *output = document_state->data_url();
+    return true;
+  }
+
+  // WebDataSource has unreachable URL means that the frame is loaded through
+  // blink::WebFrame::loadData(), and the base URL will be in the redirect
+  // chain. However, we never visited the baseURL. So in this case, we should
+  // use the unreachable URL as the original URL.
+  if (ds->hasUnreachableURL()) {
+    *output = ds->unreachableURL();
+    return true;
+  }
+
+  return false;
+}
+
 // Returns the original request url. If there is no redirect, the original
 // url is the same as ds->request()->url(). If the WebDataSource belongs to a
 // frame was loaded by loadData, the original url will be ds->unreachableURL()
 GURL GetOriginalRequestURL(WebDataSource* ds) {
-  // WebDataSource has unreachable URL means that the frame is loaded through
-  // blink::WebFrame::loadData(), and the base URL will be in the redirect
-  // chain. However, we never visited the baseURL. So in this case, we should
-  // use the unreachable URL as the original URL.
-  if (ds->hasUnreachableURL())
-    return ds->unreachableURL();
+  GURL overriden_url;
+  if (MaybeGetOverriddenURL(ds, &overriden_url))
+    return overriden_url;
 
   std::vector<GURL> redirects;
   GetRedirectChain(ds, &redirects);
   if (!redirects.empty())
     return redirects.at(0);
 
   return ds->originalRequest().url();
 }
 
 bool IsBrowserInitiated(NavigationParams* pending) {
@@ skipping 4503 matching lines @@
 
   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))) {
-      LoadDataURL(common_params, frame_);
+      LoadDataURL(common_params, frame_, load_type);
     } 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 219 matching lines @@
       MakeCommonNavigationParams(request, should_replace_current_entry),
       BeginNavigationParams(
           request->httpMethod().latin1(), GetWebURLRequestHeaders(*request),
           GetLoadFlagsForWebURLRequest(*request), request->hasUserGesture(),
           request->skipServiceWorker(),
           GetRequestContextTypeForWebURLRequest(*request)),
       GetRequestBodyForWebURLRequest(*request)));
 }
 
 void RenderFrameImpl::LoadDataURL(const CommonNavigationParams& params,
-                                  WebFrame* frame) {
+                                  WebFrame* frame,
+                                  blink::WebFrameLoadType load_type) {
   // 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;
+    bool replace = load_type == blink::WebFrameLoadType::ReloadFromOrigin ||
+                   load_type == blink::WebFrameLoadType::Reload;
     frame->loadData(
         WebData(data.c_str(), data.length()),
         WebString::fromUTF8(mime_type),
         WebString::fromUTF8(charset),
         base_url,
+        // Needed so that history-url-only changes don't become reloads.
         params.history_url_for_data_url,
-        false);
+        replace);
   } else {
     CHECK(false) << "Invalid URL passed: "
                  << params.url.possibly_invalid_spec();
   }
 }
 
 void RenderFrameImpl::SendUpdateState() {
   DCHECK(SiteIsolationPolicy::UseSubframeNavigationEntries());
   if (current_history_item_.isNull())
     return;
@@ skipping 43 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();
+
+  GURL overriden_url;
+  if (MaybeGetOverriddenURL(ds, &overriden_url))
+    return overriden_url;
 
   const WebURLRequest& request = ds->request();
   return request.url();
 }
 
 void RenderFrameImpl::PopulateDocumentStateFromPending(
     DocumentState* document_state) {
   document_state->set_request_time(
       pending_navigation_params_->request_params.request_time);
 
@@ skipping 46 matching lines @@
 
 void RenderFrameImpl::UpdateNavigationState(DocumentState* document_state) {
   if (pending_navigation_params_) {
     // If this is a browser-initiated load that doesn't override
     // navigation_start, set it here.
     if (pending_navigation_params_->common_params.navigation_start.is_null()) {
       pending_navigation_params_->common_params.navigation_start =
           base::TimeTicks::Now();
     }
     document_state->set_navigation_state(CreateNavigationStateFromPending());
+
+    const CommonNavigationParams& common_params =
+        pending_navigation_params_->common_params;
+    bool load_data = !common_params.base_url_for_data_url.is_empty() &&
+                     !common_params.history_url_for_data_url.is_empty() &&
+                     common_params.url.SchemeIs(url::kDataScheme);
+    document_state->set_was_load_data_with_base_url_request(load_data);
+    if (load_data)
+      document_state->set_data_url(common_params.url);
+
     pending_navigation_params_.reset();
   } else {
     document_state->set_navigation_state(
         NavigationStateImpl::CreateContentInitiated());
   }
 }
 
 #if defined(OS_ANDROID)
 WebMediaPlayer* RenderFrameImpl::CreateAndroidWebMediaPlayer(
     WebMediaPlayerClient* client,
@@ skipping 133 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