Convert //chrome/browser/sync_file_system from scoped_ptr to std::unique_ptr

chrome/browser/sync_file_system/drive_backend/metadata_database_unittest.cc

 // Copyright 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 "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 
 #include <stdint.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/leveldb_wrapper.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database_index_interface.h"
@@ skipping 78 matching lines @@
 
 template <typename Key, typename Value>
 void ExpectEquivalent(const base::hash_map<Key, Value>& left,
                       const base::hash_map<Key, Value>& right) {
   ExpectEquivalentMaps(std::map<Key, Value>(left.begin(), left.end()),
                        std::map<Key, Value>(right.begin(), right.end()));
 }
 
 template <typename Key, typename Value>
 void ExpectEquivalent(
-    const base::ScopedPtrHashMap<Key, scoped_ptr<Value>>& left,
-    const base::ScopedPtrHashMap<Key, scoped_ptr<Value>>& right) {
+    const base::ScopedPtrHashMap<Key, std::unique_ptr<Value>>& left,
+    const base::ScopedPtrHashMap<Key, std::unique_ptr<Value>>& right) {
   ExpectEquivalentMaps(std::map<Key, Value*>(left.begin(), left.end()),
                        std::map<Key, Value*>(right.begin(), right.end()));
 }
 
 template <typename Container>
 void ExpectEquivalentSets(const Container& left, const Container& right);
 
 template <typename Value, typename Comparator>
 void ExpectEquivalent(const std::set<Value, Comparator>& left,
                       const std::set<Value, Comparator>& right) {
@@ skipping 90 matching lines @@
     return status;
   }
 
   void DropDatabase() {
     metadata_database_.reset();
     message_loop_.RunUntilIdle();
   }
 
   void SetUpDatabaseByTrackedFiles(const TrackedFile** tracked_files,
                                    int size) {
-    scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
+    std::unique_ptr<LevelDBWrapper> db = InitializeLevelDB();
     ASSERT_TRUE(db);
 
     for (int i = 0; i < size; ++i) {
       const TrackedFile* file = tracked_files[i];
       if (file->should_be_absent)
         continue;
       if (!file->tracker_only)
         EXPECT_TRUE(PutFileToDB(db.get(), file->metadata).ok());
       EXPECT_TRUE(PutTrackerToDB(db.get(), file->tracker).ok());
     }
@@ skipping 17 matching lines @@
         file.tracker.tracker_id(), nullptr));
   }
 
   void VerifyTrackedFiles(const TrackedFile** tracked_files, int size) {
     for (int i = 0; i < size; ++i)
       VerifyTrackedFile(*tracked_files[i]);
   }
 
   MetadataDatabase* metadata_database() { return metadata_database_.get(); }
 
