Standardize StringToInt{,64} interface.

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"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/string_number_conversions.h"
+#include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/escape.h"
 #include "net/http/http_util.h"
 
+using base::StringPiece;
 using base::Time;
 using base::TimeDelta;
 
 namespace net {
 
 //-----------------------------------------------------------------------------
 
 namespace {
 
 // These headers are RFC 2616 hop-by-hop headers;
@@ skipping 658 matching lines @@
 
   if (p == code) {
     DVLOG(1) << "missing response status number; assuming 200";
     raw_headers_.append(" 200 OK");
     response_code_ = 200;
     return;
   }
   raw_headers_.push_back(' ');
   raw_headers_.append(code, p);
   raw_headers_.push_back(' ');
-  base::StringToInt(code, p, &response_code_);
+  base::StringToInt(StringPiece(&(*code), (int)(p - code)),

[erikwright (departed), 2011/12/14 04:24:08]

code & p are iterators...

+                    &response_code_);
 
   // Skip whitespace.
   while (*p == ' ')
     ++p;
 
   // Trim trailing whitespace.
   while (line_end > p && line_end[-1] == ' ')
     --line_end;
 
   if (p == line_end) {
@@ skipping 352 matching lines @@
   const char kMaxAgePrefix[] = "max-age=";
   const size_t kMaxAgePrefixLen = arraysize(kMaxAgePrefix) - 1;
 
   void* iter = NULL;
   while (EnumerateHeader(&iter, name, &value)) {
     if (value.size() > kMaxAgePrefixLen) {
       if (LowerCaseEqualsASCII(value.begin(),
                                value.begin() + kMaxAgePrefixLen,
                                kMaxAgePrefix)) {
         int64 seconds;
-        base::StringToInt64(value.begin() + kMaxAgePrefixLen,
-                            value.end(),
+        base::StringToInt64(StringPiece(value.begin() + kMaxAgePrefixLen,
+                                        value.end()),
                             &seconds);
         *result = TimeDelta::FromSeconds(seconds);
         return true;
       }
     }
   }
 
   return false;
 }
 
@@ skipping 157 matching lines @@
   if (!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(first_byte_pos_begin,
-                                    first_byte_pos_end,
+      bool ok = base::StringToInt64(StringPiece(first_byte_pos_begin,
+                                                first_byte_pos_end),
                                     first_byte_position);
 
       // Obtain last-byte-pos.
       std::string::const_iterator last_byte_pos_begin =
           byte_range_resp_spec.begin() + minus_position + 1;
       std::string::const_iterator last_byte_pos_end =
           byte_range_resp_spec.end();
       HttpUtil::TrimLWS(&last_byte_pos_begin, &last_byte_pos_end);
 
-      ok &= base::StringToInt64(last_byte_pos_begin,
-                                last_byte_pos_end,
+      ok &= base::StringToInt64(StringPiece(last_byte_pos_begin,
+                                            last_byte_pos_end),
                                 last_byte_position);
       if (!ok) {
         *first_byte_position = *last_byte_position = -1;
         return false;
       }
       if (*first_byte_position < 0 || *last_byte_position < 0 ||
           *first_byte_position > *last_byte_position)
         return false;
     } else {
       return false;
     }
   }
 
   // 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, "*")) {
     return false;
-  } else if (!base::StringToInt64(instance_length_begin,
-                                  instance_length_end,
+  } 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.
   if (*first_byte_position < 0 || *last_byte_position < 0 ||
       *instance_length < 0 || *instance_length - 1 < *last_byte_position)
     return false;
 
   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