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

content/browser/indexed_db/indexed_db_leveldb_coding.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 <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:
 // (database id, object store id, index id). For each, 0 is reserved for
 // meta-data.
 // The prefix makes sure that data for a specific database, object store, and
 // index are grouped together. The locality is important for performance: common
 // operations should only need a minimal number of seek operations. For example,
 // all the meta-data for a database is grouped together so that reading that
 // meta-data only requires one seek.
@@ skipping 156 matching lines @@
 static const unsigned char kObjectStoreFreeListTypeByte = 150;
 static const unsigned char kIndexFreeListTypeByte = 151;
 static const unsigned char kObjectStoreNamesTypeByte = 200;
 static const unsigned char kIndexNamesKeyTypeByte = 201;
 
 static const unsigned char kObjectMetaDataTypeMaximum = 255;
 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);
 #endif
   uint64 n = static_cast<uint64>(value);
 
   do {
     unsigned char c = n;
     into->push_back(c);
     n >>= 8;
   } 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);
 #endif
   uint64 n = static_cast<uint64>(value);
 
   do {
     unsigned char c = n & 0x7f;
     n >>= 7;
     if (n)
       c |= 0x80;
     into->push_back(c);
   } 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.
   size_t length = value.length();
   size_t current = into->size();
   into->resize(into->size() + length * sizeof(char16));
 
   const char16* src = value.c_str();
   char16* dst = reinterpret_cast<char16*>(&*into->begin() + current);
   for (unsigned i = 0; i < length; ++i)
     *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()) {
     case WebIDBKey::NullType:
     case WebIDBKey::InvalidType:
     case WebIDBKey::MinType: {
       NOTREACHED();
       EncodeByte(kIndexedDBKeyNullTypeByte, into);
       return;
     }
@@ skipping 24 matching lines @@
       EncodeDouble(value.number(), into);
       DCHECK_EQ(static_cast<size_t>(9),
                 static_cast<size_t>(into->size() - previous_size));
       return;
     }
   }
 
   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.
   EncodeByte(kIndexedDBKeyPathTypeCodedByte1, into);
   EncodeByte(kIndexedDBKeyPathTypeCodedByte2, into);
   EncodeByte(static_cast<char>(value.type()), into);
   switch (value.type()) {
     case WebIDBKeyPath::NullType:
       break;
     case WebIDBKeyPath::StringType: {
@@ skipping 251 matching lines @@
     case kIndexedDBKeyNumberTypeByte:
       if (slice->size() < sizeof(double))
         return false;
       slice->remove_prefix(sizeof(double));
       return true;
   }
   NOTREACHED();
   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;
 
   if (result)
     result->assign(start, slice->begin());
   return true;
 }
 
 static WebIDBKey::Type KeyTypeByteToKeyType(unsigned char type) {
@@ skipping 110 matching lines @@
       if (d > e)
         return 1;
       return 0;
     }
   }
 
   NOTREACHED();
   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());
   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;
 
   const char* ptr_a = KeyType::Decode(a.begin(), a.end(), &key_a);
   DCHECK(ptr_a);
   if (!ptr_a) {
     *ok = false;
     return 0;
   }
   const char* ptr_b = KeyType::Decode(b.begin(), b.end(), &key_b);
   DCHECK(ptr_b);
   if (!ptr_b) {
     *ok = false;
     return 0;
   }
 
   *ok = true;
   return key_a.Compare(key_b);
 }
 
 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;
   KeyPrefix prefix_b;
   const char* ptr_a = KeyPrefix::Decode(a.begin(), a.end(), &prefix_a);
   const char* ptr_b = KeyPrefix::Decode(b.begin(), b.end(), &prefix_b);
   DCHECK(ptr_a);
   DCHECK(ptr_b);
   DCHECK(prefix_a.database_id_);
   DCHECK(prefix_a.object_store_id_);
   DCHECK_EQ(prefix_a.index_id_, ExistsEntryKey::kSpecialIndexNumber);
   DCHECK(prefix_b.database_id_);
   DCHECK(prefix_b.object_store_id_);
   DCHECK_EQ(prefix_b.index_id_, ExistsEntryKey::kSpecialIndexNumber);
   DCHECK_NE(ptr_a, a.end());
   DCHECK_NE(ptr_b, b.end());
   // Prefixes are not compared - it is assumed this was already done.
   DCHECK(!prefix_a.Compare(prefix_b));
 
   StringPiece slice_a(ptr_a, a.end() - ptr_a);
   StringPiece slice_b(ptr_b, b.end() - ptr_b);
   return CompareEncodedIDBKeys(&slice_a, &slice_b, ok);
 }
 
 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;
   KeyPrefix prefix_b;
   const char* ptr_a = KeyPrefix::Decode(a.begin(), a.end(), &prefix_a);
   const char* ptr_b = KeyPrefix::Decode(b.begin(), b.end(), &prefix_b);
   DCHECK(ptr_a);
   DCHECK(ptr_b);
   DCHECK(prefix_a.database_id_);
   DCHECK(prefix_a.object_store_id_);
   DCHECK_EQ(prefix_a.index_id_, ObjectStoreDataKey::kSpecialIndexNumber);
   DCHECK(prefix_b.database_id_);
   DCHECK(prefix_b.object_store_id_);
   DCHECK_EQ(prefix_b.index_id_, ObjectStoreDataKey::kSpecialIndexNumber);
   DCHECK_NE(ptr_a, a.end());
   DCHECK_NE(ptr_b, b.end());
   // Prefixes are not compared - it is assumed this was already done.
   DCHECK(!prefix_a.Compare(prefix_b));
 
   StringPiece slice_a(ptr_a, a.end() - ptr_a);
   StringPiece slice_b(ptr_b, b.end() - ptr_b);
   return CompareEncodedIDBKeys(&slice_a, &slice_b, ok);
 }
 
 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;
   KeyPrefix prefix_b;
   const char* ptr_a = KeyPrefix::Decode(a.begin(), a.end(), &prefix_a);
   const char* ptr_b = KeyPrefix::Decode(b.begin(), b.end(), &prefix_b);
   DCHECK(ptr_a);
   DCHECK(ptr_b);
   DCHECK(prefix_a.database_id_);
   DCHECK(prefix_a.object_store_id_);
