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

content/browser/indexed_db/leveldb/leveldb_transaction.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/leveldb/leveldb_transaction.h"
 
-#include <string>
-
 #include "base/logging.h"
 #include "content/browser/indexed_db/leveldb/leveldb_database.h"
-#include "content/browser/indexed_db/leveldb/leveldb_slice.h"
 #include "content/browser/indexed_db/leveldb/leveldb_write_batch.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 
+using base::StringPiece;
+
 namespace content {
 
 scoped_refptr<LevelDBTransaction> LevelDBTransaction::Create(
     LevelDBDatabase* db) {
   return make_scoped_refptr(new LevelDBTransaction(db));
 }
 
 LevelDBTransaction::LevelDBTransaction(LevelDBDatabase* db)
     : db_(db), snapshot_(db), comparator_(db->Comparator()), finished_(false) {
   tree_.abstractor().comparator_ = comparator_;
@@ skipping 13 matching lines @@
     ++iterator;
   }
   tree_.Purge();
 
   for (size_t i = 0; i < nodes.size(); ++i)
     delete nodes[i];
 }
 
 LevelDBTransaction::~LevelDBTransaction() { ClearTree(); }
 
-static void InitVector(const LevelDBSlice& slice, std::vector<char>* vector) {
-  vector->clear();
-  vector->insert(vector->end(), slice.begin(), slice.end());
-}
-
-void LevelDBTransaction::Set(const LevelDBSlice& key,
-                             std::vector<char>* value,
+void LevelDBTransaction::Set(const StringPiece& key,
+                             std::string* value,
                              bool deleted) {
   DCHECK(!finished_);
   bool new_node = false;
   AVLTreeNode* node = tree_.Search(key);
 
   if (!node) {
     node = new AVLTreeNode;
-    InitVector(key, &node->key);
+    node->key = key.as_string();
     tree_.Insert(node);
     new_node = true;
   }
   node->value.swap(*value);
   node->deleted = deleted;
 
   if (new_node)
     NotifyIteratorsOfTreeChange();
 }
 
-void LevelDBTransaction::Put(const LevelDBSlice& key,
-                             std::vector<char>* value) {
+void LevelDBTransaction::Put(const StringPiece& key, std::string* value) {
   Set(key, value, false);
 }
 
-void LevelDBTransaction::Remove(const LevelDBSlice& key) {
-  std::vector<char> empty;
+void LevelDBTransaction::Remove(const StringPiece& key) {
+  std::string empty;
   Set(key, &empty, true);
 }
 
-bool LevelDBTransaction::Get(const LevelDBSlice& key,
+bool LevelDBTransaction::Get(const StringPiece& key,
                              std::string* value,
                              bool* found) {
   *found = false;
   DCHECK(!finished_);
   AVLTreeNode* node = tree_.Search(key);
 
   if (node) {
     if (node->deleted)
       return true;
 
-    value->assign(node->value.begin(), node->value.end());
+    *value = node->value;
     *found = true;
     return true;
   }
 
   bool ok = db_->Get(key, value, found, &snapshot_);
   if (!ok) {
     DCHECK(!*found);
     return false;
   }
   return true;
 }
 
 bool LevelDBTransaction::Commit() {
   DCHECK(!finished_);
 
   if (tree_.IsEmpty()) {
     finished_ = true;
     return true;
   }
 
   scoped_ptr<LevelDBWriteBatch> write_batch = LevelDBWriteBatch::Create();
 
   TreeType::Iterator iterator;
   iterator.StartIterLeast(&tree_);
 
   while (*iterator) {
     AVLTreeNode* node = *iterator;
     if (!node->deleted)
-      write_batch->Put(LevelDBSlice(node->key), LevelDBSlice(node->value));
+      write_batch->Put(node->key, node->value);
     else
-      write_batch->Remove(LevelDBSlice(node->key));
+      write_batch->Remove(node->key);
     ++iterator;
   }
 
   if (!db_->Write(*write_batch))
     return false;
 
   ClearTree();
   finished_ = true;
   return true;
 }
@@ skipping 14 matching lines @@
 }
 
 bool LevelDBTransaction::TreeIterator::IsValid() const { return !!*iterator_; }
 
 void LevelDBTransaction::TreeIterator::SeekToLast() {
   iterator_.StartIterGreatest(tree_);
   if (IsValid())
     key_ = (*iterator_)->key;
 }
 
-void LevelDBTransaction::TreeIterator::Seek(const LevelDBSlice& target) {
+void LevelDBTransaction::TreeIterator::Seek(const StringPiece& target) {
   iterator_.StartIter(tree_, target, TreeType::EQUAL);
   if (!IsValid())
     iterator_.StartIter(tree_, target, TreeType::GREATER);
 
   if (IsValid())
     key_ = (*iterator_)->key;
 }
 
 void LevelDBTransaction::TreeIterator::Next() {
   DCHECK(IsValid());
   ++iterator_;
   if (IsValid()) {
-    DCHECK(transaction_->comparator_->Compare(LevelDBSlice((*iterator_)->key),
-                                              LevelDBSlice(key_)) >
-           0);
+    DCHECK_GE(transaction_->comparator_->Compare((*iterator_)->key, key_), 0);
     key_ = (*iterator_)->key;
   }
 }
 
 void LevelDBTransaction::TreeIterator::Prev() {
   DCHECK(IsValid());
   --iterator_;
   if (IsValid()) {
-    DCHECK(tree_->abstractor().comparator_->Compare(
-               LevelDBSlice((*iterator_)->key), LevelDBSlice(key_)) <
-           0);
+    DCHECK_LT(tree_->abstractor().comparator_->Compare((*iterator_)->key, key_),
+              0);
     key_ = (*iterator_)->key;
   }
 }
 
-LevelDBSlice LevelDBTransaction::TreeIterator::Key() const {
+StringPiece LevelDBTransaction::TreeIterator::Key() const {
   DCHECK(IsValid());
-  return LevelDBSlice(key_);
+  return key_;
 }
 
-LevelDBSlice LevelDBTransaction::TreeIterator::Value() const {
+StringPiece LevelDBTransaction::TreeIterator::Value() const {
   DCHECK(IsValid());
   DCHECK(!IsDeleted());
-  return LevelDBSlice((*iterator_)->value);
+  return (*iterator_)->value;
 }
 
 bool LevelDBTransaction::TreeIterator::IsDeleted() const {
   DCHECK(IsValid());
   return (*iterator_)->deleted;
 }
 
 void LevelDBTransaction::TreeIterator::Reset() {
   DCHECK(IsValid());
-  iterator_.StartIter(tree_, LevelDBSlice(key_), TreeType::EQUAL);
+  iterator_.StartIter(tree_, key_, TreeType::EQUAL);
   DCHECK(IsValid());
 }
 
 LevelDBTransaction::TreeIterator::~TreeIterator() {}
 
 LevelDBTransaction::TreeIterator::TreeIterator(LevelDBTransaction* transaction)
     : tree_(&transaction->tree_), transaction_(transaction) {}
 
 scoped_ptr<LevelDBTransaction::TransactionIterator>
 LevelDBTransaction::TransactionIterator::Create(
@@ skipping 23 matching lines @@
 
 void LevelDBTransaction::TransactionIterator::SeekToLast() {
   tree_iterator_->SeekToLast();
   db_iterator_->SeekToLast();
   direction_ = REVERSE;
 
   HandleConflictsAndDeletes();
   SetCurrentIteratorToLargestKey();
 }
 
-void LevelDBTransaction::TransactionIterator::Seek(const LevelDBSlice& target) {
+void LevelDBTransaction::TransactionIterator::Seek(const StringPiece& target) {
   tree_iterator_->Seek(target);
   db_iterator_->Seek(target);
   direction_ = FORWARD;
 
   HandleConflictsAndDeletes();
   SetCurrentIteratorToSmallestKey();
 }
 
 void LevelDBTransaction::TransactionIterator::Next() {
   DCHECK(IsValid());
@@ skipping 51 matching lines @@
            comparator_->Compare(non_current->Key(), Key()) < 0);
 
     direction_ = REVERSE;
   }
 
   current_->Prev();
   HandleConflictsAndDeletes();
   SetCurrentIteratorToLargestKey();
 }
 
-LevelDBSlice LevelDBTransaction::TransactionIterator::Key() const {
+StringPiece LevelDBTransaction::TransactionIterator::Key() const {
   DCHECK(IsValid());
   if (tree_changed_)
     RefreshTreeIterator();
   return current_->Key();
 }
 
-LevelDBSlice LevelDBTransaction::TransactionIterator::Value() const {
+StringPiece LevelDBTransaction::TransactionIterator::Value() const {
   DCHECK(IsValid());
   if (tree_changed_)
     RefreshTreeIterator();
   return current_->Value();
 }
 
 void LevelDBTransaction::TransactionIterator::TreeChanged() {
   tree_changed_ = true;
 }
 
@@ skipping 122 matching lines @@
   return make_scoped_ptr(new LevelDBWriteOnlyTransaction(db));
 }
 
 LevelDBWriteOnlyTransaction::LevelDBWriteOnlyTransaction(LevelDBDatabase* db)
     : db_(db), write_batch_(LevelDBWriteBatch::Create()), finished_(false) {}
 
 LevelDBWriteOnlyTransaction::~LevelDBWriteOnlyTransaction() {
   write_batch_->Clear();
 }
 
-void LevelDBWriteOnlyTransaction::Remove(const LevelDBSlice& key) {
+void LevelDBWriteOnlyTransaction::Remove(const StringPiece& key) {
   DCHECK(!finished_);
   write_batch_->Remove(key);
 }
 
 bool LevelDBWriteOnlyTransaction::Commit() {
   DCHECK(!finished_);
 
   if (!db_->Write(*write_batch_))
     return false;
 
   finished_ = true;
   write_batch_->Clear();
   return true;
 }
 
 }  // namespace content