Move StringToLowerASCII to base namespace

net/base/sdch_manager.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 "net/base/sdch_manager.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 251 matching lines @@
 }
 
 // static
 void SdchManager::EnableSecureSchemeSupport(bool enabled) {
   g_secure_scheme_supported_ = enabled;
 }
 
 void SdchManager::BlacklistDomain(const GURL& url) {
   SetAllowLatencyExperiment(url, false);
 
-  std::string domain(StringToLowerASCII(url.host()));
+  std::string domain(base::StringToLowerASCII(url.host()));
   int count = blacklisted_domains_[domain];
   if (count > 0)
     return;  // Domain is already blacklisted.
 
   count = 1 + 2 * exponential_blacklist_count_[domain];
   if (count > 0)
     exponential_blacklist_count_[domain] = count;
   else
     count = INT_MAX;
 
   blacklisted_domains_[domain] = count;
 }
 
 void SdchManager::BlacklistDomainForever(const GURL& url) {
   SetAllowLatencyExperiment(url, false);
 
-  std::string domain(StringToLowerASCII(url.host()));
+  std::string domain(base::StringToLowerASCII(url.host()));
   exponential_blacklist_count_[domain] = INT_MAX;
   blacklisted_domains_[domain] = INT_MAX;
 }
 
 void SdchManager::ClearBlacklistings() {
   blacklisted_domains_.clear();
   exponential_blacklist_count_.clear();
 }
 
 void SdchManager::ClearDomainBlacklisting(const std::string& domain) {
-  blacklisted_domains_.erase(StringToLowerASCII(domain));
+  blacklisted_domains_.erase(base::StringToLowerASCII(domain));
 }
 
 int SdchManager::BlackListDomainCount(const std::string& domain) {
   if (blacklisted_domains_.end() == blacklisted_domains_.find(domain))
     return 0;
-  return blacklisted_domains_[StringToLowerASCII(domain)];
+  return blacklisted_domains_[base::StringToLowerASCII(domain)];
 }
 
 int SdchManager::BlacklistDomainExponential(const std::string& domain) {
   if (exponential_blacklist_count_.end() ==
       exponential_blacklist_count_.find(domain))
     return 0;
-  return exponential_blacklist_count_[StringToLowerASCII(domain)];
+  return exponential_blacklist_count_[base::StringToLowerASCII(domain)];
 }
 
 bool SdchManager::IsInSupportedDomain(const GURL& url) {
   DCHECK(CalledOnValidThread());
   if (!g_sdch_enabled_ )
     return false;
 
   if (!secure_scheme_supported() && url.SchemeIsSecure())
     return false;
 
   if (blacklisted_domains_.empty())
     return true;
 
-  std::string domain(StringToLowerASCII(url.host()));
+  std::string domain(base::StringToLowerASCII(url.host()));
   DomainCounter::iterator it = blacklisted_domains_.find(domain);
   if (blacklisted_domains_.end() == it)
     return true;
 
   int count = it->second - 1;
   if (count > 0)
     blacklisted_domains_[domain] = count;
   else
     blacklisted_domains_.erase(domain);
   SdchErrorRecovery(DOMAIN_BLACKLIST_INCLUDES_TARGET);
@@ skipping 82 matching lines @@
     if (colon_index > line_end)
       break;
 
     size_t value_start = dictionary_text.find_first_not_of(" \t",
                                                            colon_index + 1);
     if (std::string::npos != value_start) {
       if (value_start >= line_end)
         break;
       std::string name(dictionary_text, line_start, colon_index - line_start);
       std::string value(dictionary_text, value_start, line_end - value_start);
-      name = StringToLowerASCII(name);
+      name = base::StringToLowerASCII(name);
       if (name == "domain") {
         domain = value;
       } else if (name == "path") {
         path = value;
       } else if (name == "format-version") {
         if (value != "1.0")
           return false;
       } else if (name == "max-age") {
         int64 seconds;
         base::StringToInt64(value, &seconds);
@@ skipping 132 matching lines @@
       case '/':
         (*output)[i] = '_';
         continue;
       default:
         continue;
     }
   }
 }
 
 }  // namespace net