Pass blob info through from the IPC to the backing store on put.

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/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
@@ skipping 33 matching lines @@
   IndexedDBValue m_value2;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IndexedDBBackingStoreTest);
 };
 
 TEST_F(IndexedDBBackingStoreTest, PutGetConsistency) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
+    ScopedVector<webkit_blob::BlobDataHandle> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     leveldb::Status s = backing_store_->PutRecord(
-        &transaction1, 1, 1, m_key1, m_value1, &record);
+        &transaction1, 1, 1, m_key1, m_value1, &handles, &record);
     EXPECT_TRUE(s.ok());
     transaction1.Commit();
   }
 
   {
     IndexedDBBackingStore::Transaction transaction2(backing_store_);
     transaction2.Begin();
     IndexedDBValue result_value;
     leveldb::Status s =
         backing_store_->GetRecord(&transaction2, 1, 1, m_key1, &result_value);
@@ skipping 12 matching lines @@
   const int64 high_index_id = 1ULL << 29;
 
   const int64 invalid_high_index_id = 1ULL << 37;
 
   const IndexedDBKey& index_key = m_key2;
   std::string index_key_raw;
   EncodeIDBKey(index_key, &index_key_raw);
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_);
     transaction1.Begin();
+    ScopedVector<webkit_blob::BlobDataHandle> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     leveldb::Status s = backing_store_->PutRecord(&transaction1,
                                                   high_database_id,
                                                   high_object_store_id,
                                                   m_key1,
                                                   m_value1,
+                                                  &handles,
                                                   &record);
     EXPECT_TRUE(s.ok());
 
     s = backing_store_->PutIndexDataForRecord(&transaction1,
                                               high_database_id,
                                               high_object_store_id,
                                               invalid_high_index_id,
                                               index_key,
                                               record);
     EXPECT_FALSE(s.ok());
@@ skipping 51 matching lines @@
   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
 
   IndexedDBValue result_value;
 
   IndexedDBBackingStore::Transaction transaction1(backing_store_);
   transaction1.Begin();
 
+  ScopedVector<webkit_blob::BlobDataHandle> handles;
   IndexedDBBackingStore::RecordIdentifier record;
   leveldb::Status s = backing_store_->PutRecord(&transaction1,
                                                 database_id,
                                                 KeyPrefix::kInvalidId,
                                                 m_key1,
                                                 m_value1,
+                                                &handles,
                                                 &record);
   EXPECT_FALSE(s.ok());
   s = backing_store_->PutRecord(
-      &transaction1, database_id, 0, m_key1, m_value1, &record);
+      &transaction1, database_id, 0, m_key1, m_value1, &handles, &record);
   EXPECT_FALSE(s.ok());
   s = backing_store_->PutRecord(&transaction1,
                                 KeyPrefix::kInvalidId,
                                 object_store_id,
                                 m_key1,
                                 m_value1,
+                                &handles,
                                 &record);
   EXPECT_FALSE(s.ok());
   s = backing_store_->PutRecord(
-      &transaction1, 0, object_store_id, m_key1, m_value1, &record);
+      &transaction1, 0, object_store_id, m_key1, m_value1, &handles, &record);
   EXPECT_FALSE(s.ok());
 
   s = backing_store_->GetRecord(
       &transaction1, database_id, KeyPrefix::kInvalidId, m_key1, &result_value);
   EXPECT_FALSE(s.ok());
   s = backing_store_->GetRecord(
       &transaction1, database_id, 0, m_key1, &result_value);
   EXPECT_FALSE(s.ok());
   s = backing_store_->GetRecord(&transaction1,
                                 KeyPrefix::kInvalidId,
@@ skipping 117 matching lines @@
     EXPECT_EQ(index_name, index.name);
     EXPECT_EQ(index_key_path, index.key_path);
     EXPECT_EQ(unique, index.unique);
     EXPECT_EQ(multi_entry, index.multi_entry);
   }
 }
 
 }  // namespace
 
 }  // namespace content