Convert remaining StringToLowerASCII to ToLowerASCII

net/http/http_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.
 
 // The rules for parsing content-types were borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_util.h"
 
 #include <algorithm>
@@ skipping 115 matching lines @@
   // include a comma, so this check makes us a bit more tolerant.
   if (content_type_str.length() != 0 &&
       content_type_str != "*/*" &&
       content_type_str.find_first_of('/') != std::string::npos) {
     // Common case here is that mime_type is empty
     bool eq = !mime_type->empty() &&
               base::LowerCaseEqualsASCII(
                   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));
     }
   }
 }
 
 // static
 // Parse the Range header according to RFC 2616 14.35.1
 // ranges-specifier = byte-ranges-specifier
 // byte-ranges-specifier = bytes-unit "=" byte-range-set
 // byte-range-set  = 1#( byte-range-spec | suffix-byte-range-spec )
 // byte-range-spec = first-byte-pos "-" [last-byte-pos]
@@ skipping 161 matching lines @@
   "trailer",
   "transfer-encoding",
   "upgrade",
   "user-agent",
   "via",
 };
 }  // anonymous namespace
 
 // 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;
   for (size_t i = 0; i < arraysize(kForbiddenHeaderFields); ++i) {
     if (lower_name == kForbiddenHeaderFields[i])
       return false;
   }
   return true;
 }
 
@@ skipping 479 matching lines @@
     TrimLWS(&values_begin_, &values_end_);
 
     // if we got a header name, then we are done.
     return true;
   }
   return false;
 }
 
 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()) {
     if (base::LowerCaseEqualsASCII(base::StringPiece(name_begin_, name_end_),
                                    name)) {
       return true;
     }
   }
 
   return false;
@@ skipping 106 matching lines @@
       value_is_quoted_ = true;
       // Do not store iterators into this. See declaration of unquoted_value_.
       unquoted_value_ = HttpUtil::Unquote(value_begin_, value_end_);
     }
   }
 
   return true;
 }
 
 }  // namespace net