Implement new referrer policies

net/url_request/url_request_job.cc

 // Copyright (c) 2012 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 "net/url_request/url_request_job.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 69 matching lines @@
 
   std::string referrer_policy_header;
   request->GetResponseHeaderByName("Referrer-Policy", &referrer_policy_header);
   std::vector<std::string> policy_tokens =
       base::SplitString(referrer_policy_header, ",", base::TRIM_WHITESPACE,
                         base::SPLIT_WANT_NONEMPTY);
 
   UMA_HISTOGRAM_BOOLEAN("Net.URLRequest.ReferrerPolicyHeaderPresentOnRedirect",
                         !policy_tokens.empty());
 
+  // Per https://w3c.github.io/webappsec-referrer-policy/#unknown-policy-values,
+  // use the last recognized policy value, and ignore unknown policies.
   for (const auto& token : policy_tokens) {
     if (base::CompareCaseInsensitiveASCII(token, "no-referrer") == 0) {
       new_policy = URLRequest::NO_REFERRER;
       continue;
     }
 
     if (base::CompareCaseInsensitiveASCII(token,
                                           "no-referrer-when-downgrade") == 0) {
       new_policy =
           URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
       continue;
     }
 
     if (base::CompareCaseInsensitiveASCII(token, "origin") == 0) {
       new_policy = URLRequest::ORIGIN;
       continue;
     }
 
     if (base::CompareCaseInsensitiveASCII(token, "origin-when-cross-origin") ==
         0) {
       new_policy = URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN;
       continue;
     }
 
     if (base::CompareCaseInsensitiveASCII(token, "unsafe-url") == 0) {
       new_policy = URLRequest::NEVER_CLEAR_REFERRER;
       continue;
     }
+
+    if (base::CompareCaseInsensitiveASCII(token, "same-origin") == 0) {
+      new_policy = URLRequest::CLEAR_REFERRER_ON_TRANSITION_CROSS_ORIGIN;
+      continue;
+    }
+
+    if (base::CompareCaseInsensitiveASCII(token, "strict-origin") == 0) {
+      new_policy =
+          URLRequest::ORIGIN_CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
+      continue;
+    }
+
+    if (base::CompareCaseInsensitiveASCII(
+            token, "strict-origin-when-cross-origin") == 0) {
+      new_policy =
+          URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN;
+      continue;
+    }
   }
   return new_policy;
 }
 
 }  // namespace
 
 // Each SourceStreams own the previous SourceStream in the chain, but the
 // ultimate source is URLRequestJob, which has other ownership semantics, so
 // this class is a proxy for URLRequestJob that is owned by the first stream
 // (in dataflow order).
@@ skipping 227 matching lines @@
 }
 
 void URLRequestJob::NotifyURLRequestDestroyed() {
 }
 
 void URLRequestJob::GetConnectionAttempts(ConnectionAttempts* out) const {
   out->clear();
 }
 
 // static
-GURL URLRequestJob::ComputeReferrerForRedirect(
-    URLRequest::ReferrerPolicy policy,
-    const GURL& original_referrer,
-    const GURL& redirect_destination) {
+GURL URLRequestJob::ComputeReferrerForPolicy(URLRequest::ReferrerPolicy policy,
+                                             const GURL& original_referrer,
+                                             const GURL& destination) {
   bool secure_referrer_but_insecure_destination =
       original_referrer.SchemeIsCryptographic() &&
-      !redirect_destination.SchemeIsCryptographic();
+      !destination.SchemeIsCryptographic();
   url::Origin referrer_origin(original_referrer);
-  bool same_origin =
-      referrer_origin.IsSameOriginWith(url::Origin(redirect_destination));
+  bool same_origin = referrer_origin.IsSameOriginWith(url::Origin(destination));
   switch (policy) {
     case URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
       return secure_referrer_but_insecure_destination ? GURL()
                                                       : original_referrer;
 
     case URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN:
       if (same_origin) {
         return original_referrer;
       } else if (secure_referrer_but_insecure_destination) {
         return GURL();
       } else {
         return referrer_origin.GetURL();
       }
 
     case URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN:
       return same_origin ? original_referrer : referrer_origin.GetURL();
 
     case URLRequest::NEVER_CLEAR_REFERRER:
       return original_referrer;
     case URLRequest::ORIGIN:
       return referrer_origin.GetURL();
+    case URLRequest::CLEAR_REFERRER_ON_TRANSITION_CROSS_ORIGIN:
+      if (same_origin)
+        return original_referrer;
+      return GURL();
+    case URLRequest::ORIGIN_CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
+      if (secure_referrer_but_insecure_destination)
+        return GURL();
+      return referrer_origin.GetURL();
     case URLRequest::NO_REFERRER:
       return GURL();
     case URLRequest::MAX_REFERRER_POLICY:
       NOTREACHED();
       return GURL();
   }
 
   NOTREACHED();
   return GURL();
 }
@@ skipping 426 matching lines @@
   } else {
     redirect_info.new_first_party_for_cookies =
         request_->first_party_for_cookies();
   }
 
   redirect_info.new_referrer_policy =
       ProcessReferrerPolicyHeaderOnRedirect(request_);
 
   // Alter the referrer if redirecting cross-origin (especially HTTP->HTTPS).
   redirect_info.new_referrer =
-      ComputeReferrerForRedirect(redirect_info.new_referrer_policy,
-                                 GURL(request_->referrer()),
-                                 redirect_info.new_url)
+      ComputeReferrerForPolicy(redirect_info.new_referrer_policy,
+                               GURL(request_->referrer()),
+                               redirect_info.new_url)
           .spec();
 
   std::string include_referer;
   request_->GetResponseHeaderByName("include-referred-token-binding-id",
                                     &include_referer);
   include_referer = base::ToLowerASCII(include_referer);
   if (include_referer == "true" &&
       request_->ssl_info().token_binding_negotiated) {
     redirect_info.referred_token_binding_host = url.host();
   }
@@ skipping 18 matching lines @@
   int64_t total_sent_bytes = GetTotalSentBytes();
   DCHECK_GE(total_sent_bytes, last_notified_total_sent_bytes_);
   if (total_sent_bytes > last_notified_total_sent_bytes_) {
     network_delegate_->NotifyNetworkBytesSent(
         request_, total_sent_bytes - last_notified_total_sent_bytes_);
   }
   last_notified_total_sent_bytes_ = total_sent_bytes;
 }
 
 }  // namespace net