Move LowerCaseEqualsASCII to base namespace

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 100 matching lines @@
 
       std::string::const_iterator param_name_begin = tokenizer.token_begin();
       std::string::const_iterator param_name_end = equals_sign;
       TrimLWS(&param_name_begin, &param_name_end);
 
       std::string::const_iterator param_value_begin = equals_sign + 1;
       std::string::const_iterator param_value_end = tokenizer.token_end();
       DCHECK(param_value_begin <= tokenizer.token_end());
       TrimLWS(&param_value_begin, &param_value_end);
 
-      if (LowerCaseEqualsASCII(param_name_begin, param_name_end, "charset")) {
+      if (base::LowerCaseEqualsASCII(param_name_begin, param_name_end,
+                                     "charset")) {
         // TODO(abarth): Refactor this function to consistently use iterators.
         charset_val = param_value_begin - begin;
         charset_end = param_value_end - begin;
         type_has_charset = true;
-      } else if (LowerCaseEqualsASCII(param_name_begin, param_name_end,
-                                      "boundary")) {
+      } else if (base::LowerCaseEqualsASCII(param_name_begin, param_name_end,
+                                            "boundary")) {
         if (boundary)
           boundary->assign(param_value_begin, param_value_end);
       }
     }
   }
 
   if (type_has_charset) {
     // Trim leading and trailing whitespace from charset_val.  We include
     // '(' in the trailing trim set to catch media-type comments, which are
     // not at all standard, but may occur in rare cases.
@@ skipping 15 matching lines @@
   // also, if type_val is the same as mime_type, then just update the
   // charset.  however, if charset is empty and mime_type hasn't
   // changed, then don't wipe-out an existing charset.  We
   // also want to reject a mime-type if it does not include a slash.
   // some servers give junk after the charset parameter, which may
   // 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() && LowerCaseEqualsASCII(begin + type_val,
-                                                          begin + type_end,
-                                                          mime_type->data());
+    bool eq = !mime_type->empty() &&
+              base::LowerCaseEqualsASCII(begin + type_val, begin + type_end,
+                                         mime_type->data());
     if (!eq) {
       mime_type->assign(begin + type_val, begin + type_end);
       base::StringToLowerASCII(mime_type);
     }
     if ((!eq && *had_charset) || type_has_charset) {
       *had_charset = true;
       charset->assign(begin + charset_val, begin + charset_end);
       base::StringToLowerASCII(charset);
     }
   }
 }
 
 // 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]
 // first-byte-pos  = 1*DIGIT
 // last-byte-pos   = 1*DIGIT
 bool HttpUtil::ParseRanges(const std::string& headers,
                            std::vector<HttpByteRange>* ranges) {
   std::string ranges_specifier;
   HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\r\n");
 
   while (it.GetNext()) {
     // Look for "Range" header.
-    if (!LowerCaseEqualsASCII(it.name(), "range"))
+    if (!base::LowerCaseEqualsASCII(it.name(), "range"))
       continue;
     ranges_specifier = it.values();
     // We just care about the first "Range" header, so break here.
     break;
   }
 
   if (ranges_specifier.empty())
     return false;
 
   return ParseRangeHeader(ranges_specifier, ranges);
 }
 
 // static
 bool HttpUtil::ParseRangeHeader(const std::string& ranges_specifier,
                                 std::vector<HttpByteRange>* ranges) {
   size_t equal_char_offset = ranges_specifier.find('=');
   if (equal_char_offset == std::string::npos)
     return false;
 
   // Try to extract bytes-unit part.
   std::string::const_iterator bytes_unit_begin = ranges_specifier.begin();
   std::string::const_iterator bytes_unit_end = bytes_unit_begin +
                                                equal_char_offset;
   std::string::const_iterator byte_range_set_begin = bytes_unit_end + 1;
   std::string::const_iterator byte_range_set_end = ranges_specifier.end();
 
   TrimLWS(&bytes_unit_begin, &bytes_unit_end);
   // "bytes" unit identifier is not found.
-  if (!LowerCaseEqualsASCII(bytes_unit_begin, bytes_unit_end, "bytes"))
+  if (!base::LowerCaseEqualsASCII(bytes_unit_begin, bytes_unit_end, "bytes"))
     return false;
 
   ValuesIterator byte_range_set_iterator(byte_range_set_begin,
                                          byte_range_set_end, ',');
   while (byte_range_set_iterator.GetNext()) {
     size_t minus_char_offset = byte_range_set_iterator.value().find('-');
     // If '-' character is not found, reports failure.
     if (minus_char_offset == std::string::npos)
       return false;
 
@@ skipping 145 matching lines @@
 // static
 std::string HttpUtil::StripHeaders(const std::string& headers,
                                    const char* const headers_to_remove[],
                                    size_t headers_to_remove_len) {
   std::string stripped_headers;
   HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\r\n");
 
   while (it.GetNext()) {
     bool should_remove = false;
     for (size_t i = 0; i < headers_to_remove_len; ++i) {
-      if (LowerCaseEqualsASCII(it.name_begin(), it.name_end(),
-                               headers_to_remove[i])) {
+      if (base::LowerCaseEqualsASCII(it.name_begin(), it.name_end(),
+                                     headers_to_remove[i])) {
         should_remove = true;
         break;
       }
     }
     if (!should_remove) {
       // Assume that name and values are on the same line.
       stripped_headers.append(it.name_begin(), it.values_end());
       stripped_headers.append("\r\n");
     }
   }
@@ skipping 14 matching lines @@
     "set-cookie",
     // The format of auth-challenges mixes both space separated tokens and
     // comma separated properties, so coalescing on comma won't work.
     "www-authenticate",
     "proxy-authenticate",
     // STS specifies that UAs must not process any STS headers after the first
     // one.
     "strict-transport-security"
   };
   for (size_t i = 0; i < arraysize(kNonCoalescingHeaders); ++i) {
-    if (LowerCaseEqualsASCII(name_begin, name_end, kNonCoalescingHeaders[i]))
+    if (base::LowerCaseEqualsASCII(name_begin, name_end,
+                                   kNonCoalescingHeaders[i]))
       return true;
   }
   return false;
 }
 
 bool HttpUtil::IsLWS(char c) {
   return strchr(HTTP_LWS, c) != NULL;
 }
 
 void HttpUtil::TrimLWS(std::string::const_iterator* begin,
@@ skipping 93 matching lines @@
 // some slop at the start. If the "http" string could not be found
 // then returns -1.
 // static
 int HttpUtil::LocateStartOfStatusLine(const char* buf, int buf_len) {
   const int slop = 4;
   const int http_len = 4;
 
   if (buf_len >= http_len) {
     int i_max = std::min(buf_len - http_len, slop);
     for (int i = 0; i <= i_max; ++i) {
-      if (LowerCaseEqualsASCII(buf + i, buf + i + http_len, "http"))
+      if (base::LowerCaseEqualsASCII(buf + i, buf + i + http_len, "http"))
         return i;
     }
   }
   return -1;  // Not found
 }
 
 int HttpUtil::LocateEndOfHeaders(const char* buf, int buf_len, int i) {
   bool was_lf = false;
   char last_c = '\0';
   for (; i < buf_len; ++i) {
@@ skipping 175 matching lines @@
     return false;
 
   if (!etag_header.empty()) {
     size_t slash = etag_header.find('/');
     if (slash == std::string::npos || slash == 0)
       return true;
 
     std::string::const_iterator i = etag_header.begin();
     std::string::const_iterator j = etag_header.begin() + slash;
     TrimLWS(&i, &j);
-    if (!LowerCaseEqualsASCII(i, j, "w"))
+    if (!base::LowerCaseEqualsASCII(i, j, "w"))
       return true;
   }
 
   base::Time last_modified;
   if (!base::Time::FromString(last_modified_header.c_str(), &last_modified))
     return false;
 
   base::Time date;
   if (!base::Time::FromString(date_header.c_str(), &date))
     return false;
@@ skipping 80 matching lines @@
   }
   return false;
 }
 
 bool HttpUtil::HeadersIterator::AdvanceTo(const char* name) {
   DCHECK(name != NULL);
   DCHECK_EQ(0, base::StringToLowerASCII<std::string>(name).compare(name))
       << "the header name must be in all lower case";
 
   while (GetNext()) {
-    if (LowerCaseEqualsASCII(name_begin_, name_end_, name)) {
+    if (base::LowerCaseEqualsASCII(name_begin_, name_end_, name)) {
       return true;
     }
   }
 
   return false;
 }
 
 HttpUtil::ValuesIterator::ValuesIterator(
     std::string::const_iterator values_begin,
     std::string::const_iterator values_end,
@@ skipping 88 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