Move StringToLowerASCII to 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 190 matching lines @@
 
   for (size_t i = 0; i < parsed_.size(); ++i) {
     DCHECK(!parsed_[i].is_continuation());
 
     // Locate the start of the next header.
     size_t k = i;
     while (++k < parsed_.size() && parsed_[k].is_continuation()) {}
     --k;
 
     std::string header_name(parsed_[i].name_begin, parsed_[i].name_end);
-    StringToLowerASCII(&header_name);
+    base::StringToLowerASCII(&header_name);
 
     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);
       blob.push_back('\0');
     }
 
     i = k;
   }
   blob.push_back('\0');
@@ skipping 22 matching lines @@
 
     // Locate the start of the next header.
     size_t k = i;
     while (++k < new_parsed.size() && new_parsed[k].is_continuation()) {}
     --k;
 
     const std::string::const_iterator& name_begin = new_parsed[i].name_begin;
     const std::string::const_iterator& name_end = new_parsed[i].name_end;
     if (ShouldUpdateHeader(name_begin, name_end)) {
       std::string name(name_begin, name_end);
-      StringToLowerASCII(&name);
+      base::StringToLowerASCII(&name);
       updated_headers.insert(name);
 
       // Preserve this header line in the merged result, making sure there is
       // a null after the value.
       new_raw_headers.append(name_begin, new_parsed[k].value_end);
       new_raw_headers.push_back('\0');
     }
 
     i = k;
   }
 
   // Now, build the new raw headers.
   MergeWithHeaders(new_raw_headers, updated_headers);
 }
 
 void HttpResponseHeaders::MergeWithHeaders(const std::string& raw_headers,
                                            const HeaderSet& headers_to_remove) {
   std::string new_raw_headers(raw_headers);
   for (size_t i = 0; i < parsed_.size(); ++i) {
     DCHECK(!parsed_[i].is_continuation());
 
     // Locate the start of the next header.
     size_t k = i;
     while (++k < parsed_.size() && parsed_[k].is_continuation()) {}
     --k;
 
     std::string name(parsed_[i].name_begin, parsed_[i].name_end);
-    StringToLowerASCII(&name);
+    base::StringToLowerASCII(&name);
     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);
       new_raw_headers.push_back('\0');
     }
 
     i = k;
   }
   new_raw_headers.push_back('\0');
 
   // Make this object hold the new data.
   raw_headers_.clear();
   parsed_.clear();
   Parse(new_raw_headers);
 }
 
 void HttpResponseHeaders::RemoveHeader(const std::string& name) {
   // Copy up to the null byte.  This just copies the status line.
   std::string new_raw_headers(raw_headers_.c_str());
   new_raw_headers.push_back('\0');
 
   std::string lowercase_name(name);
-  StringToLowerASCII(&lowercase_name);
+  base::StringToLowerASCII(&lowercase_name);
   HeaderSet to_remove;
   to_remove.insert(lowercase_name);
   MergeWithHeaders(new_raw_headers, to_remove);
 }
 
 void HttpResponseHeaders::RemoveHeaderLine(const std::string& name,
                                            const std::string& value) {
   std::string name_lowercase(name);
-  StringToLowerASCII(&name_lowercase);
+  base::StringToLowerASCII(&name_lowercase);
 
   std::string new_raw_headers(GetStatusLine());
   new_raw_headers.push_back('\0');
 
   new_raw_headers.reserve(raw_headers_.size());
 
   void* iter = NULL;
   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);
-    StringToLowerASCII(&old_header_name_lowercase);
+    base::StringToLowerASCII(&old_header_name_lowercase);
 
     if (name_lowercase == old_header_name_lowercase &&
         value == old_header_value)
       continue;
 
     new_raw_headers.append(old_header_name);
     new_raw_headers.push_back(':');
     new_raw_headers.push_back(' ');
     new_raw_headers.append(old_header_value);
     new_raw_headers.push_back('\0');
@@ skipping 130 matching lines @@
   typedef base::hash_map<std::string, size_t> HeadersMap;
   HeadersMap headers_map;
   HeadersMap::iterator iter = headers_map.end();
 
   std::vector<std::string> headers;
 
   for (size_t i = 0; i < parsed_.size(); ++i) {
     DCHECK(!parsed_[i].is_continuation());
 
     std::string name(parsed_[i].name_begin, parsed_[i].name_end);
-    std::string lower_name = StringToLowerASCII(name);
+    std::string lower_name = base::StringToLowerASCII(name);
 
     iter = headers_map.find(lower_name);
     if (iter == headers_map.end()) {
       iter = headers_map.insert(
           HeadersMap::value_type(lower_name, headers.size())).first;
       headers.push_back(name + ": ");
     } else {
       headers[iter->second].append(", ");
     }
 
@@ skipping 355 matching lines @@
         // Skip over comma for next position.
         item_end = item_next;
         item_next++;
       }
       // trim off leading and trailing whitespace in this item.
       HttpUtil::TrimLWS(&item, &item_end);
 
       // assuming the header is not empty, lowercase and insert into set
       if (item_end > item) {
         std::string name(&*item, item_end - item);
-        StringToLowerASCII(&name);
+        base::StringToLowerASCII(&name);
         result->insert(name);
       }
 
       // Continue to next item.
       item = item_next;
     }
   }
 }
 
 void HttpResponseHeaders::AddHopByHopHeaders(HeaderSet* result) {
@@ skipping 530 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