@@ skipping 36 matching lines @@
   if (slice_b.empty())
     return 1;
 
   result = CompareEncodedIDBKeys(&slice_a, &slice_b, ok);
   if (!*ok || result)
     return result;
 
   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();
   const char* ptr_b = b.begin();
   const char* end_a = a.end();
   const char* end_b = b.end();
 
   KeyPrefix prefix_a;
   KeyPrefix prefix_b;
 
@@ skipping 105 matching lines @@
       break;
   }
 
   NOTREACHED();
   *ok = false;
   return 0;
 }
 
 }  // 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);
   if (!ok)
     return 0;
   return result;
 }
 
 KeyPrefix::KeyPrefix()
     : database_id_(INVALID_TYPE),
@@ skipping 87 matching lines @@
   {
     StringPiece slice(start, index_id_bytes);
     if (!DecodeInt(&slice, &result->index_id_))
       return 0;
   }
   start += index_id_bytes;
 
   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);
   EncodeIntSafely(index_id, kMaxIndexId, &index_id_string);
 
   DCHECK(database_id_string.size() <= kMaxDatabaseIdSizeBytes);
   DCHECK(object_store_id_string.size() <= kMaxObjectStoreIdSizeBytes);
   DCHECK(index_id_string.size() <= kMaxIndexIdSizeBytes);
 
   unsigned char first_byte =
       (database_id_string.size() - 1)
           << (kMaxObjectStoreIdSizeBits + kMaxIndexIdSizeBits) |
       (object_store_id_string.size() - 1) << kMaxIndexIdSizeBits |
       (index_id_string.size() - 1);
   COMPILE_ASSERT(kMaxDatabaseIdSizeBits + kMaxObjectStoreIdSizeBits +
                          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());

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

these inserts can become appends now, no?

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

