Move StringToUpperASCII and LowerCaseEqualsASCII to the base namespace

net/http/http_response_headers.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 header parsing were borrowed from Firefox:
 // http://lxr.mozilla.org/seamonkey/source/netwerk/protocol/http/src/nsHttpResponseHead.cpp
 // The rules for parsing content-types were also borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_response_headers.h"
@@ skipping 80 matching lines @@
 // this list:
 const char* const kNonUpdatedHeaderPrefixes[] = {
   "content-",
   "x-content-",
   "x-webkit-"
 };
 
 bool ShouldUpdateHeader(const std::string::const_iterator& name_begin,
                         const std::string::const_iterator& name_end) {
   for (size_t i = 0; i < arraysize(kNonUpdatedHeaders); ++i) {
-    if (LowerCaseEqualsASCII(name_begin, name_end, kNonUpdatedHeaders[i]))
+    if (base::LowerCaseEqualsASCII(name_begin, name_end,
+                                   kNonUpdatedHeaders[i]))
       return false;
   }
   for (size_t i = 0; i < arraysize(kNonUpdatedHeaderPrefixes); ++i) {
     if (StartsWithASCII(std::string(name_begin, name_end),
                         kNonUpdatedHeaderPrefixes[i], false))
       return false;
   }
   return true;
 }
 
