Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/attachments/attachment_store_test_template.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 SYNC_INTERNAL_API_ATTACHMENTS_ATTACHMENT_STORE_TEST_TEMPLATE_H_
 #define SYNC_INTERNAL_API_ATTACHMENTS_ATTACHMENT_STORE_TEST_TEMPLATE_H_
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "sync/api/attachments/attachment.h"
 #include "sync/api/attachments/attachment_store.h"
 #include "sync/internal_api/public/attachments/attachment_util.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // AttachmentStoreTest defines tests for AttachmentStore. To instantiate these
@@ skipping 17 matching lines @@
 namespace syncer {
 
 const char kTestData1[] = "test data 1";
 const char kTestData2[] = "test data 2";
 
 template <typename AttachmentStoreFactory>
 class AttachmentStoreTest : public testing::Test {
  protected:
   AttachmentStoreFactory attachment_store_factory;
   base::MessageLoop message_loop;
-  scoped_ptr<AttachmentStore> store;
-  scoped_ptr<AttachmentStoreForSync> store_for_sync;
+  std::unique_ptr<AttachmentStore> store;
+  std::unique_ptr<AttachmentStoreForSync> store_for_sync;
   AttachmentStore::Result result;
-  scoped_ptr<AttachmentMap> attachments;
-  scoped_ptr<AttachmentIdList> failed_attachment_ids;
-  scoped_ptr<AttachmentMetadataList> attachment_metadata;
+  std::unique_ptr<AttachmentMap> attachments;
+  std::unique_ptr<AttachmentIdList> failed_attachment_ids;
+  std::unique_ptr<AttachmentMetadataList> attachment_metadata;
 
   AttachmentStore::ReadCallback read_callback;
   AttachmentStore::WriteCallback write_callback;
   AttachmentStore::DropCallback drop_callback;
   AttachmentStore::ReadMetadataCallback read_metadata_callback;
 
   scoped_refptr<base::RefCountedString> some_data1;
   scoped_refptr<base::RefCountedString> some_data2;
 
   AttachmentStoreTest() {}
@@ skipping 35 matching lines @@
     attachment_metadata.reset();
   }
 
   void CopyResult(AttachmentStore::Result* destination_result,
                   const AttachmentStore::Result& source_result) {
     *destination_result = source_result;
   }
 
   void CopyResultAttachments(
       AttachmentStore::Result* destination_result,
-      scoped_ptr<AttachmentMap>* destination_attachments,
-      scoped_ptr<AttachmentIdList>* destination_failed_attachment_ids,
+      std::unique_ptr<AttachmentMap>* destination_attachments,
+      std::unique_ptr<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_attachments = std::move(source_attachments);
     *destination_failed_attachment_ids =
         std::move(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);
   }
 };
 
 TYPED_TEST_CASE_P(AttachmentStoreTest);
 
 // Verify that CreateAttachmentStoreForSync() creates valid object.
 TYPED_TEST_P(AttachmentStoreTest, CreateAttachmentStoreForSync) {
-  scoped_ptr<AttachmentStoreForSync> attachment_store_for_sync =
+  std::unique_ptr<AttachmentStoreForSync> attachment_store_for_sync =
       this->store->CreateAttachmentStoreForSync();
   EXPECT_NE(nullptr, attachment_store_for_sync);
 }
 
 // Verify that we do not overwrite existing attachments and that we do not treat
 // it as an error.
 TYPED_TEST_P(AttachmentStoreTest, Write_NoOverwriteNoError) {
   // Create two attachments with the same id but different data.
   Attachment attachment1 = Attachment::Create(this->some_data1);
   Attachment attachment2 =
@@ skipping 367 matching lines @@
                            Read_OneNotFound,
                            Drop_DropTwoButOnlyOneExists,
                            Drop_DoesNotExist,
                            ReadMetadataById,
                            ReadMetadata,
                            SetSyncReference_DropSyncReference);
 
 }  // namespace syncer
 
 #endif  // SYNC_INTERNAL_API_ATTACHMENTS_ATTACHMENT_STORE_TEST_TEMPLATE_H_