IndexedDB: WrapUnique(new T(args..)) -> MakeUnique<T>(args...)

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"
@@ skipping 47 matching lines @@
 IndexedDBDispatcherHost::IndexedDBDispatcherHost(
     int ipc_process_id,
     net::URLRequestContextGetter* request_context_getter,
     IndexedDBContextImpl* indexed_db_context,
     ChromeBlobStorageContext* blob_storage_context)
     : BrowserMessageFilter(IndexedDBMsgStart),
       request_context_getter_(request_context_getter),
       request_context_(NULL),
       indexed_db_context_(indexed_db_context),
       blob_storage_context_(blob_storage_context),
-      database_dispatcher_host_(new DatabaseDispatcherHost(this)),
-      cursor_dispatcher_host_(new CursorDispatcherHost(this)),
+      database_dispatcher_host_(base::MakeUnique<DatabaseDispatcherHost>(this)),
+      cursor_dispatcher_host_(base::MakeUnique<CursorDispatcherHost>(this)),
       ipc_process_id_(ipc_process_id) {
   DCHECK(indexed_db_context_.get());
 }
 
 IndexedDBDispatcherHost::IndexedDBDispatcherHost(
     int ipc_process_id,
     net::URLRequestContext* request_context,
     IndexedDBContextImpl* indexed_db_context,
     ChromeBlobStorageContext* blob_storage_context)
     : BrowserMessageFilter(IndexedDBMsgStart),
       request_context_(request_context),
       indexed_db_context_(indexed_db_context),
       blob_storage_context_(blob_storage_context),
-      database_dispatcher_host_(new DatabaseDispatcherHost(this)),
-      cursor_dispatcher_host_(new CursorDispatcherHost(this)),
+      database_dispatcher_host_(base::MakeUnique<DatabaseDispatcherHost>(this)),
+      cursor_dispatcher_host_(base::MakeUnique<CursorDispatcherHost>(this)),
       ipc_process_id_(ipc_process_id) {
   DCHECK(indexed_db_context_.get());
 }
 
 IndexedDBDispatcherHost::~IndexedDBDispatcherHost() {
   for (auto& iter : blob_data_handle_map_)
     delete iter.second.first;
 }
 
 void IndexedDBDispatcherHost::OnChannelConnected(int32_t peer_pid) {
@@ skipping 278 matching lines @@
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
   scoped_refptr<IndexedDBCallbacks> callbacks = new IndexedDBCallbacks(
       this, params.ipc_thread_id, params.ipc_callbacks_id,
       params.ipc_database_callbacks_id, host_transaction_id, params.origin);
   callbacks->SetConnectionOpenStartTime(begin_time);
   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks =
       new IndexedDBDatabaseCallbacks(
           this, params.ipc_thread_id, params.ipc_database_callbacks_id);
   std::unique_ptr<IndexedDBPendingConnection> connection =
-      base::WrapUnique(new IndexedDBPendingConnection(
+      base::MakeUnique<IndexedDBPendingConnection>(
           callbacks, database_callbacks, ipc_process_id_, host_transaction_id,
-          params.version));
+          params.version);
   DCHECK(request_context_);
   context()->GetIDBFactory()->Open(params.name, std::move(connection),
                                    request_context_, params.origin,
                                    indexed_db_path);
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryDeleteDatabase(
     const IndexedDBHostMsg_FactoryDeleteDatabase_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
@@ skipping 290 matching lines @@
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   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));
   connection->database()->Get(
       parent_->HostTransactionId(params.transaction_id), params.object_store_id,
-      params.index_id,
-      base::WrapUnique(new IndexedDBKeyRange(params.key_range)),
+      params.index_id, base::MakeUnique<IndexedDBKeyRange>(params.key_range),
       params.key_only, callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnGetAll(
     const IndexedDBHostMsg_DatabaseGetAll_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   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));
   connection->database()->GetAll(
       parent_->HostTransactionId(params.transaction_id), params.object_store_id,
-      params.index_id,
-      base::WrapUnique(new IndexedDBKeyRange(params.key_range)),
+      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)
@@ skipping 51 matching lines @@
       blob_info[i] = IndexedDBBlobInfo(info.uuid, info.mime_type, info.size);
     }
   }
 
   // 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::WrapUnique(new IndexedDBKey(params.key)),
