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

content/browser/indexed_db/indexed_db_backing_store.h

 // 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.
 
 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_
 
+#include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/indexed_db/indexed_db.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
 #include "content/browser/indexed_db/leveldb/leveldb_iterator.h"
@@ skipping 73 matching lines @@
       const string16& name,
       const IndexedDBKeyPath& key_path,
       bool auto_increment);
   virtual bool DeleteObjectStore(
       IndexedDBBackingStore::Transaction* transaction,
       int64 database_id,
       int64 object_store_id) WARN_UNUSED_RESULT;
 
   class CONTENT_EXPORT RecordIdentifier {
    public:
-    RecordIdentifier(const std::vector<char>& primary_key, int64 version);
+    RecordIdentifier(const std::string& primary_key, int64 version);
     RecordIdentifier();
     ~RecordIdentifier();
 
-    const std::vector<char>& primary_key() const { return primary_key_; }
+    const std::string& primary_key() const { return primary_key_; }
     int64 version() const { return version_; }
-    void Reset(const std::vector<char>& primary_key, int64 version) {
+    void Reset(const std::string& primary_key, int64 version) {
       primary_key_ = primary_key;
       version_ = version;
     }
 
    private:
     // TODO(jsbell): Make it more clear that this is the *encoded* version of
     // the key.
-    std::vector<char> primary_key_;
+    std::string primary_key_;
     int64 version_;
     DISALLOW_COPY_AND_ASSIGN(RecordIdentifier);
   };
 
   virtual bool GetRecord(IndexedDBBackingStore::Transaction* transaction,
                          int64 database_id,
                          int64 object_store_id,
                          const IndexedDBKey& key,
-                         std::vector<char>* record) WARN_UNUSED_RESULT;
+                         std::string* record) WARN_UNUSED_RESULT;
   virtual bool 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) WARN_UNUSED_RESULT;
   virtual bool ClearObjectStore(IndexedDBBackingStore::Transaction* transaction,
                                 int64 database_id,
                                 int64 object_store_id) WARN_UNUSED_RESULT;
   virtual bool DeleteRecord(IndexedDBBackingStore::Transaction* transaction,
                             int64 database_id,
                             int64 object_store_id,
                             const RecordIdentifier& record) WARN_UNUSED_RESULT;
   virtual bool GetKeyGeneratorCurrentNumber(
       IndexedDBBackingStore::Transaction* transaction,
@@ skipping 56 matching lines @@
       READY = 0,
       SEEK
     };
 
     struct CursorOptions {
       CursorOptions();
       ~CursorOptions();
       int64 database_id;
       int64 object_store_id;
       int64 index_id;
-      std::vector<char> low_key;
+      std::string low_key;
       bool low_open;
-      std::vector<char> high_key;
+      std::string high_key;
       bool high_open;
       bool forward;
       bool unique;
     };
 
     const IndexedDBKey& key() const { return *current_key_; }
     bool ContinueFunction() { return ContinueFunction(NULL, SEEK); }
     bool ContinueFunction(const IndexedDBKey* key, IteratorState state);
     bool Advance(uint32 count);
     bool FirstSeek();
 
     virtual Cursor* Clone() = 0;
     virtual const IndexedDBKey& primary_key() const;
-    virtual std::vector<char>* Value() = 0;
+    virtual std::string* Value() = 0;
     virtual const RecordIdentifier& record_identifier() const;
     virtual bool LoadCurrentRow() = 0;
 
    protected:
     Cursor(LevelDBTransaction* transaction,
            const CursorOptions& cursor_options);
     explicit Cursor(const IndexedDBBackingStore::Cursor* other);
 
-    virtual std::vector<char> EncodeKey(const IndexedDBKey& key) = 0;
+    virtual std::string EncodeKey(const IndexedDBKey& key) = 0;
 
     bool IsPastBounds() const;
     bool HaveEnteredRange() const;
 
     LevelDBTransaction* transaction_;
     const CursorOptions cursor_options_;
     scoped_ptr<LevelDBIterator> iterator_;
     scoped_ptr<IndexedDBKey> current_key_;
     IndexedDBBackingStore::RecordIdentifier record_identifier_;
   };
@@ skipping 58 matching lines @@
   static scoped_refptr<IndexedDBBackingStore> Create(
       const std::string& identifier,
       scoped_ptr<LevelDBDatabase> db,
       scoped_ptr<LevelDBComparator> comparator);
 
   bool 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);
   bool GetIndexes(int64 database_id,
                   int64 object_store_id,
                   IndexedDBObjectStoreMetadata::IndexMap* map)
       WARN_UNUSED_RESULT;
 
   std::string identifier_;
 
   scoped_ptr<LevelDBDatabase> db_;
   scoped_ptr<LevelDBComparator> comparator_;
   base::WeakPtrFactory<IndexedDBBackingStore> weak_factory_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_BACKING_STORE_H_