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

content/browser/indexed_db/leveldb/leveldb_database.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_database.h"
 
 #include <cerrno>
-#include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "content/browser/indexed_db/leveldb/leveldb_comparator.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_write_batch.h"
 #include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/env_idb.h"
 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h"
 #include "third_party/leveldatabase/src/include/leveldb/comparator.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/env.h"
 #include "third_party/leveldatabase/src/include/leveldb/slice.h"
 
+using base::StringPiece;
+
 namespace content {
 
-static leveldb::Slice MakeSlice(const std::vector<char>& value) {
-  DCHECK_GT(value.size(), static_cast<size_t>(0));
-  return leveldb::Slice(&*value.begin(), value.size());
+static leveldb::Slice MakeSlice(const StringPiece& s) {
+  return leveldb::Slice(s.begin(), s.size());
 }
 
-static leveldb::Slice MakeSlice(const LevelDBSlice& s) {
-  return leveldb::Slice(s.begin(), s.end() - s.begin());
-}
-
-static LevelDBSlice MakeLevelDBSlice(const leveldb::Slice& s) {
-  return LevelDBSlice(s.data(), s.data() + s.size());
+static StringPiece MakeStringPiece(const leveldb::Slice& s) {
+  return StringPiece(s.data(), s.size());
 }
 
 class ComparatorAdapter : public leveldb::Comparator {
  public:
   explicit ComparatorAdapter(const LevelDBComparator* comparator)
       : comparator_(comparator) {}
 
   virtual int Compare(const leveldb::Slice& a, const leveldb::Slice& b) const
       OVERRIDE {
-    return comparator_->Compare(MakeLevelDBSlice(a), MakeLevelDBSlice(b));
+    return comparator_->Compare(MakeStringPiece(a), MakeStringPiece(b));
   }
 
   virtual const char* Name() const OVERRIDE { return comparator_->Name(); }
 
   // TODO(jsbell): Support the methods below in the future.
   virtual void FindShortestSeparator(std::string* start,
                                      const leveldb::Slice& limit) const
       OVERRIDE {}
   virtual void FindShortSuccessor(std::string* key) const OVERRIDE {}
 
@@ skipping 260 matching lines @@
 
   scoped_ptr<LevelDBDatabase> result(new LevelDBDatabase);
   result->env_ = in_memory_env.Pass();
   result->db_ = make_scoped_ptr(db);
   result->comparator_adapter_ = comparator_adapter.Pass();
   result->comparator_ = comparator;
 
   return result.Pass();
 }
 
-bool LevelDBDatabase::Put(const LevelDBSlice& key,
-                          std::vector<char>* value) {
+bool LevelDBDatabase::Put(const StringPiece& key, std::string* value) {
   leveldb::WriteOptions write_options;
   write_options.sync = true;
 
   const leveldb::Status s =
       db_->Put(write_options, MakeSlice(key), MakeSlice(*value));
   if (s.ok())
     return true;
   LOG(ERROR) << "LevelDB put failed: " << s.ToString();
   return false;
 }
 
-bool LevelDBDatabase::Remove(const LevelDBSlice& key) {
+bool LevelDBDatabase::Remove(const StringPiece& key) {
   leveldb::WriteOptions write_options;
   write_options.sync = true;
 
   const leveldb::Status s = db_->Delete(write_options, MakeSlice(key));
   if (s.ok())
     return true;
   if (s.IsNotFound())
     return false;
   LOG(ERROR) << "LevelDB remove failed: " << s.ToString();
   return false;
 }
 
-bool LevelDBDatabase::Get(const LevelDBSlice& key,
+bool LevelDBDatabase::Get(const StringPiece& key,
                           std::string* value,
                           bool* found,
                           const LevelDBSnapshot* snapshot) {
   *found = false;
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;  // TODO(jsbell): Disable this if the
                                          // performance impact is too great.
   read_options.snapshot = snapshot ? snapshot->snapshot_ : 0;
 
   const leveldb::Status s = db_->Get(read_options, MakeSlice(key), value);
@@ skipping 20 matching lines @@
   return false;
 }
 
 namespace {
 class IteratorImpl : public LevelDBIterator {
  public:
   virtual ~IteratorImpl() {}
 
   virtual bool IsValid() const OVERRIDE;
   virtual void SeekToLast() OVERRIDE;
-  virtual void Seek(const LevelDBSlice& target) OVERRIDE;
+  virtual void Seek(const StringPiece& target) OVERRIDE;
   virtual void Next() OVERRIDE;
   virtual void Prev() OVERRIDE;
-  virtual LevelDBSlice Key() const OVERRIDE;
-  virtual LevelDBSlice Value() const OVERRIDE;
+  virtual StringPiece Key() const OVERRIDE;
+  virtual StringPiece Value() const OVERRIDE;
 
  private:
   friend class content::LevelDBDatabase;
   explicit IteratorImpl(scoped_ptr<leveldb::Iterator> iterator);
   void CheckStatus();
 
   scoped_ptr<leveldb::Iterator> iterator_;
 };
 }
 
 IteratorImpl::IteratorImpl(scoped_ptr<leveldb::Iterator> it)
     : iterator_(it.Pass()) {}
 
 void IteratorImpl::CheckStatus() {
   const leveldb::Status s = iterator_->status();
   if (!s.ok())
     LOG(ERROR) << "LevelDB iterator error: " << s.ToString();
 }
 
 bool IteratorImpl::IsValid() const { return iterator_->Valid(); }
 
 void IteratorImpl::SeekToLast() {
   iterator_->SeekToLast();
   CheckStatus();
 }
 
-void IteratorImpl::Seek(const LevelDBSlice& target) {
+void IteratorImpl::Seek(const StringPiece& target) {
   iterator_->Seek(MakeSlice(target));
   CheckStatus();
 }
 
 void IteratorImpl::Next() {
   DCHECK(IsValid());
   iterator_->Next();
   CheckStatus();
 }
 
 void IteratorImpl::Prev() {
   DCHECK(IsValid());
   iterator_->Prev();
   CheckStatus();
 }
 
-LevelDBSlice IteratorImpl::Key() const {
+StringPiece IteratorImpl::Key() const {
   DCHECK(IsValid());
-  return MakeLevelDBSlice(iterator_->key());
+  return MakeStringPiece(iterator_->key());
 }
 
-LevelDBSlice IteratorImpl::Value() const {
+StringPiece IteratorImpl::Value() const {
   DCHECK(IsValid());
-  return MakeLevelDBSlice(iterator_->value());
+  return MakeStringPiece(iterator_->value());
 }
 
 scoped_ptr<LevelDBIterator> LevelDBDatabase::CreateIterator(
     const LevelDBSnapshot* snapshot) {
   leveldb::ReadOptions read_options;
   read_options.verify_checksums = true;  // TODO(jsbell): Disable this if the
                                          // performance impact is too great.
   read_options.snapshot = snapshot ? snapshot->snapshot_ : 0;
 
   scoped_ptr<leveldb::Iterator> i(db_->NewIterator(read_options));
   return scoped_ptr<LevelDBIterator>(new IteratorImpl(i.Pass()));
 }
 
 const LevelDBComparator* LevelDBDatabase::Comparator() const {
   return comparator_;
 }
 
 }  // namespace content