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

content/browser/indexed_db/indexed_db_leveldb_coding.cc

Index: content/browser/indexed_db/indexed_db_leveldb_coding.cc
diff --git a/content/browser/indexed_db/indexed_db_leveldb_coding.cc b/content/browser/indexed_db/indexed_db_leveldb_coding.cc
index cbd3caf47e7db48007dc1b768ccd8dfb5b10c6c0..f5e5034c8e0dd1ab5f8f3895888cd899c950a6f5 100644
--- a/content/browser/indexed_db/indexed_db_leveldb_coding.cc
+++ b/content/browser/indexed_db/indexed_db_leveldb_coding.cc
@@ -6,20 +6,17 @@
 
 #include <iterator>
 #include <limits>
-#include <string>
 
 #include "base/logging.h"
 #include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.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 "third_party/WebKit/public/platform/WebIDBKeyPath.h"
 
 // LevelDB stores key/value pairs. Keys and values are strings of bytes,
-// normally of type std::vector<char>.
+// normally of type std::string.
 //
 // The keys in the backing store are variable-length tuples with different types
 // of fields. Each key in the backing store starts with a ternary prefix:
@@ -196,32 +193,32 @@ static const unsigned char kIndexMetaDataTypeMaximum = 255;
 
 const unsigned char kMinimumIndexId = 30;
 
