CSP, PlzNavigate: make clear what happens with unique origins.

content/common/content_security_policy/csp_source.cc

 // Copyright 2017 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 <sstream>
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/content_security_policy/csp_context.h"
 #include "url/url_canon.h"
@@ skipping 19 matching lines @@
   NotMatching,
   MatchingWildcard,
   MatchingUpgrade,
   MatchingExact
 };
 enum class SchemeMatchingResult { NotMatching, MatchingUpgrade, MatchingExact };
 
 SchemeMatchingResult SourceAllowScheme(const CSPSource& source,
                                        const GURL& url,
                                        CSPContext* context) {
-  const std::string& source_scheme =
-      source.scheme.empty() ? context->GetSelfScheme() : source.scheme;
+  // The source doesn't specify a scheme and the current origin is unique. In
+  // this case, the url doesn't match regardless of its scheme.
+  if (source.scheme.empty() && !context->self_source())
+    return SchemeMatchingResult::NotMatching;
 
-  if (source_scheme.empty()) {
-    if (context->ProtocolIsSelf(url))
-      return SchemeMatchingResult::MatchingExact;
-    return SchemeMatchingResult::NotMatching;
-  }
+  // |allowed_scheme| is guaranteed to be non-empty.
+  const std::string& allowed_scheme =
+      source.scheme.empty() ? context->self_source()->scheme : source.scheme;
 
-  if (url.SchemeIs(source_scheme))
+  if (url.SchemeIs(allowed_scheme))
     return SchemeMatchingResult::MatchingExact;
 
-  if ((source_scheme == url::kHttpScheme && url.SchemeIs(url::kHttpsScheme)) ||
-      (source_scheme == url::kHttpScheme &&
+  // Implicitly allow using a more secure version of a protocol when the
+  // non-secure one is allowed.
+  if ((allowed_scheme == url::kHttpScheme && url.SchemeIs(url::kHttpsScheme)) ||
+      (allowed_scheme == url::kHttpScheme &&
        url.SchemeIs(url::kHttpsSuboriginScheme)) ||
-      (source_scheme == url::kWsScheme && url.SchemeIs(url::kWssScheme))) {
+      (allowed_scheme == url::kWsScheme && url.SchemeIs(url::kWssScheme))) {
     return SchemeMatchingResult::MatchingUpgrade;
   }
-
-  if ((source_scheme == url::kHttpScheme &&
+  if ((allowed_scheme == url::kHttpScheme &&
        url.SchemeIs(url::kHttpSuboriginScheme)) ||
-      (source_scheme == url::kHttpsScheme &&
+      (allowed_scheme == url::kHttpsScheme &&
        url.SchemeIs(url::kHttpsSuboriginScheme))) {
     return SchemeMatchingResult::MatchingExact;
   }
 
   return SchemeMatchingResult::NotMatching;
 }
 
 bool SourceAllowHost(const CSPSource& source, const GURL& url) {
   if (source.is_host_wildcard) {
     if (source.host.empty())
@@ skipping 170 matching lines @@
 
 bool CSPSource::HasHost() const {
   return !host.empty() || is_host_wildcard;
 }
 
 bool CSPSource::HasPath() const {
   return !path.empty();
 }
 
 }  // namespace content