-  scoped_ptr<LevelDBWrapper> InitializeLevelDB() {
+  std::unique_ptr<LevelDBWrapper> InitializeLevelDB() {
     leveldb::DB* db = nullptr;
     leveldb::Options options;
     options.create_if_missing = true;
     options.max_open_files = 0;  // Use minimum.
     options.env = in_memory_env_.get();
     leveldb::Status status =
         leveldb::DB::Open(options, database_dir_.path().AsUTF8Unsafe(), &db);
     EXPECT_TRUE(status.ok());
 
-    scoped_ptr<LevelDBWrapper> wrapper(new LevelDBWrapper(make_scoped_ptr(db)));
+    std::unique_ptr<LevelDBWrapper> wrapper(
+        new LevelDBWrapper(base::WrapUnique(db)));
 
     wrapper->Put(kDatabaseVersionKey, base::Int64ToString(3));
     SetUpServiceMetadata(wrapper.get());
 
     return wrapper;
   }
 
   void SetUpServiceMetadata(LevelDBWrapper* db) {
     ServiceMetadata service_metadata;
     service_metadata.set_largest_change_id(kInitialChangeID);
@@ skipping 90 matching lines @@
   }
 
   TrackedFile CreateTrackedFolder(const TrackedFile& parent,
                                   const std::string& title) {
     TrackedFile folder;
     folder.metadata = CreateFolderMetadata(parent.metadata, title);
     folder.tracker = CreateTracker(parent.tracker, folder.metadata);
     return folder;
   }
 
-  scoped_ptr<google_apis::FileResource> CreateFileResourceFromMetadata(
+  std::unique_ptr<google_apis::FileResource> CreateFileResourceFromMetadata(
       const FileMetadata& file) {
-    scoped_ptr<google_apis::FileResource> file_resource(
+    std::unique_ptr<google_apis::FileResource> file_resource(
         new google_apis::FileResource);
     for (int i = 0; i < file.details().parent_folder_ids_size(); ++i) {
       google_apis::ParentReference parent;
       parent.set_file_id(file.details().parent_folder_ids(i));
       file_resource->mutable_parents()->push_back(parent);
     }
 
     file_resource->set_file_id(file.file_id());
     file_resource->set_title(file.details().title());
     if (file.details().file_kind() == FILE_KIND_FOLDER) {
       file_resource->set_mime_type("application/vnd.google-apps.folder");
     } else if (file.details().file_kind() == FILE_KIND_FILE) {
       file_resource->set_mime_type("text/plain");
       file_resource->set_file_size(0);
     } else {
       file_resource->set_mime_type("application/vnd.google-apps.document");
     }
     file_resource->set_md5_checksum(file.details().md5());
     file_resource->set_etag(file.details().etag());
     file_resource->set_created_date(base::Time::FromInternalValue(
         file.details().creation_time()));
     file_resource->set_modified_date(base::Time::FromInternalValue(
         file.details().modification_time()));
 
     return file_resource;
   }
 
-  scoped_ptr<google_apis::ChangeResource> CreateChangeResourceFromMetadata(
+  std::unique_ptr<google_apis::ChangeResource> CreateChangeResourceFromMetadata(
       const FileMetadata& file) {
-    scoped_ptr<google_apis::ChangeResource> change(
+    std::unique_ptr<google_apis::ChangeResource> change(
         new google_apis::ChangeResource);
     change->set_change_id(file.details().change_id());
     change->set_file_id(file.file_id());
     change->set_deleted(file.details().missing());
     if (change->is_deleted())
       return change;
 
     change->set_file(CreateFileResourceFromMetadata(file));
     return change;
   }
@@ skipping 17 matching lines @@
     FileDetails* details = file->mutable_details();
     details->set_md5(
         "md5_value_" + base::Int64ToString(next_md5_sequence_number_++));
     details->set_change_id(++current_change_id_);
   }
 
   void ApplyNoopChangeToMetadata(FileMetadata* file) {
     file->mutable_details()->set_change_id(++current_change_id_);
   }
 
-  void PushToChangeList(scoped_ptr<google_apis::ChangeResource> change,
+  void PushToChangeList(std::unique_ptr<google_apis::ChangeResource> change,
                         ScopedVector<google_apis::ChangeResource>* changes) {
     changes->push_back(change.release());
   }
 
   leveldb::Status PutFileToDB(LevelDBWrapper* db, const FileMetadata& file) {
     PutFileMetadataToDB(file, db);
     return db->Commit();
   }
 
   leveldb::Status PutTrackerToDB(LevelDBWrapper* db,
@@ skipping 31 matching lines @@
     {
       SCOPED_TRACE("Expect equivalent dirty_trackers_ contents.");
       ExpectEquivalent(index1->dirty_trackers_, index2->dirty_trackers_);
     }
   }
 
   void VerifyReloadConsistencyForOnDisk(
       MetadataDatabaseIndexOnDisk* index1,
       MetadataDatabaseIndexOnDisk* index2) {
     ExpectEquivalentServiceMetadata(index1, index2);
-    scoped_ptr<LevelDBWrapper::Iterator> itr1 =
+    std::unique_ptr<LevelDBWrapper::Iterator> itr1 =
         index1->GetDBForTesting()->NewIterator();
-    scoped_ptr<LevelDBWrapper::Iterator> itr2 =
+    std::unique_ptr<LevelDBWrapper::Iterator> itr2 =
         index2->GetDBForTesting()->NewIterator();
     for (itr1->SeekToFirst(), itr2->SeekToFirst();
          itr1->Valid() && itr2->Valid();
          itr1->Next(), itr2->Next()) {
       EXPECT_EQ(itr1->key().ToString(), itr2->key().ToString());
       EXPECT_EQ(itr1->value().ToString(), itr2->value().ToString());
     }
     EXPECT_TRUE(!itr1->Valid());
     EXPECT_TRUE(!itr2->Valid());
   }
 
   void VerifyReloadConsistency() {
-    scoped_ptr<MetadataDatabase> metadata_database_2;
+    std::unique_ptr<MetadataDatabase> metadata_database_2;
     ASSERT_EQ(SYNC_STATUS_OK, MetadataDatabase::CreateForTesting(
                                   std::move(metadata_database_->db_),
                                   metadata_database_->enable_on_disk_index_,
                                   &metadata_database_2));
     metadata_database_->db_ = std::move(metadata_database_2->db_);
 
     MetadataDatabaseIndexInterface* index1 = metadata_database_->index_.get();
     MetadataDatabaseIndexInterface* index2 = metadata_database_2->index_.get();
     if (GetParam()) {
       VerifyReloadConsistencyForOnDisk(
@@ skipping 70 matching lines @@
   void ResetTrackerID(FileTracker* tracker) {
     tracker->set_tracker_id(GetTrackerIDByFileID(tracker->file_id()));
   }
 
   int64_t current_change_id() const { return current_change_id_; }
 
  private:
   base::ScopedTempDir database_dir_;
   base::MessageLoop message_loop_;
 
-  scoped_ptr<leveldb::Env> in_memory_env_;
-  scoped_ptr<MetadataDatabase> metadata_database_;
+  std::unique_ptr<leveldb::Env> in_memory_env_;
+  std::unique_ptr<MetadataDatabase> metadata_database_;
 
   int64_t current_change_id_;
   int64_t next_tracker_id_;
   int64_t next_file_id_number_;
   int64_t next_md5_sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(MetadataDatabaseTest);
 };
 
 INSTANTIATE_TEST_CASE_P(MetadataDatabaseTestWithIndexesOnDisk,
                         MetadataDatabaseTest,
                         ::testing::Values(true, false));
 
 TEST_P(MetadataDatabaseTest, InitializationTest_Empty) {
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
   DropDatabase();
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
 
   DropDatabase();
 
-  scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
+  std::unique_ptr<LevelDBWrapper> db = InitializeLevelDB();
   db->Put(kServiceMetadataKey, "Unparsable string");
   EXPECT_TRUE(db->Commit().ok());
   db.reset();
 
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
 }
 
 TEST_P(MetadataDatabaseTest, InitializationTest_SimpleTree) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedFolder(sync_root, "app_id"));
@@ skipping 88 matching lines @@
 
   FileMetadata file(CreateFileMetadata(folder, "file"));
   FileTracker file_tracker(CreateTracker(folder_tracker, file));
 
   FileMetadata inactive_folder(CreateFolderMetadata(app_root, "folder"));
   FileTracker inactive_folder_tracker(CreateTracker(app_root_tracker,
                                                     inactive_folder));
   inactive_folder_tracker.set_active(false);
 
   {
-    scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
+    std::unique_ptr<LevelDBWrapper> db = InitializeLevelDB();
     ASSERT_TRUE(db);
 
     EXPECT_TRUE(PutFileToDB(db.get(), sync_root).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), sync_root_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), app_root).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), app_root_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), folder).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), file).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), file_tracker).ok());
