Upstream android net related code (part 2)

net/http/http_response_headers.cc

 // Copyright (c) 2011 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 311 matching lines @@
   HeaderSet empty_to_remove;
   MergeWithHeaders(new_raw_headers, empty_to_remove);
 }
 
 void HttpResponseHeaders::Parse(const std::string& raw_input) {
   raw_headers_.reserve(raw_input.size());
 
   // ParseStatusLine adds a normalized status line to raw_headers_
   std::string::const_iterator line_begin = raw_input.begin();
   std::string::const_iterator line_end =
-      find(line_begin, raw_input.end(), '\0');
+      std::find(line_begin, raw_input.end(), '\0');
   // has_headers = true, if there is any data following the status line.
   // Used by ParseStatusLine() to decide if a HTTP/0.9 is really a HTTP/1.0.
   bool has_headers = (line_end != raw_input.end() &&
                       (line_end + 1) != raw_input.end() &&
                       *(line_end + 1) != '\0');
   ParseStatusLine(line_begin, line_end, has_headers);
 
   if (line_end == raw_input.end()) {
     raw_headers_.push_back('\0');
     return;
@@ skipping 107 matching lines @@
   return std::string(raw_headers_.c_str());
 }
 
 std::string HttpResponseHeaders::GetStatusText() const {
   // GetStatusLine() is already normalized, so it has the format:
   // <http_version> SP <response_code> SP <status_text>
   std::string status_text = GetStatusLine();
   std::string::const_iterator begin = status_text.begin();
   std::string::const_iterator end = status_text.end();
   for (int i = 0; i < 2; ++i)
-    begin = find(begin, end, ' ') + 1;
+    begin = std::find(begin, end, ' ') + 1;
   return std::string(begin, end);
 }
 
 bool HttpResponseHeaders::EnumerateHeaderLines(void** iter,
                                                std::string* name,
                                                std::string* value) const {
   size_t i = reinterpret_cast<size_t>(*iter);
   if (i == parsed_.size())
     return false;
 
@@ skipping 79 matching lines @@
     return HttpVersion();
   }
 
   p += 4;
 
   if (p >= line_end || *p != '/') {
     DVLOG(1) << "missing version";
     return HttpVersion();
   }
 
-  std::string::const_iterator dot = find(p, line_end, '.');
+  std::string::const_iterator dot = std::find(p, line_end, '.');
   if (dot == line_end) {
     DVLOG(1) << "malformed version";
     return HttpVersion();
   }
 
   ++p;  // from / to first digit.
   ++dot;  // from . to second digit.
 
   if (!(*p >= '0' && *p <= '9' && *dot >= '0' && *dot <= '9')) {
     DVLOG(1) << "malformed version number";
@@ skipping 26 matching lines @@
     // Treat everything else like HTTP 1.0
     http_version_ = HttpVersion(1, 0);
     raw_headers_ = "HTTP/1.0";
   }
   if (parsed_http_version_ != http_version_) {
     DVLOG(1) << "assuming HTTP/" << http_version_.major_value() << "."
              << http_version_.minor_value();
   }
 
   // TODO(eroman): this doesn't make sense if ParseVersion failed.
-  std::string::const_iterator p = find(line_begin, line_end, ' ');
+  std::string::const_iterator p = std::find(line_begin, line_end, ' ');
 
   if (p == line_end) {
     DVLOG(1) << "missing response status; assuming 200 OK";
     raw_headers_.append(" 200 OK");
     raw_headers_.push_back('\0');
     response_code_ = 200;
     return;
   }
 
   // Skip whitespace.
@@ skipping 614 matching lines @@
   // We have all the values; let's verify that they make sense for a 206
   // response.
   if (*first_byte_position < 0 || *last_byte_position < 0 ||
       *instance_length < 0 || *instance_length - 1 < *last_byte_position)
     return false;
 
   return true;
 }
 
 }  // namespace net