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

content/browser/indexed_db/indexed_db_backing_store.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_backing_store.h"
 
-#include <string>
-
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/leveldb/leveldb_comparator.h"
 #include "content/browser/indexed_db/leveldb/leveldb_database.h"
 #include "content/browser/indexed_db/leveldb/leveldb_iterator.h"
-#include "content/browser/indexed_db/leveldb/leveldb_slice.h"
 #include "content/browser/indexed_db/leveldb/leveldb_transaction.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/indexed_db/indexed_db_key_range.h"
 #include "third_party/WebKit/public/platform/WebIDBKey.h"
 #include "third_party/WebKit/public/platform/WebIDBKeyPath.h"
 
 using base::StringPiece;
 
 // TODO(jsbell): Make blink push the version during the open() call.
@@ skipping 50 matching lines @@
     NOTREACHED();                                         \
     RecordInternalError(type, location);                  \
   } while (0)
 
 #define INTERNAL_READ_ERROR(location) REPORT_ERROR("Read", location)
 #define INTERNAL_CONSISTENCY_ERROR(location) \
   REPORT_ERROR("Consistency", location)
 #define INTERNAL_WRITE_ERROR(location) REPORT_ERROR("Write", location)
 
 static void PutBool(LevelDBTransaction* transaction,
-                    const LevelDBSlice& key,
+                    const StringPiece& key,
                     bool value) {
-  std::vector<char> buffer;
+  std::string buffer;
   EncodeBool(value, &buffer);
   transaction->Put(key, &buffer);
 }
 
 template <typename DBOrTransaction>
 static bool GetInt(DBOrTransaction* db,
-                   const LevelDBSlice& key,
+                   const StringPiece& key,
                    int64* found_int,
                    bool* found) {
   std::string result;
   bool ok = db->Get(key, &result, found);
   if (!ok)
     return false;
   if (!*found)
     return true;
   StringPiece slice(result);
   return DecodeInt(&slice, found_int) && slice.empty();
 }
 
 static void PutInt(LevelDBTransaction* transaction,
-                   const LevelDBSlice& key,
+                   const StringPiece& key,
                    int64 value) {
   DCHECK_GE(value, 0);
-  std::vector<char> buffer;
+  std::string buffer;
   EncodeInt(value, &buffer);
   transaction->Put(key, &buffer);
 }
 
 template <typename DBOrTransaction>
 WARN_UNUSED_RESULT static bool GetVarInt(DBOrTransaction* db,
-                                         const LevelDBSlice& key,
+                                         const StringPiece& key,
                                          int64* found_int,
                                          bool* found) {
   std::string result;
   bool ok = db->Get(key, &result, found);
   if (!ok)
     return false;
   if (!*found)
     return true;
   StringPiece slice(result);
   return DecodeVarInt(&slice, found_int) && slice.empty();
 }
 
 static void PutVarInt(LevelDBTransaction* transaction,
-                      const LevelDBSlice& key,
+                      const StringPiece& key,
                       int64 value) {
-  std::vector<char> buffer;
+  std::string buffer;
   EncodeVarInt(value, &buffer);
   transaction->Put(key, &buffer);
 }
 
 template <typename DBOrTransaction>
 WARN_UNUSED_RESULT static bool GetString(DBOrTransaction* db,
-                                         const LevelDBSlice& key,
+                                         const StringPiece& key,
                                          string16* found_string,
                                          bool* found) {
   std::string result;
   *found = false;
   bool ok = db->Get(key, &result, found);
   if (!ok)
     return false;
   if (!*found)
     return true;
   StringPiece slice(result);
   return DecodeString(&slice, found_string) && slice.empty();
 }
 
 static void PutString(LevelDBTransaction* transaction,
-                      const LevelDBSlice& key,
+                      const StringPiece& key,
                       const string16& value) {
-  std::vector<char> buffer;
+  std::string buffer;
   EncodeString(value, &buffer);
   transaction->Put(key, &buffer);
 }
 
 static void PutIDBKeyPath(LevelDBTransaction* transaction,
-                          const LevelDBSlice& key,
+                          const StringPiece& key,
                           const IndexedDBKeyPath& value) {
-  std::vector<char> buffer;
+  std::string buffer;
   EncodeIDBKeyPath(value, &buffer);
   transaction->Put(key, &buffer);
 }
 
