Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/attachments/attachment_store_frontend_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/attachment_store_frontend.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "sync/api/attachments/attachment.h"
 #include "sync/api/attachments/attachment_id.h"
 #include "sync/api/attachments/attachment_store_backend.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
@@ skipping 79 matching lines @@
       : init_call_count_(0),
         read_call_count_(0),
         write_call_count_(0),
         add_component_call_count_(0),
         drop_call_count_(0),
         read_metadata_by_id_call_count_(0),
         read_metadata_call_count_(0),
         dtor_call_count_(0) {}
 
   void SetUp() override {
-    scoped_ptr<AttachmentStoreBackend> backend(new MockAttachmentStore(
+    std::unique_ptr<AttachmentStoreBackend> backend(new MockAttachmentStore(
         base::Bind(&AttachmentStoreFrontendTest::InitCalled,
                    base::Unretained(this)),
         base::Bind(&AttachmentStoreFrontendTest::ReadCalled,
                    base::Unretained(this)),
         base::Bind(&AttachmentStoreFrontendTest::WriteCalled,
                    base::Unretained(this)),
         base::Bind(&AttachmentStoreFrontendTest::SetReferenceCalled,
                    base::Unretained(this)),
         base::Bind(&AttachmentStoreFrontendTest::DropReferenceCalled,
                    base::Unretained(this)),
         base::Bind(&AttachmentStoreFrontendTest::ReadMetadataByIdCalled,
                    base::Unretained(this)),
         base::Bind(&AttachmentStoreFrontendTest::ReadMetadataCalled,
                    base::Unretained(this)),
         base::Bind(&AttachmentStoreFrontendTest::DtorCalled,
                    base::Unretained(this))));
     attachment_store_frontend_ = new AttachmentStoreFrontend(
         std::move(backend), base::ThreadTaskRunnerHandle::Get());
   }
 
   static void DoneWithResult(const AttachmentStore::Result& result) {
     NOTREACHED();
   }
 
-  static void ReadDone(const AttachmentStore::Result& result,
-                       scoped_ptr<AttachmentMap> attachments,
-                       scoped_ptr<AttachmentIdList> unavailable_attachments) {
+  static void ReadDone(
+      const AttachmentStore::Result& result,
+      std::unique_ptr<AttachmentMap> attachments,
+      std::unique_ptr<AttachmentIdList> unavailable_attachments) {
     NOTREACHED();
   }
 
-  static void ReadMetadataDone(const AttachmentStore::Result& result,
-                               scoped_ptr<AttachmentMetadataList> metadata) {
+  static void ReadMetadataDone(
+      const AttachmentStore::Result& result,
+      std::unique_ptr<AttachmentMetadataList> metadata) {
     NOTREACHED();
   }
 
   void InitCalled() { ++init_call_count_; }
 
   void ReadCalled() { ++read_call_count_; }
 
   void WriteCalled() { ++write_call_count_; }
 
   void SetReferenceCalled() { ++add_component_call_count_; }
@@ skipping 73 matching lines @@
 
   // Releasing referehce to AttachmentStoreFrontend should result in
   // MockAttachmentStore being deleted on backend loop.
   attachment_store_frontend_ = NULL;
   EXPECT_EQ(dtor_call_count_, 0);
   RunMessageLoop();
   EXPECT_EQ(dtor_call_count_, 1);
 }
 
 }  // namespace syncer