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

content/browser/indexed_db/indexed_db_backing_store_unittest.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 "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
@@ skipping 11 matching lines @@
 namespace {
 
 class IndexedDBBackingStoreTest : public testing::Test {
  public:
   IndexedDBBackingStoreTest() {}
   virtual void SetUp() {
     std::string file_identifier;
     backing_store_ = IndexedDBBackingStore::OpenInMemory(file_identifier);
 
     // useful keys and values during tests
-    const char raw_value1[] = "value1";
-
-    const char raw_value2[] = "value2";
-    const char raw_value3[] = "value3";
-    m_value1.insert(
-        m_value1.end(), &raw_value1[0], &raw_value1[0] + sizeof(raw_value1));
-    m_value2.insert(
-        m_value2.end(), &raw_value2[0], &raw_value2[0] + sizeof(raw_value2));
-    m_value3.insert(
-        m_value3.end(), &raw_value3[0], &raw_value3[0] + sizeof(raw_value3));
+    m_value1 = "value1";
+    m_value2 = "value2";
+    m_value3 = "value3";
     m_key1 = IndexedDBKey(99, WebIDBKey::NumberType);
     m_key2 = IndexedDBKey(ASCIIToUTF16("key2"));
     m_key3 = IndexedDBKey(ASCIIToUTF16("key3"));
   }
 
  protected:
   scoped_refptr<IndexedDBBackingStore> backing_store_;
 
   // Sample keys and values that are consistent.
   IndexedDBKey m_key1;
   IndexedDBKey m_key2;
   IndexedDBKey m_key3;
-  std::vector<char> m_value1;
-  std::vector<char> m_value2;
-  std::vector<char> m_value3;
+  std::string m_value1;
+  std::string m_value2;
+  std::string m_value3;
 };
 
 TEST_F(IndexedDBBackingStoreTest, PutGetConsistency) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
     IndexedDBBackingStore::RecordIdentifier record;
     bool ok = backing_store_->PutRecord(
         &transaction1, 1, 1, m_key1, m_value1, &record);
     EXPECT_TRUE(ok);
     transaction1.Commit();
   }
 
   {
     IndexedDBBackingStore::Transaction transaction2(backing_store_);
     transaction2.Begin();
-    std::vector<char> result_value;
+    std::string result_value;
     bool ok =
         backing_store_->GetRecord(&transaction2, 1, 1, m_key1, &result_value);
     transaction2.Commit();
     EXPECT_TRUE(ok);
     EXPECT_EQ(m_value1, result_value);
   }
 }
 
 // Make sure that using very high ( more than 32 bit ) values for database_id
 // and object_store_id still work.
 TEST_F(IndexedDBBackingStoreTest, HighIds) {
   const int64 high_database_id = 1ULL << 35;
   const int64 high_object_store_id = 1ULL << 39;
   // index_ids are capped at 32 bits for storage purposes.
   const int64 high_index_id = 1ULL << 29;
 
   const int64 invalid_high_index_id = 1ULL << 37;
 
   const IndexedDBKey& index_key = m_key2;
-  std::vector<char> index_key_raw;
+  std::string index_key_raw;
   EncodeIDBKey(index_key, &index_key_raw);
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
     IndexedDBBackingStore::RecordIdentifier record;
     bool ok = backing_store_->PutRecord(&transaction1,
                                         high_database_id,
                                         high_object_store_id,
                                         m_key1,
                                         m_value1,
@@ skipping 16 matching lines @@
                                                record);
     EXPECT_TRUE(ok);
 
     ok = transaction1.Commit();
     EXPECT_TRUE(ok);
   }
 
   {
     IndexedDBBackingStore::Transaction transaction2(backing_store_);
     transaction2.Begin();
-    std::vector<char> result_value;
+    std::string result_value;
     bool ok = backing_store_->GetRecord(&transaction2,
                                         high_database_id,
                                         high_object_store_id,
                                         m_key1,
                                         &result_value);
     EXPECT_TRUE(ok);
     EXPECT_EQ(m_value1, result_value);
 
     scoped_ptr<IndexedDBKey> new_primary_key;
     ok = backing_store_->GetPrimaryKeyViaIndex(&transaction2,
@@ skipping 19 matching lines @@
 }
 
 // Make sure that other invalid ids do not crash.
 TEST_F(IndexedDBBackingStoreTest, InvalidIds) {
   // valid ids for use when testing invalid ids
   const int64 database_id = 1;
   const int64 object_store_id = 1;
   const int64 index_id = kMinimumIndexId;
   const int64 invalid_low_index_id = 19;  // index_ids must be > kMinimumIndexId
 
-  std::vector<char> result_value;
+  std::string result_value;
 
   IndexedDBBackingStore::Transaction transaction1(backing_store_);
   transaction1.Begin();
 
   IndexedDBBackingStore::RecordIdentifier record;
   bool ok = backing_store_->PutRecord(&transaction1,
                                       database_id,
                                       KeyPrefix::kInvalidId,
                                       m_key1,
                                       m_value1,
@@ skipping 240 matching lines @@
 
   GURL ok_origin("http://someorigin.com:82/");
   scoped_refptr<IndexedDBBackingStore> diskStore2 =
       factory->TestOpenBackingStore(ok_origin, base_path);
   EXPECT_TRUE(diskStore2);
 }
 
 }  // namespace
 
 }  // namespace content