Standardize StringToInt{,64} interface.

base/string_piece.h

 // 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.
 // Copied from strings/stringpiece.h with modifications
 //
 // A string-like object that points to a sized piece of memory.
 //
 // Functions or methods may use const StringPiece& parameters to accept either
 // a "const char*" or a "string" value that will be implicitly converted to
 // a StringPiece.  The implicit conversion means that it is often appropriate
@@ skipping 42 matching lines @@
   // We provide non-explicit singleton constructors so users can pass
   // in a "const char*" or a "string" wherever a "StringPiece" is
   // expected.
   StringPiece() : ptr_(NULL), length_(0) { }
   StringPiece(const char* str)
     : ptr_(str), length_((str == NULL) ? 0 : strlen(str)) { }
   StringPiece(const std::string& str)
     : ptr_(str.data()), length_(str.size()) { }
   StringPiece(const char* offset, size_type len)
     : ptr_(offset), length_(len) { }
+  StringPiece(const std::string::const_iterator& begin,
+              const std::string::const_iterator& end)
+    : ptr_((end > begin) ? &(*begin) : NULL),
+      length_((end > begin) ? (size_type)(end - begin) : 0) { }
 
   // data() may return a pointer to a buffer with embedded NULs, and the
   // returned buffer may or may not be null terminated.  Therefore it is
   // typically a mistake to pass data() to a routine that expects a NUL
   // terminated string.
   const char* data() const { return ptr_; }
   size_type size() const { return length_; }
   size_type length() const { return length_; }
   bool empty() const { return length_ == 0; }
 
@@ skipping 117 matching lines @@
   // in a "const char16*" or a "string16" wherever a "StringPiece16" is
   // expected.
   StringPiece16() : ptr_(NULL), length_(0) { }
   StringPiece16(const char16* str)
       : ptr_(str),
         length_((str == NULL) ? 0 : string16::traits_type::length(str)) { }
   StringPiece16(const string16& str)
       : ptr_(str.data()), length_(str.size()) { }
   StringPiece16(const char16* offset, size_type len)
       : ptr_(offset), length_(len) { }
+  StringPiece16(const string16::const_iterator& begin,
+                const string16::const_iterator& end)
+      : ptr_((end > begin) ? &(*begin) : NULL),
+        length_((end > begin) ? (size_type)(end - begin) : 0) { }
 
   // data() may return a pointer to a buffer with embedded NULs, and the
   // returned buffer may or may not be null terminated.  Therefore it is
   // typically a mistake to pass data() to a routine that expects a NUL
   // terminated string.
   const char16* data() const { return ptr_; }
   size_type size() const { return length_; }
   size_type length() const { return length_; }
   bool empty() const { return length_ == 0; }
 
@@ skipping 130 matching lines @@
 }
 inline size_t hash_value(const base::StringPiece16& sp16) {
   HASH_STRING_PIECE(base::StringPiece16, sp16);
 }
 
 #endif  // COMPILER
 
 }  // namespace BASE_HASH_NAMESPACE
 
 #endif  // BASE_STRING_PIECE_H_