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

content/browser/indexed_db/indexed_db_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/indexed_db_database.h"
 
 #include <math.h>
-#include <vector>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_factory.h"
@@ skipping 202 matching lines @@
   const scoped_ptr<IndexedDBKeyRange> key_range_;
   const indexed_db::CursorType cursor_type_;
   const scoped_refptr<IndexedDBCallbacks> callbacks_;
 };
 
 class PutOperation : public IndexedDBTransaction::Operation {
  public:
   PutOperation(scoped_refptr<IndexedDBBackingStore> backing_store,
                int64 database_id,
                const IndexedDBObjectStoreMetadata& object_store,
-               std::vector<char>* value,
+               std::string* value,
                scoped_ptr<IndexedDBKey> key,
                IndexedDBDatabase::PutMode put_mode,
                scoped_refptr<IndexedDBCallbacks> callbacks,
                const std::vector<int64>& index_ids,
                const std::vector<IndexedDBDatabase::IndexKeys>& index_keys)
       : backing_store_(backing_store),
         database_id_(database_id),
         object_store_(object_store),
         key_(key.Pass()),
         put_mode_(put_mode),
         callbacks_(callbacks),
         index_ids_(index_ids),
         index_keys_(index_keys) {
     value_.swap(*value);
   }
   virtual void Perform(IndexedDBTransaction* transaction) OVERRIDE;
 
  private:
   const scoped_refptr<IndexedDBBackingStore> backing_store_;
   const int64 database_id_;
   const IndexedDBObjectStoreMetadata object_store_;
-  std::vector<char> value_;
+  std::string value_;
   scoped_ptr<IndexedDBKey> key_;
   const IndexedDBDatabase::PutMode put_mode_;
   const scoped_refptr<IndexedDBCallbacks> callbacks_;
   const std::vector<int64> index_ids_;
   const std::vector<IndexedDBDatabase::IndexKeys> index_keys_;
 };
 
 class SetIndexesReadyOperation : public IndexedDBTransaction::Operation {
  public:
   explicit SetIndexesReadyOperation(size_t index_count)
@@ skipping 559 matching lines @@
       return;
     }
 
     key = &backing_store_cursor->key();
   }
 
   scoped_ptr<IndexedDBKey> primary_key;
   bool ok;
   if (index_id_ == IndexedDBIndexMetadata::kInvalidId) {
     // Object Store Retrieval Operation
-    std::vector<char> value;
+    std::string value;
     ok = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                    database_id_,
                                    object_store_id_,
                                    *key,
                                    &value);
     if (!ok) {
       callbacks_->OnError(
           IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetRecord."));
       return;
@@ skipping 31 matching lines @@
     callbacks_->OnSuccess();
     return;
   }
   if (cursor_type_ == indexed_db::CURSOR_KEY_ONLY) {
     // Index Value Retrieval Operation
     callbacks_->OnSuccess(*primary_key);
     return;
   }
 
   // Index Referenced Value Retrieval Operation
-  std::vector<char> value;
+  std::string value;
   ok = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                  database_id_,
                                  object_store_id_,
                                  *primary_key,
                                  &value);
   if (!ok) {
     callbacks_->OnError(
         IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
                                "Internal error in GetRecord."));
     return;
@@ skipping 46 matching lines @@
   return backing_store->MaybeUpdateKeyGeneratorCurrentNumber(
       transaction->BackingStoreTransaction(),
       database_id,
       object_store_id,
       static_cast<int64>(floor(key->number())) + 1,
       check_current);
 }
 
 void IndexedDBDatabase::Put(int64 transaction_id,
                             int64 object_store_id,
-                            std::vector<char>* value,
+                            std::string* value,
                             scoped_ptr<IndexedDBKey> key,
                             PutMode put_mode,
                             scoped_refptr<IndexedDBCallbacks> callbacks,
                             const std::vector<int64>& index_ids,
                             const std::vector<IndexKeys>& index_keys) {
   IDB_TRACE("IndexedDBDatabase::Put");
   TransactionMap::const_iterator trans_iterator =
       transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return;
@@ skipping 297 matching lines @@
           transaction->BackingStoreTransaction(),
           database_id_,
           object_store_id_,
           index_id_,
           *key_range_,
           direction_);
     }
   }
 
   if (!backing_store_cursor) {
-    callbacks_->OnSuccess(static_cast<std::vector<char>*>(NULL));
+    callbacks_->OnSuccess(static_cast<std::string*>(NULL));
     return;
   }
 
   IndexedDBDatabase::TaskType task_type(
       static_cast<IndexedDBDatabase::TaskType>(task_type_));
   scoped_refptr<IndexedDBCursor> cursor = IndexedDBCursor::Create(
       backing_store_cursor.Pass(), cursor_type_, task_type, transaction);
   callbacks_->OnSuccess(
       cursor, cursor->key(), cursor->primary_key(), cursor->Value());
 }
@@ skipping 592 matching lines @@
 
 void IndexedDBDatabase::VersionChangeAbortOperation::Perform(
     IndexedDBTransaction* transaction) {
   IDB_TRACE("VersionChangeAbortOperation");
   DCHECK(!transaction);
   database_->metadata_.version = previous_version_;
   database_->metadata_.int_version = previous_int_version_;
 }
 
 }  // namespace content