Move IsStringUTF8/ASCII to base namespace

chrome/browser/internal_auth.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/browser/internal_auth.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/base64.h"
@@ skipping 71 matching lines @@
       tick < kKeyRegenerationHardTicks ||
       tick > kint64max - kKeyRegenerationHardTicks) {
     return 0;
   }
   return tick;
 }
 
 bool IsDomainSane(const std::string& domain) {
   return !domain.empty() &&
       domain.size() <= kStringLengthLimit &&
-      IsStringUTF8(domain) &&
+      base::IsStringUTF8(domain) &&
       domain.find_first_of(kItemSeparator) == std::string::npos;
 }
 
 bool IsVarSane(const std::string& var) {
   static const char kAllowedChars[] =
       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
       "abcdefghijklmnopqrstuvwxyz"
       "0123456789"
       "_";
   COMPILE_ASSERT(
       sizeof(kAllowedChars) == 26 + 26 + 10 + 1 + 1, some_mess_with_chars);
   // We must not allow kItemSeparator in anything used as an input to construct
   // message to sign.
   DCHECK(std::find(kAllowedChars, kAllowedChars + arraysize(kAllowedChars),
       kItemSeparator) == kAllowedChars + arraysize(kAllowedChars));
   DCHECK(std::find(kAllowedChars, kAllowedChars + arraysize(kAllowedChars),
       kVarValueSeparator) == kAllowedChars + arraysize(kAllowedChars));
   return !var.empty() &&
       var.size() <= kStringLengthLimit &&
-      IsStringASCII(var) &&
+      base::IsStringASCII(var) &&
       var.find_first_not_of(kAllowedChars) == std::string::npos &&
       !IsAsciiDigit(var[0]);
 }
 
 bool IsValueSane(const std::string& value) {
   return value.size() <= kStringLengthLimit &&
-      IsStringUTF8(value) &&
+      base::IsStringUTF8(value) &&
       value.find_first_of(kItemSeparator) == std::string::npos;
 }
 
 bool IsVarValueMapSane(const VarValueMap& map) {
   if (map.size() > kVarsLimit)
     return false;
   for (VarValueMap::const_iterator it = map.begin(); it != map.end(); ++it) {
     const std::string& var = it->first;
     const std::string& value = it->second;
     if (!IsVarSane(var) || !IsValueSane(value))
@@ skipping 128 matching lines @@
   static int get_verification_window_ticks() {
     return InternalAuthVerification::get_verification_window_ticks();
   }
 
   // Returns tick bound to given passport on success or zero on failure.
   int64 PreVerifyPassport(
     const std::string& passport,
     const std::string& domain,
     int64 current_tick) {
     if (passport.size() != kPassportSize ||
-        !IsStringASCII(passport) ||
+        !base::IsStringASCII(passport) ||
         !IsDomainSane(domain) ||
         current_tick <= dark_tick_ ||
         current_tick > key_change_tick_  + kKeyRegenerationHardTicks ||
         key_.empty() ||
         engine_ == NULL) {
       return 0;
     }
 
     // Passport consists of 2 parts: first hmac and then tick.
     std::string tick_decimal =
@@ skipping 186 matching lines @@
     const std::string& domain, const VarValueMap& var_value_map) {
   return g_generation_service.Get().GeneratePassport(domain, var_value_map, 0);
 }
 
 // static
 void InternalAuthGeneration::GenerateNewKey() {
   g_generation_service.Get().GenerateNewKey();
 }
 
 }  // namespace chrome