Move StringToLowerASCII to base namespace

net/base/mime_util.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 <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 749 matching lines @@
 // wildcards.  The plugin mime types could be:
 //      application/x-foo
 //      application/*
 //      application/*+xml
 //      *
 // Also tests mime parameters -- all parameters in the pattern must be present
 // in the tested type for a match to succeed.
 bool MimeUtil::MatchesMimeType(const std::string& mime_type_pattern,
                                const std::string& mime_type) const {
   // Verify caller is passing lowercase strings.
-  DCHECK_EQ(StringToLowerASCII(mime_type_pattern), mime_type_pattern);
-  DCHECK_EQ(StringToLowerASCII(mime_type), mime_type);
+  DCHECK_EQ(base::StringToLowerASCII(mime_type_pattern), mime_type_pattern);
+  DCHECK_EQ(base::StringToLowerASCII(mime_type), mime_type);
 
   if (mime_type_pattern.empty())
     return false;
 
   std::string::size_type semicolon = mime_type_pattern.find(';');
   const std::string base_pattern(mime_type_pattern.substr(0, semicolon));
   semicolon = mime_type.find(';');
   const std::string base_type(mime_type.substr(0, semicolon));
 
   if (base_pattern == "*" || base_pattern == "*/*")
@@ skipping 49 matching lines @@
     return false;
 
   if (top_level_type)
     *top_level_type = components[0];
   if (subtype)
     *subtype = components[1];
   return true;
 }
 
 bool MimeUtil::IsValidTopLevelMimeType(const std::string& type_string) const {
-  std::string lower_type = StringToLowerASCII(type_string);
+  std::string lower_type = base::StringToLowerASCII(type_string);
   for (size_t i = 0; i < arraysize(legal_top_level_types); ++i) {
     if (lower_type.compare(legal_top_level_types[i]) == 0)
       return true;
   }
 
   return type_string.size() > 2 && StartsWithASCII(type_string, "x-", false);
 }
 
 bool MimeUtil::AreSupportedMediaCodecs(
     const std::vector<std::string>& codecs) const {
@@ skipping 411 matching lines @@
     (*target)[old_target_size + i] = *iter;
 }
 }
 
 void GetExtensionsForMimeType(
     const std::string& unsafe_mime_type,
     std::vector<base::FilePath::StringType>* extensions) {
   if (unsafe_mime_type == "*/*" || unsafe_mime_type == "*")
     return;
 
-  const std::string mime_type = StringToLowerASCII(unsafe_mime_type);
+  const std::string mime_type = base::StringToLowerASCII(unsafe_mime_type);
   base::hash_set<base::FilePath::StringType> unique_extensions;
 
   if (EndsWith(mime_type, "/*", true)) {
     std::string leading_mime_type = mime_type.substr(0, mime_type.length() - 1);
 
     // Find the matching StandardType from within kStandardTypes, or fall
     // through to the last (default) StandardType.
     const StandardType* type = NULL;
     for (size_t i = 0; i < arraysize(kStandardTypes); ++i) {
       type = &(kStandardTypes[i]);
@@ skipping 75 matching lines @@
   post_data->append("\r\n" + value + "\r\n");
 }
 
 void AddMultipartFinalDelimiterForUpload(const std::string& mime_boundary,
                                          std::string* post_data) {
   DCHECK(post_data);
   post_data->append("--" + mime_boundary + "--\r\n");
 }
 
 }  // namespace net