+                              base::MakeUnique<IndexedDBKey>(params.key),
                               params.put_mode, callbacks, params.index_keys);
   // Size can't be big enough to overflow because it represents the
   // actual bytes passed through IPC.
   transaction_size_map_[host_transaction_id] += params.value.bits.size();
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnSetIndexKeys(
     const IndexedDBHostMsg_DatabaseSetIndexKeys_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, params.ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
   int64_t host_transaction_id =
       parent_->HostTransactionId(params.transaction_id);
   connection->database()->SetIndexKeys(
       host_transaction_id, params.object_store_id,
-      base::WrapUnique(new IndexedDBKey(params.primary_key)),
-      params.index_keys);
+      base::MakeUnique<IndexedDBKey>(params.primary_key), params.index_keys);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnSetIndexesReady(
     int32_t ipc_database_id,
     int64_t transaction_id,
     int64_t object_store_id,
     const std::vector<int64_t>& index_ids) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
       parent_->GetOrTerminateProcess(&map_, ipc_database_id);
   if (!connection || !connection->IsConnected())
     return;
 
   connection->database()->SetIndexesReady(
       parent_->HostTransactionId(transaction_id), object_store_id, index_ids);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnOpenCursor(
     const IndexedDBHostMsg_DatabaseOpenCursor_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   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, -1));
   connection->database()->OpenCursor(
       parent_->HostTransactionId(params.transaction_id), params.object_store_id,
-      params.index_id,
-      base::WrapUnique(new IndexedDBKeyRange(params.key_range)),
+      params.index_id, base::MakeUnique<IndexedDBKeyRange>(params.key_range),
       params.direction, params.key_only, params.task_type, callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnCount(
     const IndexedDBHostMsg_DatabaseCount_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   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));
   connection->database()->Count(
       parent_->HostTransactionId(params.transaction_id), params.object_store_id,
-      params.index_id,
-      base::WrapUnique(new IndexedDBKeyRange(params.key_range)), callbacks);
+      params.index_id, base::MakeUnique<IndexedDBKeyRange>(params.key_range),
+      callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnDeleteRange(
     const IndexedDBHostMsg_DatabaseDeleteRange_Params& params) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   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));
   connection->database()->DeleteRange(
       parent_->HostTransactionId(params.transaction_id), params.object_store_id,
-      base::WrapUnique(new IndexedDBKeyRange(params.key_range)), callbacks);
+      base::MakeUnique<IndexedDBKeyRange>(params.key_range), callbacks);
 }
 
 void IndexedDBDispatcherHost::DatabaseDispatcherHost::OnClear(
     int32_t ipc_thread_id,
     int32_t ipc_callbacks_id,
     int32_t ipc_database_id,
     int64_t transaction_id,
     int64_t object_store_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBConnection* connection =
@@ skipping 164 matching lines @@
     int32_t ipc_thread_id,
     int32_t ipc_callbacks_id,
     const IndexedDBKey& key,
     const IndexedDBKey& primary_key) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   IndexedDBCursor* idb_cursor =
       parent_->GetOrTerminateProcess(&map_, ipc_cursor_id);
   if (!idb_cursor)
     return;
 
-  idb_cursor->Continue(key.IsValid() ? base::WrapUnique(new IndexedDBKey(key))
+  idb_cursor->Continue(key.IsValid() ? base::MakeUnique<IndexedDBKey>(key)
                                      : std::unique_ptr<IndexedDBKey>(),
                        primary_key.IsValid()
-                           ? base::WrapUnique(new IndexedDBKey(primary_key))
+                           ? base::MakeUnique<IndexedDBKey>(primary_key)
                            : std::unique_ptr<IndexedDBKey>(),
                        new IndexedDBCallbacks(parent_, ipc_thread_id,
                                               ipc_callbacks_id, ipc_cursor_id));
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnPrefetch(
     int32_t ipc_cursor_id,
     int32_t ipc_thread_id,
     int32_t ipc_callbacks_id,
     int n) {
@@ skipping 26 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