Move string tokenizer to base/strings.

chrome/common/extensions/csp_validator.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 "chrome/common/extensions/csp_validator.h"
 
 #include "base/string_split.h"
-#include "base/string_tokenizer.h"
 #include "base/string_util.h"
+#include "base/strings/string_tokenizer.h"
 
 namespace extensions {
 
 namespace csp_validator {
 
 namespace {
 
 const char kDefaultSrc[] = "default-src";
 const char kScriptSrc[] = "script-src";
 const char kObjectSrc[] = "object-src";
 
 const char kSandboxDirectiveName[] = "sandbox";
 const char kAllowSameOriginToken[] = "allow-same-origin";
 const char kAllowTopNavigation[] = "allow-top-navigation";
 const char kAllowPopups[] = "allow-popups";
 
 struct DirectiveStatus {
   explicit DirectiveStatus(const char* name)
     : directive_name(name)
     , seen_in_policy(false)
     , is_secure(false) {
   }
 
   const char* directive_name;
   bool seen_in_policy;
   bool is_secure;
 };
 
-bool HasOnlySecureTokens(StringTokenizer& tokenizer, Manifest::Type type) {
+bool HasOnlySecureTokens(base::StringTokenizer& tokenizer,
+                         Manifest::Type type) {
   while (tokenizer.GetNext()) {
     std::string source = tokenizer.token();
     StringToLowerASCII(&source);
 
     // Don't alow whitelisting of all hosts. This boils down to:
     //   1. Maximum of 2 '*' characters.
     //   2. Each '*' is either followed by a '.' or preceded by a ':'
     int wildcards = 0;
     size_t length = source.length();
     for (size_t i = 0; i < length; ++i) {
@@ skipping 33 matching lines @@
     }
 
     return false;
   }
 
   return true;  // Empty values default to 'none', which is secure.
 }
 
 // Returns true if |directive_name| matches |status.directive_name|.
 bool UpdateStatus(const std::string& directive_name,
-                  StringTokenizer& tokenizer,
+                  base::StringTokenizer& tokenizer,
                   DirectiveStatus* status,
                   Manifest::Type type) {
   if (status->seen_in_policy)
     return false;
   if (directive_name != status->directive_name)
     return false;
   status->seen_in_policy = true;
   status->is_secure = HasOnlySecureTokens(tokenizer, type);
   return true;
 }
@@ skipping 14 matching lines @@
   // See http://www.w3.org/TR/CSP/#parse-a-csp-policy for parsing algorithm.
   std::vector<std::string> directives;
   base::SplitString(policy, ';', &directives);
 
   DirectiveStatus default_src_status(kDefaultSrc);
   DirectiveStatus script_src_status(kScriptSrc);
   DirectiveStatus object_src_status(kObjectSrc);
 
   for (size_t i = 0; i < directives.size(); ++i) {
     std::string& input = directives[i];
-    StringTokenizer tokenizer(input, " \t\r\n");
+    base::StringTokenizer tokenizer(input, " \t\r\n");
     if (!tokenizer.GetNext())
       continue;
 
     std::string directive_name = tokenizer.token();
     StringToLowerASCII(&directive_name);
 
     if (UpdateStatus(directive_name, tokenizer, &default_src_status, type))
       continue;
     if (UpdateStatus(directive_name, tokenizer, &script_src_status, type))
       continue;
@@ skipping 19 matching lines @@
 bool ContentSecurityPolicyIsSandboxed(
     const std::string& policy, Manifest::Type type) {
   // See http://www.w3.org/TR/CSP/#parse-a-csp-policy for parsing algorithm.
   std::vector<std::string> directives;
   base::SplitString(policy, ';', &directives);
 
   bool seen_sandbox = false;
 
   for (size_t i = 0; i < directives.size(); ++i) {
     std::string& input = directives[i];
-    StringTokenizer tokenizer(input, " \t\r\n");
+    base::StringTokenizer tokenizer(input, " \t\r\n");
     if (!tokenizer.GetNext())
       continue;
 
     std::string directive_name = tokenizer.token();
     StringToLowerASCII(&directive_name);
 
     if (directive_name != kSandboxDirectiveName)
       continue;
 
     seen_sandbox = true;
@@ skipping 13 matching lines @@
       }
     }
   }
 
   return seen_sandbox;
 }
 
 }  // csp_validator
 
 }  // extensions