IndexedDB: Switch key/value handling from vector<char> to std::string

content/browser/indexed_db/indexed_db_leveldb_coding_unittest.cc

 // Copyright (c) 2013 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.
 
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
 
 #include <limits>
-#include <string>

[alecflett, 2013/07/09 18:26:30]

I think you still want <string> here, no?

[jsbell, 2013/07/09 19:41:46]

Per pkasting on IRC: "Per the style guide, foo_unittest.cc should #include foo.h
first, just like foo.cc does.  (Then it doesn't need to repeat anything else.)"

(So technically, more of the includes below could be removed too.)

 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
-#include "content/browser/indexed_db/leveldb/leveldb_slice.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using WebKit::WebIDBKey;
 using WebKit::WebIDBKeyPath;
 
 namespace content {
 
@@ skipping 10 matching lines @@
 }
 
 static IndexedDBKey CreateArrayIDBKey(const IndexedDBKey& key1,
                                       const IndexedDBKey& key2) {
   IndexedDBKey::KeyArray array;
   array.push_back(key1);
   array.push_back(key2);
   return IndexedDBKey(array);
 }
 
-static std::vector<char> WrappedEncodeByte(char value) {
-  std::vector<char> buffer;
+static std::string WrappedEncodeByte(char value) {
+  std::string buffer;
   EncodeByte(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeByte) {
-  std::vector<char> expected;
+  std::string expected;
   expected.push_back(0);
   unsigned char c;
 
   c = 0;
   expected[0] = c;
   EXPECT_EQ(expected, WrappedEncodeByte(c));
 
   c = 1;
   expected[0] = c;
   EXPECT_EQ(expected, WrappedEncodeByte(c));
 
   c = 255;
   expected[0] = c;
   EXPECT_EQ(expected, WrappedEncodeByte(c));
 }
 
 TEST(IndexedDBLevelDBCodingTest, DecodeByte) {
   std::vector<unsigned char> test_cases;
   test_cases.push_back(0);
   test_cases.push_back(1);
   test_cases.push_back(255);
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
     unsigned char n = test_cases[i];
-    std::vector<char> v;
+    std::string v;
     EncodeByte(n, &v);
 
     unsigned char res;
     ASSERT_GT(v.size(), static_cast<size_t>(0));
     StringPiece slice(&*v.begin(), v.size());
     EXPECT_TRUE(DecodeByte(&slice, &res));
     EXPECT_EQ(n, res);
     EXPECT_TRUE(slice.empty());
   }
 
   {
     StringPiece slice;
     unsigned char value;
     EXPECT_FALSE(DecodeByte(&slice, &value));
   }
 }
 
-static std::vector<char> WrappedEncodeBool(bool value) {
-  std::vector<char> buffer;
+static std::string WrappedEncodeBool(bool value) {
+  std::string buffer;
   EncodeBool(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeBool) {
   {
-    std::vector<char> expected;
+    std::string expected;
     expected.push_back(1);
     EXPECT_EQ(expected, WrappedEncodeBool(true));
   }
   {
-    std::vector<char> expected;
+    std::string expected;
     expected.push_back(0);
     EXPECT_EQ(expected, WrappedEncodeBool(false));
   }
 }
 
-static int CompareKeys(const std::vector<char>& a, const std::vector<char>& b) {
+static int CompareKeys(const std::string& a, const std::string& b) {
   bool ok;
   int result = CompareEncodedIDBKeys(a, b, &ok);
   EXPECT_TRUE(ok);
   return result;
 }
 
 TEST(IndexedDBLevelDBCodingTest, MaxIDBKey) {
-  std::vector<char> max_key = MaxIDBKey();
+  std::string max_key = MaxIDBKey();
 
-  std::vector<char> min_key = MinIDBKey();
-  std::vector<char> array_key;
+  std::string min_key = MinIDBKey();
+  std::string array_key;
   EncodeIDBKey(IndexedDBKey(IndexedDBKey::KeyArray()), &array_key);
-  std::vector<char> string_key;
+  std::string string_key;
   EncodeIDBKey(IndexedDBKey(ASCIIToUTF16("Hello world")), &string_key);
-  std::vector<char> number_key;
+  std::string number_key;
   EncodeIDBKey(IndexedDBKey(3.14, WebIDBKey::NumberType), &number_key);
-  std::vector<char> date_key;
+  std::string date_key;
   EncodeIDBKey(IndexedDBKey(1000000, WebIDBKey::DateType), &date_key);
 
   EXPECT_GT(CompareKeys(max_key, min_key), 0);
   EXPECT_GT(CompareKeys(max_key, array_key), 0);
   EXPECT_GT(CompareKeys(max_key, string_key), 0);
   EXPECT_GT(CompareKeys(max_key, number_key), 0);
   EXPECT_GT(CompareKeys(max_key, date_key), 0);
 }
 
 TEST(IndexedDBLevelDBCodingTest, MinIDBKey) {
-  std::vector<char> min_key = MinIDBKey();
+  std::string min_key = MinIDBKey();
 
-  std::vector<char> max_key = MaxIDBKey();
-  std::vector<char> array_key;
+  std::string max_key = MaxIDBKey();
+  std::string array_key;
   EncodeIDBKey(IndexedDBKey(IndexedDBKey::KeyArray()), &array_key);
-  std::vector<char> string_key;
+  std::string string_key;
   EncodeIDBKey(IndexedDBKey(ASCIIToUTF16("Hello world")), &string_key);
-  std::vector<char> number_key;
+  std::string number_key;
   EncodeIDBKey(IndexedDBKey(3.14, WebIDBKey::NumberType), &number_key);
-  std::vector<char> date_key;
+  std::string date_key;
   EncodeIDBKey(IndexedDBKey(1000000, WebIDBKey::DateType), &date_key);
 
   EXPECT_LT(CompareKeys(min_key, max_key), 0);
   EXPECT_LT(CompareKeys(min_key, array_key), 0);
   EXPECT_LT(CompareKeys(min_key, string_key), 0);
   EXPECT_LT(CompareKeys(min_key, number_key), 0);
   EXPECT_LT(CompareKeys(min_key, date_key), 0);
 }
 
-static std::vector<char> WrappedEncodeInt(int64 value) {
-  std::vector<char> buffer;
+static std::string WrappedEncodeInt(int64 value) {
+  std::string buffer;
   EncodeInt(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeInt) {
   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeInt(0).size());
   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeInt(1).size());
   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeInt(255).size());
   EXPECT_EQ(static_cast<size_t>(2), WrappedEncodeInt(256).size());
   EXPECT_EQ(static_cast<size_t>(4), WrappedEncodeInt(0xffffffff).size());
 #ifdef NDEBUG
   EXPECT_EQ(static_cast<size_t>(8), WrappedEncodeInt(-1).size());
 #endif
 }
 
 TEST(IndexedDBLevelDBCodingTest, DecodeBool) {
   {
-    std::vector<char> encoded;
+    std::string encoded;
     encoded.push_back(1);
     StringPiece slice(&*encoded.begin(), encoded.size());
     bool value;
     EXPECT_TRUE(DecodeBool(&slice, &value));
     EXPECT_TRUE(value);
     EXPECT_TRUE(slice.empty());
   }
   {
-    std::vector<char> encoded;
+    std::string encoded;
     encoded.push_back(0);
     StringPiece slice(&*encoded.begin(), encoded.size());
     bool value;
     EXPECT_TRUE(DecodeBool(&slice, &value));
     EXPECT_FALSE(value);
     EXPECT_TRUE(slice.empty());
   }
   {
     StringPiece slice;
     bool value;
@@ skipping 10 matching lines @@
   test_cases.push_back(65535);
   test_cases.push_back(655536);
   test_cases.push_back(7711192431755665792ll);
   test_cases.push_back(0x7fffffffffffffffll);
 #ifdef NDEBUG
   test_cases.push_back(-3);
 #endif
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
     int64 n = test_cases[i];
-    std::vector<char> v = WrappedEncodeInt(n);
+    std::string v = WrappedEncodeInt(n);
     ASSERT_GT(v.size(), static_cast<size_t>(0));
     StringPiece slice(&*v.begin(), v.size());
     int64 value;
     EXPECT_TRUE(DecodeInt(&slice, &value));
     EXPECT_EQ(n, value);
     EXPECT_TRUE(slice.empty());
 
     // Verify decoding at an offset, to detect unaligned memory access.
     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
     EXPECT_TRUE(DecodeInt(&slice, &value));
     EXPECT_EQ(n, value);
     EXPECT_TRUE(slice.empty());
   }
   {
     StringPiece slice;
     int64 value;
     EXPECT_FALSE(DecodeInt(&slice, &value));
   }
 }
 
-static std::vector<char> WrappedEncodeVarInt(int64 value) {
-  std::vector<char> buffer;
+static std::string WrappedEncodeVarInt(int64 value) {
+  std::string buffer;
   EncodeVarInt(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeVarInt) {
   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeVarInt(0).size());
   EXPECT_EQ(static_cast<size_t>(1), WrappedEncodeVarInt(1).size());
   EXPECT_EQ(static_cast<size_t>(2), WrappedEncodeVarInt(255).size());
   EXPECT_EQ(static_cast<size_t>(2), WrappedEncodeVarInt(256).size());
   EXPECT_EQ(static_cast<size_t>(5), WrappedEncodeVarInt(0xffffffff).size());
@@ skipping 15 matching lines @@
   test_cases.push_back(65535);
   test_cases.push_back(655536);
   test_cases.push_back(7711192431755665792ll);
   test_cases.push_back(0x7fffffffffffffffll);
 #ifdef NDEBUG
   test_cases.push_back(-3);
 #endif
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
     int64 n = test_cases[i];
-    std::vector<char> v = WrappedEncodeVarInt(n);
+    std::string v = WrappedEncodeVarInt(n);
     ASSERT_GT(v.size(), static_cast<size_t>(0));
     StringPiece slice(&*v.begin(), v.size());
     int64 res;
     EXPECT_TRUE(DecodeVarInt(&slice, &res));
     EXPECT_EQ(n, res);
     EXPECT_TRUE(slice.empty());
 
     slice = StringPiece(&*v.begin(), v.size() - 1);
     EXPECT_FALSE(DecodeVarInt(&slice, &res));
 
     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
     EXPECT_FALSE(DecodeVarInt(&slice, &res));
 
     // Verify decoding at an offset, to detect unaligned memory access.
     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
     EXPECT_TRUE(DecodeVarInt(&slice, &res));
     EXPECT_EQ(n, res);
     EXPECT_TRUE(slice.empty());
   }
 }
 
-static std::vector<char> WrappedEncodeString(string16 value) {
-  std::vector<char> buffer;
+static std::string WrappedEncodeString(string16 value) {
+  std::string buffer;
   EncodeString(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeString) {
   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 
   EXPECT_EQ(static_cast<size_t>(0),
             WrappedEncodeString(ASCIIToUTF16("")).size());
@@ skipping 13 matching lines @@
 
   std::vector<string16> test_cases;
   test_cases.push_back(string16());
   test_cases.push_back(ASCIIToUTF16("a"));
   test_cases.push_back(ASCIIToUTF16("foo"));
   test_cases.push_back(test_string_a);
   test_cases.push_back(test_string_b);
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
     const string16& test_case = test_cases[i];
-    std::vector<char> v = WrappedEncodeString(test_case);
+    std::string v = WrappedEncodeString(test_case);
 
     StringPiece slice;
     if (v.size()) {
       slice = StringPiece(&*v.begin(), v.size());
     }
 
     string16 result;
     EXPECT_TRUE(DecodeString(&slice, &result));
     EXPECT_EQ(test_case, result);
     EXPECT_TRUE(slice.empty());
 
     // Verify decoding at an offset, to detect unaligned memory access.
     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
     EXPECT_TRUE(DecodeString(&slice, &result));
     EXPECT_EQ(test_case, result);
     EXPECT_TRUE(slice.empty());
   }
 }
 
-static std::vector<char> WrappedEncodeStringWithLength(string16 value) {
-  std::vector<char> buffer;
+static std::string WrappedEncodeStringWithLength(string16 value) {
+  std::string buffer;
   EncodeStringWithLength(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeStringWithLength) {
   const char16 test_string_a[] = {'f', 'o', 'o', '\0'};
   const char16 test_string_b[] = {0xdead, 0xbeef, '\0'};
 
   EXPECT_EQ(static_cast<size_t>(1),
             WrappedEncodeStringWithLength(string16()).size());
@@ skipping 18 matching lines @@
   std::vector<string16> test_cases;
   test_cases.push_back(ASCIIToUTF16(""));
   test_cases.push_back(ASCIIToUTF16("a"));
   test_cases.push_back(ASCIIToUTF16("foo"));
   test_cases.push_back(string16(test_string_a));
   test_cases.push_back(string16(test_string_b));
   test_cases.push_back(string16(long_string));
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
     string16 s = test_cases[i];
-    std::vector<char> v = WrappedEncodeStringWithLength(s);
+    std::string v = WrappedEncodeStringWithLength(s);
     ASSERT_GT(v.size(), static_cast<size_t>(0));
     StringPiece slice(&*v.begin(), v.size());
     string16 res;
     EXPECT_TRUE(DecodeStringWithLength(&slice, &res));
     EXPECT_EQ(s, res);
     EXPECT_TRUE(slice.empty());
 
     slice = StringPiece(&*v.begin(), v.size() - 1);
     EXPECT_FALSE(DecodeStringWithLength(&slice, &res));
 
     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
     EXPECT_FALSE(DecodeStringWithLength(&slice, &res));
 
     // Verify decoding at an offset, to detect unaligned memory access.
     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
     EXPECT_TRUE(DecodeStringWithLength(&slice, &res));
     EXPECT_EQ(s, res);
     EXPECT_TRUE(slice.empty());
   }
 }
 
-static int CompareStrings(const std::vector<char>& p,
-                          const std::vector<char>& q) {
+static int CompareStrings(const std::string& p, const std::string& q) {
   bool ok;
   DCHECK(!p.empty());
   DCHECK(!q.empty());
   StringPiece slice_p(&*p.begin(), p.size());
   StringPiece slice_q(&*q.begin(), q.size());
   int result = CompareEncodedStringsWithLength(&slice_p, &slice_q, &ok);
   EXPECT_TRUE(ok);
   EXPECT_TRUE(slice_p.empty());
   EXPECT_TRUE(slice_q.empty());
   return result;
@@ skipping 23 matching lines @@
 
   for (size_t i = 0; i < test_cases.size() - 1; ++i) {
     string16 a = test_cases[i];
     string16 b = test_cases[i + 1];
 
     EXPECT_LT(a.compare(b), 0);
     EXPECT_GT(b.compare(a), 0);
     EXPECT_EQ(a.compare(a), 0);
     EXPECT_EQ(b.compare(b), 0);
 
-    std::vector<char> encoded_a = WrappedEncodeStringWithLength(a);
+    std::string encoded_a = WrappedEncodeStringWithLength(a);
     EXPECT_TRUE(encoded_a.size());
-    std::vector<char> encoded_b = WrappedEncodeStringWithLength(b);
+    std::string encoded_b = WrappedEncodeStringWithLength(b);
     EXPECT_TRUE(encoded_a.size());
 
     EXPECT_LT(CompareStrings(encoded_a, encoded_b), 0);
     EXPECT_GT(CompareStrings(encoded_b, encoded_a), 0);
     EXPECT_EQ(CompareStrings(encoded_a, encoded_a), 0);
     EXPECT_EQ(CompareStrings(encoded_b, encoded_b), 0);
   }
 }
 
-static std::vector<char> WrappedEncodeDouble(double value) {
-  std::vector<char> buffer;
+static std::string WrappedEncodeDouble(double value) {
+  std::string buffer;
   EncodeDouble(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeDouble) {
   EXPECT_EQ(static_cast<size_t>(8), WrappedEncodeDouble(0).size());
   EXPECT_EQ(static_cast<size_t>(8), WrappedEncodeDouble(3.14).size());
 }
 
 TEST(IndexedDBLevelDBCodingTest, DecodeDouble) {
   std::vector<double> test_cases;
   test_cases.push_back(3.14);
   test_cases.push_back(-3.14);
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
     double value = test_cases[i];
-    std::vector<char> v = WrappedEncodeDouble(value);
+    std::string v = WrappedEncodeDouble(value);
     ASSERT_GT(v.size(), static_cast<size_t>(0));
     StringPiece slice(&*v.begin(), v.size());
     double result;
     EXPECT_TRUE(DecodeDouble(&slice, &result));
     EXPECT_EQ(value, result);
     EXPECT_TRUE(slice.empty());
 
     slice = StringPiece(&*v.begin(), v.size() - 1);
     EXPECT_FALSE(DecodeDouble(&slice, &result));
 
     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
     EXPECT_FALSE(DecodeDouble(&slice, &result));
 
     // Verify decoding at an offset, to detect unaligned memory access.
     v.insert(v.begin(), static_cast<size_t>(1), static_cast<char>(0));
     slice = StringPiece(&*v.begin() + 1, v.size() - 1);
     EXPECT_TRUE(DecodeDouble(&slice, &result));
     EXPECT_EQ(value, result);
     EXPECT_TRUE(slice.empty());
   }
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeDecodeIDBKey) {
   IndexedDBKey expected_key;
   scoped_ptr<IndexedDBKey> decoded_key;
-  std::vector<char> v;
+  std::string v;
   StringPiece slice;
 
   std::vector<IndexedDBKey> test_cases;
   test_cases.push_back(IndexedDBKey(1234, WebIDBKey::NumberType));
   test_cases.push_back(IndexedDBKey(7890, WebIDBKey::DateType));
   test_cases.push_back(IndexedDBKey(ASCIIToUTF16("Hello World!")));
   test_cases.push_back(IndexedDBKey(IndexedDBKey::KeyArray()));
 
   IndexedDBKey::KeyArray array;
   array.push_back(IndexedDBKey(1234, WebIDBKey::NumberType));
@@ skipping 12 matching lines @@
     EXPECT_TRUE(slice.empty());
 
     slice = StringPiece(&*v.begin(), v.size() - 1);
     EXPECT_FALSE(DecodeIDBKey(&slice, &decoded_key));
 
     slice = StringPiece(&*v.begin(), static_cast<size_t>(0));
     EXPECT_FALSE(DecodeIDBKey(&slice, &decoded_key));
   }
 }
 
-static std::vector<char> WrappedEncodeIDBKeyPath(
-    const IndexedDBKeyPath& value) {
-  std::vector<char> buffer;
+static std::string WrappedEncodeIDBKeyPath(const IndexedDBKeyPath& value) {
+  std::string buffer;
   EncodeIDBKeyPath(value, &buffer);
   return buffer;
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeDecodeIDBKeyPath) {
   std::vector<IndexedDBKeyPath> key_paths;
-  std::vector<std::vector<char> > encoded_paths;
+  std::vector<std::string> encoded_paths;
 
   {
     key_paths.push_back(IndexedDBKeyPath());
     char expected[] = {0, 0,  // Header
                        0      // Type is null
     };
     encoded_paths.push_back(
-        std::vector<char>(expected, expected + arraysize(expected)));
+        std::string(expected, expected + arraysize(expected)));
   }
 
   {
     key_paths.push_back(IndexedDBKeyPath(string16()));
     char expected[] = {0, 0,  // Header
                        1,     // Type is string
                        0      // Length is 0
     };
     encoded_paths.push_back(
-        std::vector<char>(expected, expected + arraysize(expected)));
+        std::string(expected, expected + arraysize(expected)));
   }
 
   {
     key_paths.push_back(IndexedDBKeyPath(ASCIIToUTF16("foo")));
     char expected[] = {0, 0,                      // Header
                        1,                         // Type is string
                        3, 0, 'f', 0, 'o', 0, 'o'  // String length 3, UTF-16BE
     };
     encoded_paths.push_back(
-        std::vector<char>(expected, expected + arraysize(expected)));
+        std::string(expected, expected + arraysize(expected)));
   }
 
   {
     key_paths.push_back(IndexedDBKeyPath(ASCIIToUTF16("foo.bar")));
     char expected[] = {0, 0,  // Header
                        1,     // Type is string
                        7, 0, 'f', 0, 'o', 0, 'o', 0, '.', 0, 'b', 0, 'a', 0,
                        'r'  // String length 7, UTF-16BE
     };
     encoded_paths.push_back(
-        std::vector<char>(expected, expected + arraysize(expected)));
+        std::string(expected, expected + arraysize(expected)));
   }
 
   {
     std::vector<string16> array;
     array.push_back(string16());
     array.push_back(ASCIIToUTF16("foo"));
     array.push_back(ASCIIToUTF16("foo.bar"));
 
     key_paths.push_back(IndexedDBKeyPath(array));
     char expected[] = {0, 0,                       // Header
                        2, 3,                       // Type is array, length is 3
                        0,                          // Member 1 (String length 0)
                        3, 0, 'f', 0, 'o', 0, 'o',  // Member 2 (String length 3)
                        7, 0, 'f', 0, 'o', 0, 'o', 0, '.', 0, 'b', 0, 'a', 0,
                        'r'  // Member 3 (String length 7)
     };
     encoded_paths.push_back(
-        std::vector<char>(expected, expected + arraysize(expected)));
+        std::string(expected, expected + arraysize(expected)));
   }
 
   ASSERT_EQ(key_paths.size(), encoded_paths.size());
   for (size_t i = 0; i < key_paths.size(); ++i) {
     IndexedDBKeyPath key_path = key_paths[i];
-    std::vector<char> encoded = encoded_paths[i];
+    std::string encoded = encoded_paths[i];
 
-    std::vector<char> v = WrappedEncodeIDBKeyPath(key_path);
+    std::string v = WrappedEncodeIDBKeyPath(key_path);
     EXPECT_EQ(encoded, v);
 
     StringPiece slice(&*encoded.begin(), encoded.size());
     IndexedDBKeyPath decoded;
     EXPECT_TRUE(DecodeIDBKeyPath(&slice, &decoded));
     EXPECT_EQ(key_path, decoded);
     EXPECT_TRUE(slice.empty());
   }
 }
 
@@ skipping 63 matching lines @@
   keys.push_back(CreateArrayIDBKey(CreateArrayIDBKey(CreateArrayIDBKey())));
   keys.push_back(CreateArrayIDBKey(
       CreateArrayIDBKey(CreateArrayIDBKey(CreateArrayIDBKey()))));
 
   for (size_t i = 0; i < keys.size() - 1; ++i) {
     const IndexedDBKey& key_a = keys[i];
     const IndexedDBKey& key_b = keys[i + 1];
 
     EXPECT_TRUE(key_a.IsLessThan(key_b));
 
-    std::vector<char> encoded_a;
+    std::string encoded_a;
     EncodeIDBKey(key_a, &encoded_a);
     EXPECT_TRUE(encoded_a.size());
-    std::vector<char> encoded_b;
+    std::string encoded_b;
     EncodeIDBKey(key_b, &encoded_b);
     EXPECT_TRUE(encoded_b.size());
 
-    std::vector<char> extracted_a;
-    std::vector<char> extracted_b;
+    std::string extracted_a;
+    std::string extracted_b;
     StringPiece slice;
 
     slice = StringPiece(&*encoded_a.begin(), encoded_a.size());
     EXPECT_TRUE(ExtractEncodedIDBKey(&slice, &extracted_a));
     EXPECT_TRUE(slice.empty());
     EXPECT_EQ(encoded_a, extracted_a);
 
     slice = StringPiece(&*encoded_b.begin(), encoded_b.size());
     EXPECT_TRUE(ExtractEncodedIDBKey(&slice, &extracted_b));
     EXPECT_TRUE(slice.empty());
     EXPECT_EQ(encoded_b, extracted_b);
 
     EXPECT_LT(CompareKeys(extracted_a, extracted_b), 0);
     EXPECT_GT(CompareKeys(extracted_b, extracted_a), 0);
     EXPECT_EQ(CompareKeys(extracted_a, extracted_a), 0);
     EXPECT_EQ(CompareKeys(extracted_b, extracted_b), 0);
 
     slice = StringPiece(&*encoded_a.begin(), encoded_a.size() - 1);
     EXPECT_FALSE(ExtractEncodedIDBKey(&slice, &extracted_a));
   }
 }
 
 TEST(IndexedDBLevelDBCodingTest, ComparisonTest) {
-  std::vector<std::vector<char> > keys;
+  std::vector<std::string> keys;
   keys.push_back(SchemaVersionKey::Encode());
   keys.push_back(MaxDatabaseIdKey::Encode());
   keys.push_back(DatabaseFreeListKey::Encode(0));
   keys.push_back(DatabaseFreeListKey::EncodeMaxKey());
   keys.push_back(DatabaseNameKey::Encode("", ASCIIToUTF16("")));
   keys.push_back(DatabaseNameKey::Encode("", ASCIIToUTF16("a")));
   keys.push_back(DatabaseNameKey::Encode("a", ASCIIToUTF16("a")));
   keys.push_back(
       DatabaseMetaDataKey::Encode(1, DatabaseMetaDataKey::ORIGIN_NAME));
   keys.push_back(
@@ skipping 57 matching lines @@
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MinIDBKey(), 0));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MinIDBKey(), 1));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MaxIDBKey(), 0));
   keys.push_back(IndexDataKey::Encode(1, 1, 30, MaxIDBKey(), MaxIDBKey(), 1));
   keys.push_back(IndexDataKey::Encode(1, 1, 31, MinIDBKey(), MinIDBKey(), 0));
   keys.push_back(IndexDataKey::Encode(1, 2, 30, MinIDBKey(), MinIDBKey(), 0));
   keys.push_back(
       IndexDataKey::EncodeMaxKey(1, 2, std::numeric_limits<int32>::max() - 1));
 
   for (size_t i = 0; i < keys.size(); ++i) {
-    const LevelDBSlice key_a(keys[i]);
-    EXPECT_EQ(Compare(key_a, key_a, false), 0);
+    EXPECT_EQ(Compare(keys[i], keys[i], false), 0);
 
     for (size_t j = i + 1; j < keys.size(); ++j) {
-      const LevelDBSlice key_b(keys[j]);
-      EXPECT_LT(Compare(key_a, key_b, false), 0);
-      EXPECT_GT(Compare(key_b, key_a, false), 0);
+      EXPECT_LT(Compare(keys[i], keys[j], false), 0);
+      EXPECT_GT(Compare(keys[j], keys[i], false), 0);
     }
   }
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeVarIntVSEncodeByteTest) {
   std::vector<unsigned char> test_cases;
   test_cases.push_back(0);
   test_cases.push_back(1);
   test_cases.push_back(127);
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
     unsigned char n = test_cases[i];
 
-    std::vector<char> vA = WrappedEncodeByte(n);
-    std::vector<char> vB = WrappedEncodeVarInt(static_cast<int64>(n));
+    std::string vA = WrappedEncodeByte(n);
+    std::string vB = WrappedEncodeVarInt(static_cast<int64>(n));
 
     EXPECT_EQ(vA.size(), vB.size());
     EXPECT_EQ(*vA.begin(), *vB.begin());
   }
 }
 
 }  // namespace
 
 }  // namespace content