Remove legacy StartsWithASCII function.

extensions/common/csp_validator.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 "extensions/common/csp_validator.h"
 
 #include <vector>
 
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 39 matching lines @@
   const char* directive_name;
   bool seen_in_policy;
 };
 
 // Returns whether |url| starts with |scheme_and_separator| and does not have a
 // too permissive wildcard host name. If |should_check_rcd| is true, then the
 // Public suffix list is used to exclude wildcard TLDs such as "https://*.org".
 bool isNonWildcardTLD(const std::string& url,
                       const std::string& scheme_and_separator,
                       bool should_check_rcd) {
-  if (!base::StartsWithASCII(url, scheme_and_separator, true))
+  if (!base::StartsWith(url, scheme_and_separator,
+                        base::CompareCase::SENSITIVE))
     return false;
 
   size_t start_of_host = scheme_and_separator.length();
 
   size_t end_of_host = url.find("/", start_of_host);
   if (end_of_host == std::string::npos)
     end_of_host = url.size();
 
   // Note: It is sufficient to only compare the first character against '*'
   // because the CSP only allows wildcards at the start of a directive, see
@@ skipping 55 matching lines @@
     std::string source = tokenizer->token();
     base::StringToLowerASCII(&source);
     bool is_secure_csp_token = false;
 
     // We might need to relax this whitelist over time.
     if (source == "'self'" || source == "'none'" ||
         source == "http://127.0.0.1" ||
         base::LowerCaseEqualsASCII(source, "blob:") ||
         base::LowerCaseEqualsASCII(source, "filesystem:") ||
         base::LowerCaseEqualsASCII(source, "http://localhost") ||
-        base::StartsWithASCII(source, "http://127.0.0.1:", true) ||
-        base::StartsWithASCII(source, "http://localhost:", true) ||
+        base::StartsWith(source, "http://127.0.0.1:",
+                         base::CompareCase::SENSITIVE) ||
+        base::StartsWith(source, "http://localhost:",
+                         base::CompareCase::SENSITIVE) ||
         isNonWildcardTLD(source, "https://", true) ||
         isNonWildcardTLD(source, "chrome://", false) ||
         isNonWildcardTLD(source, std::string(extensions::kExtensionScheme) +
                                      url::kStandardSchemeSeparator,
                          false) ||
-        base::StartsWithASCII(source, "chrome-extension-resource:", true)) {
+        base::StartsWith(source, "chrome-extension-resource:",
+                         base::CompareCase::SENSITIVE)) {
       is_secure_csp_token = true;
     } else if ((options & OPTIONS_ALLOW_UNSAFE_EVAL) &&
                source == "'unsafe-eval'") {
       is_secure_csp_token = true;
     }
 
     if (is_secure_csp_token) {
       sane_csp_parts->push_back(source);
     } else if (warnings) {
       warnings->push_back(CSPInstallWarning(ErrorUtils::FormatErrorMessage(
@@ skipping 183 matching lines @@
       }
     }
   }
 
   return seen_sandbox;
 }
 
 }  // namespace csp_validator
 
 }  // namespace extensions