Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/attachments/on_disk_attachment_store_unittest.cc

 // 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.
 
 #include "sync/internal_api/public/attachments/on_disk_attachment_store.h"
 
 #include <stdint.h>
+
 #include <string>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "sync/internal_api/attachments/attachment_store_test_template.h"
 #include "sync/internal_api/attachments/proto/attachment_store.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
@@ skipping 10 matching lines @@
 }
 
 }  // namespace
 
 // Instantiation of common attachment store tests.
 class OnDiskAttachmentStoreFactory {
  public:
   OnDiskAttachmentStoreFactory() {}
   ~OnDiskAttachmentStoreFactory() {}
 
-  scoped_ptr<AttachmentStore> CreateAttachmentStore() {
+  std::unique_ptr<AttachmentStore> CreateAttachmentStore() {
     EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
-    scoped_ptr<AttachmentStore> store;
+    std::unique_ptr<AttachmentStore> store;
     AttachmentStore::Result result = AttachmentStore::UNSPECIFIED_ERROR;
     store = AttachmentStore::CreateOnDiskStore(
         temp_dir_.path(), base::ThreadTaskRunnerHandle::Get(),
         base::Bind(&AttachmentStoreCreated, &result));
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
     EXPECT_EQ(AttachmentStore::SUCCESS, result);
     return store;
   }
 
  private:
   base::ScopedTempDir temp_dir_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(OnDisk,
                               AttachmentStoreTest,
                               OnDiskAttachmentStoreFactory);
 
 // Tests specific to OnDiskAttachmentStore.
 class OnDiskAttachmentStoreSpecificTest : public testing::Test {
  public:
   base::ScopedTempDir temp_dir_;
   base::FilePath db_path_;
   base::MessageLoop message_loop_;
-  scoped_ptr<AttachmentStore> store_;
+  std::unique_ptr<AttachmentStore> store_;
 
   OnDiskAttachmentStoreSpecificTest() {}
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     db_path_ = temp_dir_.path().Append(FILE_PATH_LITERAL("leveldb"));
     base::CreateDirectory(db_path_);
   }
 
   void CopyResult(AttachmentStore::Result* destination_result,
                   const AttachmentStore::Result& source_result) {
     *destination_result = source_result;
   }
 
   void CopyResultAttachments(
       AttachmentStore::Result* destination_result,
       AttachmentIdList* destination_failed_attachment_ids,
       const AttachmentStore::Result& source_result,
-      scoped_ptr<AttachmentMap> source_attachments,
-      scoped_ptr<AttachmentIdList> source_failed_attachment_ids) {
+      std::unique_ptr<AttachmentMap> source_attachments,
+      std::unique_ptr<AttachmentIdList> source_failed_attachment_ids) {
     CopyResult(destination_result, source_result);
     *destination_failed_attachment_ids = *source_failed_attachment_ids;
   }
 
   void CopyResultMetadata(
       AttachmentStore::Result* destination_result,
-      scoped_ptr<AttachmentMetadataList>* destination_metadata,
+      std::unique_ptr<AttachmentMetadataList>* destination_metadata,
       const AttachmentStore::Result& source_result,
-      scoped_ptr<AttachmentMetadataList> source_metadata) {
+      std::unique_ptr<AttachmentMetadataList> source_metadata) {
     CopyResult(destination_result, source_result);
     *destination_metadata = std::move(source_metadata);
   }
 
-  scoped_ptr<leveldb::DB> OpenLevelDB() {
+  std::unique_ptr<leveldb::DB> OpenLevelDB() {
     leveldb::DB* db;
     leveldb::Options options;
     options.create_if_missing = true;
     leveldb::Status s =
         leveldb::DB::Open(options, db_path_.AsUTF8Unsafe(), &db);
     EXPECT_TRUE(s.ok());
-    return make_scoped_ptr(db);
+    return base::WrapUnique(db);
   }
 
   void UpdateRecord(const std::string& key, const std::string& content) {
-    scoped_ptr<leveldb::DB> db = OpenLevelDB();
+    std::unique_ptr<leveldb::DB> db = OpenLevelDB();
     leveldb::Status s = db->Put(leveldb::WriteOptions(), key, content);
     EXPECT_TRUE(s.ok());
   }
 
   void UpdateStoreMetadataRecord(const std::string& content) {
     UpdateRecord("database-metadata", content);
   }
 
   void UpdateAttachmentMetadataRecord(const AttachmentId& attachment_id,
                                       const std::string& content) {
     std::string metadata_key =
         OnDiskAttachmentStore::MakeMetadataKeyFromAttachmentId(attachment_id);
     UpdateRecord(metadata_key, content);
   }
 
   std::string ReadStoreMetadataRecord() {
-    scoped_ptr<leveldb::DB> db = OpenLevelDB();
+    std::unique_ptr<leveldb::DB> db = OpenLevelDB();
     std::string content;
     leveldb::Status s =
         db->Get(leveldb::ReadOptions(), "database-metadata", &content);
     EXPECT_TRUE(s.ok());
     return content;
   }
 
   void VerifyAttachmentRecordsPresent(const AttachmentId& attachment_id,
                                       bool expect_records_present) {
-    scoped_ptr<leveldb::DB> db = OpenLevelDB();
+    std::unique_ptr<leveldb::DB> db = OpenLevelDB();
 
     std::string metadata_key =
         OnDiskAttachmentStore::MakeMetadataKeyFromAttachmentId(attachment_id);
     std::string data_key =
         OnDiskAttachmentStore::MakeDataKeyFromAttachmentId(attachment_id);
     std::string data;
     leveldb::Status s = db->Get(leveldb::ReadOptions(), data_key, &data);
     if (expect_records_present)
       EXPECT_TRUE(s.ok());
     else
@@ skipping 297 matching lines @@
   UpdateRecord("zzz", "foobar");
 
   // Create attachment store.
   AttachmentStore::Result create_result = AttachmentStore::UNSPECIFIED_ERROR;
   store_ = AttachmentStore::CreateOnDiskStore(
       temp_dir_.path(), base::ThreadTaskRunnerHandle::Get(),
       base::Bind(&AttachmentStoreCreated, &create_result));
 
   // Read all metadata. Should be getting no error and zero entries.
   AttachmentStore::Result metadata_result = AttachmentStore::UNSPECIFIED_ERROR;
-  scoped_ptr<AttachmentMetadataList> metadata_list;
+  std::unique_ptr<AttachmentMetadataList> metadata_list;
   store_->ReadMetadata(
       base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResultMetadata,
                  base::Unretained(this), &metadata_result, &metadata_list));
   RunLoop();
   EXPECT_EQ(AttachmentStore::SUCCESS, create_result);
   EXPECT_EQ(AttachmentStore::SUCCESS, metadata_result);
   EXPECT_EQ(0U, metadata_list->size());
   metadata_list.reset();
 
   // Write 3 attachments to the store
@@ skipping 41 matching lines @@
   store_->ReadMetadata(
       base::Bind(&OnDiskAttachmentStoreSpecificTest::CopyResultMetadata,
                  base::Unretained(this), &metadata_result, &metadata_list));
   RunLoop();
   EXPECT_EQ(AttachmentStore::SUCCESS, create_result);
   EXPECT_EQ(AttachmentStore::UNSPECIFIED_ERROR, metadata_result);
   EXPECT_EQ(2U, metadata_list->size());
 }
 
 }  // namespace syncer