Convert remaining StringToLowerASCII to ToLowerASCII

extensions/common/message_bundle.cc

 // Copyright 2014 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 "extensions/common/message_bundle.h"
 
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 58 matching lines @@
 
 bool MessageBundle::Init(const CatalogVector& locale_catalogs,
                          std::string* error) {
   dictionary_.clear();
 
   for (CatalogVector::const_reverse_iterator it = locale_catalogs.rbegin();
        it != locale_catalogs.rend(); ++it) {
     base::DictionaryValue* catalog = (*it).get();
     for (base::DictionaryValue::Iterator message_it(*catalog);
          !message_it.IsAtEnd(); message_it.Advance()) {
-      std::string key(base::StringToLowerASCII(message_it.key()));
+      std::string key(base::ToLowerASCII(message_it.key()));
       if (!IsValidName(message_it.key()))
         return BadKeyMessage(key, error);
       std::string value;
       if (!GetMessageValue(message_it.key(), message_it.value(), &value, error))
         return false;
       // Keys are not case-sensitive.
       dictionary_[key] = value;
     }
   }
 
@@ skipping 94 matching lines @@
                                   content_key.c_str(),
                                   name_key.c_str());
       return false;
     }
     std::string content;
     if (!placeholder->GetString(kContentKey, &content)) {
       *error = base::StringPrintf("Invalid \"%s\" element for key %s.",
                                   kContentKey, name_key.c_str());
       return false;
     }
-    (*placeholders)[base::StringToLowerASCII(content_key)] = content;
+    (*placeholders)[base::ToLowerASCII(content_key)] = content;
   }
 
   return true;
 }
 
 bool MessageBundle::ReplacePlaceholders(const SubstitutionMap& placeholders,
                                         std::string* message,
                                         std::string* error) const {
   return ReplaceVariables(placeholders,
                           kPlaceholderBegin,
@@ skipping 28 matching lines @@
   while (true) {
     beg_index = message->find(var_begin_delimiter, beg_index);
     if (beg_index == message->npos)
       return true;
 
     // Advance it immediately to the begining of possible variable name.
     beg_index += var_begin_delimiter_size;
     if (beg_index >= message->size())
       return true;
     std::string::size_type end_index =
-      message->find(var_end_delimiter, beg_index);
+        message->find(var_end_delimiter, beg_index);
     if (end_index == message->npos)
       return true;
 
     // Looking for 1 in substring of ...$1$....
     const std::string& var_name =
       message->substr(beg_index, end_index - beg_index);
     if (!IsValidName(var_name))
       continue;
-    SubstitutionMap::const_iterator it =
-      variables.find(base::StringToLowerASCII(var_name));
+    auto it = variables.find(base::ToLowerASCII(var_name));
     if (it == variables.end()) {
       *error = base::StringPrintf("Variable %s%s%s used but not defined.",
                                   var_begin_delimiter.c_str(),
                                   var_name.c_str(),
                                   var_end_delimiter.c_str());
       return false;
     }
 
     // Replace variable with its value.
     std::string value = it->second;
@@ skipping 27 matching lines @@
 
 // Dictionary interface.
 
 std::string MessageBundle::GetL10nMessage(const std::string& name) const {
   return GetL10nMessage(name, dictionary_);
 }
 
 // static
 std::string MessageBundle::GetL10nMessage(const std::string& name,
                                           const SubstitutionMap& dictionary) {
-  SubstitutionMap::const_iterator it =
-      dictionary.find(base::StringToLowerASCII(name));
+  auto it = dictionary.find(base::ToLowerASCII(name));
   if (it != dictionary.end()) {
     return it->second;
   }
 
   return std::string();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // Renderer helper functions.
@@ skipping 27 matching lines @@
     return &(it->second);
 
   return NULL;
 }
 
 void EraseL10nMessagesMap(const std::string& extension_id) {
   g_extension_to_messages_map.Get().messages_map.erase(extension_id);
 }
 
 }  // namespace extensions