Convert remaining StringToLowerASCII to ToLowerASCII.

Remove StringToLowerASCII. This removes the template and makes a consistent call that can take a string piece.

http_response_headers.cc in HttpResponseHeaders::RemoveHeaderLine there seemed to be a bug where it did
  std::string old_header_name_lowercase(name);
where it actually meant
  std::string old_header_name_lowercase(old_header_name);
I fixed this.

There were a number of cases where url.host() or url.scheme() was passed to ToLowerASCII. These are already guaranteed lower-case, so I removed the call.

There were a number of cases in net that did return ToLowerASCII().c_str() when the return type is a std::string, which is unnecessary and wasteful. I removed the c_str() call.

NOPRESUBMIT=true
(for touching code with wstrings)

Review URL: https://codereview.chromium.org/1282363003

Cr-Commit-Position: refs/heads/master@{#342869}

87 files changed, 171 insertions, 237 deletions

diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index 3ec74a5..b1cdd39 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -303,22 +303,6 @@ BASE_EXPORT bool IsStringASCII(const string16& str);
 BASE_EXPORT bool IsStringASCII(const std::wstring& str);
 #endif
 
-// Converts the elements of the given string.  This version uses a pointer to
-// clearly differentiate it from the non-pointer variant.
-// TODO(brettw) remove this. Callers should use base::ToLowerASCII above.
-template <class str> inline void StringToLowerASCII(str* s) {
-  for (typename str::iterator i = s->begin(); i != s->end(); ++i)
-    *i = ToLowerASCII(*i);
-}
-
-// TODO(brettw) remove this. Callers should use base::ToLowerASCII above.
-template <class str> inline str StringToLowerASCII(const str& s) {
-  // for std::string and std::wstring
-  str output(s);
-  StringToLowerASCII(&output);
-  return output;
-}
-
 // Compare the lower-case form of the given string against the given
 // previously-lower-cased ASCII string (typically a constant).
 BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece str,
diff --git a/components/mime_util/mime_util.cc b/components/mime_util/mime_util.cc
index 6c51a9e..fa7471b 100644
--- a/components/mime_util/mime_util.cc
+++ b/components/mime_util/mime_util.cc
@@ -155,7 +155,7 @@ bool MimeUtil::IsSupportedImageMimeType(const std::string& mime_type) const {
 }
 
 bool MimeUtil::IsSupportedNonImageMimeType(const std::string& mime_type) const {
-  return non_image_types_.find(base::StringToLowerASCII(mime_type)) !=
+  return non_image_types_.find(base::ToLowerASCII(mime_type)) !=
              non_image_types_.end() ||
 #if !defined(OS_IOS)
          media::IsSupportedMediaMimeType(mime_type) ||
@@ -169,7 +169,7 @@ bool MimeUtil::IsSupportedNonImageMimeType(const std::string& mime_type) const {
 }
 
 bool MimeUtil::IsUnsupportedTextMimeType(const std::string& mime_type) const {
-  return unsupported_text_types_.find(base::StringToLowerASCII(mime_type)) !=
+  return unsupported_text_types_.find(base::ToLowerASCII(mime_type)) !=
          unsupported_text_types_.end();
 }
 
diff --git a/components/storage_monitor/portable_device_watcher_win.cc b/components/storage_monitor/portable_device_watcher_win.cc
index 0d2e5a8..b57f80a 100644
--- a/components/storage_monitor/portable_device_watcher_win.cc
+++ b/components/storage_monitor/portable_device_watcher_win.cc
@@ -60,7 +60,7 @@ base::string16 GetPnpDeviceId(LPARAM data) {
     return base::string16();
   base::string16 device_id(dev_interface->dbcc_name);
   DCHECK(base::IsStringASCII(device_id));
-  return base::StringToLowerASCII(device_id);
+  return base::ToLowerASCII(device_id);
 }
 
 // Gets the friendly name of the device specified by the |pnp_device_id|. On
diff --git a/components/update_client/utils.cc b/components/update_client/utils.cc
index 11e8060..2b66050 100644
--- a/components/update_client/utils.cc
+++ b/components/update_client/utils.cc
@@ -188,7 +188,7 @@ bool DeleteFileAndEmptyParentDirectory(const base::FilePath& filepath) {
 std::string GetCrxComponentID(const CrxComponent& component) {
   const size_t kCrxIdSize = 16;
   CHECK_GE(component.pk_hash.size(), kCrxIdSize);
-  return HexStringToID(base::StringToLowerASCII(
+  return HexStringToID(base::ToLowerASCII(
       base::HexEncode(&component.pk_hash[0], kCrxIdSize)));
 }
 
diff --git a/components/url_matcher/regex_set_matcher.cc b/components/url_matcher/regex_set_matcher.cc
index 1b0b7f3..ae994db 100644
--- a/components/url_matcher/regex_set_matcher.cc
+++ b/components/url_matcher/regex_set_matcher.cc
@@ -47,8 +47,7 @@ bool RegexSetMatcher::Match(const std::string& text,
 
   // FilteredRE2 expects lowercase for prefiltering, but we still
   // match case-sensitively.
-  std::vector<RE2ID> atoms(FindSubstringMatches(
-      base::StringToLowerASCII(text)));
+  std::vector<RE2ID> atoms(FindSubstringMatches(base::ToLowerASCII(text)));
 
   std::vector<RE2ID> re2_ids;
   filtered_re2_->AllMatches(text, atoms, &re2_ids);
diff --git a/content/browser/accessibility/browser_accessibility_win.cc b/content/browser/accessibility/browser_accessibility_win.cc
index 57e5e56..b4d0aa5 100644
--- a/content/browser/accessibility/browser_accessibility_win.cc
+++ b/content/browser/accessibility/browser_accessibility_win.cc
@@ -2758,8 +2758,8 @@ STDMETHODIMP BrowserAccessibilityWin::get_computedStyleForProperties(
   // We only cache a single style property for now: DISPLAY
 
   for (unsigned short i = 0; i < num_style_properties; ++i) {
-    base::string16 name = (LPCWSTR)style_properties[i];
-    base::StringToLowerASCII(&name);
+    base::string16 name = base::ToLowerASCII(
+        reinterpret_cast<const base::char16*>(style_properties[i]));
     if (name == L"display") {
       base::string16 display = GetString16Attribute(
           ui::AX_ATTR_DISPLAY);
diff --git a/content/browser/cache_storage/cache_storage.cc b/content/browser/cache_storage/cache_storage.cc
index 71d2c35..f511164 100644
--- a/content/browser/cache_storage/cache_storage.cc
+++ b/content/browser/cache_storage/cache_storage.cc
@@ -338,7 +338,7 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
 
   static std::string HexedHash(const std::string& value) {
     std::string value_hash = base::SHA1HashString(value);
-    std::string valued_hexed_hash = base::StringToLowerASCII(
+    std::string valued_hexed_hash = base::ToLowerASCII(
         base::HexEncode(value_hash.c_str(), value_hash.length()));
     return valued_hexed_hash;
   }
diff --git a/content/browser/cache_storage/cache_storage_manager.cc b/content/browser/cache_storage/cache_storage_manager.cc
index cc13c44..6c0a1a74 100644
--- a/content/browser/cache_storage/cache_storage_manager.cc
+++ b/content/browser/cache_storage/cache_storage_manager.cc
@@ -323,7 +323,7 @@ base::FilePath CacheStorageManager::ConstructLegacyOriginPath(
     const base::FilePath& root_path,
     const GURL& origin) {
   const std::string origin_hash = base::SHA1HashString(origin.spec());
-  const std::string origin_hash_hex = base::StringToLowerASCII(
+  const std::string origin_hash_hex = base::ToLowerASCII(
       base::HexEncode(origin_hash.c_str(), origin_hash.length()));
   return root_path.AppendASCII(origin_hash_hex);
 }
@@ -334,7 +334,7 @@ base::FilePath CacheStorageManager::ConstructOriginPath(
     const GURL& origin) {
   const std::string identifier = storage::GetIdentifierFromOrigin(origin);
   const std::string origin_hash = base::SHA1HashString(identifier);
-  const std::string origin_hash_hex = base::StringToLowerASCII(
+  const std::string origin_hash_hex = base::ToLowerASCII(
       base::HexEncode(origin_hash.c_str(), origin_hash.length()));
   return root_path.AppendASCII(origin_hash_hex);
 }
diff --git a/content/child/browser_font_resource_trusted.cc b/content/child/browser_font_resource_trusted.cc
index a48a1ad..d9ca6d6 100644
--- a/content/child/browser_font_resource_trusted.cc
+++ b/content/child/browser_font_resource_trusted.cc
@@ -201,9 +201,9 @@ WebFontDescription PPFontDescToWebFontDesc(
     // we should use the fixed or regular font size. It's difficult at this
     // level to detect if the requested font is fixed width, so we only apply
     // the alternate font size to the default fixed font family.
-    if (base::StringToLowerASCII(resolved_family) ==
-        base::StringToLowerASCII(GetFontFromMap(prefs.fixed_font_family_map,
-                                                kCommonScript)))
+    if (base::ToLowerASCII(resolved_family) ==
+        base::ToLowerASCII(GetFontFromMap(prefs.fixed_font_family_map,
+                                          kCommonScript)))
       result.size = static_cast<float>(prefs.default_fixed_font_size);
     else
       result.size = static_cast<float>(prefs.default_font_size);
diff --git a/content/child/npapi/npobject_stub.cc b/content/child/npapi/npobject_stub.cc
index fb910d9..367024b 100644
--- a/content/child/npapi/npobject_stub.cc
+++ b/content/child/npapi/npobject_stub.cc
@@ -259,7 +259,7 @@ void NPObjectStub::OnSetProperty(const NPIdentifier_Param& name,
       static base::FilePath plugin_path =
           base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
               switches::kPluginPath);
-      static std::wstring filename = base::StringToLowerASCII(
+      static std::wstring filename = base::ToLowerASCII(
           plugin_path.BaseName().value());
       static NPIdentifier fullscreen =
           WebBindings::getStringIdentifier("fullScreen");
diff --git a/content/child/npapi/plugin_host.cc b/content/child/npapi/plugin_host.cc
index e9cdb4a..ea7d0a0 100644
--- a/content/child/npapi/plugin_host.cc
+++ b/content/child/npapi/plugin_host.cc
@@ -271,7 +271,7 @@ bool PluginHost::SetPostData(const char* buf,
           break;
         case GETVALUE:
           // Got a header.
-          name = base::StringToLowerASCII(std::string(start, ptr - start));
+          name = base::ToLowerASCII(base::StringPiece(start, ptr - start));
           base::TrimWhitespace(name, base::TRIM_ALL, &name);
           start = ptr + 1;
           break;
diff --git a/content/child/npapi/plugin_stream.cc b/content/child/npapi/plugin_stream.cc
index 4066dce..282f69b 100644
--- a/content/child/npapi/plugin_stream.cc
+++ b/content/child/npapi/plugin_stream.cc
@@ -64,7 +64,7 @@ bool PluginStream::Open(const std::string& mime_type,
 
   bool seekable_stream = false;
   if (request_is_seekable) {
-    std::string headers_lc = base::StringToLowerASCII(headers);
+    std::string headers_lc = base::ToLowerASCII(headers);
     if (headers_lc.find("accept-ranges: bytes") != std::string::npos) {
       seekable_stream = true;
     }
diff --git a/content/child/npapi/webplugin_delegate_impl_win.cc b/content/child/npapi/webplugin_delegate_impl_win.cc
index 0249f69..7a8ae8e 100644
--- a/content/child/npapi/webplugin_delegate_impl_win.cc
+++ b/content/child/npapi/webplugin_delegate_impl_win.cc
@@ -248,8 +248,8 @@ WebPluginDelegateImpl::WebPluginDelegateImpl(WebPlugin* plugin,
   memset(&window_, 0, sizeof(window_));
 
   const WebPluginInfo& plugin_info = instance_->plugin_lib()->plugin_info();
-  std::wstring filename =
-      base::StringToLowerASCII(plugin_info.path.BaseName().value());
+  base::string16 filename =
+      base::ToLowerASCII(plugin_info.path.BaseName().value());
 
   if (instance_->mime_type() == kFlashPluginSwfMimeType ||
       filename == kFlashPlugin) {
diff --git a/content/common/plugin_list.cc b/content/common/plugin_list.cc
index 1cc8fa5..c162727 100644
--- a/content/common/plugin_list.cc
+++ b/content/common/plugin_list.cc
@@ -145,7 +145,7 @@ bool PluginList::ParseMimeTypes(
 
   for (size_t i = 0; i < mime_types.size(); ++i) {
     WebPluginMimeType mime_type;
-    mime_type.mime_type = base::StringToLowerASCII(mime_types[i]);
+    mime_type.mime_type = base::ToLowerASCII(mime_types[i]);
     if (file_extensions.size() > i) {
       mime_type.file_extensions = base::SplitString(
           file_extensions[i], ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
@@ -317,7 +317,7 @@ void PluginList::GetPluginInfoArray(
     bool include_npapi,
     std::vector<WebPluginInfo>* info,
     std::vector<std::string>* actual_mime_types) {
-  DCHECK(mime_type == base::StringToLowerASCII(mime_type));
+  DCHECK(mime_type == base::ToLowerASCII(mime_type));
   DCHECK(info);
 
   if (!use_stale)
@@ -353,7 +353,7 @@ void PluginList::GetPluginInfoArray(
   std::string::size_type last_dot = path.rfind('.');
   if (last_dot != std::string::npos && mime_type.empty()) {
     std::string extension =
-        base::StringToLowerASCII(std::string(path, last_dot+1));
+        base::ToLowerASCII(base::StringPiece(path).substr(last_dot + 1));
     std::string actual_mime_type;
     for (size_t i = 0; i < plugins_list_.size(); ++i) {
       if (SupportsExtension(plugins_list_[i], extension, &actual_mime_type)) {
diff --git a/content/common/plugin_list_win.cc b/content/common/plugin_list_win.cc
index 98694a2..4b20953 100644
--- a/content/common/plugin_list_win.cc
+++ b/content/common/plugin_list_win.cc
@@ -395,9 +395,9 @@ bool PluginList::ShouldLoadPluginUsingPluginList(
   if (should_check_version) {
     for (size_t j = 0; j < plugins->size(); ++j) {
       base::FilePath::StringType plugin1 =
-          base::StringToLowerASCII((*plugins)[j].path.BaseName().value());
+          base::ToLowerASCII((*plugins)[j].path.BaseName().value());
       base::FilePath::StringType plugin2 =
-          base::StringToLowerASCII(info.path.BaseName().value());
+          base::ToLowerASCII(info.path.BaseName().value());
       if ((plugin1 == plugin2 && HaveSharedMimeType((*plugins)[j], info)) ||
           (plugin1 == kJavaDeploy1 && plugin2 == kJavaDeploy2) ||
           (plugin1 == kJavaDeploy2 && plugin2 == kJavaDeploy1)) {
@@ -424,7 +424,7 @@ bool PluginList::ShouldLoadPluginUsingPluginList(
 
   // Troublemakers.
   base::FilePath::StringType filename =
-      base::StringToLowerASCII(info.path.BaseName().value());
+      base::ToLowerASCII(info.path.BaseName().value());
   // Depends on XPCOM.
   if (filename == kMozillaActiveXPlugin)
     return false;
diff --git a/content/public/browser/media_device_id.cc b/content/public/browser/media_device_id.cc
index c8e5f23..aefe67a 100644
--- a/content/public/browser/media_device_id.cc
+++ b/content/public/browser/media_device_id.cc
@@ -24,7 +24,7 @@ std::string GetHMACForMediaDeviceID(const ResourceContext::SaltCallback& sc,
   bool result = hmac.Init(security_origin.spec()) &&
       hmac.Sign(raw_unique_id + salt, &digest[0], digest.size());
   DCHECK(result);
-  return base::StringToLowerASCII(base::HexEncode(&digest[0], digest.size()));
+  return base::ToLowerASCII(base::HexEncode(&digest[0], digest.size()));
 }
 
 bool DoesMediaDeviceIDMatchHMAC(const ResourceContext::SaltCallback& sc,
diff --git a/content/renderer/accessibility/blink_ax_tree_source.cc b/content/renderer/accessibility/blink_ax_tree_source.cc
index ee00519..7254ca2 100644
--- a/content/renderer/accessibility/blink_ax_tree_source.cc
+++ b/content/renderer/accessibility/blink_ax_tree_source.cc
@@ -382,10 +382,10 @@ void BlinkAXTreeSource::SerializeNode(blink::WebAXObject src,
     // a WebElement method that returns the original lower cased tagName.
     dst->AddStringAttribute(
         ui::AX_ATTR_HTML_TAG,
-        base::StringToLowerASCII(UTF16ToUTF8(
+        base::ToLowerASCII(UTF16ToUTF8(
             base::StringPiece16(element.tagName()))));
     for (unsigned i = 0; i < element.attributeCount(); ++i) {
-      std::string name = base::StringToLowerASCII(UTF16ToUTF8(
+      std::string name = base::ToLowerASCII(UTF16ToUTF8(
           base::StringPiece16(element.attributeLocalName(i))));
       std::string value =
           UTF16ToUTF8(base::StringPiece16(element.attributeValue(i)));
diff --git a/content/renderer/manifest/manifest_parser.cc b/content/renderer/manifest/manifest_parser.cc
index f496485..f979a42 100644
--- a/content/renderer/manifest/manifest_parser.cc
+++ b/content/renderer/manifest/manifest_parser.cc
@@ -47,7 +47,7 @@ std::vector<gfx::Size> ParseIconSizesHTML(const base::string16& sizes_str16) {
 
   std::vector<gfx::Size> sizes;
   std::string sizes_str =
-      base::StringToLowerASCII(base::UTF16ToUTF8(sizes_str16));
+      base::ToLowerASCII(base::UTF16ToUTF8(sizes_str16));
   std::vector<std::string> sizes_str_list = base::SplitString(
       sizes_str, base::kWhitespaceASCII, base::KEEP_WHITESPACE,
       base::SPLIT_WANT_NONEMPTY);
diff --git a/content/renderer/npapi/webplugin_impl.cc b/content/renderer/npapi/webplugin_impl.cc
index bb42af9..8e8a1e9 100644
--- a/content/renderer/npapi/webplugin_impl.cc
+++ b/content/renderer/npapi/webplugin_impl.cc
@@ -553,11 +553,11 @@ WebPluginImpl::WebPluginImpl(
       first_geometry_update_(true),
       ignore_response_error_(false),
       file_path_(file_path),
-      mime_type_(base::UTF16ToASCII(base::StringPiece16(params.mimeType))),
+      mime_type_(base::ToLowerASCII(base::UTF16ToASCII(
+          base::StringPiece16(params.mimeType)))),
       loader_client_(this),
       weak_factory_(this) {
   DCHECK_EQ(params.attributeNames.size(), params.attributeValues.size());
-  base::StringToLowerASCII(&mime_type_);
 
   for (size_t i = 0; i < params.attributeNames.size(); ++i) {
     arg_names_.push_back(params.attributeNames[i].utf8());
diff --git a/content/shell/browser/shell_content_browser_client.cc b/content/shell/browser/shell_content_browser_client.cc
index ff5503f..433ec23 100644
--- a/content/shell/browser/shell_content_browser_client.cc
+++ b/content/shell/browser/shell_content_browser_client.cc
@@ -183,7 +183,6 @@ ShellContentBrowserClient::CreateRequestContextForStoragePartition(
 bool ShellContentBrowserClient::IsHandledURL(const GURL& url) {
   if (!url.is_valid())
     return false;
-  DCHECK_EQ(url.scheme(), base::StringToLowerASCII(url.scheme()));
   // Keep in sync with ProtocolHandlers added by
   // ShellURLRequestContextGetter::GetURLRequestContext().
   static const char* const kProtocolList[] = {
diff --git a/content/shell/renderer/layout_test/blink_test_runner.cc b/content/shell/renderer/layout_test/blink_test_runner.cc
index 6ff28a8..7e23c03 100644
--- a/content/shell/renderer/layout_test/blink_test_runner.cc
+++ b/content/shell/renderer/layout_test/blink_test_runner.cc
@@ -534,7 +534,7 @@ std::string BlinkTestRunner::PathToLocalResource(const std::string& resource) {
   // Some layout tests use file://// which we resolve as a UNC path. Normalize
   // them to just file:///.
   std::string result = resource;
-  while (base::StringToLowerASCII(result).find("file:////") == 0) {
+  while (base::ToLowerASCII(result).find("file:////") == 0) {
     result = result.substr(0, strlen("file:///")) +
              result.substr(strlen("file:////"));
   }
diff --git a/crypto/symmetric_key_unittest.cc b/crypto/symmetric_key_unittest.cc
index 28e44d2..ef8e7e1 100644
--- a/crypto/symmetric_key_unittest.cc
+++ b/crypto/symmetric_key_unittest.cc
@@ -100,7 +100,7 @@ TEST_P(SymmetricKeyDeriveKeyFromPasswordTest, DeriveKeyFromPassword) {
   key->GetRawKey(&raw_key);
   EXPECT_EQ(test_data.key_size_in_bits / 8, raw_key.size());
   EXPECT_EQ(test_data.expected,
-            base::StringToLowerASCII(base::HexEncode(raw_key.data(),
+            base::ToLowerASCII(base::HexEncode(raw_key.data(),
                                                raw_key.size())));
 }
 
diff --git a/device/core/device_monitor_win.cc b/device/core/device_monitor_win.cc
index 3449c82..eab9e16 100644
--- a/device/core/device_monitor_win.cc
+++ b/device/core/device_monitor_win.cc
@@ -114,7 +114,7 @@ class DeviceMonitorMessageWindow {
 
       std::string device_path(base::SysWideToUTF8(db->dbcc_name));
       DCHECK(base::IsStringASCII(device_path));
-      device_path = base::StringToLowerASCII(device_path);
+      device_path = base::ToLowerASCII(device_path);
 
       if (wparam == DBT_DEVICEARRIVAL) {
         if (device_monitor) {
diff --git a/device/hid/hid_service_win.cc b/device/hid/hid_service_win.cc
index 627cc01..cde47b2 100644
--- a/device/hid/hid_service_win.cc
+++ b/device/hid/hid_service_win.cc
@@ -121,7 +121,7 @@ void HidServiceWin::EnumerateOnFileThread(
           base::SysWideToUTF8(device_interface_detail_data->DevicePath));
       DCHECK(base::IsStringASCII(device_path));
       AddDeviceOnFileThread(service, task_runner,
-                            base::StringToLowerASCII(device_path));
+                            base::ToLowerASCII(device_path));
     }
   }
 
diff --git a/extensions/browser/api/web_request/web_request_api_helpers.cc b/extensions/browser/api/web_request/web_request_api_helpers.cc
index fb6908f..fae5cdc 100644
--- a/extensions/browser/api/web_request/web_request_api_helpers.cc
+++ b/extensions/browser/api/web_request/web_request_api_helpers.cc
@@ -344,14 +344,12 @@ EventResponseDelta* CalculateOnHeadersReceivedDelta(
     std::string name;
     std::string value;
     while (old_response_headers->EnumerateHeaderLines(&iter, &name, &value)) {
-      std::string name_lowercase(name);
-      base::StringToLowerASCII(&name_lowercase);
+      std::string name_lowercase = base::ToLowerASCII(name);
 
       bool header_found = false;
-      for (ResponseHeaders::const_iterator i = new_response_headers->begin();
-           i != new_response_headers->end(); ++i) {
-        if (base::LowerCaseEqualsASCII(i->first, name_lowercase.c_str()) &&
-            value == i->second) {
+      for (const auto& i : *new_response_headers) {
+        if (base::LowerCaseEqualsASCII(i.first, name_lowercase) &&
+            value == i.second) {
           header_found = true;
           break;
         }
@@ -1019,9 +1017,7 @@ void MergeCookiesInOnHeadersReceivedResponses(
 
 // Converts the key of the (key, value) pair to lower case.
 static ResponseHeader ToLowerCase(const ResponseHeader& header) {
-  std::string lower_key(header.first);
-  base::StringToLowerASCII(&lower_key);
-  return ResponseHeader(lower_key, header.second);
+  return ResponseHeader(base::ToLowerASCII(header.first), header.second);
 }
 
 // Returns the extension ID of the first extension in |deltas| that removes the
@@ -1029,14 +1025,11 @@ static ResponseHeader ToLowerCase(const ResponseHeader& header) {
 static std::string FindRemoveResponseHeader(
     const EventResponseDeltas& deltas,
     const std::string& key) {
-  std::string lower_key = base::StringToLowerASCII(key);
-  EventResponseDeltas::const_iterator delta;
-  for (delta = deltas.begin(); delta != deltas.end(); ++delta) {
-    ResponseHeaders::const_iterator i;
-    for (i = (*delta)->deleted_response_headers.begin();
-         i != (*delta)->deleted_response_headers.end(); ++i) {
-      if (base::StringToLowerASCII(i->first) == lower_key)
-        return (*delta)->extension_id;
+  std::string lower_key = base::ToLowerASCII(key);
+  for (const auto& delta : deltas) {
+    for (const auto& deleted_hdr : delta->deleted_response_headers) {
+      if (base::ToLowerASCII(deleted_hdr.first) == lower_key)
+        return delta->extension_id;
     }
   }
   return std::string();
diff --git a/extensions/browser/extension_registry.cc b/extensions/browser/extension_registry.cc
index a7e839d..176bf89 100644
--- a/extensions/browser/extension_registry.cc
+++ b/extensions/browser/extension_registry.cc
@@ -110,7 +110,7 @@ void ExtensionRegistry::TriggerOnUninstalled(const Extension* extension,
 
 const Extension* ExtensionRegistry::GetExtensionById(const std::string& id,
                                                      int include_mask) const {
-  std::string lowercase_id = base::StringToLowerASCII(id);
+  std::string lowercase_id = base::ToLowerASCII(id);
   if (include_mask & ENABLED) {
     const Extension* extension = enabled_extensions_.GetByID(lowercase_id);
     if (extension)
diff --git a/extensions/browser/extension_throttle_manager.cc b/extensions/browser/extension_throttle_manager.cc
index bd92f61..f59b1b3 100644
--- a/extensions/browser/extension_throttle_manager.cc
+++ b/extensions/browser/extension_throttle_manager.cc
@@ -175,7 +175,7 @@ std::string ExtensionThrottleManager::GetIdFromUrl(const GURL& url) const {
     return url.possibly_invalid_spec();
 
   GURL id = url.ReplaceComponents(url_id_replacements_);
-  return base::StringToLowerASCII(id.spec()).c_str();
+  return base::ToLowerASCII(id.spec());
 }
 
 void ExtensionThrottleManager::GarbageCollectEntriesIfNecessary() {
diff --git a/extensions/browser/sandboxed_unpacker.cc b/extensions/browser/sandboxed_unpacker.cc
index 5af7af4..7b27e85 100644
--- a/extensions/browser/sandboxed_unpacker.cc
+++ b/extensions/browser/sandboxed_unpacker.cc
@@ -219,7 +219,7 @@ SandboxedUnpacker::SandboxedUnpacker(
     const scoped_refptr<base::SequencedTaskRunner>& unpacker_io_task_runner,
     SandboxedUnpackerClient* client)
     : crx_path_(file.path),
-      package_hash_(base::StringToLowerASCII(file.expected_hash)),
+      package_hash_(base::ToLowerASCII(file.expected_hash)),
       check_crx_hash_(false),
       client_(client),
       extensions_dir_(extensions_dir),
diff --git a/extensions/browser/verified_contents.cc b/extensions/browser/verified_contents.cc
index d9ff75c2..c467cf9 100644
--- a/extensions/browser/verified_contents.cc
+++ b/extensions/browser/verified_contents.cc
@@ -187,7 +187,7 @@ bool VerifiedContents::InitFrom(const base::FilePath& path,
       base::FilePath file_path =
           base::FilePath::FromUTF8Unsafe(file_path_string);
       RootHashes::iterator i = root_hashes_.insert(std::make_pair(
-          base::StringToLowerASCII(file_path.value()), std::string()));
+          base::ToLowerASCII(file_path.value()), std::string()));
       i->second.swap(root_hash);
     }
 
@@ -198,14 +198,14 @@ bool VerifiedContents::InitFrom(const base::FilePath& path,
 
 bool VerifiedContents::HasTreeHashRoot(
     const base::FilePath& relative_path) const {
-  base::FilePath::StringType path = base::StringToLowerASCII(
+  base::FilePath::StringType path = base::ToLowerASCII(
       relative_path.NormalizePathSeparatorsTo('/').value());
   return root_hashes_.find(path) != root_hashes_.end();
 }
 
 bool VerifiedContents::TreeHashRootEquals(const base::FilePath& relative_path,
                                           const std::string& expected) const {
-  base::FilePath::StringType path = base::StringToLowerASCII(
+  base::FilePath::StringType path = base::ToLowerASCII(
       relative_path.NormalizePathSeparatorsTo('/').value());
   for (RootHashes::const_iterator i = root_hashes_.find(path);
        i != root_hashes_.end();
diff --git a/extensions/common/csp_validator.cc b/extensions/common/csp_validator.cc
index 842fc80..8f9406f 100644
--- a/extensions/common/csp_validator.cc
+++ b/extensions/common/csp_validator.cc
@@ -292,9 +292,7 @@ std::string SanitizeContentSecurityPolicy(
     if (!tokenizer.GetNext())
       continue;
 
-    std::string directive_name = tokenizer.token();
-    base::StringToLowerASCII(&directive_name);
-
+    std::string directive_name = base::ToLowerASCII(tokenizer.token_piece());
     if (UpdateStatus(directive_name, &tokenizer, &default_src_status, options,
                      &sane_csp_parts, &default_src_csp_warnings))
       continue;
@@ -348,17 +346,14 @@ bool ContentSecurityPolicyIsSandboxed(
     if (!tokenizer.GetNext())
       continue;
 
-    std::string directive_name = tokenizer.token();
-    base::StringToLowerASCII(&directive_name);
-
+    std::string directive_name = base::ToLowerASCII(tokenizer.token_piece());
     if (directive_name != kSandboxDirectiveName)
       continue;
 
     seen_sandbox = true;
 
     while (tokenizer.GetNext()) {
-      std::string token = tokenizer.token();
-      base::StringToLowerASCII(&token);
+      std::string token = base::ToLowerASCII(tokenizer.token_piece());
 
       // The same origin token negates the sandboxing.
       if (token == kAllowSameOriginToken)
diff --git a/extensions/common/message_bundle.cc b/extensions/common/message_bundle.cc
index d71513f..2c387e1 100644
--- a/extensions/common/message_bundle.cc
+++ b/extensions/common/message_bundle.cc
@@ -76,7 +76,7 @@ bool MessageBundle::Init(const CatalogVector& locale_catalogs,
     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;
@@ -191,7 +191,7 @@ bool MessageBundle::GetPlaceholders(const base::DictionaryValue& name_tree,
                                   kContentKey, name_key.c_str());
       return false;
     }
-    (*placeholders)[base::StringToLowerASCII(content_key)] = content;
+    (*placeholders)[base::ToLowerASCII(content_key)] = content;
   }
 
   return true;
@@ -240,7 +240,7 @@ bool MessageBundle::ReplaceVariables(const SubstitutionMap& variables,
     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;
 
@@ -249,8 +249,7 @@ bool MessageBundle::ReplaceVariables(const SubstitutionMap& variables,
       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(),
@@ -298,8 +297,7 @@ std::string MessageBundle::GetL10nMessage(const std::string& name) const {
 // 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;
   }
diff --git a/extensions/common/permissions/socket_permission_entry.cc b/extensions/common/permissions/socket_permission_entry.cc
index 86c61de..012eda0 100644
--- a/extensions/common/permissions/socket_permission_entry.cc
+++ b/extensions/common/permissions/socket_permission_entry.cc
@@ -75,7 +75,7 @@ bool SocketPermissionEntry::Check(
   if (pattern_.type != request.type)
     return false;
 
-  std::string lhost = base::StringToLowerASCII(request.host);
+  std::string lhost = base::ToLowerASCII(request.host);
   if (pattern_.host != lhost) {
     if (!match_subdomains_)
       return false;
@@ -166,7 +166,7 @@ bool SocketPermissionEntry::ParseHostPattern(
   if (!result.pattern_.host.empty()) {
     if (StartsOrEndsWithWhitespace(result.pattern_.host))
       return false;
-    result.pattern_.host = base::StringToLowerASCII(result.pattern_.host);
+    result.pattern_.host = base::ToLowerASCII(result.pattern_.host);
 
     // The first component can optionally be '*' to match all subdomains.
     std::vector<std::string> host_components =
diff --git a/google_apis/gaia/gaia_auth_util.cc b/google_apis/gaia/gaia_auth_util.cc
index cc5e17c..caf802f 100644
--- a/google_apis/gaia/gaia_auth_util.cc
+++ b/google_apis/gaia/gaia_auth_util.cc
@@ -35,8 +35,7 @@ std::string CanonicalizeEmailImpl(const std::string& email_address,
       base::RemoveChars(parts[0], ".", &parts[0]);
   }
 
-  std::string new_email = base::StringToLowerASCII(
-      base::JoinString(parts, "@"));
+  std::string new_email = base::ToLowerASCII(base::JoinString(parts, "@"));
   VLOG(1) << "Canonicalized " << email_address << " to " << new_email;
   return new_email;
 }
@@ -72,7 +71,7 @@ std::string CanonicalizeEmail(const std::string& email_address) {
 std::string CanonicalizeDomain(const std::string& domain) {
   // Canonicalization of domain names means lower-casing them. Make sure to
   // update this function in sync with Canonicalize if this ever changes.
-  return base::StringToLowerASCII(domain);
+  return base::ToLowerASCII(domain);
 }
 
 std::string SanitizeEmail(const std::string& email_address) {
diff --git a/google_apis/gcm/engine/gservices_settings.cc b/google_apis/gcm/engine/gservices_settings.cc
index c50f3e8..6621ff8 100644
--- a/google_apis/gcm/engine/gservices_settings.cc
+++ b/google_apis/gcm/engine/gservices_settings.cc
@@ -198,7 +198,7 @@ std::string GServicesSettings::CalculateDigest(const SettingsMap& settings) {
       reinterpret_cast<const unsigned char*>(&data[0]), data.size(), hash);
   std::string digest =
       kDigestVersionPrefix + base::HexEncode(hash, base::kSHA1Length);
-  digest = base::StringToLowerASCII(digest);
+  digest = base::ToLowerASCII(digest);
   return digest;
 }
 
diff --git a/ios/chrome/browser/chrome_url_util.mm b/ios/chrome/browser/chrome_url_util.mm
index 9389114..0d871a8 100644
--- a/ios/chrome/browser/chrome_url_util.mm
+++ b/ios/chrome/browser/chrome_url_util.mm
@@ -47,7 +47,7 @@ bool UrlHasChromeScheme(NSURL* url) {
 }
 
 bool IsHandledProtocol(const std::string& scheme) {
-  DCHECK_EQ(scheme, base::StringToLowerASCII(scheme));
+  DCHECK_EQ(scheme, base::ToLowerASCII(scheme));
   if (scheme == url::kAboutScheme)
     return true;
   if (scheme == url::kDataScheme)
diff --git a/media/base/mime_util.cc b/media/base/mime_util.cc
index 50a99c6..2eaf206 100644
--- a/media/base/mime_util.cc
+++ b/media/base/mime_util.cc
@@ -396,8 +396,7 @@ void MimeUtil::InitializeMimeTypeMaps() {
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const {
-  return media_map_.find(base::StringToLowerASCII(mime_type)) !=
-         media_map_.end();
+  return media_map_.find(base::ToLowerASCII(mime_type)) != media_map_.end();
 }
 
 
@@ -439,14 +438,14 @@ void MimeUtil::ParseCodecString(const std::string& codecs,
 }
 
 bool MimeUtil::IsStrictMediaMimeType(const std::string& mime_type) const {
-  return strict_format_map_.find(base::StringToLowerASCII(mime_type)) !=
+  return strict_format_map_.find(base::ToLowerASCII(mime_type)) !=
          strict_format_map_.end();
 }
 
 SupportsType MimeUtil::IsSupportedStrictMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs) const {
-  const std::string mime_type_lower_case = base::StringToLowerASCII(mime_type);
+  const std::string mime_type_lower_case = base::ToLowerASCII(mime_type);
   StrictMappings::const_iterator it_strict_map =
       strict_format_map_.find(mime_type_lower_case);
   if (it_strict_map == strict_format_map_.end())
diff --git a/media/blink/cache_util.cc b/media/blink/cache_util.cc
index 65bed43..4d1c9c3 100644
--- a/media/blink/cache_util.cc
+++ b/media/blink/cache_util.cc
@@ -47,8 +47,7 @@ uint32 GetReasonsForUncacheability(const WebURLResponse& response) {
   }
 
   std::string cache_control_header =
-      response.httpHeaderField("cache-control").utf8();
-  base::StringToLowerASCII(&cache_control_header);
+      base::ToLowerASCII(response.httpHeaderField("cache-control").utf8());
   if (cache_control_header.find("no-cache") != std::string::npos)
     reasons |= kNoCache;
   if (cache_control_header.find("no-store") != std::string::npos)
diff --git a/media/blink/key_system_config_selector.cc b/media/blink/key_system_config_selector.cc
index 778f2b4..a727722 100644
--- a/media/blink/key_system_config_selector.cc
+++ b/media/blink/key_system_config_selector.cc
@@ -281,7 +281,7 @@ bool KeySystemConfigSelector::IsSupportedContentType(
     KeySystemConfigSelector::ConfigState* config_state) {
   // TODO(sandersd): Move contentType parsing from Blink to here so that invalid
   // parameters can be rejected. http://crbug.com/417561
-  std::string container_lower = base::StringToLowerASCII(container_mime_type);
+  std::string container_lower = base::ToLowerASCII(container_mime_type);
 
   // Check that |container_mime_type| is supported by Chrome.
   if (!media::IsSupportedMediaMimeType(container_lower))
diff --git a/mojo/services/network/http_server_apptest.cc b/mojo/services/network/http_server_apptest.cc
index 32c249c..18c7e5c 100644
--- a/mojo/services/network/http_server_apptest.cc
+++ b/mojo/services/network/http_server_apptest.cc
@@ -113,12 +113,12 @@ void CheckHeaders(const TestHeaders& expected,
   std::map<std::string, std::string> header_map;
   for (size_t i = 0; i < headers.size(); ++i) {
     std::string lower_name =
-        base::StringToLowerASCII(headers[i]->name.To<std::string>());
+        base::ToLowerASCII(headers[i]->name.To<std::string>());
     header_map[lower_name] = headers[i]->value;
   }
 
   for (const auto& item : expected) {
-    std::string lower_name = base::StringToLowerASCII(item.first);
+    std::string lower_name = base::ToLowerASCII(item.first);
     EXPECT_NE(header_map.end(), header_map.find(lower_name));
     EXPECT_EQ(item.second, header_map[lower_name]);
   }
diff --git a/mojo/shell/network_fetcher.cc b/mojo/shell/network_fetcher.cc
index da403a3..c520477 100644
--- a/mojo/shell/network_fetcher.cc
+++ b/mojo/shell/network_fetcher.cc
@@ -130,7 +130,7 @@ bool NetworkFetcher::ComputeAppId(const base::FilePath& path,
   ctx->Finish(string_as_array(&output), output.size());
   output = base::HexEncode(output.c_str(), output.size());
   // Using lowercase for compatiblity with sha256sum output.
-  *digest_string = base::StringToLowerASCII(output);
+  *digest_string = base::ToLowerASCII(output);
   return true;
 }
 
diff --git a/net/base/data_url.cc b/net/base/data_url.cc
index 4f26456..26720c5 100644
--- a/net/base/data_url.cc
+++ b/net/base/data_url.cc
@@ -43,7 +43,7 @@ bool DataURL::Parse(const GURL& url, std::string* mime_type,
   std::vector<std::string>::iterator iter = meta_data.begin();
   if (iter != meta_data.end()) {
     mime_type->swap(*iter);
-    base::StringToLowerASCII(mime_type);
+    *mime_type = base::ToLowerASCII(*mime_type);
     ++iter;
   }
 
diff --git a/net/base/filename_util.cc b/net/base/filename_util.cc
index 01b9f63..0969f71 100644
--- a/net/base/filename_util.cc
+++ b/net/base/filename_util.cc
@@ -163,10 +163,9 @@ bool IsReservedNameOnWindows(const base::FilePath::StringType& filename) {
       "com5", "com6", "com7", "com8", "com9", "lpt1", "lpt2",  "lpt3",
       "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "clock$"};
 #if defined(OS_WIN)
-  std::string filename_lower =
-      base::StringToLowerASCII(base::WideToUTF8(filename));
+  std::string filename_lower = base::ToLowerASCII(base::WideToUTF8(filename));
 #elif defined(OS_POSIX)
-  std::string filename_lower = base::StringToLowerASCII(filename);
+  std::string filename_lower = base::ToLowerASCII(filename);
 #endif
 
   for (size_t i = 0; i < arraysize(known_devices); ++i) {
diff --git a/net/base/filename_util_internal.cc b/net/base/filename_util_internal.cc
index 697e8cf..8b57d79 100644
--- a/net/base/filename_util_internal.cc
+++ b/net/base/filename_util_internal.cc
@@ -90,8 +90,7 @@ std::string GetFileNameFromURL(const GURL& url,
 // Returns whether the specified extension is automatically integrated into the
 // windows shell.
 bool IsShellIntegratedExtension(const base::FilePath::StringType& extension) {
-  base::FilePath::StringType extension_lower =
-      base::StringToLowerASCII(extension);
+  base::FilePath::StringType extension_lower = base::ToLowerASCII(extension);
 
   // http://msdn.microsoft.com/en-us/library/ms811694.aspx
   // Right-clicking on shortcuts can be magical.
diff --git a/net/base/host_mapping_rules.cc b/net/base/host_mapping_rules.cc
index 4532b66..5e60425 100644
--- a/net/base/host_mapping_rules.cc
+++ b/net/base/host_mapping_rules.cc
@@ -74,7 +74,7 @@ bool HostMappingRules::AddRuleFromString(const std::string& rule_string) {
   // Test for EXCLUSION rule.
   if (parts.size() == 2 && base::LowerCaseEqualsASCII(parts[0], "exclude")) {
     ExclusionRule rule;
-    rule.hostname_pattern = base::StringToLowerASCII(parts[1]);
+    rule.hostname_pattern = base::ToLowerASCII(parts[1]);
     exclusion_rules_.push_back(rule);
     return true;
   }
@@ -82,7 +82,7 @@ bool HostMappingRules::AddRuleFromString(const std::string& rule_string) {
   // Test for MAP rule.
   if (parts.size() == 3 && base::LowerCaseEqualsASCII(parts[0], "map")) {
     MapRule rule;
-    rule.hostname_pattern = base::StringToLowerASCII(parts[1]);
+    rule.hostname_pattern = base::ToLowerASCII(parts[1]);
 
     if (!ParseHostAndPort(parts[2], &rule.replacement_hostname,
                           &rule.replacement_port)) {
diff --git a/net/base/mime_util.cc b/net/base/mime_util.cc
index 9adb2fe..0d51120 100644
--- a/net/base/mime_util.cc
+++ b/net/base/mime_util.cc
@@ -224,12 +224,12 @@ bool MatchesMimeTypeParameters(const std::string& mime_type_pattern,
     // 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())
@@ -327,7 +327,7 @@ bool MimeUtil::ParseMimeTypeWithoutParameter(
 }
 
 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;
@@ -521,7 +521,7 @@ void GetExtensionsForMimeType(
   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)) {
diff --git a/net/base/net_util.cc b/net/base/net_util.cc
index b27246b..42159d9 100644
--- a/net/base/net_util.cc
+++ b/net/base/net_util.cc
@@ -65,7 +65,7 @@ namespace net {
 namespace {
 
 std::string NormalizeHostname(const std::string& host) {
-  std::string result = base::StringToLowerASCII(host);
+  std::string result = base::ToLowerASCII(host);
   if (!result.empty() && *result.rbegin() == '.')
     result.resize(result.size() - 1);
   return result;
diff --git a/net/base/network_change_notifier.cc b/net/base/network_change_notifier.cc
index d994969..12a6377 100644
--- a/net/base/network_change_notifier.cc
+++ b/net/base/network_change_notifier.cc
@@ -670,7 +670,7 @@ NetworkChangeNotifier::ConnectionTypeFromInterfaceList(
 #endif
     // Remove VMware network interfaces as they're internal and should not be
     // used to determine the network connection type.
-    if (base::StringToLowerASCII(interfaces[i].friendly_name).find("vmnet") !=
+    if (base::ToLowerASCII(interfaces[i].friendly_name).find("vmnet") !=
         std::string::npos) {
       continue;
     }
diff --git a/net/base/sdch_manager.cc b/net/base/sdch_manager.cc
index 52a4077..e4104e0 100644
--- a/net/base/sdch_manager.cc
+++ b/net/base/sdch_manager.cc
@@ -112,8 +112,7 @@ void SdchManager::BlacklistDomain(const GURL& url,
                                   SdchProblemCode blacklist_reason) {
   SetAllowLatencyExperiment(url, false);
 
-  BlacklistInfo* blacklist_info =
-      &blacklisted_domains_[base::StringToLowerASCII(url.host())];
+  BlacklistInfo* blacklist_info = &blacklisted_domains_[url.host()];
 
   if (blacklist_info->count > 0)
     return;  // Domain is already blacklisted.
@@ -133,8 +132,7 @@ void SdchManager::BlacklistDomainForever(const GURL& url,
                                          SdchProblemCode blacklist_reason) {
   SetAllowLatencyExperiment(url, false);
 
-  BlacklistInfo* blacklist_info =
-      &blacklisted_domains_[base::StringToLowerASCII(url.host())];
+  BlacklistInfo* blacklist_info = &blacklisted_domains_[url.host()];
   blacklist_info->count = INT_MAX;
   blacklist_info->exponential_count = INT_MAX;
   blacklist_info->reason = blacklist_reason;
@@ -145,14 +143,14 @@ void SdchManager::ClearBlacklistings() {
 }
 
 void SdchManager::ClearDomainBlacklisting(const std::string& domain) {
-  BlacklistInfo* blacklist_info = &blacklisted_domains_[
-      base::StringToLowerASCII(domain)];
+  BlacklistInfo* blacklist_info =
+      &blacklisted_domains_[base::ToLowerASCII(domain)];
   blacklist_info->count = 0;
   blacklist_info->reason = SDCH_OK;
 }
 
 int SdchManager::BlackListDomainCount(const std::string& domain) {
-  std::string domain_lower(base::StringToLowerASCII(domain));
+  std::string domain_lower(base::ToLowerASCII(domain));
 
   if (blacklisted_domains_.end() == blacklisted_domains_.find(domain_lower))
     return 0;
@@ -160,7 +158,7 @@ int SdchManager::BlackListDomainCount(const std::string& domain) {
 }
 
 int SdchManager::BlacklistDomainExponential(const std::string& domain) {
-  std::string domain_lower(base::StringToLowerASCII(domain));
+  std::string domain_lower(base::ToLowerASCII(domain));
 
   if (blacklisted_domains_.end() == blacklisted_domains_.find(domain_lower))
     return 0;
@@ -175,8 +173,7 @@ SdchProblemCode SdchManager::IsInSupportedDomain(const GURL& url) {
   if (blacklisted_domains_.empty())
     return SDCH_OK;
 
-  DomainBlacklistInfo::iterator it =
-      blacklisted_domains_.find(base::StringToLowerASCII(url.host()));
+  auto it = blacklisted_domains_.find(url.host());
   if (blacklisted_domains_.end() == it || it->second.count == 0)
     return SDCH_OK;
 
@@ -374,7 +371,7 @@ SdchProblemCode SdchManager::AddSdchDictionary(
         break;
       std::string name(dictionary_text, line_start, colon_index - line_start);
       std::string value(dictionary_text, value_start, line_end - value_start);
-      name = base::StringToLowerASCII(name);
+      name = base::ToLowerASCII(name);
       if (name == "domain") {
         domain = value;
       } else if (name == "path") {
diff --git a/net/cert/x509_certificate.cc b/net/cert/x509_certificate.cc
index c328904..dc3cd80 100644
--- a/net/cert/x509_certificate.cc
+++ b/net/cert/x509_certificate.cc
@@ -618,7 +618,7 @@ bool X509Certificate::VerifyHostname(
       DVLOG(1) << "Bad name in cert: " << *it;
       continue;
     }
-    std::string presented_name(base::StringToLowerASCII(*it));
+    std::string presented_name(base::ToLowerASCII(*it));
 
     // Remove trailing dot, if any.
     if (*presented_name.rbegin() == '.')
diff --git a/net/cookies/cookie_constants.cc b/net/cookies/cookie_constants.cc
index 0afe6ef..05fe22e 100644
--- a/net/cookies/cookie_constants.cc
+++ b/net/cookies/cookie_constants.cc
@@ -30,8 +30,7 @@ NET_EXPORT const std::string CookiePriorityToString(CookiePriority priority) {
 }
 
 NET_EXPORT CookiePriority StringToCookiePriority(const std::string& priority) {
-  std::string priority_comp(priority);
-  base::StringToLowerASCII(&priority_comp);
+  std::string priority_comp = base::ToLowerASCII(priority);
 
   if (priority_comp == kPriorityHigh)
     return COOKIE_PRIORITY_HIGH;
diff --git a/net/cookies/parsed_cookie.cc b/net/cookies/parsed_cookie.cc
index 3f281a6..bd8b0dc 100644
--- a/net/cookies/parsed_cookie.cc
+++ b/net/cookies/parsed_cookie.cc
@@ -398,7 +398,7 @@ void ParsedCookie::ParseTokenValuePairs(const std::string& cookie_line) {
 
     // From RFC2109: "Attributes (names) (attr) are case-insensitive."
     if (pair_num != 0)
-      base::StringToLowerASCII(&pair.first);
+      pair.first = base::ToLowerASCII(pair.first);
     // Ignore Set-Cookie directives contaning control characters. See
     // http://crbug.com/238041.
     if (!IsValidCookieAttributeValue(pair.first) ||
diff --git a/net/dns/dns_config_service_win.cc b/net/dns/dns_config_service_win.cc
index 23206d4..443ee27 100644
--- a/net/dns/dns_config_service_win.cc
+++ b/net/dns/dns_config_service_win.cc
@@ -241,7 +241,7 @@ HostsParseWinResult AddLocalhostEntries(DnsHosts* hosts) {
       !ParseDomainASCII(buffer, &localname)) {
     return HOSTS_PARSE_WIN_COMPUTER_NAME_FAILED;
   }
-  base::StringToLowerASCII(&localname);
+  localname = base::ToLowerASCII(localname);
 
   bool have_ipv4 =
       hosts->count(DnsHostsKey(localname, ADDRESS_FAMILY_IPV4)) > 0;
diff --git a/net/dns/dns_hosts.cc b/net/dns/dns_hosts.cc
index 706c66b..9e641b6 100644
--- a/net/dns/dns_hosts.cc
+++ b/net/dns/dns_hosts.cc
@@ -154,7 +154,7 @@ void ParseHostsWithCommaMode(const std::string& contents,
       }
     } else {
       DnsHostsKey key(parser.token().as_string(), family);
-      base::StringToLowerASCII(&key.first);
+      key.first = base::ToLowerASCII(key.first);
       IPAddressNumber* mapped_ip = &(*dns_hosts)[key];
       if (mapped_ip->empty())
         *mapped_ip = ip;
diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc
index d3f8365..2fdd254 100644
--- a/net/dns/host_resolver_impl.cc
+++ b/net/dns/host_resolver_impl.cc
@@ -2118,7 +2118,7 @@ bool HostResolverImpl::ServeFromHosts(const Key& key,
   addresses->clear();
 
   // HOSTS lookups are case-insensitive.
-  std::string hostname = base::StringToLowerASCII(key.hostname);
+  std::string hostname = base::ToLowerASCII(key.hostname);
 
   const DnsHosts& hosts = dns_client_->GetConfig()->hosts;
 
diff --git a/net/ftp/ftp_directory_listing_parser_vms.cc b/net/ftp/ftp_directory_listing_parser_vms.cc
index ac7a464..eb92a19 100644
--- a/net/ftp/ftp_directory_listing_parser_vms.cc
+++ b/net/ftp/ftp_directory_listing_parser_vms.cc
@@ -46,10 +46,10 @@ bool ParseVmsFilename(const base::string16& raw_filename,
   if (filename_parts.size() != 2)
     return false;
   if (base::EqualsASCII(filename_parts[1], "DIR")) {
-    *parsed_filename = base::StringToLowerASCII(filename_parts[0]);
+    *parsed_filename = base::ToLowerASCII(filename_parts[0]);
     *type = FtpDirectoryListingEntry::DIRECTORY;
   } else {
-    *parsed_filename = base::StringToLowerASCII(listing_parts[0]);
+    *parsed_filename = base::ToLowerASCII(listing_parts[0]);
     *type = FtpDirectoryListingEntry::FILE;
   }
   return true;
diff --git a/net/ftp/ftp_network_transaction.cc b/net/ftp/ftp_network_transaction.cc
index bf52c21..b3bb976 100644
--- a/net/ftp/ftp_network_transaction.cc
+++ b/net/ftp/ftp_network_transaction.cc
@@ -820,7 +820,7 @@ int FtpNetworkTransaction::ProcessResponseSYST(
       // comparisons easily. If it is not ASCII, we leave the system type
       // as unknown.
       if (base::IsStringASCII(line)) {
-        line = base::StringToLowerASCII(line);
+        line = base::ToLowerASCII(line);
 
         // Remove all whitespace, to correctly handle cases like fancy "V M S"
         // response instead of "VMS".
diff --git a/net/http/http_auth_handler_factory.cc b/net/http/http_auth_handler_factory.cc
index 4f09c9f..b148aad 100644
--- a/net/http/http_auth_handler_factory.cc
+++ b/net/http/http_auth_handler_factory.cc
@@ -106,7 +106,7 @@ void HttpAuthHandlerRegistryFactory::SetURLSecurityManager(
 void HttpAuthHandlerRegistryFactory::RegisterSchemeFactory(
     const std::string& scheme,
     HttpAuthHandlerFactory* factory) {
-  std::string lower_scheme = base::StringToLowerASCII(scheme);
+  std::string lower_scheme = base::ToLowerASCII(scheme);
   FactoryMap::iterator it = factory_map_.find(lower_scheme);
   if (it != factory_map_.end()) {
     delete it->second;
@@ -119,7 +119,7 @@ void HttpAuthHandlerRegistryFactory::RegisterSchemeFactory(
 
 HttpAuthHandlerFactory* HttpAuthHandlerRegistryFactory::GetSchemeFactory(
     const std::string& scheme) const {
-  std::string lower_scheme = base::StringToLowerASCII(scheme);
+  std::string lower_scheme = base::ToLowerASCII(scheme);
   FactoryMap::const_iterator it = factory_map_.find(lower_scheme);
   if (it == factory_map_.end()) {
     return NULL;                  // |scheme| is not registered.
@@ -190,7 +190,7 @@ int HttpAuthHandlerRegistryFactory::CreateAuthHandler(
     handler->reset();
     return ERR_INVALID_RESPONSE;
   }
-  std::string lower_scheme = base::StringToLowerASCII(scheme);
+  std::string lower_scheme = base::ToLowerASCII(scheme);
   FactoryMap::iterator it = factory_map_.find(lower_scheme);
   if (it == factory_map_.end()) {
     handler->reset();
diff --git a/net/http/http_auth_multi_round_parse.cc b/net/http/http_auth_multi_round_parse.cc
index efee2bb..1d0edac 100644
--- a/net/http/http_auth_multi_round_parse.cc
+++ b/net/http/http_auth_multi_round_parse.cc
@@ -17,7 +17,7 @@ bool SchemeIsValid(const std::string& scheme,
   // There is no guarantee that challenge->scheme() is valid ASCII, but
   // LowerCaseEqualsASCII will do the right thing even if it isn't.
   return base::LowerCaseEqualsASCII(challenge->scheme(),
-                                    base::StringToLowerASCII(scheme).c_str());
+                                    base::ToLowerASCII(scheme));
 }
 
 }  // namespace
diff --git a/net/http/http_log_util.cc b/net/http/http_log_util.cc
index 8e071e3..87c2fd9 100644
--- a/net/http/http_log_util.cc
+++ b/net/http/http_log_util.cc
@@ -19,7 +19,7 @@ bool ShouldRedactChallenge(HttpAuthChallengeTokenizer* challenge) {
   if (challenge->challenge_text().find(',') != std::string::npos)
     return false;
 
-  std::string scheme = base::StringToLowerASCII(challenge->scheme());
+  std::string scheme = base::ToLowerASCII(challenge->scheme());
   // Invalid input.
   if (scheme.empty())
     return false;
diff --git a/net/http/http_response_headers.cc b/net/http/http_response_headers.cc
index 119ec52..c535e0a 100644
--- a/net/http/http_response_headers.cc
+++ b/net/http/http_response_headers.cc
@@ -206,9 +206,8 @@ void HttpResponseHeaders::Persist(base::Pickle* pickle,
     while (++k < parsed_.size() && parsed_[k].is_continuation()) {}
     --k;
 
-    std::string header_name(parsed_[i].name_begin, parsed_[i].name_end);
-    base::StringToLowerASCII(&header_name);
-
+    std::string header_name = base::ToLowerASCII(
+        base::StringPiece(parsed_[i].name_begin, parsed_[i].name_end));
     if (filter_headers.find(header_name) == filter_headers.end()) {
       // Make sure there is a null after the value.
       blob.append(parsed_[i].name_begin, parsed_[k].value_end);
@@ -248,9 +247,7 @@ void HttpResponseHeaders::Update(const HttpResponseHeaders& new_headers) {
 
     base::StringPiece name(new_parsed[i].name_begin, new_parsed[i].name_end);
     if (ShouldUpdateHeader(name)) {
-      std::string name_lower;
-      name.CopyToString(&name_lower);
-      base::StringToLowerASCII(&name_lower);
+      std::string name_lower = base::ToLowerASCII(name);
       updated_headers.insert(name_lower);
 
       // Preserve this header line in the merged result, making sure there is
@@ -277,8 +274,8 @@ void HttpResponseHeaders::MergeWithHeaders(const std::string& raw_headers,
     while (++k < parsed_.size() && parsed_[k].is_continuation()) {}
     --k;
 
-    std::string name(parsed_[i].name_begin, parsed_[i].name_end);
-    base::StringToLowerASCII(&name);
+    std::string name = base::ToLowerASCII(
+        base::StringPiece(parsed_[i].name_begin, parsed_[i].name_end));
     if (headers_to_remove.find(name) == headers_to_remove.end()) {
       // It's ok to preserve this header in the final result.
       new_raw_headers.append(parsed_[i].name_begin, parsed_[k].value_end);
@@ -300,8 +297,7 @@ void HttpResponseHeaders::RemoveHeader(const std::string& name) {
   std::string new_raw_headers(raw_headers_.c_str());
   new_raw_headers.push_back('\0');
 
-  std::string lowercase_name(name);
-  base::StringToLowerASCII(&lowercase_name);
+  std::string lowercase_name = base::ToLowerASCII(name);
   HeaderSet to_remove;
   to_remove.insert(lowercase_name);
   MergeWithHeaders(new_raw_headers, to_remove);
@@ -309,8 +305,7 @@ void HttpResponseHeaders::RemoveHeader(const std::string& name) {
 
 void HttpResponseHeaders::RemoveHeaderLine(const std::string& name,
                                            const std::string& value) {
-  std::string name_lowercase(name);
-  base::StringToLowerASCII(&name_lowercase);
+  std::string name_lowercase = base::ToLowerASCII(name);
 
   std::string new_raw_headers(GetStatusLine());
   new_raw_headers.push_back('\0');
@@ -321,9 +316,7 @@ void HttpResponseHeaders::RemoveHeaderLine(const std::string& name,
   std::string old_header_name;
   std::string old_header_value;
   while (EnumerateHeaderLines(&iter, &old_header_name, &old_header_value)) {
-    std::string old_header_name_lowercase(name);
-    base::StringToLowerASCII(&old_header_name_lowercase);
-
+    std::string old_header_name_lowercase = base::ToLowerASCII(old_header_name);
     if (name_lowercase == old_header_name_lowercase &&
         value == old_header_value)
       continue;
@@ -473,7 +466,7 @@ void HttpResponseHeaders::GetNormalizedHeaders(std::string* output) const {
     DCHECK(!parsed_[i].is_continuation());
 
     std::string name(parsed_[i].name_begin, parsed_[i].name_end);
-    std::string lower_name = base::StringToLowerASCII(name);
+    std::string lower_name = base::ToLowerASCII(name);
 
     iter = headers_map.find(lower_name);
     if (iter == headers_map.end()) {
@@ -843,9 +836,8 @@ void HttpResponseHeaders::AddNonCacheableHeaders(HeaderSet* result) const {
 
       // assuming the header is not empty, lowercase and insert into set
       if (item_end > item) {
-        std::string name(&*item, item_end - item);
-        base::StringToLowerASCII(&name);
-        result->insert(name);
+        result->insert(
+            base::ToLowerASCII(base::StringPiece(&*item, item_end - item)));
       }
 
       // Continue to next item.
diff --git a/net/http/http_util.cc b/net/http/http_util.cc
index 9abcfc8..f1e5143 100644
--- a/net/http/http_util.cc
+++ b/net/http/http_util.cc
@@ -133,13 +133,13 @@ void HttpUtil::ParseContentType(const std::string& content_type_str,
                   base::StringPiece(begin + type_val, begin + type_end),
                   mime_type->data());
     if (!eq) {
-      mime_type->assign(begin + type_val, begin + type_end);
-      base::StringToLowerASCII(mime_type);
+      *mime_type = base::ToLowerASCII(
+          base::StringPiece(begin + type_val, begin + type_end));
     }
     if ((!eq && *had_charset) || type_has_charset) {
       *had_charset = true;
-      charset->assign(begin + charset_val, begin + charset_end);
-      base::StringToLowerASCII(charset);
+      *charset = base::ToLowerASCII(
+          base::StringPiece(begin + charset_val, begin + charset_end));
     }
   }
 }
@@ -321,7 +321,7 @@ const char* const kForbiddenHeaderFields[] = {
 
 // static
 bool HttpUtil::IsSafeHeader(const std::string& name) {
-  std::string lower_name(base::StringToLowerASCII(name));
+  std::string lower_name(base::ToLowerASCII(name));
   if (base::StartsWith(lower_name, "proxy-", base::CompareCase::SENSITIVE) ||
       base::StartsWith(lower_name, "sec-", base::CompareCase::SENSITIVE))
     return false;
@@ -821,7 +821,7 @@ bool HttpUtil::HeadersIterator::GetNext() {
 
 bool HttpUtil::HeadersIterator::AdvanceTo(const char* name) {
   DCHECK(name != NULL);
-  DCHECK_EQ(0, base::StringToLowerASCII<std::string>(name).compare(name))
+  DCHECK_EQ(0, base::ToLowerASCII(name).compare(name))
       << "the header name must be in all lower case";
 
   while (GetNext()) {
diff --git a/net/http/transport_security_state.cc b/net/http/transport_security_state.cc
index b343223..4db4696 100644
--- a/net/http/transport_security_state.cc
+++ b/net/http/transport_security_state.cc
@@ -433,8 +433,7 @@ bool DecodeHSTSPreloadRaw(const std::string& search_hostname,
   // |hostname| has already undergone IDN conversion, so should be
   // entirely A-Labels. The preload data is entirely normalized to
   // lower case.
-  base::StringToLowerASCII(&hostname);
-
+  hostname = base::ToLowerASCII(hostname);
   if (hostname.empty()) {
     return true;
   }
diff --git a/net/proxy/proxy_bypass_rules.cc b/net/proxy/proxy_bypass_rules.cc
index f2f3261..be18edb 100644
--- a/net/proxy/proxy_bypass_rules.cc
+++ b/net/proxy/proxy_bypass_rules.cc
@@ -24,10 +24,9 @@ class HostnamePatternRule : public ProxyBypassRules::Rule {
   HostnamePatternRule(const std::string& optional_scheme,
                       const std::string& hostname_pattern,
                       int optional_port)
-      : optional_scheme_(base::StringToLowerASCII(optional_scheme)),
-        hostname_pattern_(base::StringToLowerASCII(hostname_pattern)),
-        optional_port_(optional_port) {
-  }
+      : optional_scheme_(base::ToLowerASCII(optional_scheme)),
+        hostname_pattern_(base::ToLowerASCII(hostname_pattern)),
+        optional_port_(optional_port) {}
 
   bool Matches(const GURL& url) const override {
     if (optional_port_ != -1 && url.EffectiveIntPort() != optional_port_)
@@ -38,8 +37,7 @@ class HostnamePatternRule : public ProxyBypassRules::Rule {
 
     // Note it is necessary to lower-case the host, since GURL uses capital
     // letters for percent-escaped characters.
-    return base::MatchPattern(base::StringToLowerASCII(url.host()),
-                              hostname_pattern_);
+    return base::MatchPattern(url.host(), hostname_pattern_);
   }
 
   std::string ToString() const override {
diff --git a/net/server/http_server.cc b/net/server/http_server.cc
index a3c4b52..dff0e60 100644
--- a/net/server/http_server.cc
+++ b/net/server/http_server.cc
@@ -412,7 +412,7 @@ bool HttpServer::ParseHeaders(const char* data,
           buffer.clear();
           break;
         case ST_NAME:
-          header_name = base::StringToLowerASCII(buffer);
+          header_name = base::ToLowerASCII(buffer);
           buffer.clear();
           break;
         case ST_VALUE:
diff --git a/net/server/http_server_request_info.cc b/net/server/http_server_request_info.cc
index df5cff6..07c15a5 100644
--- a/net/server/http_server_request_info.cc
+++ b/net/server/http_server_request_info.cc
@@ -15,7 +15,7 @@ HttpServerRequestInfo::~HttpServerRequestInfo() {}
 
 std::string HttpServerRequestInfo::GetHeaderValue(
     const std::string& header_name) const {
-  DCHECK_EQ(base::StringToLowerASCII(header_name), header_name);
+  DCHECK_EQ(base::ToLowerASCII(header_name), header_name);
   HttpServerRequestInfo::HeadersMap::const_iterator it =
       headers.find(header_name);
   if (it != headers.end())
@@ -26,9 +26,8 @@ std::string HttpServerRequestInfo::GetHeaderValue(
 bool HttpServerRequestInfo::HasHeaderValue(
     const std::string& header_name,
     const std::string& header_value) const {
-  DCHECK_EQ(base::StringToLowerASCII(header_value), header_value);
-  std::string complete_value = GetHeaderValue(header_name);
-  base::StringToLowerASCII(&complete_value);
+  DCHECK_EQ(base::ToLowerASCII(header_value), header_value);
+  std::string complete_value = base::ToLowerASCII(GetHeaderValue(header_name));
 
   for (const base::StringPiece& cur :
        base::SplitString(complete_value, ",", base::KEEP_WHITESPACE,
diff --git a/net/server/http_server_unittest.cc b/net/server/http_server_unittest.cc
index 8830e3f..170a720 100644
--- a/net/server/http_server_unittest.cc
+++ b/net/server/http_server_unittest.cc
@@ -297,7 +297,7 @@ TEST_F(HttpServerTest, RequestWithHeaders) {
   ASSERT_EQ("", GetRequest(0).data);
 
   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
-    std::string field = base::StringToLowerASCII(std::string(kHeaders[i][0]));
+    std::string field = base::ToLowerASCII(std::string(kHeaders[i][0]));
     std::string value = kHeaders[i][2];
     ASSERT_EQ(1u, GetRequest(0).headers.count(field)) << field;
     ASSERT_EQ(value, GetRequest(0).headers[field]) << kHeaders[i][0];
@@ -325,7 +325,7 @@ TEST_F(HttpServerTest, RequestWithDuplicateHeaders) {
   ASSERT_EQ("", GetRequest(0).data);
 
   for (size_t i = 0; i < arraysize(kHeaders); ++i) {
-    std::string field = base::StringToLowerASCII(std::string(kHeaders[i][0]));
+    std::string field = base::ToLowerASCII(std::string(kHeaders[i][0]));
     std::string value = (field == "duplicateheader") ? "2,4" : kHeaders[i][2];
     ASSERT_EQ(1u, GetRequest(0).headers.count(field)) << field;
     ASSERT_EQ(value, GetRequest(0).headers[field]) << kHeaders[i][0];
diff --git a/net/spdy/spdy_http_utils.cc b/net/spdy/spdy_http_utils.cc
index c7dcb38..aab758a 100644
--- a/net/spdy/spdy_http_utils.cc
+++ b/net/spdy/spdy_http_utils.cc
@@ -105,7 +105,7 @@ void CreateSpdyHeadersFromHttpRequest(const HttpRequestInfo& info,
 
   HttpRequestHeaders::Iterator it(request_headers);
   while (it.GetNext()) {
-    std::string name = base::StringToLowerASCII(it.name());
+    std::string name = base::ToLowerASCII(it.name());
     if (name == "connection" || name == "proxy-connection" ||
         name == "transfer-encoding" || name == "host") {
       continue;
@@ -173,7 +173,7 @@ void CreateSpdyHeadersFromHttpResponse(
   void* iter = NULL;
   std::string raw_name, value;
   while (response_headers.EnumerateHeaderLines(&iter, &raw_name, &value)) {
-    std::string name = base::StringToLowerASCII(raw_name);
+    std::string name = base::ToLowerASCII(raw_name);
     AddSpdyHeader(name, value, headers);
   }
 }
diff --git a/net/test/embedded_test_server/http_request.cc b/net/test/embedded_test_server/http_request.cc
index 26cb49e..9e0c80f 100644
--- a/net/test/embedded_test_server/http_request.cc
+++ b/net/test/embedded_test_server/http_request.cc
@@ -93,15 +93,14 @@ HttpRequestParser::ParseResult HttpRequestParser::ParseHeaders() {
     DCHECK_EQ(3u, header_line_tokens.size());
     // Method.
     http_request_->method_string = header_line_tokens[0];
-    http_request_->method = GetMethodType(base::StringToLowerASCII(
-        header_line_tokens[0]));
+    http_request_->method =
+        GetMethodType(base::ToLowerASCII(header_line_tokens[0]));
     // Address.
     // Don't build an absolute URL as the parser does not know (should not
     // know) anything about the server address.
     http_request_->relative_url = header_line_tokens[1];
     // Protocol.
-    const std::string protocol =
-        base::StringToLowerASCII(header_line_tokens[2]);
+    const std::string protocol = base::ToLowerASCII(header_line_tokens[2]);
     CHECK(protocol == "http/1.0" || protocol == "http/1.1") <<
         "Protocol not supported: " << protocol;
   }
diff --git a/net/tools/quic/spdy_balsa_utils.cc b/net/tools/quic/spdy_balsa_utils.cc
index 76a3bdc..29d0c90 100644
--- a/net/tools/quic/spdy_balsa_utils.cc
+++ b/net/tools/quic/spdy_balsa_utils.cc
@@ -50,8 +50,7 @@ void PopulateSpdyHeaderBlock(const BalsaHeaders& headers,
 
     // This unfortunately involves loads of copying, but its the simplest way
     // to sort the headers and leverage the framer.
-    string name = hi->first.as_string();
-    base::StringToLowerASCII(&name);
+    string name = base::ToLowerASCII(hi->first.as_string());
     SpdyHeaderBlock::iterator it = block->find(name);
     if (it != block->end()) {
       it->second.reserve(it->second.size() + 1 + hi->second.size());
diff --git a/net/url_request/url_request_backoff_manager.cc b/net/url_request/url_request_backoff_manager.cc
index 51560e3..13632b3 100644
--- a/net/url_request/url_request_backoff_manager.cc
+++ b/net/url_request/url_request_backoff_manager.cc
@@ -126,7 +126,7 @@ std::string URLRequestBackoffManager::GetIdFromUrl(const GURL& url) const {
     return url.possibly_invalid_spec();
 
   GURL id = url.ReplaceComponents(url_id_replacements_);
-  return base::StringToLowerASCII(id.spec()).c_str();
+  return base::ToLowerASCII(id.spec());
 }
 
 void URLRequestBackoffManager::OnNetworkChange() {
diff --git a/net/url_request/url_request_throttler_manager.cc b/net/url_request/url_request_throttler_manager.cc
index 88a9d2c..3f08e9e 100644
--- a/net/url_request/url_request_throttler_manager.cc
+++ b/net/url_request/url_request_throttler_manager.cc
@@ -142,7 +142,7 @@ std::string URLRequestThrottlerManager::GetIdFromUrl(const GURL& url) const {
     return url.possibly_invalid_spec();
 
   GURL id = url.ReplaceComponents(url_id_replacements_);
-  return base::StringToLowerASCII(id.spec()).c_str();
+  return base::ToLowerASCII(id.spec());
 }
 
 void URLRequestThrottlerManager::GarbageCollectEntriesIfNecessary() {
diff --git a/pdf/document_loader.cc b/pdf/document_loader.cc
index a156cbe..868a8c4 100644
--- a/pdf/document_loader.cc
+++ b/pdf/document_loader.cc
@@ -53,7 +53,7 @@ std::string GetMultiPartBoundary(const std::string& headers) {
   net::HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\n");
   while (it.GetNext()) {
     if (base::LowerCaseEqualsASCII(it.name(), "content-type")) {
-      std::string type = base::StringToLowerASCII(it.values());
+      std::string type = base::ToLowerASCII(it.values());
       if (base::StartsWith(type, "multipart/", base::CompareCase::SENSITIVE)) {
         const char* boundary = strstr(type.c_str(), "boundary=");
         if (!boundary) {
diff --git a/pdf/pdfium/pdfium_page.cc b/pdf/pdfium/pdfium_page.cc
index a7912a6..79410c4 100644
--- a/pdf/pdfium/pdfium_page.cc
+++ b/pdf/pdfium/pdfium_page.cc
@@ -204,8 +204,8 @@ base::Value* PDFiumPage::GetTextBoxAsValue(double page_height,
         DCHECK(targets[i].url[targets[i].url.size() - 1] != '\0');
 
       // PDFium may change the case of generated links.
-      std::string lowerCaseURL = base::StringToLowerASCII(targets[i].url);
-      std::string lowerCaseText = base::StringToLowerASCII(text_utf8);
+      std::string lowerCaseURL = base::ToLowerASCII(targets[i].url);
+      std::string lowerCaseText = base::ToLowerASCII(text_utf8);
       size_t pos = lowerCaseText.find(lowerCaseURL, start);
       size_t length = targets[i].url.size();
       if (pos == std::string::npos) {
diff --git a/ppapi/proxy/file_chooser_resource.cc b/ppapi/proxy/file_chooser_resource.cc
index 324f11b..9f949c0 100644
--- a/ppapi/proxy/file_chooser_resource.cc
+++ b/ppapi/proxy/file_chooser_resource.cc
@@ -93,8 +93,7 @@ void FileChooserResource::PopulateAcceptTypes(
       continue;
     if (type.find_first_of('/') == std::string::npos && type[0] != '.')
       continue;
-    base::StringToLowerASCII(&type);
-    output->push_back(type);
+    output->push_back(base::ToLowerASCII(type));
   }
 }
 
diff --git a/remoting/signaling/jid_util.cc b/remoting/signaling/jid_util.cc
index ca0c909..08e525d 100644
--- a/remoting/signaling/jid_util.cc
+++ b/remoting/signaling/jid_util.cc
@@ -12,9 +12,9 @@ std::string NormalizeJid(const std::string& jid) {
   std::string bare_jid;
   std::string resource;
   if (SplitJidResource(jid, &bare_jid, &resource)) {
-    return base::StringToLowerASCII(bare_jid) + "/" + resource;
+    return base::ToLowerASCII(bare_jid) + "/" + resource;
   }
-  return base::StringToLowerASCII(bare_jid);
+  return base::ToLowerASCII(bare_jid);
 }
 
 bool SplitJidResource(const std::string& full_jid,
diff --git a/sql/statement.cc b/sql/statement.cc
index 038ebde..09c95da 100644
--- a/sql/statement.cc
+++ b/sql/statement.cc
@@ -210,8 +210,8 @@ ColType Statement::ColumnType(int col) const {
 }
 
 ColType Statement::DeclaredColumnType(int col) const {
-  std::string column_type(sqlite3_column_decltype(ref_->stmt(), col));
-  base::StringToLowerASCII(&column_type);
+  std::string column_type = base::ToLowerASCII(
+      sqlite3_column_decltype(ref_->stmt(), col));
 
   if (column_type == "integer")
     return COLUMN_TYPE_INTEGER;
diff --git a/storage/common/database/database_identifier.cc b/storage/common/database/database_identifier.cc
index e642a1a..094e01f 100644
--- a/storage/common/database/database_identifier.cc
+++ b/storage/common/database/database_identifier.cc
@@ -116,7 +116,7 @@ DatabaseIdentifier::DatabaseIdentifier(const std::string& scheme,
                                        bool is_unique,
                                        bool is_file)
     : scheme_(scheme),
-      hostname_(base::StringToLowerASCII(hostname)),
+      hostname_(base::ToLowerASCII(hostname)),
       port_(port),
       is_unique_(is_unique),
       is_file_(is_file) {
diff --git a/sync/internal_api/public/base/attachment_id_proto.cc b/sync/internal_api/public/base/attachment_id_proto.cc
index 6692ab7..b457fc6 100644
--- a/sync/internal_api/public/base/attachment_id_proto.cc
+++ b/sync/internal_api/public/base/attachment_id_proto.cc
@@ -13,7 +13,7 @@ namespace syncer {
 sync_pb::AttachmentIdProto CreateAttachmentIdProto(size_t size,
                                                    uint32_t crc32c) {
   sync_pb::AttachmentIdProto proto;
-  std::string guid = base::StringToLowerASCII(base::GenerateGUID());
+  std::string guid = base::ToLowerASCII(base::GenerateGUID());
   DCHECK(!guid.empty());
   // Requirements are that this id must be a unique RFC4122 UUID, formatted in
   // lower case.
diff --git a/sync/internal_api/public/base/attachment_id_proto_unittest.cc b/sync/internal_api/public/base/attachment_id_proto_unittest.cc
index 2f9d3f0..f6b3bdf 100644
--- a/sync/internal_api/public/base/attachment_id_proto_unittest.cc
+++ b/sync/internal_api/public/base/attachment_id_proto_unittest.cc
@@ -23,8 +23,7 @@ TEST(AttachmentIdProtoTest, UniqueIdFormat) {
               testing::MatchesRegex(
                   "\\w\\w\\w\\w\\w\\w\\w\\w-\\w\\w\\w\\w-\\w\\w\\w\\w-"
                   "\\w\\w\\w\\w-\\w\\w\\w\\w\\w\\w\\w\\w\\w\\w\\w\\w"));
-  EXPECT_EQ(base::StringToLowerASCII(id_proto.unique_id()),
-            id_proto.unique_id());
+  EXPECT_EQ(base::ToLowerASCII(id_proto.unique_id()), id_proto.unique_id());
 }
 
 TEST(AttachmentIdProtoTest, CreateAttachmentMetadata_Empty) {
diff --git a/ui/base/clipboard/clipboard_util_win.cc b/ui/base/clipboard/clipboard_util_win.cc
index 91d58a0..c0c05b0 100644
--- a/ui/base/clipboard/clipboard_util_win.cc
+++ b/ui/base/clipboard/clipboard_util_win.cc
@@ -473,7 +473,7 @@ void ClipboardUtil::CFHtmlExtractMetadata(const std::string& cf_html,
   // If the comments cannot be found, like copying from OpenOffice Writer,
   // we simply fall back to using StartFragment/EndFragment bytecount values
   // to determine the fragment indexes.
-  std::string cf_html_lower = base::StringToLowerASCII(cf_html);
+  std::string cf_html_lower = base::ToLowerASCII(cf_html);
   size_t markup_start = cf_html_lower.find("<html", 0);
   if (html_start) {
     *html_start = markup_start;
diff --git a/ui/chromeos/network/network_connect.cc b/ui/chromeos/network/network_connect.cc
index 508ead1..23e1109 100644
--- a/ui/chromeos/network/network_connect.cc
+++ b/ui/chromeos/network/network_connect.cc
@@ -609,8 +609,7 @@ base::string16 NetworkConnectImpl::GetShillErrorString(
         IDS_CHROMEOS_NETWORK_ERROR_PPP_AUTH_FAILED);
   }
 
-  if (base::StringToLowerASCII(error) ==
-      base::StringToLowerASCII(std::string(shill::kUnknownString))) {
+  if (base::ToLowerASCII(error) == base::ToLowerASCII(shill::kUnknownString)) {
     return l10n_util::GetStringUTF16(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
   }
   return l10n_util::GetStringFUTF16(IDS_NETWORK_UNRECOGNIZED_ERROR,
diff --git a/ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.cc b/ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.cc
index 1e7ef06..22ac345 100644
--- a/ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.cc
+++ b/ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.cc
@@ -768,8 +768,8 @@ MatchUSBID::MatchUSBID(const std::string& arg) : MatchCriteria(arg) {
     }
     std::vector<std::string> tokens = base::SplitString(
         args_[i], ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-    vid_patterns_.push_back(base::StringToLowerASCII(tokens[0]));
-    pid_patterns_.push_back(base::StringToLowerASCII(tokens[1]));
+    vid_patterns_.push_back(base::ToLowerASCII(tokens[0]));
+    pid_patterns_.push_back(base::ToLowerASCII(tokens[1]));
   }
   if (vid_patterns_.empty()) {
     LOG(ERROR) << "No valid USB ID pattern found, will be ignored: \"" << arg
diff --git a/ui/gfx/font_fallback_win.cc b/ui/gfx/font_fallback_win.cc
index e5771cf..ecb85ae 100644
--- a/ui/gfx/font_fallback_win.cc
+++ b/ui/gfx/font_fallback_win.cc
@@ -29,7 +29,7 @@ void QueryFontsFromRegistry(std::map<std::string, std::string>* map) {
   base::win::RegistryValueIterator it(HKEY_LOCAL_MACHINE, kFonts);
   for (; it.Valid(); ++it) {
     const std::string filename =
-        base::StringToLowerASCII(base::WideToUTF8(it.Value()));
+        base::ToLowerASCII(base::WideToUTF8(it.Value()));
     (*map)[filename] = base::WideToUTF8(it.Name());
   }
 }
@@ -44,7 +44,7 @@ void GetFontNamesFromFilename(const std::string& filename,
     QueryFontsFromRegistry(font_map);
 
   std::map<std::string, std::string>::const_iterator it =
-      font_map->find(base::StringToLowerASCII(filename));
+      font_map->find(base::ToLowerASCII(filename));
   if (it == font_map->end())
     return;
 
diff --git a/ui/gfx/font_list_unittest.cc b/ui/gfx/font_list_unittest.cc
index 76755fc..1295839 100644
--- a/ui/gfx/font_list_unittest.cc
+++ b/ui/gfx/font_list_unittest.cc
@@ -260,8 +260,7 @@ TEST(FontListTest, MAYBE_Fonts_DeriveWithSizeDelta) {
 TEST(FontListTest, MAYBE_Fonts_GetHeight_GetBaseline) {
   // If a font list has only one font, the height and baseline must be the same.
   Font font1("Arial", 16);
-  ASSERT_EQ("arial",
-            base::StringToLowerASCII(font1.GetActualFontNameForTesting()));
+  ASSERT_EQ("arial", base::ToLowerASCII(font1.GetActualFontNameForTesting()));
   FontList font_list1("Arial, 16px");
   EXPECT_EQ(font1.GetHeight(), font_list1.GetHeight());
   EXPECT_EQ(font1.GetBaseline(), font_list1.GetBaseline());
@@ -269,8 +268,7 @@ TEST(FontListTest, MAYBE_Fonts_GetHeight_GetBaseline) {
   // If there are two different fonts, the font list returns the max value
   // for the baseline (ascent) and height.
   Font font2("Symbol", 16);
-  ASSERT_EQ("symbol",
-            base::StringToLowerASCII(font2.GetActualFontNameForTesting()));
+  ASSERT_EQ("symbol", base::ToLowerASCII(font2.GetActualFontNameForTesting()));
   EXPECT_NE(font1.GetBaseline(), font2.GetBaseline());
   // TODO(ananta): Find a size and font pair with reliably distinct descents.
   EXPECT_NE(font1.GetHeight(), font2.GetHeight());
diff --git a/ui/gfx/font_unittest.cc b/ui/gfx/font_unittest.cc
index 4b81c81..102c7c8 100644
--- a/ui/gfx/font_unittest.cc
+++ b/ui/gfx/font_unittest.cc
@@ -58,8 +58,7 @@ TEST_F(FontTest, MAYBE_LoadArial) {
   EXPECT_EQ(cf.GetStyle(), Font::NORMAL);
   EXPECT_EQ(cf.GetFontSize(), 16);
   EXPECT_EQ(cf.GetFontName(), "Arial");
-  EXPECT_EQ("arial",
-            base::StringToLowerASCII(cf.GetActualFontNameForTesting()));
+  EXPECT_EQ("arial", base::ToLowerASCII(cf.GetActualFontNameForTesting()));
 }
 
 #if defined(OS_ANDROID)
@@ -74,8 +73,7 @@ TEST_F(FontTest, MAYBE_LoadArialBold) {
   EXPECT_TRUE(bold.GetNativeFont());
 #endif
   EXPECT_EQ(bold.GetStyle(), Font::BOLD);
-  EXPECT_EQ("arial",
-            base::StringToLowerASCII(cf.GetActualFontNameForTesting()));
+  EXPECT_EQ("arial", base::ToLowerASCII(cf.GetActualFontNameForTesting()));
 }
 
 #if defined(OS_ANDROID)
@@ -139,15 +137,13 @@ TEST_F(FontTest, MAYBE_AvgWidths) {
 // http://crbug.com/347429
 TEST_F(FontTest, MAYBE_GetActualFontNameForTesting) {
   Font arial("Arial", 16);
-  EXPECT_EQ("arial",
-            base::StringToLowerASCII(arial.GetActualFontNameForTesting()))
+  EXPECT_EQ("arial", base::ToLowerASCII(arial.GetActualFontNameForTesting()))
       << "********\n"
       << "Your test environment seems to be missing Arial font, which is "
       << "needed for unittests.  Check if Arial font is installed.\n"
       << "********";
   Font symbol("Symbol", 16);
-  EXPECT_EQ("symbol",
-            base::StringToLowerASCII(symbol.GetActualFontNameForTesting()))
+  EXPECT_EQ("symbol", base::ToLowerASCII(symbol.GetActualFontNameForTesting()))
       << "********\n"
       << "Your test environment seems to be missing Symbol font, which is "
       << "needed for unittests.  Check if Symbol font is installed.\n"
@@ -156,8 +152,7 @@ TEST_F(FontTest, MAYBE_GetActualFontNameForTesting) {
   const char* const invalid_font_name = "no_such_font_name";
   Font fallback_font(invalid_font_name, 16);
   EXPECT_NE(invalid_font_name,
-            base::StringToLowerASCII(
-                fallback_font.GetActualFontNameForTesting()));
+            base::ToLowerASCII(fallback_font.GetActualFontNameForTesting()));
 }
 
 #if defined(OS_WIN)
diff --git a/ui/gfx/render_text_unittest.cc b/ui/gfx/render_text_unittest.cc
index bad1262..44ecd7d 100644
--- a/ui/gfx/render_text_unittest.cc
+++ b/ui/gfx/render_text_unittest.cc
@@ -1506,11 +1506,10 @@ TEST_F(RenderTextTest, StringSizeRespectsFontListMetrics) {
   // Check that Arial and Symbol have different font metrics.
   Font arial_font("Arial", 16);
   ASSERT_EQ("arial",
-            base::StringToLowerASCII(arial_font.GetActualFontNameForTesting()));
+            base::ToLowerASCII(arial_font.GetActualFontNameForTesting()));
   Font symbol_font("Symbol", 16);
   ASSERT_EQ("symbol",
-            base::StringToLowerASCII(
-                symbol_font.GetActualFontNameForTesting()));
+            base::ToLowerASCII(symbol_font.GetActualFontNameForTesting()));
   EXPECT_NE(arial_font.GetHeight(), symbol_font.GetHeight());
   EXPECT_NE(arial_font.GetBaseline(), symbol_font.GetBaseline());
   // "a" should be rendered with Arial, not with Symbol.
@@ -2897,9 +2896,9 @@ TEST_F(RenderTextTest, HarfBuzz_FontListFallback) {
   const std::vector<Font>& fonts = font_list.GetFonts();
   ASSERT_EQ(2u, fonts.size());
   ASSERT_EQ("arial",
-            base::StringToLowerASCII(fonts[0].GetActualFontNameForTesting()));
+            base::ToLowerASCII(fonts[0].GetActualFontNameForTesting()));
   ASSERT_EQ("symbol",
-            base::StringToLowerASCII(fonts[1].GetActualFontNameForTesting()));
+            base::ToLowerASCII(fonts[1].GetActualFontNameForTesting()));
 
   // "⊕" (CIRCLED PLUS) should be rendered with Symbol rather than falling back
   // to some other font that's present on the system.
diff --git a/ui/gl/gl_version_info.cc b/ui/gl/gl_version_info.cc
index c3cec4d..cc960b0 100644
--- a/ui/gl/gl_version_info.cc
+++ b/ui/gl/gl_version_info.cc
@@ -67,7 +67,7 @@ void GLVersionInfo::ParseVersionString(const char* version_str,
   *is_es3 = false;
   if (!version_str)
     return;
-  std::string lstr(base::StringToLowerASCII(std::string(version_str)));
+  std::string lstr(base::ToLowerASCII(version_str));
   *is_es = (lstr.length() > 12) && (lstr.substr(0, 9) == "opengl es");
   if (*is_es)
     lstr = lstr.substr(10, 3);