@@ skipping 513 matching lines @@
 // static
 HttpVersion HttpResponseHeaders::ParseVersion(
     std::string::const_iterator line_begin,
     std::string::const_iterator line_end) {
   std::string::const_iterator p = line_begin;
 
   // RFC2616 sec 3.1: HTTP-Version   = "HTTP" "/" 1*DIGIT "." 1*DIGIT
   // TODO: (1*DIGIT apparently means one or more digits, but we only handle 1).
   // TODO: handle leading zeros, which is allowed by the rfc1616 sec 3.1.
 
-  if ((line_end - p < 4) || !LowerCaseEqualsASCII(p, p + 4, "http")) {
+  if ((line_end - p < 4) || !base::LowerCaseEqualsASCII(p, p + 4, "http")) {
     DVLOG(1) << "missing status line";
     return HttpVersion();
   }
 
   p += 4;
 
   if (p >= line_end || *p != '/') {
     DVLOG(1) << "missing version";
     return HttpVersion();
   }
@@ skipping 110 matching lines @@
 bool HttpResponseHeaders::GetCacheControlDirective(const StringPiece& directive,
                                                    TimeDelta* result) const {
   StringPiece name("cache-control");
   std::string value;
 
   size_t directive_size = directive.size();
 
   void* iter = NULL;
   while (EnumerateHeader(&iter, name, &value)) {
     if (value.size() > directive_size + 1 &&
-        LowerCaseEqualsASCII(value.begin(),
-                             value.begin() + directive_size,
-                             directive.begin()) &&
+        base::LowerCaseEqualsASCII(value.begin(),
+                                   value.begin() + directive_size,
+                                   directive.begin()) &&
         value[directive_size] == '=') {
       int64 seconds;
       base::StringToInt64(
           StringPiece(value.begin() + directive_size + 1, value.end()),
           &seconds);
       *result = TimeDelta::FromSeconds(seconds);
       return true;
     }
   }
 
@@ skipping 398 matching lines @@
   // meaningful when we don't know that this response was from a proxy, but
   // Mozilla also does this, so we'll do the same.
   std::string connection_val;
   if (!EnumerateHeader(NULL, "connection", &connection_val))
     EnumerateHeader(NULL, "proxy-connection", &connection_val);
 
   bool keep_alive;
 
   if (http_version_ == HttpVersion(1, 0)) {
     // HTTP/1.0 responses default to NOT keep-alive
-    keep_alive = LowerCaseEqualsASCII(connection_val, "keep-alive");
+    keep_alive = base::LowerCaseEqualsASCII(connection_val, "keep-alive");
   } else {
     // HTTP/1.1 responses default to keep-alive
-    keep_alive = !LowerCaseEqualsASCII(connection_val, "close");
+    keep_alive = !base::LowerCaseEqualsASCII(connection_val, "close");
   }
 
   return keep_alive;
 }
 
 bool HttpResponseHeaders::HasStrongValidators() const {
   std::string etag_header;
   EnumerateHeader(NULL, "etag", &etag_header);
   std::string last_modified_header;
   EnumerateHeader(NULL, "Last-Modified", &last_modified_header);
@@ skipping 54 matching lines @@
   size_t space_position = content_range_spec.find(' ');
   if (space_position == std::string::npos)
     return false;
 
   // Invalid header if it doesn't contain "bytes-unit".
   std::string::const_iterator content_range_spec_begin =
       content_range_spec.begin();
   std::string::const_iterator content_range_spec_end =
       content_range_spec.begin() + space_position;
   HttpUtil::TrimLWS(&content_range_spec_begin, &content_range_spec_end);
-  if (!LowerCaseEqualsASCII(content_range_spec_begin,
-                            content_range_spec_end,
-                            "bytes")) {
+  if (!base::LowerCaseEqualsASCII(content_range_spec_begin,
+                                  content_range_spec_end,
+                                  "bytes")) {
     return false;
   }
 
   size_t slash_position = content_range_spec.find('/', space_position + 1);
   if (slash_position == std::string::npos)
     return false;
 
   // Obtain the part behind the space and before slash.
   std::string::const_iterator byte_range_resp_spec_begin =
       content_range_spec.begin() + space_position + 1;
   std::string::const_iterator byte_range_resp_spec_end =
       content_range_spec.begin() + slash_position;
   HttpUtil::TrimLWS(&byte_range_resp_spec_begin, &byte_range_resp_spec_end);
 
   // Parse the byte-range-resp-spec part.
   std::string byte_range_resp_spec(byte_range_resp_spec_begin,
                                    byte_range_resp_spec_end);
   // If byte-range-resp-spec != "*".
-  if (!LowerCaseEqualsASCII(byte_range_resp_spec, "*")) {
+  if (!base::LowerCaseEqualsASCII(byte_range_resp_spec, "*")) {
     size_t minus_position = byte_range_resp_spec.find('-');
     if (minus_position != std::string::npos) {
       // Obtain first-byte-pos.
       std::string::const_iterator first_byte_pos_begin =
           byte_range_resp_spec.begin();
       std::string::const_iterator first_byte_pos_end =
           byte_range_resp_spec.begin() + minus_position;
       HttpUtil::TrimLWS(&first_byte_pos_begin, &first_byte_pos_end);
 
       bool ok = base::StringToInt64(StringPiece(first_byte_pos_begin,
@@ skipping 23 matching lines @@
   }
 
   // Parse the instance-length part.
   // If instance-length == "*".
   std::string::const_iterator instance_length_begin =
       content_range_spec.begin() + slash_position + 1;
   std::string::const_iterator instance_length_end =
       content_range_spec.end();
   HttpUtil::TrimLWS(&instance_length_begin, &instance_length_end);
 
-  if (LowerCaseEqualsASCII(instance_length_begin, instance_length_end, "*")) {
+  if (base::LowerCaseEqualsASCII(instance_length_begin, instance_length_end,
+                                 "*")) {
     return false;
   } else if (!base::StringToInt64(StringPiece(instance_length_begin,
                                               instance_length_end),
                                   instance_length)) {
     *instance_length = -1;
     return false;
   }
 
   // We have all the values; let's verify that they make sense for a 206
   // response.
@@ skipping 56 matching lines @@
   return true;
 }
 
 bool HttpResponseHeaders::IsChunkEncoded() const {
   // Ignore spurious chunked responses from HTTP/1.0 servers and proxies.
   return GetHttpVersion() >= HttpVersion(1, 1) &&
       HasHeaderValue("Transfer-Encoding", "chunked");
 }
 
 }  // namespace net