Preserving Content-Type header from http request in OpenURL path.

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 <utility>
 #include <vector>
@@ skipping 3053 matching lines @@
                                         blink::WebNavigationPolicy policy,
                                         const blink::WebString& suggested_name,
                                         bool should_replace_current_entry) {
   Referrer referrer(RenderViewImpl::GetReferrerFromRequest(frame_, request));
   if (policy == blink::WebNavigationPolicyDownload) {
     Send(new FrameHostMsg_DownloadUrl(render_view_->GetRoutingID(),
                                       GetRoutingID(), request.url(), referrer,
                                       suggested_name));
   } else {
     OpenURL(request.url(), IsHttpPost(request),
-            GetRequestBodyForWebURLRequest(request), referrer, policy,
+            GetRequestBodyForWebURLRequest(request),
+            GetWebURLRequestHeadersForOpenURLParams(request), referrer, policy,
             should_replace_current_entry, false);
   }
 }
 
 blink::WebHistoryItem RenderFrameImpl::historyItemForNewChildFrame() {
   // OOPIF enabled modes will punt this navigation to the browser in
   // decidePolicyForNavigation.
   if (SiteIsolationPolicy::UseSubframeNavigationEntries())
     return WebHistoryItem();
 
@@ skipping 1892 matching lines @@
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = info.urlRequest.url();
 
   // If the browser is interested, then give it a chance to look at the request.
   if (is_content_initiated && IsTopLevelNavigation(frame_) &&
       render_view_->renderer_preferences_
           .browser_handles_all_top_level_requests) {
     OpenURL(url, IsHttpPost(info.urlRequest),
-            GetRequestBodyForWebURLRequest(info.urlRequest), referrer,
+            GetRequestBodyForWebURLRequest(info.urlRequest),
+            GetWebURLRequestHeadersForOpenURLParams(info.urlRequest), referrer,
             info.defaultPolicy, info.replacesCurrentHistoryItem, false);
     return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
   }
 
   // In OOPIF-enabled modes, back/forward navigations in newly created subframes
   // should be sent to the browser if there is a matching FrameNavigationEntry.
   // If this frame isn't on the list of unique names that have history items,
   // fall back to loading the default url.  (We remove each name as we encounter
   // it, because it will only be used once as the frame is created.)
   if (SiteIsolationPolicy::UseSubframeNavigationEntries() &&
       info.isHistoryNavigationInNewChildFrame && is_content_initiated &&
       frame_->parent() &&
       RenderFrameImpl::FromWebFrame(frame_->parent())
               ->history_subframe_unique_names_.erase(
                   frame_->uniqueName().utf8()) > 0) {
     // Don't do this if |info| also says it is a client redirect, in which case
     // JavaScript on the page is trying to interrupt the history navigation.
     if (!info.isClientRedirect) {
       OpenURL(url, IsHttpPost(info.urlRequest),
-              GetRequestBodyForWebURLRequest(info.urlRequest), referrer,
-              info.defaultPolicy, info.replacesCurrentHistoryItem, true);
+              GetRequestBodyForWebURLRequest(info.urlRequest),
+              GetWebURLRequestHeadersForOpenURLParams(info.urlRequest),
+              referrer, info.defaultPolicy, info.replacesCurrentHistoryItem,
+              true);
       // Suppress the load in Blink but mark the frame as loading.
       return blink::WebNavigationPolicyHandledByClient;
     } else {
       // Client redirects during an initial history load should attempt to
       // cancel the history navigation.  They will create a provisional document
       // loader, causing the history load to be ignored in NavigateInternal, and
       // this IPC will try to cancel any cross-process history load.
       Send(new FrameHostMsg_CancelInitialHistoryLoad(routing_id_));
     }
   }
@@ skipping 39 matching lines @@
     if (!should_fork) {
       // Give the embedder a chance.
       should_fork = GetContentClient()->renderer()->ShouldFork(
           frame_, url, info.urlRequest.httpMethod().utf8(),
           is_initial_navigation, is_redirect, &send_referrer);
     }
 
     if (should_fork) {
       OpenURL(url, IsHttpPost(info.urlRequest),
               GetRequestBodyForWebURLRequest(info.urlRequest),
+              GetWebURLRequestHeadersForOpenURLParams(info.urlRequest),
               send_referrer ? referrer : Referrer(), info.defaultPolicy,
               info.replacesCurrentHistoryItem, false);
       return blink::WebNavigationPolicyIgnore;  // Suppress the load here.
     }
   }
 
   // Detect when a page is "forking" a new tab that can be safely rendered in
   // its own process.  This is done by sites like Gmail that try to open links
   // in new windows without script connections back to the original page.  We
   // treat such cases as browser navigations (in which we will create a new