Done.

   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());
 
   DCHECK_LE(ret.size(), kDefaultInlineBufferSize);
   return ret;
 }
 
 int KeyPrefix::Compare(const KeyPrefix& other) const {
   DCHECK(database_id_ != kInvalidId);
@@ skipping 22 matching lines @@
     return OBJECT_STORE_DATA;
   if (index_id_ == kExistsEntryIndexId)
     return EXISTS_ENTRY;
   if (index_id_ >= kMinimumIndexId)
     return INDEX_DATA;
 
   NOTREACHED();
   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;
 }
 
 DatabaseFreeListKey::DatabaseFreeListKey() : database_id_(-1) {}
 
 const char* DatabaseFreeListKey::Decode(const char* start,
                                         const char* limit,
                                         DatabaseFreeListKey* result) {
   KeyPrefix prefix;
@@ skipping 10 matching lines @@
   if (!DecodeByte(&slice, &type_byte))
     return 0;
   DCHECK_EQ(type_byte, kDatabaseFreeListTypeByte);
   if (slice.empty())
     return 0;
   if (!DecodeVarInt(&slice, &result->database_id_))
     return 0;
   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());
 }
 
 int64 DatabaseFreeListKey::DatabaseId() const {
   DCHECK_GE(database_id_, 0);
   return database_id_;
 }
 
 int DatabaseFreeListKey::Compare(const DatabaseFreeListKey& other) const {
   DCHECK_GE(database_id_, 0);
@@ skipping 17 matching lines @@
   if (!DecodeByte(&slice, &type_byte))
     return 0;
   DCHECK_EQ(type_byte, kDatabaseNameTypeByte);
   if (!DecodeStringWithLength(&slice, &result->origin_))
     return 0;
   if (!DecodeStringWithLength(&slice, &result->database_name_))
     return 0;
   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');
 }
 
 int DatabaseNameKey::Compare(const DatabaseNameKey& other) {
   if (int x = origin_.compare(other.origin_))
     return x;
   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;
 }
 
 ObjectStoreMetaDataKey::ObjectStoreMetaDataKey()
     : object_store_id_(-1), meta_data_type_(-1) {}
 
 const char* ObjectStoreMetaDataKey::Decode(const char* start,
                                            const char* limit,
                                            ObjectStoreMetaDataKey* result) {
@@ skipping 12 matching lines @@
     return 0;
   DCHECK_EQ(type_byte, kObjectStoreMetaDataTypeByte);
   if (!DecodeVarInt(&slice, &result->object_store_id_))
     return 0;
   DCHECK(result->object_store_id_);
   if (!DecodeByte(&slice, &result->meta_data_type_))
     return 0;
   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);
 }
 
 int64 ObjectStoreMetaDataKey::ObjectStoreId() const {
   DCHECK_GE(object_store_id_, 0);
   return object_store_id_;
 }
 unsigned char ObjectStoreMetaDataKey::MetaDataType() const {
   return meta_data_type_;
 }
@@ skipping 30 matching lines @@
   DCHECK_EQ(type_byte, kIndexMetaDataTypeByte);
   if (!DecodeVarInt(&slice, &result->object_store_id_))
     return 0;
   if (!DecodeVarInt(&slice, &result->index_id_))
     return 0;
   if (!DecodeByte(&slice, &result->meta_data_type_))
     return 0;
   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);
   EncodeByte(meta_data_type, &ret);
   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);
 }
 
 int IndexMetaDataKey::Compare(const IndexMetaDataKey& other) {
   DCHECK_GE(object_store_id_, 0);
   DCHECK_GE(index_id_, 0);
 
   if (int x = CompareInts(object_store_id_, other.object_store_id_))
     return x;
@@ skipping 24 matching lines @@
   unsigned char type_byte = 0;
   StringPiece slice(p, limit - p);
   if (!DecodeByte(&slice, &type_byte))
     return 0;
   DCHECK_EQ(type_byte, kObjectStoreFreeListTypeByte);
   if (!DecodeVarInt(&slice, &result->object_store_id_))
     return 0;
   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());
 }
 
 int64 ObjectStoreFreeListKey::ObjectStoreId() const {
   DCHECK_GE(object_store_id_, 0);
   return object_store_id_;
 }
 
 int ObjectStoreFreeListKey::Compare(const ObjectStoreFreeListKey& other) {
   // TODO(jsbell): It may seem strange that we're not comparing database id's,
@@ skipping 22 matching lines @@
   if (!DecodeByte(&slice, &type_byte))
     return 0;
   DCHECK_EQ(type_byte, kIndexFreeListTypeByte);
   if (!DecodeVarInt(&slice, &result->object_store_id_))
     return 0;
   if (!DecodeVarInt(&slice, &result->index_id_))
     return 0;
   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());
 }
 
 int IndexFreeListKey::Compare(const IndexFreeListKey& other) {
   DCHECK_GE(object_store_id_, 0);
   DCHECK_GE(index_id_, 0);
   if (int x = CompareInts(object_store_id_, other.object_store_id_))
     return x;
   return CompareInts(index_id_, other.index_id_);
@@ skipping 27 matching lines @@
   unsigned char type_byte = 0;
   StringPiece slice(p, limit - p);
   if (!DecodeByte(&slice, &type_byte))
     return 0;
   DCHECK_EQ(type_byte, kObjectStoreNamesTypeByte);
   if (!DecodeStringWithLength(&slice, &result->object_store_name_))
     return 0;
   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;
 }
 
 int ObjectStoreNamesKey::Compare(const ObjectStoreNamesKey& other) {
   return object_store_name_.compare(other.object_store_name_);
 }
 
 IndexNamesKey::IndexNamesKey() : object_store_id_(-1) {}
