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

content/browser/indexed_db/indexed_db_database.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_database.h"
 
 #include <math.h>
 
 #include <limits>
 #include <memory>
@@ skipping 446 matching lines @@
 }
 
 size_t IndexedDBDatabase::GetMaxMessageSizeInBytes() const {
   return kMaxIDBMessageSizeInBytes;
 }
 
 std::unique_ptr<IndexedDBConnection> IndexedDBDatabase::CreateConnection(
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int child_process_id) {
   std::unique_ptr<IndexedDBConnection> connection(
-      new IndexedDBConnection(this, database_callbacks));
+      base::MakeUnique<IndexedDBConnection>(this, database_callbacks));
   connections_.insert(connection.get());
   backing_store_->GrantChildProcessPermissions(child_process_id);
   return connection;
 }
 
 IndexedDBTransaction* IndexedDBDatabase::GetTransaction(
     int64_t transaction_id) const {
   const auto& trans_iterator = transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return NULL;
@@ skipping 311 matching lines @@
                                           blink::WebIDBOperationType type,
                                           const IndexedDBKeyRange& key_range) {
   for (auto* connection : connections_) {
     bool recorded = false;
     for (const auto& observer : connection->active_observers()) {
       if (!observer->IsRecordingType(type) ||
           !observer->IsRecordingObjectStore(object_store_id))
         continue;
       if (!recorded) {
         if (type == blink::WebIDBClear) {
-          transaction->AddObservation(connection->id(),
-                                      base::WrapUnique(new IndexedDBObservation(
-                                          object_store_id, type)));
+          transaction->AddObservation(
+              connection->id(),
+              base::MakeUnique<IndexedDBObservation>(object_store_id, type));
         } else {
           transaction->AddObservation(connection->id(),
-                                      base::WrapUnique(new IndexedDBObservation(
-                                          object_store_id, type, key_range)));
+                                      base::MakeUnique<IndexedDBObservation>(
+                                          object_store_id, type, key_range));
         }
         recorded = true;
       }
       transaction->RecordObserverForLastObservation(connection->id(),
                                                     observer->id());
     }
   }
 }
 
 void IndexedDBDatabase::SendObservations(
@@ skipping 349 matching lines @@
   const int64_t max_generator_value =
       9007199254740992LL;  // Maximum integer storable as ECMAScript number.
   int64_t current_number;
   leveldb::Status s = backing_store->GetKeyGeneratorCurrentNumber(
       transaction->BackingStoreTransaction(),
       database_id,
       object_store_id,
       &current_number);
   if (!s.ok()) {
     LOG(ERROR) << "Failed to GetKeyGeneratorCurrentNumber";
-    return base::WrapUnique(new IndexedDBKey());
+    return base::MakeUnique<IndexedDBKey>();
   }
   if (current_number < 0 || current_number > max_generator_value)
-    return base::WrapUnique(new IndexedDBKey());
+    return base::MakeUnique<IndexedDBKey>();
 
-  return base::WrapUnique(
-      new IndexedDBKey(current_number, WebIDBKeyTypeNumber));
+  return base::MakeUnique<IndexedDBKey>(current_number, WebIDBKeyTypeNumber);
 }
 
 static leveldb::Status UpdateKeyGenerator(IndexedDBBackingStore* backing_store,
                                           IndexedDBTransaction* transaction,
                                           int64_t database_id,
                                           int64_t object_store_id,
                                           const IndexedDBKey& key,
                                           bool check_current) {
   DCHECK_EQ(WebIDBKeyTypeNumber, key.type());
   return backing_store->MaybeUpdateKeyGeneratorCurrentNumber(
@@ skipping 27 matching lines @@
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), blink::WebIDBTransactionModeReadOnly);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   DCHECK(key);
   DCHECK(value);
-  std::unique_ptr<PutOperationParams> params(new PutOperationParams());
+  std::unique_ptr<PutOperationParams> params(
+      base::MakeUnique<PutOperationParams>());
   params->object_store_id = object_store_id;
   params->value.swap(*value);
   params->handles.swap(*handles);
   params->key = std::move(key);
   params->put_mode = put_mode;
   params->callbacks = callbacks;
   params->index_keys = index_keys;
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::PutOperation, this, base::Passed(&params)));
 }
@@ skipping 264 matching lines @@
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::OpenCursor", "txn.id", transaction_id);
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   std::unique_ptr<OpenCursorOperationParams> params(
-      new OpenCursorOperationParams());
+      base::MakeUnique<OpenCursorOperationParams>());
   params->object_store_id = object_store_id;
   params->index_id = index_id;
   params->key_range = std::move(key_range);
   params->direction = direction;
   params->cursor_type =
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE;
   params->task_type = task_type;
   params->callbacks = callbacks;
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::OpenCursorOperation, this, base::Passed(&params)));
@@ skipping 479 matching lines @@
 
 void IndexedDBDatabase::VersionChangeAbortOperation(
     int64_t previous_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
 }
 
 }  // namespace content