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

content/browser/indexed_db/indexed_db_dispatcher_host.cc

 // Copyright (c) 2012 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_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #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"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/indexed_db/indexed_db_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
@@ skipping 347 matching lines @@
       params.name, request_context_getter_,
       new IndexedDBCallbacks(this, params.ipc_thread_id,
                              params.ipc_callbacks_id),
       params.origin, indexed_db_path);
 }
 
 // OnPutHelper exists only to allow us to hop threads while holding a reference
 // 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(
     const std::vector<std::string>& uuids) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (const auto& uuid : uuids)
     DropBlobData(uuid);
 }
 
 void IndexedDBDispatcherHost::FinishTransaction(int64_t host_transaction_id,
@@ skipping 282 matching lines @@
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
   connection->database()->GetAll(
       parent_->HostTransactionId(params.transaction_id), params.object_store_id,
       params.index_id, base::MakeUnique<IndexedDBKeyRange>(params.key_range),
       params.key_only, params.max_count, callbacks);
 }
 
 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 =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
   scoped_refptr<IndexedDBCallbacks> callbacks(new IndexedDBCallbacks(
       parent_, params.ipc_thread_id, params.ipc_callbacks_id));
 
   int64_t host_transaction_id =
       parent_->HostTransactionId(params.transaction_id);
 
   std::vector<IndexedDBBlobInfo> blob_info(
       params.value.blob_or_file_info.size());
 
   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()) {
         path = base::FilePath::FromUTF16Unsafe(info.file_path);
         if (!policy->CanReadFile(parent_->ipc_process_id_, path)) {
           bad_message::ReceivedBadMessage(parent_,
                                           bad_message::IDBDH_CAN_READ_FILE);
           return;
         }
       }
       blob_info[i] =
           IndexedDBBlobInfo(info.uuid, path, info.file_name, info.mime_type);
       if (info.size != static_cast<uint64_t>(-1)) {
         blob_info[i].set_last_modified(
             base::Time::FromDoubleT(info.last_modified));
         blob_info[i].set_size(info.size);
       }
     } else {
       blob_info[i] = IndexedDBBlobInfo(info.uuid, info.mime_type, info.size);
     }
+    ++i;
   }
 
   // TODO(alecflett): Avoid a copy here.
   IndexedDBValue value;
   value.bits = params.value.bits;
   value.blob_info.swap(blob_info);
   connection->database()->Put(host_transaction_id, params.object_store_id,
                               &value, &scoped_handles,
                               base::MakeUnique<IndexedDBKey>(params.key),
                               params.put_mode, callbacks, params.index_keys);
@@ skipping 304 matching lines @@
     DLOG(ERROR) << "Unable to reset prefetch";
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
     int32_t ipc_object_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content