@@ skipping 17 matching lines @@
   if (!DecodeByte(&slice, &type_byte))
     return 0;
   DCHECK_EQ(type_byte, kIndexNamesKeyTypeByte);
   if (!DecodeVarInt(&slice, &result->object_store_id_))
     return 0;
   if (!DecodeStringWithLength(&slice, &result->index_name_))
     return 0;
   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);
   return ret;
 }
 
 int IndexNamesKey::Compare(const IndexNamesKey& other) {
   DCHECK_GE(object_store_id_, 0);
   if (int x = CompareInts(object_store_id_, other.object_store_id_))
     return x;
@@ skipping 14 matching lines @@
   DCHECK(prefix.object_store_id_);
   DCHECK_EQ(prefix.index_id_, kSpecialIndexNumber);
   if (p == end)
     return 0;
   StringPiece slice(p, end - p);
   if (!ExtractEncodedIDBKey(&slice, &result->encoded_user_key_))
     return 0;
   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();
+  std::string ret = prefix.Encode();
   ret.insert(ret.end(), encoded_user_key.begin(), encoded_user_key.end());
 
   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);
 }
 
 int ObjectStoreDataKey::Compare(const ObjectStoreDataKey& other, bool* ok) {
   return CompareEncodedIDBKeys(encoded_user_key_, other.encoded_user_key_, ok);
 }
 
 scoped_ptr<IndexedDBKey> ObjectStoreDataKey::user_key() const {
   scoped_ptr<IndexedDBKey> key;
@@ skipping 20 matching lines @@
   DCHECK(prefix.object_store_id_);
   DCHECK_EQ(prefix.index_id_, kSpecialIndexNumber);
   if (p == end)
     return 0;
   StringPiece slice(p, end - p);
   if (!ExtractEncodedIDBKey(&slice, &result->encoded_user_key_))
     return 0;
   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();
+  std::string ret = prefix.Encode();
   ret.insert(ret.end(), encoded_key.begin(), encoded_key.end());
   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);
 }
 
 int ExistsEntryKey::Compare(const ExistsEntryKey& other, bool* ok) {
   return CompareEncodedIDBKeys(encoded_user_key_, other.encoded_user_key_, ok);
 }
 
 scoped_ptr<IndexedDBKey> ExistsEntryKey::user_key() const {
   scoped_ptr<IndexedDBKey> key;
@@ skipping 42 matching lines @@
 
   // [optional] primary key
   if (slice.empty())
     return slice.begin();
   if (!ExtractEncodedIDBKey(&slice, &result->encoded_primary_key_))
     return 0;
 
   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();
+  std::string ret = prefix.Encode();
   ret.insert(ret.end(), encoded_user_key.begin(), encoded_user_key.end());
   EncodeVarInt(sequence_number, &ret);
   ret.insert(ret.end(), encoded_primary_key.begin(), encoded_primary_key.end());
   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,
                 MaxIDBKey(),
                 MaxIDBKey(),
                 std::numeric_limits<int64>::max());
 }
 
 int IndexDataKey::Compare(const IndexDataKey& other,
                           bool ignore_duplicates,
@@ skipping 41 matching lines @@
 scoped_ptr<IndexedDBKey> IndexDataKey::primary_key() const {
   scoped_ptr<IndexedDBKey> key;
   StringPiece slice(&encoded_primary_key_[0], encoded_primary_key_.size());
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
   return key.Pass();
 }
 
 }  // namespace content