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

content/browser/indexed_db/indexed_db_context_impl.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_context_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 148 matching lines @@
 static bool HostNameComparator(const Origin& i, const Origin& j) {
   return i.host() < j.host();
 }
 
 base::ListValue* IndexedDBContextImpl::GetAllOriginsDetails() {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   std::vector<Origin> origins = GetAllOrigins();
 
   std::sort(origins.begin(), origins.end(), HostNameComparator);
 
-  std::unique_ptr<base::ListValue> list(new base::ListValue());
+  std::unique_ptr<base::ListValue> list(base::MakeUnique<base::ListValue>());
   for (const auto& origin : origins) {
-    std::unique_ptr<base::DictionaryValue> info(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> info(
+        base::MakeUnique<base::DictionaryValue>());
     info->SetString("url", origin.Serialize());
     info->SetString("size", ui::FormatBytes(GetOriginDiskUsage(origin)));
     info->SetDouble("last_modified", GetOriginLastModified(origin).ToJsTime());
     if (!is_incognito()) {
-      std::unique_ptr<base::ListValue> paths(new base::ListValue());
+      std::unique_ptr<base::ListValue> paths(
+          base::MakeUnique<base::ListValue>());
       for (const base::FilePath& path : GetStoragePaths(origin))
         paths->AppendString(path.value());
       info->Set("paths", paths.release());
     }
     info->SetDouble("connection_count", GetConnectionCount(origin));
 
     // This ends up being O(n^2) since we iterate over all open databases
     // to extract just those in the origin, and we're iterating over all
     // origins in the outer loop.
 
     if (factory_.get()) {
       std::pair<IndexedDBFactory::OriginDBMapIterator,
                 IndexedDBFactory::OriginDBMapIterator>
           range = factory_->GetOpenDatabasesForOrigin(origin);
       // TODO(jsbell): Sort by name?
-      std::unique_ptr<base::ListValue> database_list(new base::ListValue());
+      std::unique_ptr<base::ListValue> database_list(
+          base::MakeUnique<base::ListValue>());
 
       for (IndexedDBFactory::OriginDBMapIterator it = range.first;
            it != range.second;
            ++it) {
         const IndexedDBDatabase* db = it->second;
         std::unique_ptr<base::DictionaryValue> db_info(
-            new base::DictionaryValue());
+            base::MakeUnique<base::DictionaryValue>());
 
         db_info->SetString("name", db->name());
         db_info->SetDouble("connection_count", db->ConnectionCount());
         db_info->SetDouble("active_open_delete", db->ActiveOpenDeleteCount());
         db_info->SetDouble("pending_open_delete", db->PendingOpenDeleteCount());
 
         std::unique_ptr<base::ListValue> transaction_list(
-            new base::ListValue());
+            base::MakeUnique<base::ListValue>());
         std::vector<const IndexedDBTransaction*> transactions =
             db->transaction_coordinator().GetTransactions();
         for (const auto* transaction : transactions) {
           std::unique_ptr<base::DictionaryValue> transaction_info(
-              new base::DictionaryValue());
+              base::MakeUnique<base::DictionaryValue>());
 
           const char* const kModes[] =
               { "readonly", "readwrite", "versionchange" };
           transaction_info->SetString("mode", kModes[transaction->mode()]);
           switch (transaction->state()) {
             case IndexedDBTransaction::CREATED:
               transaction_info->SetString("status", "blocked");
               break;
             case IndexedDBTransaction::STARTED:
               if (transaction->diagnostics().tasks_scheduled > 0)
@@ skipping 23 matching lines @@
                   .InMillisecondsF());
           transaction_info->SetDouble(
               "runtime",
               (base::Time::Now() - transaction->diagnostics().start_time)
                   .InMillisecondsF());
           transaction_info->SetDouble(
               "tasks_scheduled", transaction->diagnostics().tasks_scheduled);
           transaction_info->SetDouble(
               "tasks_completed", transaction->diagnostics().tasks_completed);
 
-          std::unique_ptr<base::ListValue> scope(new base::ListValue());
+          std::unique_ptr<base::ListValue> scope(
+              base::MakeUnique<base::ListValue>());
           for (const auto& id : transaction->scope()) {
             const auto& it = db->metadata().object_stores.find(id);
             if (it != db->metadata().object_stores.end())
               scope->AppendString(it->second.name);
           }
 
           transaction_info->Set("scope", scope.release());
           transaction_list->Append(std::move(transaction_info));
         }
         db_info->Set("transactions", transaction_list.release());
@@ skipping 282 matching lines @@
     quota_manager_proxy()->NotifyStorageModified(
         storage::QuotaClient::kIndexedDatabase, GURL(origin.Serialize()),
         storage::kStorageTypeTemporary, difference);
   }
 }
 
 std::set<Origin>* IndexedDBContextImpl::GetOriginSet() {
   if (!origin_set_) {
     std::vector<Origin> origins;
     GetAllOriginsAndPaths(data_path_, &origins, NULL);
-    origin_set_.reset(new std::set<Origin>(origins.begin(), origins.end()));
+    origin_set_ =
+        base::MakeUnique<std::set<Origin>>(origins.begin(), origins.end());
   }
   return origin_set_.get();
 }
 
 void IndexedDBContextImpl::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
 }
 
 base::SequencedTaskRunner* IndexedDBContextImpl::TaskRunner() const {
   return task_runner_.get();
 }
 
 }  // namespace content