IndexedDB: ScopedVector<T> -> vector<unique_ptr<T>>

... also use range-based for loops in some nearby places.

R=cmumford@chromium.org
BUG=554289

Review-Url: https://codereview.chromium.org/2255853003
Cr-Commit-Position: refs/heads/master@{#412703}

content/browser/indexed_db/indexed_db_backing_store.cc

@@ -1902,7 +1902,7 @@ leveldb::Status IndexedDBBackingStore::PutRecord(
     int64_t object_store_id,
     const IndexedDBKey& key,
     IndexedDBValue* value,
-    ScopedVector<storage::BlobDataHandle>* handles,
+    std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles,
     RecordIdentifier* record_identifier) {
   IDB_TRACE("IndexedDBBackingStore::PutRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
@@ -4367,7 +4367,7 @@ void IndexedDBBackingStore::BlobChangeRecord::SetBlobInfo(
 }
 
 void IndexedDBBackingStore::BlobChangeRecord::SetHandles(
-    ScopedVector<storage::BlobDataHandle>* handles) {
+    std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles) {
   handles_.clear();
   if (handles)
     handles_.swap(*handles);
@@ -4379,8 +4379,10 @@ IndexedDBBackingStore::BlobChangeRecord::Clone() const {
       new BlobChangeRecord(key_, object_store_id_));
   record->blob_info_ = blob_info_;
 
-  for (const auto* handle : handles_)
-    record->handles_.push_back(new storage::BlobDataHandle(*handle));
+  for (const auto& handle : handles_) {
+    record->handles_.push_back(
+        base::MakeUnique<storage::BlobDataHandle>(*handle));
+  }
   return record;
 }
 
@@ -4389,7 +4391,7 @@ leveldb::Status IndexedDBBackingStore::Transaction::PutBlobInfoIfNeeded(
     int64_t object_store_id,
     const std::string& object_store_data_key,
     std::vector<IndexedDBBlobInfo>* blob_info,
-    ScopedVector<storage::BlobDataHandle>* handles) {
+    std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles) {
   if (!blob_info || blob_info->empty()) {
     blob_change_map_.erase(object_store_data_key);
     incognito_blob_map_.erase(object_store_data_key);
@@ -4424,7 +4426,7 @@ void IndexedDBBackingStore::Transaction::PutBlobInfo(
     int64_t object_store_id,
     const std::string& object_store_data_key,
     std::vector<IndexedDBBlobInfo>* blob_info,
-    ScopedVector<storage::BlobDataHandle>* handles) {
+    std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles) {
   DCHECK_GT(object_store_data_key.size(), 0UL);
   if (database_id_ < 0)
     database_id_ = database_id;

content/browser/indexed_db/indexed_db_backing_store.h

@@ -18,7 +18,6 @@
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "base/strings/string_piece.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
@@ -111,14 +110,15 @@ class CONTENT_EXPORT IndexedDBBackingStore
     const std::vector<IndexedDBBlobInfo>& blob_info() const {
       return blob_info_;
     }
-    void SetHandles(ScopedVector<storage::BlobDataHandle>* handles);
+    void SetHandles(
+        std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles);
     std::unique_ptr<BlobChangeRecord> Clone() const;
 
    private:
     std::string key_;
     int64_t object_store_id_;
     std::vector<IndexedDBBlobInfo> blob_info_;
-    ScopedVector<storage::BlobDataHandle> handles_;
+    std::vector<std::unique_ptr<storage::BlobDataHandle>> handles_;
     DISALLOW_COPY_AND_ASSIGN(BlobChangeRecord);
   };
 
@@ -153,12 +153,13 @@ class CONTENT_EXPORT IndexedDBBackingStore
         int64_t object_store_id,
         const std::string& object_store_data_key,
         std::vector<IndexedDBBlobInfo>*,
-        ScopedVector<storage::BlobDataHandle>* handles);
-    void PutBlobInfo(int64_t database_id,
-                     int64_t object_store_id,
-                     const std::string& object_store_data_key,
-                     std::vector<IndexedDBBlobInfo>*,
-                     ScopedVector<storage::BlobDataHandle>* handles);
+        std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles);
+    void PutBlobInfo(
+        int64_t database_id,
+        int64_t object_store_id,
+        const std::string& object_store_data_key,
+        std::vector<IndexedDBBlobInfo>*,
+        std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles);
 
     LevelDBTransaction* transaction() { return transaction_.get(); }
 
@@ -453,7 +454,7 @@ class CONTENT_EXPORT IndexedDBBackingStore
       int64_t object_store_id,
       const IndexedDBKey& key,
       IndexedDBValue* value,
-      ScopedVector<storage::BlobDataHandle>* handles,
+      std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles,
       RecordIdentifier* record) WARN_UNUSED_RESULT;
   virtual leveldb::Status ClearObjectStore(
       IndexedDBBackingStore::Transaction* transaction,

content/browser/indexed_db/indexed_db_backing_store_unittest.cc

@@ -386,7 +386,7 @@ TEST_F(IndexedDBBackingStoreTest, PutGetConsistency) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
     transaction1.Begin();
-    ScopedVector<storage::BlobDataHandle> handles;
+    std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     leveldb::Status s = backing_store_->PutRecord(
         &transaction1, 1, 1, m_key1, &m_value1, &handles, &record);
@@ -418,7 +418,7 @@ TEST_F(IndexedDBBackingStoreTest, PutGetConsistencyWithBlobs) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
     transaction1.Begin();
-    ScopedVector<storage::BlobDataHandle> handles;
+    std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                           1,
@@ -505,7 +505,7 @@ TEST_F(IndexedDBBackingStoreTest, DeleteRange) {
       IndexedDBValue value3 = IndexedDBValue("value3", blob_info3);
       IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
       transaction1.Begin();
-      ScopedVector<storage::BlobDataHandle> handles;
+      std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
       IndexedDBBackingStore::RecordIdentifier record;
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
@@ -599,7 +599,7 @@ TEST_F(IndexedDBBackingStoreTest, DeleteRangeEmptyRange) {
       IndexedDBValue value3 = IndexedDBValue("value3", blob_info3);
       IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
       transaction1.Begin();
-      ScopedVector<storage::BlobDataHandle> handles;
+      std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
       IndexedDBBackingStore::RecordIdentifier record;
       EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                             1,
@@ -661,7 +661,7 @@ TEST_F(IndexedDBBackingStoreTest, DeleteRangeEmptyRange) {
 TEST_F(IndexedDBBackingStoreTest, BlobJournalInterleavedTransactions) {
   IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
   transaction1.Begin();
-  ScopedVector<storage::BlobDataHandle> handles1;
+  std::vector<std::unique_ptr<storage::BlobDataHandle>> handles1;
   IndexedDBBackingStore::RecordIdentifier record1;
   EXPECT_TRUE(backing_store_->PutRecord(&transaction1, 1, 1, m_key3, &m_value3,
                                         &handles1, &record1).ok());
@@ -675,7 +675,7 @@ TEST_F(IndexedDBBackingStoreTest, BlobJournalInterleavedTransactions) {
 
   IndexedDBBackingStore::Transaction transaction2(backing_store_.get());
   transaction2.Begin();
-  ScopedVector<storage::BlobDataHandle> handles2;
+  std::vector<std::unique_ptr<storage::BlobDataHandle>> handles2;
   IndexedDBBackingStore::RecordIdentifier record2;
   EXPECT_TRUE(backing_store_->PutRecord(&transaction2, 1, 1, m_key1, &m_value1,
                                         &handles2, &record2).ok());
@@ -698,7 +698,7 @@ TEST_F(IndexedDBBackingStoreTest, LiveBlobJournal) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
     transaction1.Begin();
-    ScopedVector<storage::BlobDataHandle> handles;
+    std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     EXPECT_TRUE(backing_store_->PutRecord(&transaction1,
                                           1,
@@ -779,7 +779,7 @@ TEST_F(IndexedDBBackingStoreTest, HighIds) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
     transaction1.Begin();
-    ScopedVector<storage::BlobDataHandle> handles;
+    std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     leveldb::Status s = backing_store_->PutRecord(&transaction1,
                                                   high_database_id,
@@ -869,7 +869,7 @@ TEST_F(IndexedDBBackingStoreTest, InvalidIds) {
   IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
   transaction1.Begin();
 
-  ScopedVector<storage::BlobDataHandle> handles;
+  std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
   IndexedDBBackingStore::RecordIdentifier record;
   leveldb::Status s = backing_store_->PutRecord(&transaction1,
                                                 database_id,

content/browser/indexed_db/indexed_db_connection.cc

@@ -5,7 +5,6 @@
 #include "content/browser/indexed_db/indexed_db_connection.h"
 
 #include "base/logging.h"
-#include "base/stl_util.h"
 
 namespace content {
 

content/browser/indexed_db/indexed_db_connection.h

@@ -5,6 +5,9 @@
 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_CONNECTION_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_CONNECTION_H_
 
+#include <memory>
+#include <vector>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"

content/browser/indexed_db/indexed_db_database.cc

@@ -7,16 +7,13 @@
 #include <math.h>
 
 #include <limits>
-#include <memory>
 #include <set>
-#include <utility>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
@@ -1196,7 +1193,7 @@ struct IndexedDBDatabase::PutOperationParams {
   PutOperationParams() {}
   int64_t object_store_id;
   IndexedDBValue value;
-  ScopedVector<storage::BlobDataHandle> handles;
+  std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
   std::unique_ptr<IndexedDBKey> key;
   blink::WebIDBPutMode put_mode;
   scoped_refptr<IndexedDBCallbacks> callbacks;
@@ -1206,14 +1203,15 @@ struct IndexedDBDatabase::PutOperationParams {
   DISALLOW_COPY_AND_ASSIGN(PutOperationParams);
 };
 
-void IndexedDBDatabase::Put(int64_t transaction_id,
-                            int64_t object_store_id,
-                            IndexedDBValue* value,
-                            ScopedVector<storage::BlobDataHandle>* handles,
-                            std::unique_ptr<IndexedDBKey> key,
-                            blink::WebIDBPutMode put_mode,
-                            scoped_refptr<IndexedDBCallbacks> callbacks,
-                            const std::vector<IndexKeys>& index_keys) {
+void IndexedDBDatabase::Put(
+    int64_t transaction_id,
+    int64_t object_store_id,
+    IndexedDBValue* value,
+    std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles,
+    std::unique_ptr<IndexedDBKey> key,
+    blink::WebIDBPutMode put_mode,
+    scoped_refptr<IndexedDBCallbacks> callbacks,
+    const std::vector<IndexKeys>& index_keys) {
   IDB_TRACE1("IndexedDBDatabase::Put", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
@@ -1295,7 +1293,7 @@ void IndexedDBDatabase::PutOperation(std::unique_ptr<PutOperationParams> params,
     }
   }
 
-  ScopedVector<IndexWriter> index_writers;
+  std::vector<std::unique_ptr<IndexWriter>> index_writers;
   base::string16 error_message;
   bool obeys_constraints = false;
   bool backing_store_success = MakeIndexWriters(transaction,
@@ -1342,11 +1340,10 @@ void IndexedDBDatabase::PutOperation(std::unique_ptr<PutOperationParams> params,
   {
     IDB_TRACE1("IndexedDBDatabase::PutOperation.UpdateIndexes", "txn.id",
                transaction->id());
-    for (size_t i = 0; i < index_writers.size(); ++i) {
-      IndexWriter* index_writer = index_writers[i];
-      index_writer->WriteIndexKeys(record_identifier, backing_store_.get(),
-                                   transaction->BackingStoreTransaction(), id(),
-                                   params->object_store_id);
+    for (const auto& writer : index_writers) {
+      writer->WriteIndexKeys(record_identifier, backing_store_.get(),
+                             transaction->BackingStoreTransaction(), id(),
+                             params->object_store_id);
     }
   }
 
@@ -1418,7 +1415,7 @@ void IndexedDBDatabase::SetIndexKeys(int64_t transaction_id,
     return;
   }
 
-  ScopedVector<IndexWriter> index_writers;
+  std::vector<std::unique_ptr<IndexWriter>> index_writers;
   base::string16 error_message;
   bool obeys_constraints = false;
   DCHECK(metadata_.object_stores.find(object_store_id) !=
@@ -1447,13 +1444,10 @@ void IndexedDBDatabase::SetIndexKeys(int64_t transaction_id,
     return;
   }
 
-  for (size_t i = 0; i < index_writers.size(); ++i) {
-    IndexWriter* index_writer = index_writers[i];
-    index_writer->WriteIndexKeys(record_identifier,
-                                 backing_store_.get(),
-                                 transaction->BackingStoreTransaction(),
-                                 id(),
-                                 object_store_id);
+  for (const auto& writer : index_writers) {
+    writer->WriteIndexKeys(record_identifier, backing_store_.get(),
+                           transaction->BackingStoreTransaction(), id(),
+                           object_store_id);
   }
 }
 

content/browser/indexed_db/indexed_db_database.h

@@ -162,7 +162,7 @@ class CONTENT_EXPORT IndexedDBDatabase
   void Put(int64_t transaction_id,
            int64_t object_store_id,
            IndexedDBValue* value,
-           ScopedVector<storage::BlobDataHandle>* handles,
+           std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles,
            std::unique_ptr<IndexedDBKey> key,
            blink::WebIDBPutMode mode,
            scoped_refptr<IndexedDBCallbacks> callbacks,

content/browser/indexed_db/indexed_db_database_unittest.cc

@@ -397,7 +397,7 @@ TEST_F(IndexedDBDatabaseOperationTest, CreatePutDelete) {
 
   // Put is asynchronous
   IndexedDBValue value("value1", std::vector<IndexedDBBlobInfo>());
-  ScopedVector<storage::BlobDataHandle> handles;
+  std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
   std::unique_ptr<IndexedDBKey> key(base::MakeUnique<IndexedDBKey>("key"));
   std::vector<IndexedDBDatabase::IndexKeys> index_keys;
   scoped_refptr<MockIndexedDBCallbacks> request(

content/browser/indexed_db/indexed_db_dispatcher_host.cc

@@ -11,7 +11,6 @@
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/scoped_vector.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ -379,8 +378,8 @@ void IndexedDBDispatcherHost::OnIDBFactoryDeleteDatabase(
 // to the IndexedDBDispatcherHost.
 void IndexedDBDispatcherHost::OnPutHelper(
     const IndexedDBHostMsg_DatabasePut_Params& params,
-    std::vector<storage::BlobDataHandle*> handles) {
-  database_dispatcher_host_->OnPut(params, handles);
+    std::vector<std::unique_ptr<storage::BlobDataHandle>> handles) {
+  database_dispatcher_host_->OnPut(params, std::move(handles));
 }
 
 void IndexedDBDispatcherHost::OnAckReceivedBlobs(
@@ -683,24 +682,23 @@ void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnGetAll(
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPutWrapper(
     const IndexedDBHostMsg_DatabasePut_Params& params) {
-  std::vector<storage::BlobDataHandle*> handles;
-  for (size_t i = 0; i < params.value.blob_or_file_info.size(); ++i) {
-    const IndexedDBMsg_BlobOrFileInfo& info = params.value.blob_or_file_info[i];
-    handles.push_back(parent_->blob_storage_context_->context()
-                          ->GetBlobDataFromUUID(info.uuid)
-                          .release());
+  std::vector<std::unique_ptr<storage::BlobDataHandle>> handles;
+  for (const auto& info : params.value.blob_or_file_info) {
+    handles.push_back(
+        parent_->blob_storage_context_->context()->GetBlobDataFromUUID(
+            info.uuid));
   }
   parent_->context()->TaskRunner()->PostTask(
       FROM_HERE, base::Bind(&IndexedDBDispatcherHost::OnPutHelper, parent_,
-                            params, handles));
+                            params, base::Passed(&handles)));
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPut(
     const IndexedDBHostMsg_DatabasePut_Params& params,
-    std::vector<storage::BlobDataHandle*> handles) {
+    std::vector<std::unique_ptr<storage::BlobDataHandle>> handles) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
 
-  ScopedVector<storage::BlobDataHandle> scoped_handles;
+  std::vector<std::unique_ptr<storage::BlobDataHandle>> scoped_handles;
   scoped_handles.swap(handles);
 
   IndexedDBConnection* connection =
@@ -719,8 +717,8 @@ void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPut(
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
 
-  for (size_t i = 0; i < params.value.blob_or_file_info.size(); ++i) {
-    const IndexedDBMsg_BlobOrFileInfo& info = params.value.blob_or_file_info[i];
+  size_t i = 0;
+  for (const auto& info : params.value.blob_or_file_info) {
     if (info.is_file) {
       base::FilePath path;
       if (!info.file_path.empty()) {
@@ -741,6 +739,7 @@ void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnPut(
     } else {
       blob_info[i] = IndexedDBBlobInfo(info.uuid, info.mime_type, info.size);
     }
+    ++i;
   }
 
   // TODO(alecflett): Avoid a copy here.

content/browser/indexed_db/indexed_db_dispatcher_host.h

@@ -187,7 +187,7 @@ class IndexedDBDispatcherHost : public BrowserMessageFilter {
     // before posting to the IDB TaskRunner for the rest of the job.
     void OnPutWrapper(const IndexedDBHostMsg_DatabasePut_Params& params);
     void OnPut(const IndexedDBHostMsg_DatabasePut_Params& params,
-               std::vector<storage::BlobDataHandle*> handles);
+               std::vector<std::unique_ptr<storage::BlobDataHandle>> handles);
     void OnSetIndexKeys(
         const IndexedDBHostMsg_DatabaseSetIndexKeys_Params& params);
     void OnSetIndexesReady(int32_t ipc_database_id,
@@ -288,8 +288,9 @@ class IndexedDBDispatcherHost : public BrowserMessageFilter {
       const IndexedDBHostMsg_FactoryDeleteDatabase_Params& p);
 
   void OnAckReceivedBlobs(const std::vector<std::string>& uuids);
-  void OnPutHelper(const IndexedDBHostMsg_DatabasePut_Params& params,
-                   std::vector<storage::BlobDataHandle*> handles);
+  void OnPutHelper(
+      const IndexedDBHostMsg_DatabasePut_Params& params,
+      std::vector<std::unique_ptr<storage::BlobDataHandle>> handles);
 
   void ResetDispatcherHosts();
   void DropBlobData(const std::string& uuid);

content/browser/indexed_db/indexed_db_fake_backing_store.cc

@@ -4,8 +4,6 @@
 
 #include "content/browser/indexed_db/indexed_db_fake_backing_store.h"
 
-#include <memory>
-
 #include "base/files/file_path.h"
 #include "net/url_request/url_request_context_getter.h"
 
@@ -82,7 +80,7 @@ leveldb::Status IndexedDBFakeBackingStore::PutRecord(
     int64_t object_store_id,
     const IndexedDBKey& key,
     IndexedDBValue* value,
-    ScopedVector<storage::BlobDataHandle>* handles,
+    std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles,
     RecordIdentifier* record) {
   return leveldb::Status::OK();
 }

content/browser/indexed_db/indexed_db_fake_backing_store.h

@@ -7,6 +7,7 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
@@ -48,13 +49,14 @@ class IndexedDBFakeBackingStore : public IndexedDBBackingStore {
                                     int64_t database_id,
                                     int64_t object_store_id) override;
 
-  leveldb::Status PutRecord(IndexedDBBackingStore::Transaction* transaction,
-                            int64_t database_id,
-                            int64_t object_store_id,
-                            const IndexedDBKey& key,
-                            IndexedDBValue* value,
-                            ScopedVector<storage::BlobDataHandle>* handles,
-                            RecordIdentifier* record) override;
+  leveldb::Status PutRecord(
+      IndexedDBBackingStore::Transaction* transaction,
+      int64_t database_id,
+      int64_t object_store_id,
+      const IndexedDBKey& key,
+      IndexedDBValue* value,
+      std::vector<std::unique_ptr<storage::BlobDataHandle>>* handles,
+      RecordIdentifier* record) override;
 
   leveldb::Status ClearObjectStore(Transaction*,
                                    int64_t database_id,

content/browser/indexed_db/indexed_db_index_writer.cc

@@ -42,14 +42,9 @@ bool IndexWriter::VerifyIndexKeys(
     base::string16* error_message) const {
   *can_add_keys = false;
   DCHECK_EQ(index_id, index_keys_.first);
-  for (size_t i = 0; i < index_keys_.second.size(); ++i) {
-    bool ok = AddingKeyAllowed(backing_store,
-                               transaction,
-                               database_id,
-                               object_store_id,
-                               index_id,
-                               (index_keys_.second)[i],
-                               primary_key,
+  for (const auto& key : index_keys_.second) {
+    bool ok = AddingKeyAllowed(backing_store, transaction, database_id,
+                               object_store_id, index_id, key, primary_key,
                                can_add_keys);
     if (!ok)
       return false;
@@ -75,14 +70,10 @@ void IndexWriter::WriteIndexKeys(
     int64_t object_store_id) const {
   int64_t index_id = index_metadata_.id;
   DCHECK_EQ(index_id, index_keys_.first);
-  for (size_t i = 0; i < index_keys_.second.size(); ++i) {
-    leveldb::Status s =
-        backing_store->PutIndexDataForRecord(transaction,
-                                             database_id,
-                                             object_store_id,
-                                             index_id,
-                                             index_keys_.second[i],
-                                             record_identifier);
+  for (const auto& key : index_keys_.second) {
+    leveldb::Status s = backing_store->PutIndexDataForRecord(
+        transaction, database_id, object_store_id, index_id, key,
+        record_identifier);
     // This should have already been verified as a valid write during
     // verify_index_keys.
     DCHECK(s.ok());
@@ -129,7 +120,7 @@ bool MakeIndexWriters(
     const IndexedDBKey& primary_key,  // makes a copy
     bool key_was_generated,
     const std::vector<IndexedDBDatabase::IndexKeys>& index_keys,
-    ScopedVector<IndexWriter>* index_writers,
+    std::vector<std::unique_ptr<IndexWriter>>* index_writers,
     base::string16* error_message,
     bool* completed) {
   *completed = false;

content/browser/indexed_db/indexed_db_index_writer.h

@@ -8,10 +8,10 @@
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_vector.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 #include "content/browser/indexed_db/indexed_db_database.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
@@ -70,7 +70,7 @@ bool MakeIndexWriters(
     const IndexedDBKey& primary_key,
     bool key_was_generated,
     const std::vector<IndexedDBDatabase::IndexKeys>& index_keys,
-    ScopedVector<IndexWriter>* index_writers,
+    std::vector<std::unique_ptr<IndexWriter>>* index_writers,
     base::string16* error_message,
     bool* completed) WARN_UNUSED_RESULT;
 

content/browser/indexed_db/indexed_db_observer_changes.h

@@ -9,12 +9,11 @@
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
-#include "base/stl_util.h"
 #include "content/browser/indexed_db/indexed_db_observation.h"
 #include "content/common/content_export.h"