-inline void EncodeIntSafely(int64 nParam, int64 max, std::vector<char>* into) {
+inline void EncodeIntSafely(int64 nParam, int64 max, std::string* into) {
   DCHECK_LE(nParam, max);
   return EncodeInt(nParam, into);
 }
 
-std::vector<char> MaxIDBKey() {
-  std::vector<char> ret;
+std::string MaxIDBKey() {
+  std::string ret;
   EncodeByte(kIndexedDBKeyNullTypeByte, &ret);
   return ret;
 }
 
-std::vector<char> MinIDBKey() {
-  std::vector<char> ret;
+std::string MinIDBKey() {
+  std::string ret;
   EncodeByte(kIndexedDBKeyMinKeyTypeByte, &ret);
   return ret;
 }
 
-void EncodeByte(unsigned char value, std::vector<char>* into) {
+void EncodeByte(unsigned char value, std::string* into) {
   into->push_back(value);
 }
 
-void EncodeBool(bool value, std::vector<char>* into) {
+void EncodeBool(bool value, std::string* into) {
   into->push_back(value ? 1 : 0);
 }
 
-void EncodeInt(int64 value, std::vector<char>* into) {
+void EncodeInt(int64 value, std::string* into) {
 #ifndef NDEBUG
   // Exercised by unit tests in debug only.
   DCHECK_GE(value, 0);
@@ -235,7 +232,7 @@ void EncodeInt(int64 value, std::vector<char>* into) {
   } while (n);
 }
 
-void EncodeVarInt(int64 value, std::vector<char>* into) {
+void EncodeVarInt(int64 value, std::string* into) {
 #ifndef NDEBUG
   // Exercised by unit tests in debug only.
   DCHECK_GE(value, 0);
@@ -251,7 +248,7 @@ void EncodeVarInt(int64 value, std::vector<char>* into) {
   } while (n);
 }
 
-void EncodeString(const string16& value, std::vector<char>* into) {
+void EncodeString(const string16& value, std::string* into) {
   if (value.empty())
     return;
   // Backing store is UTF-16BE, convert from host endianness.
@@ -265,18 +262,18 @@ void EncodeString(const string16& value, std::vector<char>* into) {
     *dst++ = htons(*src++);
 }
 
-void EncodeStringWithLength(const string16& value, std::vector<char>* into) {
+void EncodeStringWithLength(const string16& value, std::string* into) {
   EncodeVarInt(value.length(), into);
   EncodeString(value, into);
 }
 
-void EncodeDouble(double value, std::vector<char>* into) {
+void EncodeDouble(double value, std::string* into) {
   // This always has host endianness.
   const char* p = reinterpret_cast<char*>(&value);
   into->insert(into->end(), p, p + sizeof(value));
 }
 
-void EncodeIDBKey(const IndexedDBKey& value, std::vector<char>* into) {
+void EncodeIDBKey(const IndexedDBKey& value, std::string* into) {
   size_t previous_size = into->size();
   DCHECK(value.IsValid());
   switch (value.type()) {
@@ -321,7 +318,7 @@ void EncodeIDBKey(const IndexedDBKey& value, std::vector<char>* into) {
   NOTREACHED();
 }
 
-void EncodeIDBKeyPath(const IndexedDBKeyPath& value, std::vector<char>* into) {
+void EncodeIDBKeyPath(const IndexedDBKeyPath& value, std::string* into) {
   // May be typed, or may be a raw string. An invalid leading
   // byte is used to identify typed coding. New records are
   // always written as typed.
@@ -593,7 +590,7 @@ bool ExtractEncodedIDBKey(StringPiece* slice) {
   return false;
 }
 
-bool ExtractEncodedIDBKey(StringPiece* slice, std::vector<char>* result) {
+bool ExtractEncodedIDBKey(StringPiece* slice, std::string* result) {
   const char* start = slice->begin();
   if (!ExtractEncodedIDBKey(slice))
     return 0;
@@ -724,21 +721,21 @@ int CompareEncodedIDBKeys(StringPiece* slice_a,
   return 0;
 }
 
-int CompareEncodedIDBKeys(const std::vector<char>& key_a,
-                          const std::vector<char>& key_b,
+int CompareEncodedIDBKeys(const std::string& key_a,
+                          const std::string& key_b,
                           bool* ok) {
   DCHECK(!key_a.empty());
   DCHECK(!key_b.empty());
 
-  StringPiece slice_a(&*key_a.begin(), key_a.size());
-  StringPiece slice_b(&*key_b.begin(), key_b.size());
+  StringPiece slice_a(key_a);
+  StringPiece slice_b(key_b);
   return CompareEncodedIDBKeys(&slice_a, &slice_b, ok);
 }
 
 namespace {
 
 template <typename KeyType>
-int Compare(const LevelDBSlice& a, const LevelDBSlice& b, bool, bool* ok) {
+int Compare(const StringPiece& a, const StringPiece& b, bool, bool* ok) {
   KeyType key_a;
   KeyType key_b;
 
@@ -760,8 +757,8 @@ int Compare(const LevelDBSlice& a, const LevelDBSlice& b, bool, bool* ok) {
 }
 
 template <>
-int Compare<ExistsEntryKey>(const LevelDBSlice& a,
-                            const LevelDBSlice& b,
+int Compare<ExistsEntryKey>(const StringPiece& a,
+                            const StringPiece& b,
                             bool,
                             bool* ok) {
   KeyPrefix prefix_a;
@@ -787,8 +784,8 @@ int Compare<ExistsEntryKey>(const LevelDBSlice& a,
 }
 
 template <>
-int Compare<ObjectStoreDataKey>(const LevelDBSlice& a,
-                                const LevelDBSlice& b,
+int Compare<ObjectStoreDataKey>(const StringPiece& a,
+                                const StringPiece& b,
                                 bool,
                                 bool* ok) {
   KeyPrefix prefix_a;
@@ -814,8 +811,8 @@ int Compare<ObjectStoreDataKey>(const LevelDBSlice& a,
 }
 
 template <>
-int Compare<IndexDataKey>(const LevelDBSlice& a,
-                          const LevelDBSlice& b,
+int Compare<IndexDataKey>(const StringPiece& a,
+                          const StringPiece& b,
                           bool ignore_duplicates,
                           bool* ok) {
   KeyPrefix prefix_a;
@@ -872,8 +869,8 @@ int Compare<IndexDataKey>(const LevelDBSlice& a,
   return CompareInts(sequence_number_a, sequence_number_b);
 }
 
-int Compare(const LevelDBSlice& a,
-            const LevelDBSlice& b,
+int Compare(const StringPiece& a,
+            const StringPiece& b,
             bool index_keys,
             bool* ok) {
   const char* ptr_a = a.begin();
@@ -999,7 +996,7 @@ int Compare(const LevelDBSlice& a,
 
 }  // namespace
 
-int Compare(const LevelDBSlice& a, const LevelDBSlice& b, bool index_keys) {
+int Compare(const StringPiece& a, const StringPiece& b, bool index_keys) {
   bool ok;
   int result = Compare(a, b, index_keys, &ok);
   DCHECK(ok);
@@ -1107,25 +1104,25 @@ const char* KeyPrefix::Decode(const char* start,
   return start;
 }
 
-std::vector<char> KeyPrefix::EncodeEmpty() {
-  const std::vector<char> result(4, 0);
-  DCHECK(EncodeInternal(0, 0, 0) == std::vector<char>(4, 0));
+std::string KeyPrefix::EncodeEmpty() {
+  const std::string result(4, 0);
+  DCHECK(EncodeInternal(0, 0, 0) == std::string(4, 0));
   return result;
 }
 
-std::vector<char> KeyPrefix::Encode() const {
+std::string KeyPrefix::Encode() const {
   DCHECK(database_id_ != kInvalidId);
   DCHECK(object_store_id_ != kInvalidId);
   DCHECK(index_id_ != kInvalidId);
   return EncodeInternal(database_id_, object_store_id_, index_id_);
 }
 
-std::vector<char> KeyPrefix::EncodeInternal(int64 database_id,
-                                            int64 object_store_id,
-                                            int64 index_id) {
-  std::vector<char> database_id_string;
-  std::vector<char> object_store_id_string;
-  std::vector<char> index_id_string;
+std::string KeyPrefix::EncodeInternal(int64 database_id,
+                                      int64 object_store_id,
+                                      int64 index_id) {
+  std::string database_id_string;
+  std::string object_store_id_string;
+  std::string index_id_string;
 
   EncodeIntSafely(database_id, kMaxDatabaseId, &database_id_string);
   EncodeIntSafely(object_store_id, kMaxObjectStoreId, &object_store_id_string);
@@ -1144,13 +1141,12 @@ std::vector<char> KeyPrefix::EncodeInternal(int64 database_id,
                          kMaxIndexIdSizeBits ==
                      sizeof(first_byte) * 8,
                  CANT_ENCODE_IDS);
-  std::vector<char> ret;
+  std::string ret;
   ret.reserve(kDefaultInlineBufferSize);
   ret.push_back(first_byte);
-  ret.insert(ret.end(), database_id_string.begin(), database_id_string.end());
-  ret.insert(
-      ret.end(), object_store_id_string.begin(), object_store_id_string.end());
-  ret.insert(ret.end(), index_id_string.begin(), index_id_string.end());
+  ret.append(database_id_string);
+  ret.append(object_store_id_string);
+  ret.append(index_id_string);
 
   DCHECK_LE(ret.size(), kDefaultInlineBufferSize);
   return ret;
@@ -1190,20 +1186,20 @@ KeyPrefix::Type KeyPrefix::type() const {
   return INVALID_TYPE;
 }
 
-std::vector<char> SchemaVersionKey::Encode() {
-  std::vector<char> ret = KeyPrefix::EncodeEmpty();
+std::string SchemaVersionKey::Encode() {
+  std::string ret = KeyPrefix::EncodeEmpty();
   ret.push_back(kSchemaVersionTypeByte);
   return ret;
 }
 
-std::vector<char> MaxDatabaseIdKey::Encode() {
-  std::vector<char> ret = KeyPrefix::EncodeEmpty();
+std::string MaxDatabaseIdKey::Encode() {
+  std::string ret = KeyPrefix::EncodeEmpty();
   ret.push_back(kMaxDatabaseIdTypeByte);
   return ret;
 }
 
-std::vector<char> DataVersionKey::Encode() {
-  std::vector<char> ret = KeyPrefix::EncodeEmpty();
+std::string DataVersionKey::Encode() {
+  std::string ret = KeyPrefix::EncodeEmpty();
   ret.push_back(kDataVersionTypeByte);
   return ret;
 }
@@ -1234,14 +1230,14 @@ const char* DatabaseFreeListKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> DatabaseFreeListKey::Encode(int64 database_id) {
-  std::vector<char> ret = KeyPrefix::EncodeEmpty();
+std::string DatabaseFreeListKey::Encode(int64 database_id) {
+  std::string ret = KeyPrefix::EncodeEmpty();
   ret.push_back(kDatabaseFreeListTypeByte);
   EncodeVarInt(database_id, &ret);
   return ret;
 }
 
-std::vector<char> DatabaseFreeListKey::EncodeMaxKey() {
+std::string DatabaseFreeListKey::EncodeMaxKey() {
   return Encode(std::numeric_limits<int64>::max());
 }
 
@@ -1279,21 +1275,21 @@ const char* DatabaseNameKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> DatabaseNameKey::Encode(const std::string& origin_identifier,
-                                          const string16& database_name) {
-  std::vector<char> ret = KeyPrefix::EncodeEmpty();
+std::string DatabaseNameKey::Encode(const std::string& origin_identifier,
+                                    const string16& database_name) {
+  std::string ret = KeyPrefix::EncodeEmpty();
   ret.push_back(kDatabaseNameTypeByte);
   EncodeStringWithLength(base::ASCIIToUTF16(origin_identifier), &ret);
   EncodeStringWithLength(database_name, &ret);
   return ret;
 }
 
-std::vector<char> DatabaseNameKey::EncodeMinKeyForOrigin(
+std::string DatabaseNameKey::EncodeMinKeyForOrigin(
     const std::string& origin_identifier) {
   return Encode(origin_identifier, string16());
 }
 
-std::vector<char> DatabaseNameKey::EncodeStopKeyForOrigin(
+std::string DatabaseNameKey::EncodeStopKeyForOrigin(
     const std::string& origin_identifier) {
   // just after origin in collation order
   return EncodeMinKeyForOrigin(origin_identifier + '\x01');
@@ -1305,10 +1301,10 @@ int DatabaseNameKey::Compare(const DatabaseNameKey& other) {
   return database_name_.compare(other.database_name_);
 }
 
-std::vector<char> DatabaseMetaDataKey::Encode(int64 database_id,
-                                              MetaDataType meta_data_type) {
+std::string DatabaseMetaDataKey::Encode(int64 database_id,
+                                        MetaDataType meta_data_type) {
   KeyPrefix prefix(database_id);
-  std::vector<char> ret = prefix.Encode();
+  std::string ret = prefix.Encode();
   ret.push_back(meta_data_type);
   return ret;
 }
@@ -1341,25 +1337,25 @@ const char* ObjectStoreMetaDataKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> ObjectStoreMetaDataKey::Encode(int64 database_id,
-                                                 int64 object_store_id,
-                                                 unsigned char meta_data_type) {
+std::string ObjectStoreMetaDataKey::Encode(int64 database_id,
+                                           int64 object_store_id,
+                                           unsigned char meta_data_type) {
   KeyPrefix prefix(database_id);
-  std::vector<char> ret = prefix.Encode();
+  std::string ret = prefix.Encode();
   ret.push_back(kObjectStoreMetaDataTypeByte);
   EncodeVarInt(object_store_id, &ret);
   ret.push_back(meta_data_type);
   return ret;
 }
 
-std::vector<char> ObjectStoreMetaDataKey::EncodeMaxKey(int64 database_id) {
+std::string ObjectStoreMetaDataKey::EncodeMaxKey(int64 database_id) {
   return Encode(database_id,
                 std::numeric_limits<int64>::max(),
                 kObjectMetaDataTypeMaximum);
 }
 
-std::vector<char> ObjectStoreMetaDataKey::EncodeMaxKey(int64 database_id,
-                                                       int64 object_store_id) {
+std::string ObjectStoreMetaDataKey::EncodeMaxKey(int64 database_id,
+                                                 int64 object_store_id) {
   return Encode(database_id, object_store_id, kObjectMetaDataTypeMaximum);
 }
 
@@ -1410,12 +1406,12 @@ const char* IndexMetaDataKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> IndexMetaDataKey::Encode(int64 database_id,
-                                           int64 object_store_id,
-                                           int64 index_id,
-                                           unsigned char meta_data_type) {
+std::string IndexMetaDataKey::Encode(int64 database_id,
+                                     int64 object_store_id,
+                                     int64 index_id,
+                                     unsigned char meta_data_type) {
   KeyPrefix prefix(database_id);
-  std::vector<char> ret = prefix.Encode();
+  std::string ret = prefix.Encode();
   ret.push_back(kIndexMetaDataTypeByte);
   EncodeVarInt(object_store_id, &ret);
   EncodeVarInt(index_id, &ret);
@@ -1423,17 +1419,17 @@ std::vector<char> IndexMetaDataKey::Encode(int64 database_id,
   return ret;
 }
 
-std::vector<char> IndexMetaDataKey::EncodeMaxKey(int64 database_id,
-                                                 int64 object_store_id) {
+std::string IndexMetaDataKey::EncodeMaxKey(int64 database_id,
+                                           int64 object_store_id) {
   return Encode(database_id,
                 object_store_id,
                 std::numeric_limits<int64>::max(),
                 kIndexMetaDataTypeMaximum);
 }
 
-std::vector<char> IndexMetaDataKey::EncodeMaxKey(int64 database_id,
-                                                 int64 object_store_id,
-                                                 int64 index_id) {
+std::string IndexMetaDataKey::EncodeMaxKey(int64 database_id,
+                                           int64 object_store_id,
+                                           int64 index_id) {
   return Encode(
       database_id, object_store_id, index_id, kIndexMetaDataTypeMaximum);
 }
@@ -1478,16 +1474,16 @@ const char* ObjectStoreFreeListKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> ObjectStoreFreeListKey::Encode(int64 database_id,
-                                                 int64 object_store_id) {
+std::string ObjectStoreFreeListKey::Encode(int64 database_id,
+                                           int64 object_store_id) {
   KeyPrefix prefix(database_id);
-  std::vector<char> ret = prefix.Encode();
+  std::string ret = prefix.Encode();
   ret.push_back(kObjectStoreFreeListTypeByte);
   EncodeVarInt(object_store_id, &ret);
   return ret;
 }
 
-std::vector<char> ObjectStoreFreeListKey::EncodeMaxKey(int64 database_id) {
+std::string ObjectStoreFreeListKey::EncodeMaxKey(int64 database_id) {
   return Encode(database_id, std::numeric_limits<int64>::max());
 }
 
@@ -1530,19 +1526,19 @@ const char* IndexFreeListKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> IndexFreeListKey::Encode(int64 database_id,
-                                           int64 object_store_id,
-                                           int64 index_id) {
+std::string IndexFreeListKey::Encode(int64 database_id,
+                                     int64 object_store_id,
+                                     int64 index_id) {
   KeyPrefix prefix(database_id);
-  std::vector<char> ret = prefix.Encode();
+  std::string ret = prefix.Encode();
   ret.push_back(kIndexFreeListTypeByte);
   EncodeVarInt(object_store_id, &ret);
   EncodeVarInt(index_id, &ret);
   return ret;
 }
 
-std::vector<char> IndexFreeListKey::EncodeMaxKey(int64 database_id,
-                                                 int64 object_store_id) {
+std::string IndexFreeListKey::EncodeMaxKey(int64 database_id,
+                                           int64 object_store_id) {
   return Encode(
       database_id, object_store_id, std::numeric_limits<int64>::max());
 }
@@ -1590,11 +1586,10 @@ const char* ObjectStoreNamesKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> ObjectStoreNamesKey::Encode(
-    int64 database_id,
-    const string16& object_store_name) {
+std::string ObjectStoreNamesKey::Encode(int64 database_id,
+                                        const string16& object_store_name) {
   KeyPrefix prefix(database_id);
-  std::vector<char> ret = prefix.Encode();
+  std::string ret = prefix.Encode();
   ret.push_back(kObjectStoreNamesTypeByte);
   EncodeStringWithLength(object_store_name, &ret);
   return ret;
@@ -1632,11 +1627,11 @@ const char* IndexNamesKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> IndexNamesKey::Encode(int64 database_id,
-                                        int64 object_store_id,
-                                        const string16& index_name) {
+std::string IndexNamesKey::Encode(int64 database_id,
+                                  int64 object_store_id,
+                                  const string16& index_name) {
   KeyPrefix prefix(database_id);
-  std::vector<char> ret = prefix.Encode();
+  std::string ret = prefix.Encode();
   ret.push_back(kIndexNamesKeyTypeByte);
   EncodeVarInt(object_store_id, &ret);
   EncodeStringWithLength(index_name, &ret);
@@ -1671,22 +1666,21 @@ const char* ObjectStoreDataKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> ObjectStoreDataKey::Encode(
-    int64 database_id,
-    int64 object_store_id,
-    const std::vector<char> encoded_user_key) {
+std::string ObjectStoreDataKey::Encode(int64 database_id,
+                                       int64 object_store_id,
+                                       const std::string encoded_user_key) {
   KeyPrefix prefix(KeyPrefix::CreateWithSpecialIndex(
       database_id, object_store_id, kSpecialIndexNumber));
-  std::vector<char> ret = prefix.Encode();
-  ret.insert(ret.end(), encoded_user_key.begin(), encoded_user_key.end());
+  std::string ret = prefix.Encode();
+  ret.append(encoded_user_key);
 
   return ret;
 }
 
-std::vector<char> ObjectStoreDataKey::Encode(int64 database_id,
-                                             int64 object_store_id,
-                                             const IndexedDBKey& user_key) {
-  std::vector<char> encoded_key;
+std::string ObjectStoreDataKey::Encode(int64 database_id,
+                                       int64 object_store_id,
+                                       const IndexedDBKey& user_key) {
+  std::string encoded_key;
   EncodeIDBKey(user_key, &encoded_key);
   return Encode(database_id, object_store_id, encoded_key);
 }
@@ -1697,7 +1691,7 @@ int ObjectStoreDataKey::Compare(const ObjectStoreDataKey& other, bool* ok) {
 
 scoped_ptr<IndexedDBKey> ObjectStoreDataKey::user_key() const {
   scoped_ptr<IndexedDBKey> key;
-  StringPiece slice(&encoded_user_key_[0], encoded_user_key_.size());
+  StringPiece slice(encoded_user_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
@@ -1727,20 +1721,20 @@ const char* ExistsEntryKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> ExistsEntryKey::Encode(int64 database_id,
-                                         int64 object_store_id,
-                                         const std::vector<char>& encoded_key) {
+std::string ExistsEntryKey::Encode(int64 database_id,
+                                   int64 object_store_id,
+                                   const std::string& encoded_key) {
   KeyPrefix prefix(KeyPrefix::CreateWithSpecialIndex(
       database_id, object_store_id, kSpecialIndexNumber));
-  std::vector<char> ret = prefix.Encode();
-  ret.insert(ret.end(), encoded_key.begin(), encoded_key.end());
+  std::string ret = prefix.Encode();
+  ret.append(encoded_key);
   return ret;
 }
 
-std::vector<char> ExistsEntryKey::Encode(int64 database_id,
-                                         int64 object_store_id,
-                                         const IndexedDBKey& user_key) {
-  std::vector<char> encoded_key;
+std::string ExistsEntryKey::Encode(int64 database_id,
+                                   int64 object_store_id,
+                                   const IndexedDBKey& user_key) {
+  std::string encoded_key;
   EncodeIDBKey(user_key, &encoded_key);
   return Encode(database_id, object_store_id, encoded_key);
 }
@@ -1751,7 +1745,7 @@ int ExistsEntryKey::Compare(const ExistsEntryKey& other, bool* ok) {
 
 scoped_ptr<IndexedDBKey> ExistsEntryKey::user_key() const {
   scoped_ptr<IndexedDBKey> key;
-  StringPiece slice(&encoded_user_key_[0], encoded_user_key_.size());
+  StringPiece slice(encoded_user_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
@@ -1803,41 +1797,40 @@ const char* IndexDataKey::Decode(const char* start,
   return slice.begin();
 }
 
-std::vector<char> IndexDataKey::Encode(
-    int64 database_id,
-    int64 object_store_id,
-    int64 index_id,
-    const std::vector<char>& encoded_user_key,
-    const std::vector<char>& encoded_primary_key,
-    int64 sequence_number) {
+std::string IndexDataKey::Encode(int64 database_id,
+                                 int64 object_store_id,
+                                 int64 index_id,
+                                 const std::string& encoded_user_key,
+                                 const std::string& encoded_primary_key,
+                                 int64 sequence_number) {
   KeyPrefix prefix(database_id, object_store_id, index_id);
-  std::vector<char> ret = prefix.Encode();
-  ret.insert(ret.end(), encoded_user_key.begin(), encoded_user_key.end());
+  std::string ret = prefix.Encode();
+  ret.append(encoded_user_key);
   EncodeVarInt(sequence_number, &ret);
-  ret.insert(ret.end(), encoded_primary_key.begin(), encoded_primary_key.end());
+  ret.append(encoded_primary_key);
   return ret;
 }
 
-std::vector<char> IndexDataKey::Encode(int64 database_id,
-                                       int64 object_store_id,
-                                       int64 index_id,
-                                       const IndexedDBKey& user_key) {
-  std::vector<char> encoded_key;
+std::string IndexDataKey::Encode(int64 database_id,
+                                 int64 object_store_id,
+                                 int64 index_id,
+                                 const IndexedDBKey& user_key) {
+  std::string encoded_key;
   EncodeIDBKey(user_key, &encoded_key);
   return Encode(
       database_id, object_store_id, index_id, encoded_key, MinIDBKey(), 0);
 }
 
-std::vector<char> IndexDataKey::EncodeMinKey(int64 database_id,
-                                             int64 object_store_id,
-                                             int64 index_id) {
+std::string IndexDataKey::EncodeMinKey(int64 database_id,
+                                       int64 object_store_id,
+                                       int64 index_id) {
   return Encode(
       database_id, object_store_id, index_id, MinIDBKey(), MinIDBKey(), 0);
 }
 
-std::vector<char> IndexDataKey::EncodeMaxKey(int64 database_id,
-                                             int64 object_store_id,
-                                             int64 index_id) {
+std::string IndexDataKey::EncodeMaxKey(int64 database_id,
+                                       int64 object_store_id,
+                                       int64 index_id) {
   return Encode(database_id,
                 object_store_id,
                 index_id,
@@ -1882,7 +1875,7 @@ int64 IndexDataKey::IndexId() const {
 
 scoped_ptr<IndexedDBKey> IndexDataKey::user_key() const {
   scoped_ptr<IndexedDBKey> key;
-  StringPiece slice(&encoded_user_key_[0], encoded_user_key_.size());
+  StringPiece slice(encoded_user_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
@@ -1891,7 +1884,7 @@ scoped_ptr<IndexedDBKey> IndexDataKey::user_key() const {
 
 scoped_ptr<IndexedDBKey> IndexDataKey::primary_key() const {
   scoped_ptr<IndexedDBKey> key;
-  StringPiece slice(&encoded_primary_key_[0], encoded_primary_key_.size());
+  StringPiece slice(encoded_primary_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }