Send net's ReferrerPolicy back to Blink while following redirects

content/child/web_url_loader_impl.cc

 // Copyright 2014 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/child/web_url_loader_impl.h"
 
 #include <openssl/ssl.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 140 matching lines @@
     case WebURLRequest::PriorityVeryLow:
       return net::IDLE;
 
     case WebURLRequest::PriorityUnresolved:
     default:
       NOTREACHED();
       return net::LOW;
   }
 }
 
+blink::WebReferrerPolicy NetReferrerPolicyToBlinkReferrerPolicy(
+    net::URLRequest::ReferrerPolicy net_policy) {
+  switch (net_policy) {
+    case net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
+      return blink::WebReferrerPolicyNoReferrerWhenDowngrade;
+    case net::URLRequest::
+        REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN:
+      return blink::
+          WebReferrerPolicyNoReferrerWhenDowngradeOriginWhenCrossOrigin;
+    case net::URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN:
+      return blink::WebReferrerPolicyOriginWhenCrossOrigin;
+    case net::URLRequest::NEVER_CLEAR_REFERRER:
+      return blink::WebReferrerPolicyAlways;
+    case net::URLRequest::ORIGIN:
+      return blink::WebReferrerPolicyOrigin;
+    case net::URLRequest::NO_REFERRER:
+      return blink::WebReferrerPolicyNever;
+    case net::URLRequest::MAX_REFERRER_POLICY:
+      NOTREACHED();
+      return blink::WebReferrerPolicyDefault;
+  }
+  NOTREACHED();
+  return blink::WebReferrerPolicyDefault;
+}
+
 // Extracts info from a data scheme URL |url| into |info| and |data|. Returns
 // net::OK if successful. Returns a net error code otherwise.
 int GetInfoFromDataURL(const GURL& url,
                        ResourceResponseInfo* info,
                        std::string* data) {
   // Assure same time for all time fields of data: URLs.
   Time now = Time::Now();
   info->load_timing.request_start = TimeTicks::Now();
   info->load_timing.request_start_time = now;
   info->request_time = now;
@@ skipping 205 matching lines @@
   void CancelBodyStreaming();
   // We can optimize the handling of data URLs in most cases.
   bool CanHandleDataURLRequestLocally() const;
   void HandleDataURL();
 
   WebURLLoaderImpl* loader_;
   WebURLRequest request_;
   WebURLLoaderClient* client_;
   ResourceDispatcher* resource_dispatcher_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  WebReferrerPolicy referrer_policy_;
   std::unique_ptr<FtpDirectoryListingResponseDelegate> ftp_listing_delegate_;
   std::unique_ptr<StreamOverrideParameters> stream_override_;
   std::unique_ptr<SharedMemoryDataConsumerHandle::Writer> body_stream_writer_;
   enum DeferState {NOT_DEFERRING, SHOULD_DEFER, DEFERRED_DATA};
   DeferState defers_loading_;
   int request_id_;
 
   mojom::URLLoaderFactory* url_loader_factory_;
 };
 
@@ skipping 25 matching lines @@
 
 // WebURLLoaderImpl::Context --------------------------------------------------
 
 WebURLLoaderImpl::Context::Context(WebURLLoaderImpl* loader,
                                    ResourceDispatcher* resource_dispatcher,
                                    mojom::URLLoaderFactory* url_loader_factory)
     : loader_(loader),
       client_(NULL),
       resource_dispatcher_(resource_dispatcher),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      referrer_policy_(blink::WebReferrerPolicyDefault),
       defers_loading_(NOT_DEFERRING),
       request_id_(-1),
       url_loader_factory_(url_loader_factory) {}
 
 void WebURLLoaderImpl::Context::Cancel() {
   TRACE_EVENT_WITH_FLOW0("loading", "WebURLLoaderImpl::Context::Cancel", this,
                          TRACE_EVENT_FLAG_FLOW_IN);
   if (resource_dispatcher_ && // NULL in unittest.
       request_id_ != -1) {
     resource_dispatcher_->Cancel(request_id_);
@@ skipping 82 matching lines @@
   //             Check credentials flag is set when credentials mode is include.
 
   std::unique_ptr<ResourceRequest> resource_request(new ResourceRequest);
 
   resource_request->method = method;
   resource_request->url = url;
   resource_request->first_party_for_cookies = request.firstPartyForCookies();
   resource_request->request_initiator = request.requestorOrigin();
   resource_request->referrer = referrer_url;
 
-  referrer_policy_ = request.referrerPolicy();
-  resource_request->referrer_policy = referrer_policy_;
+  resource_request->referrer_policy = request.referrerPolicy();
 
   resource_request->headers = GetWebURLRequestHeaders(request);
   resource_request->load_flags = GetLoadFlagsForWebURLRequest(request);
   // origin_pid only needs to be non-zero if the request originates outside
   // the render process, so we can use requestorProcessID even for requests
   // from in-process plugins.
   resource_request->origin_pid = request.requestorProcessID();
   resource_request->resource_type = WebURLRequestToResourceType(request);
   resource_request->priority =
       ConvertWebKitPriorityToNetPriority(request.getPriority());
@@ skipping 83 matching lines @@
   TRACE_EVENT_WITH_FLOW0(
       "loading", "WebURLLoaderImpl::Context::OnReceivedRedirect",
       this, TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
 
   WebURLResponse response;
   PopulateURLResponse(request_.url(), info, &response,
                       request_.reportRawHeaders());
 
   WebURLRequest new_request;
   PopulateURLRequestForRedirect(
-      request_, redirect_info, referrer_policy_,
+      request_, redirect_info,
       info.was_fetched_via_service_worker
           ? blink::WebURLRequest::SkipServiceWorker::None
           : blink::WebURLRequest::SkipServiceWorker::All,
       &new_request);
 
   client_->willFollowRedirect(loader_, new_request, response);
   request_ = new_request;
 
   // Only follow the redirect if WebKit left the URL unmodified.
   if (redirect_info.new_url == GURL(new_request.url())) {
@@ skipping 483 matching lines @@
   std::string name;
   while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
     response->addHTTPHeaderField(WebString::fromLatin1(name),
                                  WebString::fromLatin1(value));
   }
 }
 
 void WebURLLoaderImpl::PopulateURLRequestForRedirect(
     const blink::WebURLRequest& request,
     const net::RedirectInfo& redirect_info,
-    blink::WebReferrerPolicy referrer_policy,
     blink::WebURLRequest::SkipServiceWorker skip_service_worker,
     blink::WebURLRequest* new_request) {
   // TODO(darin): We lack sufficient information to construct the actual
   // request that resulted from the redirect.
   new_request->setURL(redirect_info.new_url);
   new_request->setFirstPartyForCookies(
       redirect_info.new_first_party_for_cookies);
   new_request->setDownloadToFile(request.downloadToFile());
   new_request->setUseStreamOnResponse(request.useStreamOnResponse());
   new_request->setRequestContext(request.getRequestContext());
   new_request->setFrameType(request.getFrameType());
   new_request->setSkipServiceWorker(skip_service_worker);
   new_request->setShouldResetAppCache(request.shouldResetAppCache());
   new_request->setFetchRequestMode(request.getFetchRequestMode());
   new_request->setFetchCredentialsMode(request.getFetchCredentialsMode());
 
   new_request->setHTTPReferrer(WebString::fromUTF8(redirect_info.new_referrer),
-                              referrer_policy);
+                               NetReferrerPolicyToBlinkReferrerPolicy(
+                                   redirect_info.new_referrer_policy));
   new_request->setPriority(request.getPriority());
 
   std::string old_method = request.httpMethod().utf8();
   new_request->setHTTPMethod(WebString::fromUTF8(redirect_info.new_method));
   if (redirect_info.new_method == old_method)
     new_request->setHTTPBody(request.httpBody());
 }
 
 void WebURLLoaderImpl::loadSynchronously(const WebURLRequest& request,
                                          WebURLResponse& response,
@@ skipping 96 matching lines @@
     response->clearHTTPHeaderField(webStringName);
     while (response_headers->EnumerateHeader(&iterator, name, &value)) {
       response->addHTTPHeaderField(webStringName,
                                    WebString::fromLatin1(value));
     }
   }
   return true;
 }
 
 }  // namespace content