-static int CompareKeys(const LevelDBSlice& a, const LevelDBSlice& b) {
+static int CompareKeys(const StringPiece& a, const StringPiece& b) {
   return Compare(a, b, false /*index_keys*/);
 }
 
-static int CompareIndexKeys(const LevelDBSlice& a, const LevelDBSlice& b) {
+static int CompareIndexKeys(const StringPiece& a, const StringPiece& b) {
   return Compare(a, b, true /*index_keys*/);
 }
 
 class Comparator : public LevelDBComparator {
  public:
-  virtual int Compare(const LevelDBSlice& a, const LevelDBSlice& b) const
+  virtual int Compare(const StringPiece& a, const StringPiece& b) const
       OVERRIDE {
     return content::Compare(a, b, false /*index_keys*/);
   }
   virtual const char* Name() const OVERRIDE { return "idb_cmp1"; }
 };
 
 // 0 - Initial version.
 // 1 - Adds UserIntVersion to DatabaseMetaData.
 // 2 - Adds DataVersion to to global metadata.
 static const int64 kLatestKnownSchemaVersion = 2;
 WARN_UNUSED_RESULT static bool IsSchemaKnown(LevelDBDatabase* db, bool* known) {
   int64 db_schema_version = 0;
   bool found = false;
-  bool ok = GetInt(
-      db, LevelDBSlice(SchemaVersionKey::Encode()), &db_schema_version, &found);
+  bool ok = GetInt(db, SchemaVersionKey::Encode(), &db_schema_version, &found);
   if (!ok)
     return false;
   if (!found) {
     *known = true;
     return true;
   }
   if (db_schema_version > kLatestKnownSchemaVersion) {
     *known = false;
     return true;
   }
 
   const uint32 latest_known_data_version = kWireVersion;
   int64 db_data_version = 0;
-  ok = GetInt(
-      db, LevelDBSlice(DataVersionKey::Encode()), &db_data_version, &found);
+  ok = GetInt(db, DataVersionKey::Encode(), &db_data_version, &found);
   if (!ok)
     return false;
   if (!found) {
     *known = true;
     return true;
   }
 
   if (db_data_version > latest_known_data_version) {
     *known = false;
     return true;
   }
 
   *known = true;
   return true;
 }
 
 WARN_UNUSED_RESULT static bool SetUpMetadata(
     LevelDBDatabase* db,
     const std::string& origin_identifier) {
   const uint32 latest_known_data_version = kWireVersion;
-  const std::vector<char> schema_version_key = SchemaVersionKey::Encode();
-  const std::vector<char> data_version_key = DataVersionKey::Encode();
+  const std::string schema_version_key = SchemaVersionKey::Encode();
+  const std::string data_version_key = DataVersionKey::Encode();
 
   scoped_refptr<LevelDBTransaction> transaction =
       LevelDBTransaction::Create(db);
 
   int64 db_schema_version = 0;
   int64 db_data_version = 0;
   bool found = false;
-  bool ok = GetInt(transaction.get(),
-                   LevelDBSlice(schema_version_key),
-                   &db_schema_version,
-                   &found);
+  bool ok =
+      GetInt(transaction.get(), schema_version_key, &db_schema_version, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(SET_UP_METADATA);
     return false;
   }
   if (!found) {
     // Initialize new backing store.
     db_schema_version = kLatestKnownSchemaVersion;
-    PutInt(
-        transaction.get(), LevelDBSlice(schema_version_key), db_schema_version);
+    PutInt(transaction.get(), schema_version_key, db_schema_version);
     db_data_version = latest_known_data_version;
-    PutInt(transaction.get(), LevelDBSlice(data_version_key), db_data_version);
+    PutInt(transaction.get(), data_version_key, db_data_version);
   } else {
     // Upgrade old backing store.
     DCHECK_LE(db_schema_version, kLatestKnownSchemaVersion);
     if (db_schema_version < 1) {
       db_schema_version = 1;
-      PutInt(transaction.get(),
-             LevelDBSlice(schema_version_key),
-             db_schema_version);
-      const std::vector<char> start_key =
+      PutInt(transaction.get(), schema_version_key, db_schema_version);
+      const std::string start_key =
           DatabaseNameKey::EncodeMinKeyForOrigin(origin_identifier);
-      const std::vector<char> stop_key =
+      const std::string stop_key =
           DatabaseNameKey::EncodeStopKeyForOrigin(origin_identifier);
       scoped_ptr<LevelDBIterator> it = db->CreateIterator();
-      for (it->Seek(LevelDBSlice(start_key));
-           it->IsValid() && CompareKeys(it->Key(), LevelDBSlice(stop_key)) < 0;
+      for (it->Seek(start_key);
+           it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
            it->Next()) {
         int64 database_id = 0;
         found = false;
         bool ok = GetInt(transaction.get(), it->Key(), &database_id, &found);
         if (!ok) {
           INTERNAL_READ_ERROR(SET_UP_METADATA);
           return false;
         }
         if (!found) {
           INTERNAL_CONSISTENCY_ERROR(SET_UP_METADATA);
           return false;
         }
-        std::vector<char> int_version_key = DatabaseMetaDataKey::Encode(
+        std::string int_version_key = DatabaseMetaDataKey::Encode(
             database_id, DatabaseMetaDataKey::USER_INT_VERSION);
         PutVarInt(transaction.get(),
-                  LevelDBSlice(int_version_key),
+                  int_version_key,
                   IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION);
       }
     }
     if (db_schema_version < 2) {
       db_schema_version = 2;
-      PutInt(transaction.get(),
-             LevelDBSlice(schema_version_key),
-             db_schema_version);
+      PutInt(transaction.get(), schema_version_key, db_schema_version);
       db_data_version = kWireVersion;
-      PutInt(
-          transaction.get(), LevelDBSlice(data_version_key), db_data_version);
+      PutInt(transaction.get(), data_version_key, db_data_version);
     }
   }
 
   // All new values will be written using this serialization version.
   found = false;
-  ok = GetInt(transaction.get(),
-              LevelDBSlice(data_version_key),
-              &db_data_version,
-              &found);
+  ok = GetInt(transaction.get(), data_version_key, &db_data_version, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(SET_UP_METADATA);
     return false;
   }
   if (!found) {
     INTERNAL_CONSISTENCY_ERROR(SET_UP_METADATA);
     return false;
   }
   if (db_data_version < latest_known_data_version) {
     db_data_version = latest_known_data_version;
-    PutInt(transaction.get(), LevelDBSlice(data_version_key), db_data_version);
+    PutInt(transaction.get(), data_version_key, db_data_version);
   }
 
   DCHECK_EQ(db_schema_version, kLatestKnownSchemaVersion);
   DCHECK_EQ(db_data_version, latest_known_data_version);
 
   if (!transaction->Commit()) {
     INTERNAL_WRITE_ERROR(SET_UP_METADATA);
     return false;
   }
   return true;
 }
 
 template <typename DBOrTransaction>
 WARN_UNUSED_RESULT static bool GetMaxObjectStoreId(DBOrTransaction* db,
                                                    int64 database_id,
                                                    int64* max_object_store_id) {
-  const std::vector<char> max_object_store_id_key = DatabaseMetaDataKey::Encode(
+  const std::string max_object_store_id_key = DatabaseMetaDataKey::Encode(
       database_id, DatabaseMetaDataKey::MAX_OBJECT_STORE_ID);
   bool ok =
       GetMaxObjectStoreId(db, max_object_store_id_key, max_object_store_id);
   return ok;
 }
 
 template <typename DBOrTransaction>
 WARN_UNUSED_RESULT static bool GetMaxObjectStoreId(
     DBOrTransaction* db,
-    const std::vector<char>& max_object_store_id_key,
+    const std::string& max_object_store_id_key,
     int64* max_object_store_id) {
   *max_object_store_id = -1;
   bool found = false;
-  bool ok = GetInt(
-      db, LevelDBSlice(max_object_store_id_key), max_object_store_id, &found);
+  bool ok = GetInt(db, max_object_store_id_key, max_object_store_id, &found);
   if (!ok)
     return false;
   if (!found)
     *max_object_store_id = 0;
 
   DCHECK_GE(*max_object_store_id, 0);
   return true;
 }
 
 class DefaultLevelDBFactory : public LevelDBFactory {
@@ skipping 18 matching lines @@
       comparator_(comparator.Pass()),
       weak_factory_(this) {}
 
 IndexedDBBackingStore::~IndexedDBBackingStore() {
   // db_'s destructor uses comparator_. The order of destruction is important.
   db_.reset();
   comparator_.reset();
 }
 
 IndexedDBBackingStore::RecordIdentifier::RecordIdentifier(
-    const std::vector<char>& primary_key,
+    const std::string& primary_key,
     int64 version)
     : primary_key_(primary_key), version_(version) {
   DCHECK(!primary_key.empty());
 }
 IndexedDBBackingStore::RecordIdentifier::RecordIdentifier()
     : primary_key_(), version_(-1) {}
 IndexedDBBackingStore::RecordIdentifier::~RecordIdentifier() {}
 
 IndexedDBBackingStore::Cursor::CursorOptions::CursorOptions() {}
 IndexedDBBackingStore::Cursor::CursorOptions::~CursorOptions() {}
@@ skipping 56 matching lines @@
     base::Histogram::FactoryGet("WebCore.IndexedDB.BackingStore.OpenStatus",
                                 1,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX + 1,
                                 base::HistogramBase::kUmaTargetedHistogramFlag)
         ->Add(INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_FAILED_DIRECTORY);
     return scoped_refptr<IndexedDBBackingStore>();
   }
 
   base::FilePath identifier_path =
-      base::FilePath().AppendASCII(origin_identifier).
-      AddExtension(FILE_PATH_LITERAL(".indexeddb.leveldb"));
+      base::FilePath().AppendASCII(origin_identifier)
+          .AddExtension(FILE_PATH_LITERAL(".indexeddb.leveldb"));
 
   int limit = file_util::GetMaximumPathComponentLength(path_base);
   if (limit == -1) {
     DLOG(WARNING) << "GetMaximumPathComponentLength returned -1";
     // In limited testing, ChromeOS returns 143, other OSes 255.
 #if defined(OS_CHROMEOS)
     limit = 143;
 #else
     limit = 255;
 #endif
@@ skipping 59 matching lines @@
 
   if (db) {
     base::Histogram::FactoryGet("WebCore.IndexedDB.BackingStore.OpenStatus",
                                 1,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX + 1,
                                 base::HistogramBase::kUmaTargetedHistogramFlag)
         ->Add(INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_SUCCESS);
   } else if (is_disk_full) {
     LOG(ERROR) << "Unable to open backing store - disk is full.";
-    base::Histogram::FactoryGet(
-        "WebCore.IndexedDB.BackingStore.OpenStatus",
-        1,
-        INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX,
-        INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX + 1,
-        base::HistogramBase::kUmaTargetedHistogramFlag)
+    base::Histogram::FactoryGet("WebCore.IndexedDB.BackingStore.OpenStatus",
+                                1,
+                                INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX,
+                                INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX + 1,
+                                base::HistogramBase::kUmaTargetedHistogramFlag)
         ->Add(INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_DISK_FULL);
     return scoped_refptr<IndexedDBBackingStore>();
   } else {
     LOG(ERROR) << "IndexedDB backing store open failed, attempting cleanup";
     *data_loss = WebKit::WebIDBCallbacks::DataLossTotal;
     bool success = leveldb_factory->DestroyLevelDB(file_path);
     if (!success) {
       LOG(ERROR) << "IndexedDB backing store cleanup failed";
       base::Histogram::FactoryGet(
           "WebCore.IndexedDB.BackingStore.OpenStatus",
@@ skipping 83 matching lines @@
       new IndexedDBBackingStore(identifier, db.Pass(), comparator.Pass()));
 
   if (!SetUpMetadata(backing_store->db_.get(), identifier))
     return scoped_refptr<IndexedDBBackingStore>();
 
   return backing_store;
 }
 
 std::vector<string16> IndexedDBBackingStore::GetDatabaseNames() {
   std::vector<string16> found_names;
-  const std::vector<char> start_key =
+  const std::string start_key =
       DatabaseNameKey::EncodeMinKeyForOrigin(identifier_);
-  const std::vector<char> stop_key =
+  const std::string stop_key =
       DatabaseNameKey::EncodeStopKeyForOrigin(identifier_);
 
   DCHECK(found_names.empty());
 
   scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
-  for (it->Seek(LevelDBSlice(start_key));
-       it->IsValid() && CompareKeys(it->Key(), LevelDBSlice(stop_key)) < 0;
+  for (it->Seek(start_key);
+       it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
        it->Next()) {
     const char* p = it->Key().begin();
     const char* limit = it->Key().end();
 
     DatabaseNameKey database_name_key;
     p = DatabaseNameKey::Decode(p, limit, &database_name_key);
     DCHECK(p);
 
     found_names.push_back(database_name_key.database_name());
   }
   return found_names;
 }
 
 bool IndexedDBBackingStore::GetIDBDatabaseMetaData(
     const string16& name,
     IndexedDBDatabaseMetadata* metadata,
     bool* found) {
-  const std::vector<char> key = DatabaseNameKey::Encode(identifier_, name);
+  const std::string key = DatabaseNameKey::Encode(identifier_, name);
   *found = false;
 
-  bool ok = GetInt(db_.get(), LevelDBSlice(key), &metadata->id, found);
+  bool ok = GetInt(db_.get(), key, &metadata->id, found);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_IDBDATABASE_METADATA);
     return false;
   }
   if (!*found)
     return true;
 
   ok = GetString(db_.get(),
-                 LevelDBSlice(DatabaseMetaDataKey::Encode(
-                     metadata->id, DatabaseMetaDataKey::USER_VERSION)),
+                 DatabaseMetaDataKey::Encode(metadata->id,
+                                             DatabaseMetaDataKey::USER_VERSION),
                  &metadata->version,
                  found);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_IDBDATABASE_METADATA);
     return false;
   }
   if (!*found) {
     INTERNAL_CONSISTENCY_ERROR(GET_IDBDATABASE_METADATA);
     return false;
   }
 
   ok = GetVarInt(db_.get(),
-                 LevelDBSlice(DatabaseMetaDataKey::Encode(
-                     metadata->id, DatabaseMetaDataKey::USER_INT_VERSION)),
+                 DatabaseMetaDataKey::Encode(
+                     metadata->id, DatabaseMetaDataKey::USER_INT_VERSION),
                  &metadata->int_version,
                  found);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_IDBDATABASE_METADATA);
     return false;
   }
   if (!*found) {
     INTERNAL_CONSISTENCY_ERROR(GET_IDBDATABASE_METADATA);
     return false;
   }
@@ skipping 12 matching lines @@
 }
 
 WARN_UNUSED_RESULT static bool GetNewDatabaseId(LevelDBDatabase* db,
                                                 int64* new_id) {
   scoped_refptr<LevelDBTransaction> transaction =
       LevelDBTransaction::Create(db);
 
   *new_id = -1;
   int64 max_database_id = -1;
   bool found = false;
-  bool ok = GetInt(transaction.get(),
-                   LevelDBSlice(MaxDatabaseIdKey::Encode()),
-                   &max_database_id,
-                   &found);
+  bool ok = GetInt(
+      transaction.get(), MaxDatabaseIdKey::Encode(), &max_database_id, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_NEW_DATABASE_ID);
     return false;
   }
   if (!found)
     max_database_id = 0;
 
   DCHECK_GE(max_database_id, 0);
 
   int64 database_id = max_database_id + 1;
-  PutInt(
-      transaction.get(), LevelDBSlice(MaxDatabaseIdKey::Encode()), database_id);
+  PutInt(transaction.get(), MaxDatabaseIdKey::Encode(), database_id);
   if (!transaction->Commit()) {
     INTERNAL_WRITE_ERROR(GET_NEW_DATABASE_ID);
     return false;
   }
   *new_id = database_id;
   return true;
 }
 
 bool IndexedDBBackingStore::CreateIDBDatabaseMetaData(const string16& name,
                                                       const string16& version,
                                                       int64 int_version,
                                                       int64* row_id) {
   bool ok = GetNewDatabaseId(db_.get(), row_id);
   if (!ok)
     return false;
   DCHECK_GE(*row_id, 0);
 
   if (int_version == IndexedDBDatabaseMetadata::NO_INT_VERSION)
     int_version = IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION;
 
   scoped_refptr<LevelDBTransaction> transaction =
       LevelDBTransaction::Create(db_.get());
-  PutInt(transaction.get(),
-         LevelDBSlice(DatabaseNameKey::Encode(identifier_, name)),
-         *row_id);
-  PutString(transaction.get(),
-            LevelDBSlice(DatabaseMetaDataKey::Encode(
-                *row_id, DatabaseMetaDataKey::USER_VERSION)),
-            version);
+  PutInt(
+      transaction.get(), DatabaseNameKey::Encode(identifier_, name), *row_id);
+  PutString(
+      transaction.get(),
+      DatabaseMetaDataKey::Encode(*row_id, DatabaseMetaDataKey::USER_VERSION),
+      version);
   PutVarInt(transaction.get(),
-            LevelDBSlice(DatabaseMetaDataKey::Encode(
-                *row_id, DatabaseMetaDataKey::USER_INT_VERSION)),
+            DatabaseMetaDataKey::Encode(*row_id,
+                                        DatabaseMetaDataKey::USER_INT_VERSION),
             int_version);
   if (!transaction->Commit()) {
     INTERNAL_WRITE_ERROR(CREATE_IDBDATABASE_METADATA);
     return false;
   }
   return true;
 }
 
 bool IndexedDBBackingStore::UpdateIDBDatabaseIntVersion(
     IndexedDBBackingStore::Transaction* transaction,
     int64 row_id,
     int64 int_version) {
   if (int_version == IndexedDBDatabaseMetadata::NO_INT_VERSION)
     int_version = IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION;
   DCHECK_GE(int_version, 0) << "int_version was " << int_version;
   PutVarInt(Transaction::LevelDBTransactionFrom(transaction),
-            LevelDBSlice(DatabaseMetaDataKey::Encode(
-                row_id, DatabaseMetaDataKey::USER_INT_VERSION)),
+            DatabaseMetaDataKey::Encode(row_id,
+                                        DatabaseMetaDataKey::USER_INT_VERSION),
             int_version);
   return true;
 }
 
 bool IndexedDBBackingStore::UpdateIDBDatabaseMetaData(
     IndexedDBBackingStore::Transaction* transaction,
     int64 row_id,
     const string16& version) {
-  PutString(Transaction::LevelDBTransactionFrom(transaction),
-            LevelDBSlice(DatabaseMetaDataKey::Encode(
-                row_id, DatabaseMetaDataKey::USER_VERSION)),
-            version);
+  PutString(
+      Transaction::LevelDBTransactionFrom(transaction),
+      DatabaseMetaDataKey::Encode(row_id, DatabaseMetaDataKey::USER_VERSION),
+      version);
   return true;
 }
 
 static void DeleteRange(LevelDBTransaction* transaction,
-                        const std::vector<char>& begin,
-                        const std::vector<char>& end) {
+                        const std::string& begin,
+                        const std::string& end) {
   scoped_ptr<LevelDBIterator> it = transaction->CreateIterator();
-  for (it->Seek(LevelDBSlice(begin));
-       it->IsValid() && CompareKeys(it->Key(), LevelDBSlice(end)) < 0;
+  for (it->Seek(begin); it->IsValid() && CompareKeys(it->Key(), end) < 0;
        it->Next())
     transaction->Remove(it->Key());
 }
 
 bool IndexedDBBackingStore::DeleteDatabase(const string16& name) {
   IDB_TRACE("IndexedDBBackingStore::DeleteDatabase");
   scoped_ptr<LevelDBWriteOnlyTransaction> transaction =
       LevelDBWriteOnlyTransaction::Create(db_.get());
 
   IndexedDBDatabaseMetadata metadata;
   bool success = false;
   bool ok = GetIDBDatabaseMetaData(name, &metadata, &success);
   if (!ok)
     return false;
   if (!success)
     return true;
 
-  const std::vector<char> start_key = DatabaseMetaDataKey::Encode(
+  const std::string start_key = DatabaseMetaDataKey::Encode(
       metadata.id, DatabaseMetaDataKey::ORIGIN_NAME);
-  const std::vector<char> stop_key = DatabaseMetaDataKey::Encode(
+  const std::string stop_key = DatabaseMetaDataKey::Encode(
       metadata.id + 1, DatabaseMetaDataKey::ORIGIN_NAME);
   scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
-  for (it->Seek(LevelDBSlice(start_key));
-       it->IsValid() && CompareKeys(it->Key(), LevelDBSlice(stop_key)) < 0;
+  for (it->Seek(start_key);
+       it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
        it->Next())
     transaction->Remove(it->Key());
 
-  const std::vector<char> key = DatabaseNameKey::Encode(identifier_, name);
-  transaction->Remove(LevelDBSlice(key));
+  const std::string key = DatabaseNameKey::Encode(identifier_, name);
+  transaction->Remove(key);
 
   if (!transaction->Commit()) {
     INTERNAL_WRITE_ERROR(DELETE_DATABASE);
     return false;
   }
   return true;
 }
 
 static bool CheckObjectStoreAndMetaDataType(const LevelDBIterator* it,
-                                            const std::vector<char>& stop_key,
+                                            const std::string& stop_key,
                                             int64 object_store_id,
                                             int64 meta_data_type) {
-  if (!it->IsValid() || CompareKeys(it->Key(), LevelDBSlice(stop_key)) >= 0)
+  if (!it->IsValid() || CompareKeys(it->Key(), stop_key) >= 0)
     return false;
 
   ObjectStoreMetaDataKey meta_data_key;
   const char* p = ObjectStoreMetaDataKey::Decode(
       it->Key().begin(), it->Key().end(), &meta_data_key);
   DCHECK(p);
   if (meta_data_key.ObjectStoreId() != object_store_id)
     return false;
   if (meta_data_key.MetaDataType() != meta_data_type)
     return false;
   return true;
 }
 
 // TODO(jsbell): This should do some error handling rather than
 // plowing ahead when bad data is encountered.
 bool IndexedDBBackingStore::GetObjectStores(
     int64 database_id,
     IndexedDBDatabaseMetadata::ObjectStoreMap* object_stores) {
   IDB_TRACE("IndexedDBBackingStore::GetObjectStores");
   if (!KeyPrefix::IsValidDatabaseId(database_id))
     return false;
-  const std::vector<char> start_key =
+  const std::string start_key =
       ObjectStoreMetaDataKey::Encode(database_id, 1, 0);
-  const std::vector<char> stop_key =
+  const std::string stop_key =
       ObjectStoreMetaDataKey::EncodeMaxKey(database_id);
 
   DCHECK(object_stores->empty());
 
   scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
-  it->Seek(LevelDBSlice(start_key));
-  while (it->IsValid() && CompareKeys(it->Key(), LevelDBSlice(stop_key)) < 0) {
+  it->Seek(start_key);
+  while (it->IsValid() && CompareKeys(it->Key(), stop_key) < 0) {
     const char* p = it->Key().begin();
     const char* limit = it->Key().end();
 
     ObjectStoreMetaDataKey meta_data_key;
     p = ObjectStoreMetaDataKey::Decode(p, limit, &meta_data_key);
     DCHECK(p);
     if (meta_data_key.MetaDataType() != ObjectStoreMetaDataKey::NAME) {
       INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
       // Possible stale metadata, but don't fail the load.
       it->Next();
       continue;
     }
 
     int64 object_store_id = meta_data_key.ObjectStoreId();
 
     // TODO(jsbell): Do this by direct key lookup rather than iteration, to
     // simplify.
     string16 object_store_name;
     {
-      StringPiece slice(it->Value().AsStringPiece());
+      StringPiece slice(it->Value());
       if (!DecodeString(&slice, &object_store_name) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
     }
 
     it->Next();
     if (!CheckObjectStoreAndMetaDataType(it.get(),
                                          stop_key,
                                          object_store_id,
                                          ObjectStoreMetaDataKey::KEY_PATH)) {
       INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
       break;
     }
     IndexedDBKeyPath key_path;
     {
-      StringPiece slice(it->Value().AsStringPiece());
+      StringPiece slice(it->Value());
       if (!DecodeIDBKeyPath(&slice, &key_path) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
     }
 
     it->Next();
     if (!CheckObjectStoreAndMetaDataType(
             it.get(),
             stop_key,
             object_store_id,
             ObjectStoreMetaDataKey::AUTO_INCREMENT)) {
       INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
       break;
     }
     bool auto_increment;
     {
-      StringPiece slice(it->Value().AsStringPiece());
+      StringPiece slice(it->Value());
       if (!DecodeBool(&slice, &auto_increment) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
     }
 
     it->Next();  // Is evicatble.
     if (!CheckObjectStoreAndMetaDataType(it.get(),
                                          stop_key,
                                          object_store_id,
                                          ObjectStoreMetaDataKey::EVICTABLE)) {
       INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
@@ skipping 14 matching lines @@
     if (!CheckObjectStoreAndMetaDataType(
             it.get(),
             stop_key,
             object_store_id,
             ObjectStoreMetaDataKey::MAX_INDEX_ID)) {
       INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
       break;
     }
     int64 max_index_id;
     {
-      StringPiece slice(it->Value().AsStringPiece());
+      StringPiece slice(it->Value());
       if (!DecodeInt(&slice, &max_index_id) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
     }
 
     it->Next();  // [optional] has key path (is not null)
     if (CheckObjectStoreAndMetaDataType(it.get(),
                                         stop_key,
                                         object_store_id,
                                         ObjectStoreMetaDataKey::HAS_KEY_PATH)) {
       bool has_key_path;
       {
-        StringPiece slice(it->Value().AsStringPiece());
+        StringPiece slice(it->Value());
         if (!DecodeBool(&slice, &has_key_path))
           INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
       }
       // This check accounts for two layers of legacy coding:
       // (1) Initially, has_key_path was added to distinguish null vs. string.
       // (2) Later, null vs. string vs. array was stored in the key_path itself.
       // So this check is only relevant for string-type key_paths.
       if (!has_key_path &&
           (key_path.type() == WebKit::WebIDBKeyPath::StringType &&
            !key_path.string().empty())) {
         INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
         break;
       }
       if (!has_key_path)
         key_path = IndexedDBKeyPath();
       it->Next();
     }
 
     int64 key_generator_current_number = -1;
     if (CheckObjectStoreAndMetaDataType(
             it.get(),
             stop_key,
             object_store_id,
             ObjectStoreMetaDataKey::KEY_GENERATOR_CURRENT_NUMBER)) {
-      StringPiece slice(it->Value().AsStringPiece());
+      StringPiece slice(it->Value());
       if (!DecodeInt(&slice, &key_generator_current_number) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
 
       // TODO(jsbell): Return key_generator_current_number, cache in
       // object store, and write lazily to backing store.  For now,
       // just assert that if it was written it was valid.
       DCHECK_GE(key_generator_current_number, kKeyGeneratorInitialNumber);
       it->Next();
     }
 
     IndexedDBObjectStoreMetadata metadata(object_store_name,
                                           object_store_id,
                                           key_path,
                                           auto_increment,
                                           max_index_id);
     if (!GetIndexes(database_id, object_store_id, &metadata.indexes))
       return false;
     (*object_stores)[object_store_id] = metadata;
   }
   return true;
 }
 
 WARN_UNUSED_RESULT static bool SetMaxObjectStoreId(
     LevelDBTransaction* transaction,
     int64 database_id,
     int64 object_store_id) {
-  const std::vector<char> max_object_store_id_key = DatabaseMetaDataKey::Encode(
+  const std::string max_object_store_id_key = DatabaseMetaDataKey::Encode(
       database_id, DatabaseMetaDataKey::MAX_OBJECT_STORE_ID);
   int64 max_object_store_id = -1;
   bool ok = GetMaxObjectStoreId(
       transaction, max_object_store_id_key, &max_object_store_id);
   if (!ok) {
     INTERNAL_READ_ERROR(SET_MAX_OBJECT_STORE_ID);
     return false;
   }
 
   if (object_store_id <= max_object_store_id) {
     INTERNAL_CONSISTENCY_ERROR(SET_MAX_OBJECT_STORE_ID);
     return false;
   }
-  PutInt(transaction, LevelDBSlice(max_object_store_id_key), object_store_id);
+  PutInt(transaction, max_object_store_id_key, object_store_id);
   return true;
 }
 
 bool IndexedDBBackingStore::CreateObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const string16& name,
     const IndexedDBKeyPath& key_path,
     bool auto_increment) {
   IDB_TRACE("IndexedDBBackingStore::CreateObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
   if (!SetMaxObjectStoreId(leveldb_transaction, database_id, object_store_id))
     return false;
 
-  const std::vector<char> name_key = ObjectStoreMetaDataKey::Encode(
+  const std::string name_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::NAME);
-  const std::vector<char> key_path_key = ObjectStoreMetaDataKey::Encode(
+  const std::string key_path_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::KEY_PATH);
-  const std::vector<char> auto_increment_key = ObjectStoreMetaDataKey::Encode(
+  const std::string auto_increment_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::AUTO_INCREMENT);
-  const std::vector<char> evictable_key = ObjectStoreMetaDataKey::Encode(
+  const std::string evictable_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::EVICTABLE);
-  const std::vector<char> last_version_key = ObjectStoreMetaDataKey::Encode(
+  const std::string last_version_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::LAST_VERSION);
-  const std::vector<char> max_index_id_key = ObjectStoreMetaDataKey::Encode(
+  const std::string max_index_id_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::MAX_INDEX_ID);
-  const std::vector<char> has_key_path_key = ObjectStoreMetaDataKey::Encode(
+  const std::string has_key_path_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::HAS_KEY_PATH);
-  const std::vector<char> key_generator_current_number_key =
+  const std::string key_generator_current_number_key =
       ObjectStoreMetaDataKey::Encode(
           database_id,
           object_store_id,
           ObjectStoreMetaDataKey::KEY_GENERATOR_CURRENT_NUMBER);
-  const std::vector<char> names_key =
-      ObjectStoreNamesKey::Encode(database_id, name);
+  const std::string names_key = ObjectStoreNamesKey::Encode(database_id, name);
 
-  PutString(leveldb_transaction, LevelDBSlice(name_key), name);
-  PutIDBKeyPath(leveldb_transaction, LevelDBSlice(key_path_key), key_path);
-  PutInt(leveldb_transaction, LevelDBSlice(auto_increment_key), auto_increment);
-  PutInt(leveldb_transaction, LevelDBSlice(evictable_key), false);
-  PutInt(leveldb_transaction, LevelDBSlice(last_version_key), 1);
-  PutInt(leveldb_transaction, LevelDBSlice(max_index_id_key), kMinimumIndexId);
-  PutBool(
-      leveldb_transaction, LevelDBSlice(has_key_path_key), !key_path.IsNull());
+  PutString(leveldb_transaction, name_key, name);
+  PutIDBKeyPath(leveldb_transaction, key_path_key, key_path);
+  PutInt(leveldb_transaction, auto_increment_key, auto_increment);
+  PutInt(leveldb_transaction, evictable_key, false);
+  PutInt(leveldb_transaction, last_version_key, 1);
+  PutInt(leveldb_transaction, max_index_id_key, kMinimumIndexId);
+  PutBool(leveldb_transaction, has_key_path_key, !key_path.IsNull());
   PutInt(leveldb_transaction,
-         LevelDBSlice(key_generator_current_number_key),
+         key_generator_current_number_key,
          kKeyGeneratorInitialNumber);
-  PutInt(leveldb_transaction, LevelDBSlice(names_key), object_store_id);
+  PutInt(leveldb_transaction, names_key, object_store_id);
   return true;
 }
 
 bool IndexedDBBackingStore::DeleteObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id) {
   IDB_TRACE("IndexedDBBackingStore::DeleteObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
   string16 object_store_name;
   bool found = false;
   bool ok = GetString(
       leveldb_transaction,
-      LevelDBSlice(ObjectStoreMetaDataKey::Encode(
-          database_id, object_store_id, ObjectStoreMetaDataKey::NAME)),
+      ObjectStoreMetaDataKey::Encode(
+          database_id, object_store_id, ObjectStoreMetaDataKey::NAME),
       &object_store_name,
       &found);
   if (!ok) {
     INTERNAL_READ_ERROR(DELETE_OBJECT_STORE);
     return false;
   }
   if (!found) {
     INTERNAL_CONSISTENCY_ERROR(DELETE_OBJECT_STORE);
     return false;
   }
 
   DeleteRange(
       leveldb_transaction,
       ObjectStoreMetaDataKey::Encode(database_id, object_store_id, 0),
       ObjectStoreMetaDataKey::EncodeMaxKey(database_id, object_store_id));
 
-  leveldb_transaction->Remove(LevelDBSlice(
-      ObjectStoreNamesKey::Encode(database_id, object_store_name)));
+  leveldb_transaction->Remove(
+      ObjectStoreNamesKey::Encode(database_id, object_store_name));
 
   DeleteRange(leveldb_transaction,
               IndexFreeListKey::Encode(database_id, object_store_id, 0),
               IndexFreeListKey::EncodeMaxKey(database_id, object_store_id));
   DeleteRange(leveldb_transaction,
               IndexMetaDataKey::Encode(database_id, object_store_id, 0, 0),
               IndexMetaDataKey::EncodeMaxKey(database_id, object_store_id));
 
   return ClearObjectStore(transaction, database_id, object_store_id);
 }
 
 bool IndexedDBBackingStore::GetRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKey& key,
-    std::vector<char>* record) {
+    std::string* record) {
   IDB_TRACE("IndexedDBBackingStore::GetRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
-  const std::vector<char> leveldb_key =
+  const std::string leveldb_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, key);
   std::string data;
 
   record->clear();
 
   bool found = false;
-  bool ok = leveldb_transaction->Get(LevelDBSlice(leveldb_key), &data, &found);
+  bool ok = leveldb_transaction->Get(leveldb_key, &data, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_RECORD);
     return false;
   }
   if (!found)
     return true;
   if (data.empty()) {
     INTERNAL_READ_ERROR(GET_RECORD);
     return false;
   }
 
   int64 version;
   StringPiece slice(data);
   if (!DecodeVarInt(&slice, &version)) {
     INTERNAL_READ_ERROR(GET_RECORD);
     return false;
   }
 
-  record->insert(record->end(), slice.begin(), slice.end());
+  *record = slice.as_string();
   return true;
 }
 
 WARN_UNUSED_RESULT static bool GetNewVersionNumber(
     LevelDBTransaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64* new_version_number) {
-  const std::vector<char> last_version_key = ObjectStoreMetaDataKey::Encode(
+  const std::string last_version_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::LAST_VERSION);
 
   *new_version_number = -1;
   int64 last_version = -1;
   bool found = false;
-  bool ok = GetInt(
-      transaction, LevelDBSlice(last_version_key), &last_version, &found);
+  bool ok = GetInt(transaction, last_version_key, &last_version, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_NEW_VERSION_NUMBER);
     return false;
   }
   if (!found)
     last_version = 0;
 
   DCHECK_GE(last_version, 0);
 
   int64 version = last_version + 1;
-  PutInt(transaction, LevelDBSlice(last_version_key), version);
+  PutInt(transaction, last_version_key, version);
 
   // TODO(jsbell): Think about how we want to handle the overflow scenario.
   DCHECK(version > last_version);
 
   *new_version_number = version;
   return true;
 }
 
 bool IndexedDBBackingStore::PutRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKey& key,
-    const std::vector<char>& value,
+    const std::string& value,
     RecordIdentifier* record_identifier) {
   IDB_TRACE("IndexedDBBackingStore::PutRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   DCHECK(key.IsValid());
 
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
   int64 version = -1;
   bool ok = GetNewVersionNumber(
       leveldb_transaction, database_id, object_store_id, &version);
   if (!ok)
     return false;
   DCHECK_GE(version, 0);
-  const std::vector<char> object_storedata_key =
+  const std::string object_storedata_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, key);
 
-  std::vector<char> v;
+  std::string v;
   EncodeVarInt(version, &v);
-  v.insert(v.end(), value.begin(), value.end());
+  v.append(value);
 
-  leveldb_transaction->Put(LevelDBSlice(object_storedata_key), &v);
+  leveldb_transaction->Put(object_storedata_key, &v);
 
-  const std::vector<char> exists_entry_key =
+  const std::string exists_entry_key =
       ExistsEntryKey::Encode(database_id, object_store_id, key);
-  std::vector<char> version_encoded;
+  std::string version_encoded;
   EncodeInt(version, &version_encoded);
-  leveldb_transaction->Put(LevelDBSlice(exists_entry_key), &version_encoded);
+  leveldb_transaction->Put(exists_entry_key, &version_encoded);
 
-  std::vector<char> key_encoded;
+  std::string key_encoded;
   EncodeIDBKey(key, &key_encoded);
   record_identifier->Reset(key_encoded, version);
   return true;
 }
 
 bool IndexedDBBackingStore::ClearObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id) {
   IDB_TRACE("IndexedDBBackingStore::ClearObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
-  const std::vector<char> start_key =
+  const std::string start_key =
       KeyPrefix(database_id, object_store_id).Encode();
-  const std::vector<char> stop_key =
+  const std::string stop_key =
       KeyPrefix(database_id, object_store_id + 1).Encode();
 
   DeleteRange(leveldb_transaction, start_key, stop_key);
   return true;
 }
 
 bool IndexedDBBackingStore::DeleteRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const RecordIdentifier& record_identifier) {
   IDB_TRACE("IndexedDBBackingStore::DeleteRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
-  const std::vector<char> object_store_data_key = ObjectStoreDataKey::Encode(
+  const std::string object_store_data_key = ObjectStoreDataKey::Encode(
       database_id, object_store_id, record_identifier.primary_key());
-  leveldb_transaction->Remove(LevelDBSlice(object_store_data_key));
+  leveldb_transaction->Remove(object_store_data_key);
 
-  const std::vector<char> exists_entry_key = ExistsEntryKey::Encode(
+  const std::string exists_entry_key = ExistsEntryKey::Encode(
       database_id, object_store_id, record_identifier.primary_key());
-  leveldb_transaction->Remove(LevelDBSlice(exists_entry_key));
+  leveldb_transaction->Remove(exists_entry_key);
   return true;
 }
 
 bool IndexedDBBackingStore::GetKeyGeneratorCurrentNumber(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64* key_generator_current_number) {
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
-  const std::vector<char> key_generator_current_number_key =
+  const std::string key_generator_current_number_key =
       ObjectStoreMetaDataKey::Encode(
           database_id,
           object_store_id,
           ObjectStoreMetaDataKey::KEY_GENERATOR_CURRENT_NUMBER);
 
   *key_generator_current_number = -1;
   std::string data;
 
   bool found = false;
-  bool ok = leveldb_transaction->Get(
-      LevelDBSlice(key_generator_current_number_key), &data, &found);
+  bool ok =
+      leveldb_transaction->Get(key_generator_current_number_key, &data, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_KEY_GENERATOR_CURRENT_NUMBER);
     return false;
   }
   if (found && !data.empty()) {
     StringPiece slice(data);
     if (!DecodeInt(&slice, key_generator_current_number) || !slice.empty()) {
       INTERNAL_READ_ERROR(GET_KEY_GENERATOR_CURRENT_NUMBER);
       return false;
     }
     return true;
   }
 
   // Previously, the key generator state was not stored explicitly
   // but derived from the maximum numeric key present in existing
   // data. This violates the spec as the data may be cleared but the
   // key generator state must be preserved.
   // TODO(jsbell): Fix this for all stores on database open?
-  const std::vector<char> start_key =
+  const std::string start_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, MinIDBKey());
-  const std::vector<char> stop_key =
+  const std::string stop_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, MaxIDBKey());
 
   scoped_ptr<LevelDBIterator> it = leveldb_transaction->CreateIterator();
   int64 max_numeric_key = 0;
 
-  for (it->Seek(LevelDBSlice(start_key));
-       it->IsValid() && CompareKeys(it->Key(), LevelDBSlice(stop_key)) < 0;
+  for (it->Seek(start_key);
+       it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
        it->Next()) {
     const char* p = it->Key().begin();
     const char* limit = it->Key().end();
 
     ObjectStoreDataKey data_key;
     p = ObjectStoreDataKey::Decode(p, limit, &data_key);
     DCHECK(p);
 
     scoped_ptr<IndexedDBKey> user_key = data_key.user_key();
     if (user_key->type() == WebKit::WebIDBKey::NumberType) {
@@ skipping 21 matching lines @@
   if (check_current) {
     int64 current_number;
     bool ok = GetKeyGeneratorCurrentNumber(
         transaction, database_id, object_store_id, &current_number);
     if (!ok)
       return false;
     if (new_number <= current_number)
       return true;
   }
 
-  const std::vector<char> key_generator_current_number_key =
+  const std::string key_generator_current_number_key =
       ObjectStoreMetaDataKey::Encode(
           database_id,
           object_store_id,
           ObjectStoreMetaDataKey::KEY_GENERATOR_CURRENT_NUMBER);
-  PutInt(leveldb_transaction,
-         LevelDBSlice(key_generator_current_number_key),
-         new_number);
+  PutInt(leveldb_transaction, key_generator_current_number_key, new_number);
   return true;
 }
 
 bool IndexedDBBackingStore::KeyExistsInObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKey& key,
     RecordIdentifier* found_record_identifier,
     bool* found) {
   IDB_TRACE("IndexedDBBackingStore::KeyExistsInObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   *found = false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
-  const std::vector<char> leveldb_key =
+  const std::string leveldb_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, key);
   std::string data;
 
-  bool ok = leveldb_transaction->Get(LevelDBSlice(leveldb_key), &data, found);
+  bool ok = leveldb_transaction->Get(leveldb_key, &data, found);
   if (!ok) {
     INTERNAL_READ_ERROR(KEY_EXISTS_IN_OBJECT_STORE);
     return false;
   }
   if (!*found)
     return true;
   if (!data.size()) {
     INTERNAL_READ_ERROR(KEY_EXISTS_IN_OBJECT_STORE);
     return false;
   }
 
   int64 version;
   StringPiece slice(data);
   if (!DecodeVarInt(&slice, &version))
     return false;
 
-  std::vector<char> encoded_key;
+  std::string encoded_key;
   EncodeIDBKey(key, &encoded_key);
   found_record_identifier->Reset(encoded_key, version);
   return true;
 }
 
 static bool CheckIndexAndMetaDataKey(const LevelDBIterator* it,
-                                     const std::vector<char>& stop_key,
+                                     const std::string& stop_key,
                                      int64 index_id,
                                      unsigned char meta_data_type) {
-  if (!it->IsValid() || CompareKeys(it->Key(), LevelDBSlice(stop_key)) >= 0)
+  if (!it->IsValid() || CompareKeys(it->Key(), stop_key) >= 0)
     return false;
 
   IndexMetaDataKey meta_data_key;
   const char* p = IndexMetaDataKey::Decode(
       it->Key().begin(), it->Key().end(), &meta_data_key);
   DCHECK(p);
   if (meta_data_key.IndexId() != index_id)
     return false;
   if (meta_data_key.meta_data_type() != meta_data_type)
     return false;
   return true;
 }
 
 // TODO(jsbell): This should do some error handling rather than plowing ahead
 // when bad data is encountered.
 bool IndexedDBBackingStore::GetIndexes(
     int64 database_id,
     int64 object_store_id,
     IndexedDBObjectStoreMetadata::IndexMap* indexes) {
   IDB_TRACE("IndexedDBBackingStore::GetIndexes");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
-  const std::vector<char> start_key =
+  const std::string start_key =
       IndexMetaDataKey::Encode(database_id, object_store_id, 0, 0);
-  const std::vector<char> stop_key =
+  const std::string stop_key =
       IndexMetaDataKey::Encode(database_id, object_store_id + 1, 0, 0);
 
   DCHECK(indexes->empty());
 
   scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
-  it->Seek(LevelDBSlice(start_key));
-  while (it->IsValid() &&
-         CompareKeys(LevelDBSlice(it->Key()), LevelDBSlice(stop_key)) < 0) {
+  it->Seek(start_key);
+  while (it->IsValid() && CompareKeys(it->Key(), stop_key) < 0) {
     const char* p = it->Key().begin();
     const char* limit = it->Key().end();
 
     IndexMetaDataKey meta_data_key;
     p = IndexMetaDataKey::Decode(p, limit, &meta_data_key);
     DCHECK(p);
     if (meta_data_key.meta_data_type() != IndexMetaDataKey::NAME) {
       INTERNAL_CONSISTENCY_ERROR(GET_INDEXES);
       // Possible stale metadata due to http://webkit.org/b/85557 but don't fail
       // the load.
       it->Next();
       continue;
     }
 
     // TODO(jsbell): Do this by direct key lookup rather than iteration, to
     // simplify.
     int64 index_id = meta_data_key.IndexId();
     string16 index_name;
     {
-      StringPiece slice(it->Value().AsStringPiece());
+      StringPiece slice(it->Value());
       if (!DecodeString(&slice, &index_name) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_INDEXES);
     }
 
     it->Next();  // unique flag
     if (!CheckIndexAndMetaDataKey(
             it.get(), stop_key, index_id, IndexMetaDataKey::UNIQUE)) {
       INTERNAL_CONSISTENCY_ERROR(GET_INDEXES);
       break;
     }
     bool index_unique;
     {
-      StringPiece slice(it->Value().AsStringPiece());
+      StringPiece slice(it->Value());
       if (!DecodeBool(&slice, &index_unique) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_INDEXES);
     }
 
     it->Next();  // key_path
     if (!CheckIndexAndMetaDataKey(
             it.get(), stop_key, index_id, IndexMetaDataKey::KEY_PATH)) {
       INTERNAL_CONSISTENCY_ERROR(GET_INDEXES);
       break;
     }
     IndexedDBKeyPath key_path;
     {
-      StringPiece slice(it->Value().AsStringPiece());
+      StringPiece slice(it->Value());
       if (!DecodeIDBKeyPath(&slice, &key_path) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_INDEXES);
     }
 
     it->Next();  // [optional] multi_entry flag
     bool index_multi_entry = false;
     if (CheckIndexAndMetaDataKey(
             it.get(), stop_key, index_id, IndexMetaDataKey::MULTI_ENTRY)) {
-      StringPiece slice(it->Value().AsStringPiece());
+      StringPiece slice(it->Value());
       if (!DecodeBool(&slice, &index_multi_entry) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_INDEXES);
 
       it->Next();
     }
 
     (*indexes)[index_id] = IndexedDBIndexMetadata(
         index_name, index_id, key_path, index_unique, index_multi_entry);
   }
   return true;
 }
 
 WARN_UNUSED_RESULT static bool SetMaxIndexId(LevelDBTransaction* transaction,
                                              int64 database_id,
                                              int64 object_store_id,
                                              int64 index_id) {
   int64 max_index_id = -1;
-  const std::vector<char> max_index_id_key = ObjectStoreMetaDataKey::Encode(
+  const std::string max_index_id_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::MAX_INDEX_ID);
   bool found = false;
-  bool ok = GetInt(
-      transaction, LevelDBSlice(max_index_id_key), &max_index_id, &found);
+  bool ok = GetInt(transaction, max_index_id_key, &max_index_id, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(SET_MAX_INDEX_ID);
     return false;
   }
   if (!found)
     max_index_id = kMinimumIndexId;
 
   if (index_id <= max_index_id) {
     INTERNAL_CONSISTENCY_ERROR(SET_MAX_INDEX_ID);
     return false;
   }
 
-  PutInt(transaction, LevelDBSlice(max_index_id_key), index_id);
+  PutInt(transaction, max_index_id_key, index_id);
   return true;
 }
 
 bool IndexedDBBackingStore::CreateIndex(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64 index_id,
     const string16& name,
     const IndexedDBKeyPath& key_path,
     bool is_unique,
     bool is_multi_entry) {
   IDB_TRACE("IndexedDBBackingStore::CreateIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
   if (!SetMaxIndexId(
           leveldb_transaction, database_id, object_store_id, index_id))
     return false;
 
-  const std::vector<char> name_key = IndexMetaDataKey::Encode(
+  const std::string name_key = IndexMetaDataKey::Encode(
       database_id, object_store_id, index_id, IndexMetaDataKey::NAME);
-  const std::vector<char> unique_key = IndexMetaDataKey::Encode(
+  const std::string unique_key = IndexMetaDataKey::Encode(
       database_id, object_store_id, index_id, IndexMetaDataKey::UNIQUE);
-  const std::vector<char> key_path_key = IndexMetaDataKey::Encode(
+  const std::string key_path_key = IndexMetaDataKey::Encode(
       database_id, object_store_id, index_id, IndexMetaDataKey::KEY_PATH);
-  const std::vector<char> multi_entry_key = IndexMetaDataKey::Encode(
+  const std::string multi_entry_key = IndexMetaDataKey::Encode(
       database_id, object_store_id, index_id, IndexMetaDataKey::MULTI_ENTRY);
 
-  PutString(leveldb_transaction, LevelDBSlice(name_key), name);
-  PutBool(leveldb_transaction, LevelDBSlice(unique_key), is_unique);
-  PutIDBKeyPath(leveldb_transaction, LevelDBSlice(key_path_key), key_path);
-  PutBool(leveldb_transaction, LevelDBSlice(multi_entry_key), is_multi_entry);
+  PutString(leveldb_transaction, name_key, name);
+  PutBool(leveldb_transaction, unique_key, is_unique);
+  PutIDBKeyPath(leveldb_transaction, key_path_key, key_path);
+  PutBool(leveldb_transaction, multi_entry_key, is_multi_entry);
   return true;
 }
 
 bool IndexedDBBackingStore::DeleteIndex(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64 index_id) {
   IDB_TRACE("IndexedDBBackingStore::DeleteIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
-  const std::vector<char> index_meta_data_start =
+  const std::string index_meta_data_start =
       IndexMetaDataKey::Encode(database_id, object_store_id, index_id, 0);
-  const std::vector<char> index_meta_data_end =
+  const std::string index_meta_data_end =
       IndexMetaDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
   DeleteRange(leveldb_transaction, index_meta_data_start, index_meta_data_end);
 
-  const std::vector<char> index_data_start =
+  const std::string index_data_start =
       IndexDataKey::EncodeMinKey(database_id, object_store_id, index_id);
-  const std::vector<char> index_data_end =
+  const std::string index_data_end =
       IndexDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
   DeleteRange(leveldb_transaction, index_data_start, index_data_end);
   return true;
 }
 
 bool IndexedDBBackingStore::PutIndexDataForRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64 index_id,
     const IndexedDBKey& key,
     const RecordIdentifier& record_identifier) {
   IDB_TRACE("IndexedDBBackingStore::PutIndexDataForRecord");
   DCHECK(key.IsValid());
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return false;
 
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
-  std::vector<char> encoded_key;
+  std::string encoded_key;
   EncodeIDBKey(key, &encoded_key);
 
-  const std::vector<char> index_data_key =
+  const std::string index_data_key =
       IndexDataKey::Encode(database_id,
                            object_store_id,
                            index_id,
                            encoded_key,
                            record_identifier.primary_key(),
                            0);
 
-  std::vector<char> data;
+  std::string data;
   EncodeVarInt(record_identifier.version(), &data);
-  const std::vector<char>& primary_key = record_identifier.primary_key();
-  data.insert(data.end(), primary_key.begin(), primary_key.end());
+  data.append(record_identifier.primary_key());
 
-  leveldb_transaction->Put(LevelDBSlice(index_data_key), &data);
+  leveldb_transaction->Put(index_data_key, &data);
   return true;
 }
 
 static bool FindGreatestKeyLessThanOrEqual(LevelDBTransaction* transaction,
-                                           const std::vector<char>& target,
-                                           std::vector<char>* found_key) {
+                                           const std::string& target,
+                                           std::string* found_key) {
   scoped_ptr<LevelDBIterator> it = transaction->CreateIterator();
-  it->Seek(LevelDBSlice(target));
+  it->Seek(target);
 
   if (!it->IsValid()) {
     it->SeekToLast();
     if (!it->IsValid())
       return false;
   }
 
-  while (CompareIndexKeys(LevelDBSlice(it->Key()), LevelDBSlice(target)) > 0) {
+  while (CompareIndexKeys(it->Key(), target) > 0) {
     it->Prev();
     if (!it->IsValid())
       return false;
   }
 
   do {
-    found_key->assign(it->Key().begin(), it->Key().end());
+    *found_key = it->Key().as_string();
 
     // There can be several index keys that compare equal. We want the last one.
     it->Next();
-  } while (it->IsValid() && !CompareIndexKeys(it->Key(), LevelDBSlice(target)));
+  } while (it->IsValid() && !CompareIndexKeys(it->Key(), target));
 
   return true;
 }
 
 static bool VersionExists(LevelDBTransaction* transaction,
                           int64 database_id,
                           int64 object_store_id,
                           int64 version,
-                          const std::vector<char>& encoded_primary_key,
+                          const std::string& encoded_primary_key,
                           bool* exists) {
-  const std::vector<char> key =
+  const std::string key =
       ExistsEntryKey::Encode(database_id, object_store_id, encoded_primary_key);
   std::string data;
 
-  bool ok = transaction->Get(LevelDBSlice(key), &data, exists);
+  bool ok = transaction->Get(key, &data, exists);
   if (!ok) {
     INTERNAL_READ_ERROR(VERSION_EXISTS);
     return false;
   }
   if (!*exists)
     return true;
 
   StringPiece slice(data);
   int64 decoded;
   if (!DecodeInt(&slice, &decoded) || !slice.empty())
     return false;
   *exists = (decoded == version);
   return true;
 }
 
 bool IndexedDBBackingStore::FindKeyInIndex(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64 index_id,
     const IndexedDBKey& key,
-    std::vector<char>* found_encoded_primary_key,
+    std::string* found_encoded_primary_key,
     bool* found) {
   IDB_TRACE("IndexedDBBackingStore::FindKeyInIndex");
   DCHECK(KeyPrefix::ValidIds(database_id, object_store_id, index_id));
 
   DCHECK(found_encoded_primary_key->empty());
   *found = false;
 
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
-  const std::vector<char> leveldb_key =
+  const std::string leveldb_key =
       IndexDataKey::Encode(database_id, object_store_id, index_id, key);
   scoped_ptr<LevelDBIterator> it = leveldb_transaction->CreateIterator();
-  it->Seek(LevelDBSlice(leveldb_key));
+  it->Seek(leveldb_key);
 
   for (;;) {
     if (!it->IsValid())
       return true;
-    if (CompareIndexKeys(it->Key(), LevelDBSlice(leveldb_key)) > 0)
+    if (CompareIndexKeys(it->Key(), leveldb_key) > 0)
       return true;
 
-    StringPiece slice(it->Value().AsStringPiece());
+    StringPiece slice(it->Value());
 
     int64 version;
     if (!DecodeVarInt(&slice, &version)) {
       INTERNAL_READ_ERROR(FIND_KEY_IN_INDEX);
       return false;
     }
-    found_encoded_primary_key->insert(
-        found_encoded_primary_key->end(), slice.begin(), slice.end());
+    *found_encoded_primary_key = slice.as_string();
 
     bool exists = false;
     bool ok = VersionExists(leveldb_transaction,
                             database_id,
                             object_store_id,
                             version,
                             *found_encoded_primary_key,
                             &exists);
     if (!ok)
       return false;
@@ skipping 13 matching lines @@
     int64 database_id,
     int64 object_store_id,
     int64 index_id,
     const IndexedDBKey& key,
     scoped_ptr<IndexedDBKey>* primary_key) {
   IDB_TRACE("IndexedDBBackingStore::GetPrimaryKeyViaIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return false;
 
   bool found = false;
-  std::vector<char> found_encoded_primary_key;
+  std::string found_encoded_primary_key;
   bool ok = FindKeyInIndex(transaction,
                            database_id,
                            object_store_id,
                            index_id,
                            key,
                            &found_encoded_primary_key,
                            &found);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_PRIMARY_KEY_VIA_INDEX);
     return false;
   }
   if (!found)
     return true;
   if (!found_encoded_primary_key.size()) {
     INTERNAL_READ_ERROR(GET_PRIMARY_KEY_VIA_INDEX);
     return false;
   }
 
-  StringPiece slice(&*found_encoded_primary_key.begin(),
-                    found_encoded_primary_key.size());
+  StringPiece slice(found_encoded_primary_key);
   return DecodeIDBKey(&slice, primary_key) && slice.empty();
 }
 
 bool IndexedDBBackingStore::KeyExistsInIndex(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64 index_id,
     const IndexedDBKey& index_key,
     scoped_ptr<IndexedDBKey>* found_primary_key,
     bool* exists) {
   IDB_TRACE("IndexedDBBackingStore::KeyExistsInIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return false;
 
   *exists = false;
-  std::vector<char> found_encoded_primary_key;
+  std::string found_encoded_primary_key;
   bool ok = FindKeyInIndex(transaction,
                            database_id,
                            object_store_id,
                            index_id,
                            index_key,
                            &found_encoded_primary_key,
                            exists);
   if (!ok) {
     INTERNAL_READ_ERROR(KEY_EXISTS_IN_INDEX);
     return false;
   }
   if (!*exists)
     return true;
   if (found_encoded_primary_key.empty()) {
     INTERNAL_READ_ERROR(KEY_EXISTS_IN_INDEX);
     return false;
   }
 
-  StringPiece slice(&*found_encoded_primary_key.begin(),
-                    found_encoded_primary_key.size());
+  StringPiece slice(found_encoded_primary_key);
   return DecodeIDBKey(&slice, found_primary_key) && slice.empty();
 }
 
 IndexedDBBackingStore::Cursor::Cursor(
     const IndexedDBBackingStore::Cursor* other)
     : transaction_(other->transaction_),
       cursor_options_(other->cursor_options_),
       current_key_(new IndexedDBKey(*other->current_key_)) {
   if (other->iterator_) {
     iterator_ = transaction_->CreateIterator();
 
     if (other->iterator_->IsValid()) {
       iterator_->Seek(other->iterator_->Key());
       DCHECK(iterator_->IsValid());
     }
   }
 }
 
 IndexedDBBackingStore::Cursor::Cursor(LevelDBTransaction* transaction,
                                       const CursorOptions& cursor_options)
     : transaction_(transaction), cursor_options_(cursor_options) {}
 IndexedDBBackingStore::Cursor::~Cursor() {}
 
 bool IndexedDBBackingStore::Cursor::FirstSeek() {
   iterator_ = transaction_->CreateIterator();
   if (cursor_options_.forward)
-    iterator_->Seek(LevelDBSlice(cursor_options_.low_key));
+    iterator_->Seek(cursor_options_.low_key);
   else
-    iterator_->Seek(LevelDBSlice(cursor_options_.high_key));
+    iterator_->Seek(cursor_options_.high_key);
 
   return ContinueFunction(0, READY);
 }
 
 bool IndexedDBBackingStore::Cursor::Advance(uint32 count) {
   while (count--) {
     if (!ContinueFunction())
       return false;
   }
   return true;
@@ skipping 10 matching lines @@
   // value we yield for each key is the first duplicate in forwards
   // order.
   IndexedDBKey last_duplicate_key;
 
   bool forward = cursor_options_.forward;
 
   for (;;) {
     if (next_state == SEEK) {
       // TODO(jsbell): Optimize seeking for reverse cursors as well.
       if (first_iteration && key && key->IsValid() && forward) {
-        iterator_->Seek(LevelDBSlice(EncodeKey(*key)));
+        iterator_->Seek(EncodeKey(*key));
         first_iteration = false;
       } else if (forward) {
         iterator_->Next();
       } else {
         iterator_->Prev();
       }
     } else {
       next_state = SEEK;  // for subsequent iterations
     }
 
@@ skipping 64 matching lines @@
     break;
   }
 
   DCHECK(!last_duplicate_key.IsValid() ||
          (forward && last_duplicate_key.IsEqual(*current_key_)));
   return true;
 }
 
 bool IndexedDBBackingStore::Cursor::HaveEnteredRange() const {
   if (cursor_options_.forward) {
-    int compare = CompareIndexKeys(iterator_->Key(),
-                                   LevelDBSlice(cursor_options_.low_key));
+    int compare = CompareIndexKeys(iterator_->Key(), cursor_options_.low_key);
     if (cursor_options_.low_open) {
       return compare > 0;
     }
     return compare >= 0;
   }
-  int compare = CompareIndexKeys(iterator_->Key(),
-                                 LevelDBSlice(cursor_options_.high_key));
+  int compare = CompareIndexKeys(iterator_->Key(), cursor_options_.high_key);
   if (cursor_options_.high_open) {
     return compare < 0;
   }
   return compare <= 0;
 }
 
 bool IndexedDBBackingStore::Cursor::IsPastBounds() const {
   if (cursor_options_.forward) {
-    int compare = CompareIndexKeys(iterator_->Key(),
-                                   LevelDBSlice(cursor_options_.high_key));
+    int compare = CompareIndexKeys(iterator_->Key(), cursor_options_.high_key);
     if (cursor_options_.high_open) {
       return compare >= 0;
     }
     return compare > 0;
   }
-  int compare =
-      CompareIndexKeys(iterator_->Key(), LevelDBSlice(cursor_options_.low_key));
+  int compare = CompareIndexKeys(iterator_->Key(), cursor_options_.low_key);
   if (cursor_options_.low_open) {
     return compare <= 0;
   }
   return compare < 0;
 }
 
 const IndexedDBKey& IndexedDBBackingStore::Cursor::primary_key() const {
   return *current_key_;
 }
 
 const IndexedDBBackingStore::RecordIdentifier&
 IndexedDBBackingStore::Cursor::record_identifier() const {
   return record_identifier_;
 }
 
 class ObjectStoreKeyCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   ObjectStoreKeyCursorImpl(
       LevelDBTransaction* transaction,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(transaction, cursor_options) {}
 
   virtual Cursor* Clone() OVERRIDE {
     return new ObjectStoreKeyCursorImpl(this);
   }
 
   // IndexedDBBackingStore::Cursor
-  virtual std::vector<char>* Value() OVERRIDE {
+  virtual std::string* Value() OVERRIDE {
     NOTREACHED();
     return NULL;
   }
   virtual bool LoadCurrentRow() OVERRIDE;
 
  protected:
-  virtual std::vector<char> EncodeKey(const IndexedDBKey& key) OVERRIDE {
+  virtual std::string EncodeKey(const IndexedDBKey& key) OVERRIDE {
     return ObjectStoreDataKey::Encode(
         cursor_options_.database_id, cursor_options_.object_store_id, key);
   }
 
  private:
   explicit ObjectStoreKeyCursorImpl(const ObjectStoreKeyCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other) {}
 };
 
 bool ObjectStoreKeyCursorImpl::LoadCurrentRow() {
   const char* key_position = iterator_->Key().begin();
   const char* key_limit = iterator_->Key().end();
 
   ObjectStoreDataKey object_store_data_key;
   key_position = ObjectStoreDataKey::Decode(
       key_position, key_limit, &object_store_data_key);
   if (!key_position) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   current_key_ = object_store_data_key.user_key();
 
   int64 version;
-  StringPiece slice(iterator_->Value().AsStringPiece());
+  StringPiece slice(iterator_->Value());
   if (!DecodeVarInt(&slice, &version)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   // TODO(jsbell): This re-encodes what was just decoded; try and optimize.
-  std::vector<char> encoded_key;
+  std::string encoded_key;
   EncodeIDBKey(*current_key_, &encoded_key);
   record_identifier_.Reset(encoded_key, version);
 
   return true;
 }
 
 class ObjectStoreCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   ObjectStoreCursorImpl(
       LevelDBTransaction* transaction,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(transaction, cursor_options) {}
 
   virtual Cursor* Clone() OVERRIDE { return new ObjectStoreCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual std::vector<char>* Value() OVERRIDE { return &current_value_; }
+  virtual std::string* Value() OVERRIDE { return &current_value_; }
   virtual bool LoadCurrentRow() OVERRIDE;
 
  protected:
-  virtual std::vector<char> EncodeKey(const IndexedDBKey& key) OVERRIDE {
+  virtual std::string EncodeKey(const IndexedDBKey& key) OVERRIDE {
     return ObjectStoreDataKey::Encode(
         cursor_options_.database_id, cursor_options_.object_store_id, key);
   }
 
  private:
   explicit ObjectStoreCursorImpl(const ObjectStoreCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
         current_value_(other->current_value_) {}
 
-  std::vector<char> current_value_;
+  std::string current_value_;
 };
 
 bool ObjectStoreCursorImpl::LoadCurrentRow() {
   const char* key_position = iterator_->Key().begin();
   const char* key_limit = iterator_->Key().end();
 
   ObjectStoreDataKey object_store_data_key;
   key_position = ObjectStoreDataKey::Decode(
       key_position, key_limit, &object_store_data_key);
   if (!key_position) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   current_key_ = object_store_data_key.user_key();
 
   int64 version;
-  StringPiece slice(iterator_->Value().AsStringPiece());
+  StringPiece slice(iterator_->Value());
   if (!DecodeVarInt(&slice, &version)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   // TODO(jsbell): This re-encodes what was just decoded; try and optimize.
-  std::vector<char> encoded_key;
+  std::string encoded_key;
   EncodeIDBKey(*current_key_, &encoded_key);
   record_identifier_.Reset(encoded_key, version);
 
-  std::vector<char> value;
-  value.insert(value.end(), slice.begin(), slice.end());
-  current_value_.swap(value);
+  current_value_ = slice.as_string();
   return true;
 }
 
 class IndexKeyCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   IndexKeyCursorImpl(
       LevelDBTransaction* transaction,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(transaction, cursor_options) {}
 
   virtual Cursor* Clone() OVERRIDE { return new IndexKeyCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual std::vector<char>* Value() OVERRIDE {
+  virtual std::string* Value() OVERRIDE {
     NOTREACHED();
     return NULL;
   }
   virtual const IndexedDBKey& primary_key() const OVERRIDE {
     return *primary_key_;
   }
   virtual const IndexedDBBackingStore::RecordIdentifier& RecordIdentifier()
       const {
     NOTREACHED();
     return record_identifier_;
   }
   virtual bool LoadCurrentRow() OVERRIDE;
 
  protected:
-  virtual std::vector<char> EncodeKey(const IndexedDBKey& key) OVERRIDE {
+  virtual std::string EncodeKey(const IndexedDBKey& key) OVERRIDE {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key);
   }
 
  private:
   explicit IndexKeyCursorImpl(const IndexKeyCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
         primary_key_(new IndexedDBKey(*other->primary_key_)) {}
 
   scoped_ptr<IndexedDBKey> primary_key_;
 };
 
 bool IndexKeyCursorImpl::LoadCurrentRow() {
   const char* key_position = iterator_->Key().begin();
   const char* key_limit = iterator_->Key().end();
 
   IndexDataKey index_data_key;
   key_position = IndexDataKey::Decode(key_position, key_limit, &index_data_key);
 
   current_key_ = index_data_key.user_key();
   DCHECK(current_key_);
 
-  StringPiece slice(iterator_->Value().AsStringPiece());
+  StringPiece slice(iterator_->Value());
   int64 index_data_version;
   if (!DecodeVarInt(&slice, &index_data_version)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   if (!DecodeIDBKey(&slice, &primary_key_) || !slice.empty()) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
-  std::vector<char> primary_leveldb_key =
+  std::string primary_leveldb_key =
       ObjectStoreDataKey::Encode(index_data_key.DatabaseId(),
                                  index_data_key.ObjectStoreId(),
                                  *primary_key_);
 
   std::string result;
   bool found = false;
-  bool ok =
-      transaction_->Get(LevelDBSlice(primary_leveldb_key), &result, &found);
+  bool ok = transaction_->Get(primary_leveldb_key, &result, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
   if (!found) {
     transaction_->Remove(iterator_->Key());
     return false;
   }
   if (!result.size()) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
@@ skipping 18 matching lines @@
 class IndexCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   IndexCursorImpl(
       LevelDBTransaction* transaction,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(transaction, cursor_options) {}
 
   virtual Cursor* Clone() OVERRIDE { return new IndexCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual std::vector<char>* Value() OVERRIDE { return &current_value_; }
+  virtual std::string* Value() OVERRIDE { return &current_value_; }
   virtual const IndexedDBKey& primary_key() const OVERRIDE {
     return *primary_key_;
   }
   virtual const IndexedDBBackingStore::RecordIdentifier& RecordIdentifier()
       const {
     NOTREACHED();
     return record_identifier_;
   }
   virtual bool LoadCurrentRow() OVERRIDE;
 
  protected:
-  virtual std::vector<char> EncodeKey(const IndexedDBKey& key) OVERRIDE {
+  virtual std::string EncodeKey(const IndexedDBKey& key) OVERRIDE {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key);
   }
 
  private:
   explicit IndexCursorImpl(const IndexCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
         primary_key_(new IndexedDBKey(*other->primary_key_)),
         current_value_(other->current_value_),
         primary_leveldb_key_(other->primary_leveldb_key_) {}
 
   scoped_ptr<IndexedDBKey> primary_key_;
-  std::vector<char> current_value_;
-  std::vector<char> primary_leveldb_key_;
+  std::string current_value_;
+  std::string primary_leveldb_key_;
 };
 
 bool IndexCursorImpl::LoadCurrentRow() {
   const char* key_position = iterator_->Key().begin();
   const char* key_limit = iterator_->Key().end();
 
   IndexDataKey index_data_key;
   key_position = IndexDataKey::Decode(key_position, key_limit, &index_data_key);
 
   current_key_ = index_data_key.user_key();
   DCHECK(current_key_);
 
-  StringPiece slice(iterator_->Value().AsStringPiece());
+  StringPiece slice(iterator_->Value());
   int64 index_data_version;
   if (!DecodeVarInt(&slice, &index_data_version)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
   if (!DecodeIDBKey(&slice, &primary_key_)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   primary_leveldb_key_ =
       ObjectStoreDataKey::Encode(index_data_key.DatabaseId(),
                                  index_data_key.ObjectStoreId(),
                                  *primary_key_);
 
   std::string result;
   bool found = false;
-  bool ok =
-      transaction_->Get(LevelDBSlice(primary_leveldb_key_), &result, &found);
+  bool ok = transaction_->Get(primary_leveldb_key_, &result, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
   if (!found) {
     transaction_->Remove(iterator_->Key());
     return false;
   }
   if (!result.size()) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   int64 object_store_data_version;
   slice = StringPiece(result);
   if (!DecodeVarInt(&slice, &object_store_data_version)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   if (object_store_data_version != index_data_version) {
     transaction_->Remove(iterator_->Key());
     return false;
   }
 
-  current_value_.clear();
-  current_value_.insert(current_value_.end(), slice.begin(), slice.end());
+  current_value_ = slice.as_string();
   return true;
 }
 
 bool ObjectStoreCursorOptions(
     LevelDBTransaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKeyRange& range,
     indexed_db::CursorDirection direction,
     IndexedDBBackingStore::Cursor::CursorOptions* cursor_options) {
@@ skipping 31 matching lines @@
         return false;
       cursor_options->high_open = false;
     }
   } else {
     cursor_options->high_key =
         ObjectStoreDataKey::Encode(database_id, object_store_id, range.upper());
     cursor_options->high_open = range.upperOpen();
 
     if (!cursor_options->forward) {
       // For reverse cursors, we need a key that exists.
-      std::vector<char> found_high_key;
+      std::string found_high_key;
       if (!FindGreatestKeyLessThanOrEqual(
               transaction, cursor_options->high_key, &found_high_key))
         return false;
 
       // If the target key should not be included, but we end up with a smaller
       // key, we should include that.
       if (cursor_options->high_open &&
-          CompareIndexKeys(LevelDBSlice(found_high_key),
-                           LevelDBSlice(cursor_options->high_key)) <
-              0)
+          CompareIndexKeys(found_high_key, cursor_options->high_key) < 0)
         cursor_options->high_open = false;
 
       cursor_options->high_key = found_high_key;
     }
   }
 
   return true;
 }
 
 bool IndexCursorOptions(
@@ skipping 39 matching lines @@
       if (!FindGreatestKeyLessThanOrEqual(
               transaction, cursor_options->high_key, &cursor_options->high_key))
         return false;
       cursor_options->high_open = false;
     }
   } else {
     cursor_options->high_key = IndexDataKey::Encode(
         database_id, object_store_id, index_id, range.upper());
     cursor_options->high_open = range.upperOpen();
 
-    std::vector<char> found_high_key;
+    std::string found_high_key;
     // Seek to the *last* key in the set of non-unique keys
     if (!FindGreatestKeyLessThanOrEqual(
             transaction, cursor_options->high_key, &found_high_key))
       return false;
 
     // If the target key should not be included, but we end up with a smaller
     // key, we should include that.
     if (cursor_options->high_open &&
-        CompareIndexKeys(LevelDBSlice(found_high_key),
-                         LevelDBSlice(cursor_options->high_key)) <
-            0)
+        CompareIndexKeys(found_high_key, cursor_options->high_key) < 0)
       cursor_options->high_open = false;
 
     cursor_options->high_key = found_high_key;
   }
 
   return true;
 }
 
 scoped_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenObjectStoreCursor(
@@ skipping 126 matching lines @@
 }
 
 void IndexedDBBackingStore::Transaction::Rollback() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Rollback");
   DCHECK(transaction_.get());
   transaction_->Rollback();
   transaction_ = NULL;
 }
 
 }  // namespace content