Convert remaining StringToLowerASCII to ToLowerASCII

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 206 matching lines @@
     base::StringPairs pattern_parameters;
     base::SplitStringIntoKeyValuePairs(mime_type_pattern.substr(semicolon + 1),
                                        '=', ';', &pattern_parameters);
     base::StringPairs test_parameters;
     base::SplitStringIntoKeyValuePairs(mime_type.substr(test_semicolon + 1),
                                        '=', ';', &test_parameters);
 
     // Put the parameters to maps with the keys converted to lower case.
     StringPairMap pattern_parameter_map;
     for (const auto& pair : pattern_parameters) {
-      pattern_parameter_map[base::StringToLowerASCII(pair.first)] = pair.second;
+      pattern_parameter_map[base::ToLowerASCII(pair.first)] = pair.second;
     }
 
     StringPairMap test_parameter_map;
     for (const auto& pair : test_parameters) {
-      test_parameter_map[base::StringToLowerASCII(pair.first)] = pair.second;
+      test_parameter_map[base::ToLowerASCII(pair.first)] = pair.second;
     }
 
     if (pattern_parameter_map.size() > test_parameter_map.size())
       return false;
 
     for (const auto& parameter_pair : pattern_parameter_map) {
       const auto& test_parameter_pair_it =
           test_parameter_map.find(parameter_pair.first);
       if (test_parameter_pair_it == test_parameter_map.end())
         return false;
@@ skipping 77 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 = base::StringToLowerASCII(type_string);
+  std::string lower_type = base::ToLowerASCII(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 &&
          base::StartsWith(type_string, "x-",
                           base::CompareCase::INSENSITIVE_ASCII);
 }
 
@@ skipping 173 matching lines @@
 }
 
 }  // namespace
 
 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 = base::StringToLowerASCII(unsafe_mime_type);
+  const std::string mime_type = base::ToLowerASCII(unsafe_mime_type);
   base::hash_set<base::FilePath::StringType> unique_extensions;
 
   if (base::EndsWith(mime_type, "/*", base::CompareCase::INSENSITIVE_ASCII)) {
     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 45 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