Convert //components/[f-n]* from scoped_ptr to std::unique_ptr

components/leveldb_proto/proto_database_impl.h

 // Copyright 2014 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.
 
 #ifndef COMPONENTS_LEVELDB_PROTO_PROTO_DATABASE_IMPL_H_
 #define COMPONENTS_LEVELDB_PROTO_PROTO_DATABASE_IMPL_H_
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_checker.h"
 #include "components/leveldb_proto/leveldb_database.h"
 #include "components/leveldb_proto/proto_database.h"
 
 namespace leveldb_proto {
@@ skipping 13 matching lines @@
 
   ~ProtoDatabaseImpl() override;
 
   // ProtoDatabase implementation.
   // TODO(cjhopman): Perhaps Init() shouldn't be exposed to users and not just
   //     part of the constructor
   void Init(const char* client_name,
             const base::FilePath& database_dir,
             const typename ProtoDatabase<T>::InitCallback& callback) override;
   void UpdateEntries(
-      scoped_ptr<typename ProtoDatabase<T>::KeyEntryVector> entries_to_save,
-      scoped_ptr<KeyVector> keys_to_remove,
+      std::unique_ptr<typename ProtoDatabase<T>::KeyEntryVector>
+          entries_to_save,
+      std::unique_ptr<KeyVector> keys_to_remove,
       const typename ProtoDatabase<T>::UpdateCallback& callback) override;
   void LoadEntries(
       const typename ProtoDatabase<T>::LoadCallback& callback) override;
   void Destroy(
       const typename ProtoDatabase<T>::DestroyCallback& callback) override;
 
   // Allow callers to provide their own Database implementation.
   void InitWithDatabase(
-      scoped_ptr<LevelDB> database,
+      std::unique_ptr<LevelDB> database,
       const base::FilePath& database_dir,
       const typename ProtoDatabase<T>::InitCallback& callback);
 
  private:
   base::ThreadChecker thread_checker_;
 
   // Used to run blocking tasks in-order.
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
-  scoped_ptr<LevelDB> db_;
+  std::unique_ptr<LevelDB> db_;
   base::FilePath database_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(ProtoDatabaseImpl);
 };
 
 namespace {
 
 template <typename T>
 void RunInitCallback(const typename ProtoDatabase<T>::InitCallback& callback,
                      const bool* success) {
   callback.Run(*success);
 }
 
 template <typename T>
 void RunUpdateCallback(
     const typename ProtoDatabase<T>::UpdateCallback& callback,
     const bool* success) {
   callback.Run(*success);
 }
 
 template <typename T>
 void RunLoadCallback(const typename ProtoDatabase<T>::LoadCallback& callback,
                      const bool* success,
-                     scoped_ptr<std::vector<T>> entries) {
+                     std::unique_ptr<std::vector<T>> entries) {
   callback.Run(*success, std::move(entries));
 }
 
 template <typename T>
 void RunDestroyCallback(
     const typename ProtoDatabase<T>::DestroyCallback& callback,
     const bool* success) {
   callback.Run(*success);
 }
 
 inline void InitFromTaskRunner(LevelDB* database,
                                const base::FilePath& database_dir,
                                bool* success) {
   DCHECK(success);
 
   // TODO(cjhopman): Histogram for database size.
   *success = database->Init(database_dir);
 }
 
 inline void DestroyFromTaskRunner(const base::FilePath& database_dir,
                                   bool* success) {
   CHECK(success);
 
   *success = LevelDB::Destroy(database_dir);
 }
 
 template <typename T>
 void UpdateEntriesFromTaskRunner(
     LevelDB* database,
-    scoped_ptr<typename ProtoDatabase<T>::KeyEntryVector> entries_to_save,
-    scoped_ptr<KeyVector> keys_to_remove,
+    std::unique_ptr<typename ProtoDatabase<T>::KeyEntryVector> entries_to_save,
+    std::unique_ptr<KeyVector> keys_to_remove,
     bool* success) {
   DCHECK(success);
 
   // Serialize the values from Proto to string before passing on to database.
   KeyValueVector pairs_to_save;
   for (const auto& pair : *entries_to_save) {
     pairs_to_save.push_back(
         std::make_pair(pair.first, pair.second.SerializeAsString()));
   }
 
@@ skipping 37 matching lines @@
     DLOG(WARNING) << "Proto database will not be deleted.";
 }
 
 template <typename T>
 void ProtoDatabaseImpl<T>::Init(
     const char* client_name,
     const base::FilePath& database_dir,
     const typename ProtoDatabase<T>::InitCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   database_dir_ = database_dir;
-  InitWithDatabase(make_scoped_ptr(new LevelDB(client_name)), database_dir,
+  InitWithDatabase(base::WrapUnique(new LevelDB(client_name)), database_dir,
                    callback);
 }
 
 template <typename T>
 void ProtoDatabaseImpl<T>::Destroy(
     const typename ProtoDatabase<T>::DestroyCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(db_);
   DCHECK(!database_dir_.empty());
 
   // Note that |db_| should be released from task runner.
   if (!task_runner_->DeleteSoon(FROM_HERE, db_.release())) {
     DLOG(WARNING) << "Proto database will not be deleted.";
     callback.Run(false);
     return;
   }
 
   // After |db_| is released, we can now wipe out the database directory.
   bool* success = new bool(false);
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(DestroyFromTaskRunner, database_dir_, success),
       base::Bind(RunDestroyCallback<T>, callback, base::Owned(success)));
 }
 
 template <typename T>
 void ProtoDatabaseImpl<T>::InitWithDatabase(
-    scoped_ptr<LevelDB> database,
+    std::unique_ptr<LevelDB> database,
     const base::FilePath& database_dir,
     const typename ProtoDatabase<T>::InitCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!db_);
   DCHECK(database);
   db_.reset(database.release());
   bool* success = new bool(false);
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(InitFromTaskRunner, base::Unretained(db_.get()),
                             database_dir, success),
       base::Bind(RunInitCallback<T>, callback, base::Owned(success)));
 }
 
 template <typename T>
 void ProtoDatabaseImpl<T>::UpdateEntries(
-    scoped_ptr<typename ProtoDatabase<T>::KeyEntryVector> entries_to_save,
-    scoped_ptr<KeyVector> keys_to_remove,
+    std::unique_ptr<typename ProtoDatabase<T>::KeyEntryVector> entries_to_save,
+    std::unique_ptr<KeyVector> keys_to_remove,
     const typename ProtoDatabase<T>::UpdateCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool* success = new bool(false);
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(UpdateEntriesFromTaskRunner<T>, base::Unretained(db_.get()),
                  base::Passed(&entries_to_save), base::Passed(&keys_to_remove),
                  success),
       base::Bind(RunUpdateCallback<T>, callback, base::Owned(success)));
 }
 
 template <typename T>
 void ProtoDatabaseImpl<T>::LoadEntries(
     const typename ProtoDatabase<T>::LoadCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool* success = new bool(false);
 
-  scoped_ptr<std::vector<T> > entries(new std::vector<T>());
+  std::unique_ptr<std::vector<T>> entries(new std::vector<T>());
   // Get this pointer before entries is base::Passed() so we can use it below.
   std::vector<T>* entries_ptr = entries.get();
 
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(LoadEntriesFromTaskRunner<T>,
                             base::Unretained(db_.get()), entries_ptr, success),
       base::Bind(RunLoadCallback<T>, callback, base::Owned(success),
                  base::Passed(&entries)));
 }
 
 }  // namespace leveldb_proto
 
 #endif  // COMPONENTS_LEVELDB_PROTO_PROTO_DATABASE_IMPL_H_