Move LowerCaseEqualsASCII to base namespace

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 110 matching lines @@
                               int options,
                               std::vector<std::string>* sane_csp_parts,
                               std::vector<InstallWarning>* warnings) {
   sane_csp_parts->push_back(directive_name);
   while (tokenizer->GetNext()) {
     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'" ||
+    if (source == "'self'" || source == "'none'" ||
         source == "http://127.0.0.1" ||
-        LowerCaseEqualsASCII(source, "blob:") ||
-        LowerCaseEqualsASCII(source, "filesystem:") ||
-        LowerCaseEqualsASCII(source, "http://localhost") ||
+        base::LowerCaseEqualsASCII(source, "blob:") ||
+        base::LowerCaseEqualsASCII(source, "filesystem:") ||
+        base::LowerCaseEqualsASCII(source, "http://localhost") ||
         StartsWithASCII(source, "http://127.0.0.1:", true) ||
         StartsWithASCII(source, "http://localhost:", true) ||
         isNonWildcardTLD(source, "https://", true) ||
         isNonWildcardTLD(source, "chrome://", false) ||
-        isNonWildcardTLD(source,
-                         std::string(extensions::kExtensionScheme) +
-                         url::kStandardSchemeSeparator,
+        isNonWildcardTLD(source, std::string(extensions::kExtensionScheme) +
+                                     url::kStandardSchemeSeparator,
                          false) ||
         StartsWithASCII(source, "chrome-extension-resource:", true)) {
       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);
@@ skipping 48 matching lines @@
     int options,
     const std::vector<std::string>& directives) {
   if (!(options & OPTIONS_ALLOW_INSECURE_OBJECT_SRC))
     return false;
 
   for (size_t i = 0; i < directives.size(); ++i) {
     const std::string& input = directives[i];
     base::StringTokenizer tokenizer(input, " \t\r\n");
     if (!tokenizer.GetNext())
       continue;
-    if (!LowerCaseEqualsASCII(tokenizer.token(), kPluginTypes))
+    if (!base::LowerCaseEqualsASCII(tokenizer.token(), kPluginTypes))
       continue;
     while (tokenizer.GetNext()) {
       if (!PluginTypeAllowed(tokenizer.token()))
         return false;
     }
     // All listed plugin types are whitelisted.
     return true;
   }
   // plugin-types not specified.
   return false;
@@ skipping 116 matching lines @@
       }
     }
   }
 
   return seen_sandbox;
 }
 
 }  // namespace csp_validator
 
 }  // namespace extensions