@@ skipping 32 matching lines @@
   FileTracker folder_tracker2(CreateTracker(folder_tracker1, folder2));
   FileMetadata file(CreateFileMetadata(folder2, "file"));
   FileTracker file_tracker(CreateTracker(folder_tracker2, file));
 
   FileMetadata inactive_folder(CreateFolderMetadata(app_root, "folder1"));
   FileTracker inactive_folder_tracker(CreateTracker(app_root_tracker,
                                                     inactive_folder));
   inactive_folder_tracker.set_active(false);
 
   {
-    scoped_ptr<LevelDBWrapper> db = InitializeLevelDB();
+    std::unique_ptr<LevelDBWrapper> db = InitializeLevelDB();
     ASSERT_TRUE(db);
 
     EXPECT_TRUE(PutFileToDB(db.get(), sync_root).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), sync_root_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), app_root).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), app_root_tracker).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), folder1).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker1).ok());
     EXPECT_TRUE(PutFileToDB(db.get(), folder2).ok());
     EXPECT_TRUE(PutTrackerToDB(db.get(), folder_tracker2).ok());
@@ skipping 289 matching lines @@
 
 TEST_P(MetadataDatabaseTest, PopulateInitialDataTest) {
   TrackedFile sync_root(CreateTrackedSyncRoot());
   TrackedFile app_root(CreateTrackedFolder(sync_root, "app_root"));
   app_root.tracker.set_active(false);
 
   const TrackedFile* tracked_files[] = {
     &sync_root, &app_root
   };
 
-  scoped_ptr<google_apis::FileResource> sync_root_folder(
+  std::unique_ptr<google_apis::FileResource> sync_root_folder(
       CreateFileResourceFromMetadata(sync_root.metadata));
-  scoped_ptr<google_apis::FileResource> app_root_folder(
+  std::unique_ptr<google_apis::FileResource> app_root_folder(
       CreateFileResourceFromMetadata(app_root.metadata));
 
   ScopedVector<google_apis::FileResource> app_root_folders;
   app_root_folders.push_back(app_root_folder.release());
 
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
   EXPECT_EQ(SYNC_STATUS_OK, PopulateInitialData(
       current_change_id(),
       *sync_root_folder,
       app_root_folders));
@@ skipping 15 matching lines @@
   TrackedFile file_0(CreateTrackedFile(folder_0, "file_0"));
 
   const TrackedFile* tracked_files[] = {
     &sync_root, &app_root, &folder_0, &file_0
   };
 
   SetUpDatabaseByTrackedFiles(tracked_files, arraysize(tracked_files));
   EXPECT_EQ(SYNC_STATUS_OK, InitializeMetadataDatabase());
   VerifyTrackedFiles(tracked_files, arraysize(tracked_files));
 
-  scoped_ptr<base::ListValue> files =
+  std::unique_ptr<base::ListValue> files =
       metadata_database()->DumpFiles(app_root.tracker.app_id());
   ASSERT_EQ(2u, files->GetSize());
 
   base::DictionaryValue* file = nullptr;
   std::string str;
 
   ASSERT_TRUE(files->GetDictionary(0, &file));
   EXPECT_TRUE(file->GetString("title", &str) && str == "folder_0");
   EXPECT_TRUE(file->GetString("type", &str) && str == "folder");
   EXPECT_TRUE(file->HasKey("details"));
 
   ASSERT_TRUE(files->GetDictionary(1, &file));
   EXPECT_TRUE(file->GetString("title", &str) && str == "file_0");
   EXPECT_TRUE(file->GetString("type", &str) && str == "file");
   EXPECT_TRUE(file->HasKey("details"));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system