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

content/browser/indexed_db/leveldb/leveldb_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/leveldb/leveldb_database.h"
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #include <cerrno>
@@ skipping 98 matching lines @@
     db_.reset();
     UMA_HISTOGRAM_MEDIUM_TIMES("WebCore.IndexedDB.LevelDB.CloseTime",
                                base::TimeTicks::Now() - begin_time);
   }
 }
 
 static leveldb::Status OpenDB(
     leveldb::Comparator* comparator,
     leveldb::Env* env,
     const base::FilePath& path,
-    leveldb::DB** db,
+    std::unique_ptr<leveldb::DB>* db,
     std::unique_ptr<const leveldb::FilterPolicy>* filter_policy) {
   filter_policy->reset(leveldb::NewBloomFilterPolicy(10));
   leveldb::Options options;
   options.comparator = comparator;
   options.create_if_missing = true;
   options.paranoid_checks = true;
   options.filter_policy = filter_policy->get();
   options.reuse_logs = leveldb_env::kDefaultLogReuseOptionValue;
   options.compression = leveldb::kSnappyCompression;
 
   // For info about the troubles we've run into with this parameter, see:
   // https://code.google.com/p/chromium/issues/detail?id=227313#c11
   options.max_open_files = 80;
   options.env = env;
 
   // ChromiumEnv assumes UTF8, converts back to FilePath before using.
-  leveldb::Status s = leveldb::DB::Open(options, path.AsUTF8Unsafe(), db);
+  leveldb::DB* db_ptr = nullptr;
+  leveldb::Status s = leveldb::DB::Open(options, path.AsUTF8Unsafe(), &db_ptr);
+  db->reset(db_ptr);
 
   return s;
 }
 
 leveldb::Status LevelDBDatabase::Destroy(const base::FilePath& file_name) {
   leveldb::Options options;
   options.env = LevelDBEnv::Get();
   // ChromiumEnv assumes UTF8, converts back to FilePath before using.
   return leveldb::DestroyDB(file_name.AsUTF8Unsafe(), options);
 }
@@ skipping 15 matching lines @@
 
 std::unique_ptr<LevelDBLock> LevelDBDatabase::LockForTesting(
     const base::FilePath& file_name) {
   leveldb::Env* env = LevelDBEnv::Get();
   base::FilePath lock_path = file_name.AppendASCII("LOCK");
   leveldb::FileLock* lock = NULL;
   leveldb::Status status = env->LockFile(lock_path.AsUTF8Unsafe(), &lock);
   if (!status.ok())
     return std::unique_ptr<LevelDBLock>();
   DCHECK(lock);
-  return std::unique_ptr<LevelDBLock>(new LockImpl(env, lock));
+  return base::MakeUnique<LockImpl>(env, lock);
 }
 
 static int CheckFreeSpace(const char* const type,
                           const base::FilePath& file_name) {
   std::string name =
       std::string("WebCore.IndexedDB.LevelDB.Open") + type + "FreeDiskSpace";
   int64_t free_disk_space_in_k_bytes =
       base::SysInfo::AmountOfFreeDiskSpace(file_name) / 1024;
   if (free_disk_space_in_k_bytes < 0) {
     base::Histogram::FactoryGet(
@@ skipping 99 matching lines @@
 }
 
 leveldb::Status LevelDBDatabase::Open(const base::FilePath& file_name,
                                       const LevelDBComparator* comparator,
                                       std::unique_ptr<LevelDBDatabase>* result,
                                       bool* is_disk_full) {
   IDB_TRACE("LevelDBDatabase::Open");
   base::TimeTicks begin_time = base::TimeTicks::Now();
 
   std::unique_ptr<ComparatorAdapter> comparator_adapter(
-      new ComparatorAdapter(comparator));
+      base::MakeUnique<ComparatorAdapter>(comparator));
 
-  leveldb::DB* db;
+  std::unique_ptr<leveldb::DB> db;
   std::unique_ptr<const leveldb::FilterPolicy> filter_policy;
   const leveldb::Status s = OpenDB(comparator_adapter.get(), LevelDBEnv::Get(),
                                    file_name, &db, &filter_policy);
 
   if (!s.ok()) {
     HistogramLevelDBError("WebCore.IndexedDB.LevelDBOpenErrors", s);
     int free_space_k_bytes = CheckFreeSpace("Failure", file_name);
     // Disks with <100k of free space almost never succeed in opening a
     // leveldb database.
     if (is_disk_full)
       *is_disk_full = free_space_k_bytes >= 0 && free_space_k_bytes < 100;
 
     LOG(ERROR) << "Failed to open LevelDB database from "
                << file_name.AsUTF8Unsafe() << "," << s.ToString();
     return s;
   }
 
   UMA_HISTOGRAM_MEDIUM_TIMES("WebCore.IndexedDB.LevelDB.OpenTime",
                              base::TimeTicks::Now() - begin_time);
 
   CheckFreeSpace("Success", file_name);
 
-  (*result).reset(new LevelDBDatabase);
-  (*result)->db_ = base::WrapUnique(db);
+  (*result) = base::WrapUnique(new LevelDBDatabase());
+  (*result)->db_ = std::move(db);
   (*result)->comparator_adapter_ = std::move(comparator_adapter);
   (*result)->comparator_ = comparator;
   (*result)->filter_policy_ = std::move(filter_policy);
   (*result)->file_name_for_tracing = file_name.BaseName().AsUTF8Unsafe();
 
   return s;
 }
 
 std::unique_ptr<LevelDBDatabase> LevelDBDatabase::OpenInMemory(
     const LevelDBComparator* comparator) {
   std::unique_ptr<ComparatorAdapter> comparator_adapter(
-      new ComparatorAdapter(comparator));
+      base::MakeUnique<ComparatorAdapter>(comparator));
   std::unique_ptr<leveldb::Env> in_memory_env(
       leveldb::NewMemEnv(LevelDBEnv::Get()));
 
-  leveldb::DB* db;
+  std::unique_ptr<leveldb::DB> db;
   std::unique_ptr<const leveldb::FilterPolicy> filter_policy;
   const leveldb::Status s = OpenDB(comparator_adapter.get(),
                                    in_memory_env.get(),
                                    base::FilePath(),
                                    &db,
                                    &filter_policy);
 
   if (!s.ok()) {
     LOG(ERROR) << "Failed to open in-memory LevelDB database: " << s.ToString();
     return std::unique_ptr<LevelDBDatabase>();
   }
 
-  std::unique_ptr<LevelDBDatabase> result(new LevelDBDatabase);
+  std::unique_ptr<LevelDBDatabase> result =
+      base::WrapUnique(new LevelDBDatabase());
   result->env_ = std::move(in_memory_env);
-  result->db_ = base::WrapUnique(db);
+  result->db_ = std::move(db);
   result->comparator_adapter_ = std::move(comparator_adapter);
   result->comparator_ = comparator;
   result->filter_policy_ = std::move(filter_policy);
   result->file_name_for_tracing = "in-memory-database";
 
   return result;
 }
 
 leveldb::Status LevelDBDatabase::Put(const StringPiece& key,
                                      std::string* value) {
@@ skipping 108 matching lines @@
   dump->AddString("file_name", "", file_name_for_tracing);
 
   // Memory is allocated from system allocator (malloc).
   pmd->AddSuballocation(dump->guid(),
                         base::trace_event::MemoryDumpManager::GetInstance()
                             ->system_allocator_pool_name());
   return true;
 }
 
 }  // namespace content