Revert 114929 - Standardize StringToInt{,64} interface.

These changes address issue #106655.  All variants of StringToInt have been
converted to use the StringPiece class.  One instance of conversion, in
chrome/browser/history/text_database.cc, required copying an underlying
string.  This is because the string type in question could use 8 or 16
bit characters depending on the OS type, and because StringPiece is not
implemented as a template, the code cannot specify whether to create a
StringPiece or StringPiece16.  This should be remedied in a future CL.

R=erikwright@chromium.org
BUG=106655
TEST=


Review URL: http://codereview.chromium.org/8921006

TBR=tedvessenes@gmail.com
Review URL: http://codereview.chromium.org/8984007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@114930 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 90 insertions, 0 deletions

diff --git a/base/string_number_conversions_unittest.cc b/base/string_number_conversions_unittest.cc
index 438db07..1e5ff14 100644
--- a/base/string_number_conversions_unittest.cc
+++ b/base/string_number_conversions_unittest.cc
@@ -105,14 +105,34 @@ TEST(StringNumberConversionsTest, StringToInt) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    const char* ascii_chars = cases[i].input.c_str();
     int output = 0;
     EXPECT_EQ(cases[i].success, StringToInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt(cases[i].input.begin(),
+                                            cases[i].input.end(),
+                                            &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt(
+        ascii_chars, ascii_chars + cases[i].input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
 
     string16 utf16_input = UTF8ToUTF16(cases[i].input);
+    const char16* utf16_chars = utf16_input.c_str();
     output = 0;
     EXPECT_EQ(cases[i].success, StringToInt(utf16_input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt(utf16_input.begin(),
+                                            utf16_input.end(),
+                                            &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt(
+        utf16_chars, utf16_chars + utf16_input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
   }
 
   // One additional test to verify that conversion of numbers in strings with
@@ -123,11 +143,26 @@ TEST(StringNumberConversionsTest, StringToInt) {
   int output;
   EXPECT_FALSE(StringToInt(input_string, &output));
   EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt(input_string.begin(), input_string.end(), &output));
+  EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt(input, input + arraysize(input), &output));
+  EXPECT_EQ(6, output);
 
   string16 utf16_input = UTF8ToUTF16(input_string);
+  const char16* utf16_chars = utf16_input.c_str();
   output = 0;
   EXPECT_FALSE(StringToInt(utf16_input, &output));
   EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt(utf16_input.begin(), utf16_input.end(), &output));
+  EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt(utf16_chars,
+                           utf16_chars + utf16_input.length(),
+                           &output));
+  EXPECT_EQ(6, output);
 
   output = 0;
   const char16 negative_wide_input[] = { 0xFF4D, '4', '2', 0};
@@ -175,14 +210,34 @@ TEST(StringNumberConversionsTest, StringToInt64) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    const char* ascii_chars = cases[i].input.c_str();
     int64 output = 0;
     EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt64(cases[i].input.begin(),
+                                              cases[i].input.end(),
+                                              &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt64(
+        ascii_chars, ascii_chars + cases[i].input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
 
     string16 utf16_input = UTF8ToUTF16(cases[i].input);
+    const char16* utf16_chars = utf16_input.c_str();
     output = 0;
     EXPECT_EQ(cases[i].success, StringToInt64(utf16_input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt64(utf16_input.begin(),
+                                              utf16_input.end(),
+                                              &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, StringToInt64(
+        utf16_chars, utf16_chars + utf16_input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
   }
 
   // One additional test to verify that conversion of numbers in strings with
@@ -193,11 +248,28 @@ TEST(StringNumberConversionsTest, StringToInt64) {
   int64 output;
   EXPECT_FALSE(StringToInt64(input_string, &output));
   EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt64(input_string.begin(),
+                             input_string.end(),
+                             &output));
+  EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt64(input, input + arraysize(input), &output));
+  EXPECT_EQ(6, output);
 
   string16 utf16_input = UTF8ToUTF16(input_string);
+  const char16* utf16_chars = utf16_input.c_str();
   output = 0;
   EXPECT_FALSE(StringToInt64(utf16_input, &output));
   EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt64(utf16_input.begin(), utf16_input.end(), &output));
+  EXPECT_EQ(6, output);
+  output = 0;
+  EXPECT_FALSE(StringToInt64(utf16_chars,
+                             utf16_chars + utf16_input.length(),
+                             &output));
+  EXPECT_EQ(6, output);
 }
 
 TEST(StringNumberConversionsTest, HexStringToInt) {
@@ -238,9 +310,19 @@ TEST(StringNumberConversionsTest, HexStringToInt) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    const char* ascii_chars = cases[i].input.c_str();
     int output = 0;
     EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input.begin(),
+                                               cases[i].input.end(),
+                                               &output));
+    EXPECT_EQ(cases[i].output, output);
+    output = 0;
+    EXPECT_EQ(cases[i].success, HexStringToInt(
+        ascii_chars, ascii_chars + cases[i].input.length(), &output));
+    EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
@@ -250,6 +332,14 @@ TEST(StringNumberConversionsTest, HexStringToInt) {
   int output;
   EXPECT_FALSE(HexStringToInt(input_string, &output));
   EXPECT_EQ(0xc0ffee, output);
+  output = 0;
+  EXPECT_FALSE(HexStringToInt(input_string.begin(),
+                              input_string.end(),
+                              &output));
+  EXPECT_EQ(0xc0ffee, output);
+  output = 0;
+  EXPECT_FALSE(HexStringToInt(input, input + arraysize(input), &output));
+  EXPECT_EQ(0xc0ffee, output);
 }
 
 TEST(StringNumberConversionsTest, HexStringToBytes) {