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

content/browser/indexed_db/indexed_db_index_writer.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_index_writer.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 24 matching lines @@
     IndexedDBBackingStore* backing_store,
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     int64_t object_store_id,
     int64_t index_id,
     bool* can_add_keys,
     const IndexedDBKey& primary_key,
     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;
     if (!*can_add_keys) {
       if (error_message) {
         *error_message = ASCIIToUTF16("Unable to add key to index '") +
                          index_metadata_.name +
                          ASCIIToUTF16("': at least one key does not satisfy "
                                       "the uniqueness requirements.");
       }
       return true;
     }
   }
   *can_add_keys = true;
   return true;
 }
 
 void IndexWriter::WriteIndexKeys(
     const IndexedDBBackingStore::RecordIdentifier& record_identifier,
     IndexedDBBackingStore* backing_store,
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
     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());
   }
 }
 
 bool IndexWriter::AddingKeyAllowed(
     IndexedDBBackingStore* backing_store,
     IndexedDBBackingStore::Transaction* transaction,
     int64_t database_id,
@@ skipping 26 matching lines @@
 }
 
 bool MakeIndexWriters(
     IndexedDBTransaction* transaction,
     IndexedDBBackingStore* backing_store,
     int64_t database_id,
     const IndexedDBObjectStoreMetadata& object_store,
     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;
 
   for (const auto& it : index_keys) {
     const auto& found = object_store.indexes.find(it.first);
     if (found == object_store.indexes.end())
       continue;
     const IndexedDBIndexMetadata& index = found->second;
     IndexedDBDatabase::IndexKeys keys = it;
@@ skipping 21 matching lines @@
       return true;
 
     index_writers->push_back(std::move(index_writer));
   }
 
   *completed = true;
   return true;
 }
 
 }  // namespace content