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.

[Charlie Reis, 2015/11/24 00:22:59]

nit: Add: "(if any), storing it in |output|."

[boliu, 2015/11/24 19:03:25]

Done.

+// Return true if there is an override URL.

[Charlie Reis, 2015/11/24 00:22:59]

nit: Returns
(to be consistent with "Gets")

[boliu, 2015/11/24 19:03:25]

Done.

+bool MaybeGetURLOverride(WebDataSource* ds, GURL* output) {

[Charlie Reis, 2015/11/24 00:22:59]

nit: MaybeGetOverriddenURL

[boliu, 2015/11/24 19:03:25]

Done.

+  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 (MaybeGetURLOverride(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 2277 matching lines @@
   }
 
   DocumentState* document_state = DocumentState::FromDataSource(datasource);
   if (!document_state) {
     document_state = new DocumentState;
     datasource->setExtraData(document_state);
     if (!content_initiated)
       PopulateDocumentStateFromPending(document_state);
   }
 
-  // Carry over the user agent override flag, if it exists.
+  // The rest of RenderView assumes that a WebDataSource will always have a
+  // non-null NavigationState.
+  UpdateNavigationState(document_state);
+
+  // Carry over the user agent override flag and data URL if necessary.
   blink::WebView* webview = render_view_->webview();
   if (content_initiated && webview && webview->mainFrame() &&
       webview->mainFrame()->isWebLocalFrame() &&
       webview->mainFrame()->dataSource()) {
     DocumentState* old_document_state =
         DocumentState::FromDataSource(webview->mainFrame()->dataSource());
     if (old_document_state) {
       InternalDocumentStateData* internal_data =
           InternalDocumentStateData::FromDocumentState(document_state);
       InternalDocumentStateData* old_internal_data =
           InternalDocumentStateData::FromDocumentState(old_document_state);
       internal_data->set_is_overriding_user_agent(
           old_internal_data->is_overriding_user_agent());
+
+      document_state->set_was_load_data_with_base_url_request(

[Charlie Reis, 2015/11/24 00:22:59]

Looking closer, I'm skeptical about this call.  Won't this apply to link clicks
to different (non-data) pages?  It makes sense to carry over the user agent
override in that case, but we would no longer be on a data URL.

What's the case this was needed for?  We should set it correctly for
browser-initiated navigations in UpdateNavigationState (given your change
below).  Is this for the in-page renderer-initiated case?

If so, maybe we should copy the URL over in didNavigateWithinPage instead? 
(That might also clear the way for using NavigateState instead of
DocumentState?)

[boliu, 2015/11/24 19:03:25]

Err, this is not needed afaict. in-page navigations don't create new
DocumentState.

I think I was copying originally copying the set_is_overriding_user_agent
pattern, and didn't really know what I was doing :p

[Charlie Reis, 2015/11/24 19:32:38]

Great, I'm glad it's not needed.

+          old_document_state->was_load_data_with_base_url_request());
+      document_state->set_data_url(old_document_state->data_url());
     }
   }
 
-  // The rest of RenderView assumes that a WebDataSource will always have a
-  // non-null NavigationState.
-  UpdateNavigationState(document_state);
-
   // DocumentState::referred_by_prefetcher_ is true if we are
   // navigating from a page that used prefetching using a link on that
   // page.  We are early enough in the request process here that we
   // can still see the DocumentState of the previous page and set
   // this value appropriately.
   // TODO(gavinp): catch the important case of navigation in a new
   // renderer process.
   if (webview) {
     if (WebFrame* old_frame = webview->mainFrame()) {
       const WebURLRequest& original_request = datasource->originalRequest();
@@ skipping 2185 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 (MaybeGetURLOverride(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