@@ skipping 21 matching lines @@
       // Must not have issued the request from this page.
       is_content_initiated &&
       // Must be targeted at the current tab.
       info.defaultPolicy == blink::WebNavigationPolicyCurrentTab &&
       // Must be a JavaScript navigation, which appears as "other".
       info.navigationType == blink::WebNavigationTypeOther;
 
   if (is_fork) {
     // Open the URL via the browser, not via WebKit.
     OpenURL(url, IsHttpPost(info.urlRequest),
-            GetRequestBodyForWebURLRequest(info.urlRequest), Referrer(),
-            info.defaultPolicy, info.replacesCurrentHistoryItem, false);
+            GetRequestBodyForWebURLRequest(info.urlRequest),
+            GetWebURLRequestHeadersForOpenURLParams(info.urlRequest),
+            Referrer(), info.defaultPolicy, info.replacesCurrentHistoryItem,
+            false);
     return blink::WebNavigationPolicyIgnore;
   }
 
   bool should_dispatch_before_unload =
       info.defaultPolicy == blink::WebNavigationPolicyCurrentTab &&
       // There is no need to execute the BeforeUnload event during a redirect,
       // since it was already executed at the start of the navigation.
       !is_redirect &&
       // PlzNavigate: this should not be executed when commiting the navigation.
       (!IsBrowserSideNavigationEnabled() ||
@@ skipping 300 matching lines @@
   external_popup_menu_->DidSelectItems(canceled, selected_indices);
   external_popup_menu_.reset();
 }
 #endif
 #endif
 
 void RenderFrameImpl::OpenURL(
     const GURL& url,
     bool uses_post,
     const scoped_refptr<ResourceRequestBodyImpl>& resource_request_body,
+    const std::string& extra_headers,
     const Referrer& referrer,
     WebNavigationPolicy policy,
     bool should_replace_current_entry,
     bool is_history_navigation_in_new_child) {
   FrameHostMsg_OpenURL_Params params;
   params.url = url;
   params.uses_post = uses_post;
   params.resource_request_body = resource_request_body;
+  params.extra_headers = extra_headers;
   params.referrer = referrer;
   params.disposition = RenderViewImpl::NavigationPolicyToDisposition(policy);
 
   if (IsBrowserInitiated(pending_navigation_params_.get())) {
     // This is necessary to preserve the should_replace_current_entry value on
     // cross-process redirects, in the event it was set by a previous process.
     WebDataSource* ds = frame_->provisionalDataSource();
     DCHECK(ds);
     params.should_replace_current_entry = ds->replacesCurrentHistoryItem();
   } else {
@@ skipping 476 matching lines @@
   DCHECK(GetFetchRedirectModeForWebURLRequest(info.urlRequest) ==
          FetchRedirectMode::MANUAL_MODE);
   DCHECK(frame_->parent() ||
          GetRequestContextFrameTypeForWebURLRequest(info.urlRequest) ==
              REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL);
   DCHECK(!frame_->parent() ||
          GetRequestContextFrameTypeForWebURLRequest(info.urlRequest) ==
              REQUEST_CONTEXT_FRAME_TYPE_NESTED);
 
   Send(new FrameHostMsg_BeginNavigation(
-      routing_id_,
-      MakeCommonNavigationParams(info),
+      routing_id_, MakeCommonNavigationParams(info),
       BeginNavigationParams(
-          GetWebURLRequestHeaders(info.urlRequest),
+          GetWebURLRequestHeadersForResourceRequest(info.urlRequest),
           GetLoadFlagsForWebURLRequest(info.urlRequest),
           info.urlRequest.hasUserGesture(),
           info.urlRequest.skipServiceWorker() !=
               blink::WebURLRequest::SkipServiceWorker::None,
           GetRequestContextTypeForWebURLRequest(info.urlRequest))));
 }
 
 void RenderFrameImpl::LoadDataURL(
     const CommonNavigationParams& params,
     const RequestNavigationParams& request_params,
@@ skipping 485 matching lines @@
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets
   // the event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |pepper_last_mouse_event_target_|.
   pepper_last_mouse_event_target_ = nullptr;
 #endif
 }
 
 }  // namespace content