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

content/common/content_security_policy/csp_context.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 "content/common/content_security_policy/csp_context.h"
 
 namespace content {
 
 namespace {
 
 // Helper function that returns true if |policy| should be checked under
 // |check_csp_disposition|.
 bool ShouldCheckPolicy(const ContentSecurityPolicy& policy,
                        CSPContext::CheckCSPDisposition check_csp_disposition) {
   switch (check_csp_disposition) {
     case CSPContext::CHECK_REPORT_ONLY_CSP:
       return policy.header.type == blink::kWebContentSecurityPolicyTypeReport;
     case CSPContext::CHECK_ENFORCED_CSP:
       return policy.header.type == blink::kWebContentSecurityPolicyTypeEnforce;
     case CSPContext::CHECK_ALL_CSP:
       return true;
   }
   NOTREACHED();
   return true;
 }
 
 }  // namespace
 
-CSPContext::CSPContext() : has_self_(false) {}
-
+CSPContext::CSPContext() {}
 CSPContext::~CSPContext() {}
 
 bool CSPContext::IsAllowedByCsp(CSPDirective::Name directive_name,
                                 const GURL& url,
                                 bool is_redirect,
                                 const SourceLocation& source_location,
                                 CheckCSPDisposition check_csp_disposition) {
   if (SchemeShouldBypassCSP(url.scheme_piece()))
     return true;
 
@@ skipping 21 matching lines @@
       if (url.port() == "80")
         replacements.SetPortStr("443");
       *new_url = new_url->ReplaceComponents(replacements);
       return true;
     }
   }
   return false;
 }
 
 void CSPContext::SetSelf(const url::Origin origin) {
-  if (origin.unique()) {
-    // TODO(arthursonzogni): Decide what to do with unique origins.
-    has_self_ = false;
+  self_source_.reset();
+
+  // When the origin is unique, no URL should match with 'self'. That's why
+  // |self_source_| stays undefined here.
+  if (origin.unique())
     return;
-  }
 
   if (origin.scheme() == url::kFileScheme) {
-    has_self_ = true;
-    self_scheme_ = url::kFileScheme;
     self_source_ = CSPSource(url::kFileScheme, "", false, url::PORT_UNSPECIFIED,
                              false, "");
     return;
   }
 
-  has_self_ = true;
-  self_scheme_ = origin.scheme();
   self_source_ = CSPSource(
       origin.scheme(), origin.host(), false,
-      origin.port() == 0 ? url::PORT_UNSPECIFIED : origin.port(),  // port
-      false, "");
-}
+      origin.port() == 0 ? url::PORT_UNSPECIFIED : origin.port(), false, "");
 
-bool CSPContext::AllowSelf(const GURL& url) {
-  return has_self_ && CSPSource::Allow(self_source_, url, this);
-}
-
-bool CSPContext::ProtocolIsSelf(const GURL& url) {
-  if (!has_self_)
-    return false;
-  return url.SchemeIs(self_scheme_);
-}
-
-const std::string& CSPContext::GetSelfScheme() {
-  return self_scheme_;
+  DCHECK_NE("", self_source_->scheme);
 }
 
 bool CSPContext::SchemeShouldBypassCSP(const base::StringPiece& scheme) {
   return false;
 }
 
 void CSPContext::SanitizeDataForUseInCspViolation(
     bool is_redirect,
     CSPDirective::Name directive,
     GURL* blocked_url,
     SourceLocation* source_location) const {
   return;
 }
 
-bool CSPContext::SelfSchemeShouldBypassCsp() {
-  if (!has_self_)
-    return false;
-  return SchemeShouldBypassCSP(self_scheme_);
-}
-
 void CSPContext::ReportContentSecurityPolicyViolation(
     const CSPViolationParams& violation_params) {
   return;
 }
 
 CSPViolationParams::CSPViolationParams() = default;
 
 CSPViolationParams::CSPViolationParams(
     const std::string& directive,
     const std::string& effective_directive,
@@ skipping 13 matching lines @@
       disposition(disposition),
       after_redirect(after_redirect),
       source_location(source_location) {}
 
 CSPViolationParams::CSPViolationParams(const CSPViolationParams& other) =
     default;
 
 CSPViolationParams::~CSPViolationParams() {}
 
 }  // namespace content