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

chrome/browser/sync_file_system/drive_backend/drive_backend_sync_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 <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <stack>
 #include <utility>
 
@@ skipping 87 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> drive_task_runner =
         worker_pool->GetSequencedTaskRunnerWithShutdownBehavior(
             worker_pool->GetSequenceToken(),
             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 
     RegisterSyncableFileSystem();
     local_sync_service_ = LocalFileSyncService::CreateForTesting(
         &profile_, in_memory_env_.get());
     local_sync_service_->AddChangeObserver(this);
 
-    scoped_ptr<drive::FakeDriveService>
-        drive_service(new drive::FakeDriveService);
+    std::unique_ptr<drive::FakeDriveService> drive_service(
+        new drive::FakeDriveService);
     drive_service->Initialize("test@example.com");
     ASSERT_TRUE(drive::test_util::SetUpTestEntries(drive_service.get()));
 
-    scoped_ptr<drive::DriveUploaderInterface> uploader(
-        new drive::DriveUploader(drive_service.get(),
-                                 file_task_runner_.get()));
+    std::unique_ptr<drive::DriveUploaderInterface> uploader(
+        new drive::DriveUploader(drive_service.get(), file_task_runner_.get()));
 
     fake_drive_service_helper_.reset(new FakeDriveServiceHelper(
         drive_service.get(), uploader.get(),
         kSyncRootFolderTitle));
 
     remote_sync_service_.reset(
         new SyncEngine(base::ThreadTaskRunnerHandle::Get(),  // ui_task_runner
                        worker_task_runner_.get(),
                        drive_task_runner.get(),
                        worker_pool.get(),
@@ skipping 192 matching lines @@
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     storage::FileSystemURL url;
     base::RunLoop run_loop;
     remote_sync_service_->ProcessRemoteChange(base::Bind(
         &SetSyncStatusAndUrl, run_loop.QuitClosure(), &status, &url));
     run_loop.Run();
     return status;
   }
 
   int64_t GetLargestChangeID() {
-    scoped_ptr<google_apis::AboutResource> about_resource;
+    std::unique_ptr<google_apis::AboutResource> about_resource;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_service_helper()->GetAboutResource(&about_resource));
     if (!about_resource)
       return 0;
     return about_resource->largest_change_id();
   }
 
   void FetchRemoteChanges() {
     remote_sync_service_->OnNotificationReceived();
     WaitForIdleWorker();
@@ skipping 278 matching lines @@
 
   // MetadataDatabase is normally used on the worker thread.
   // Use this only when there is no task running on the worker.
   MetadataDatabase* metadata_database() {
     return sync_worker()->context_->metadata_database_.get();
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   base::ScopedTempDir base_dir_;
-  scoped_ptr<leveldb::Env> in_memory_env_;
+  std::unique_ptr<leveldb::Env> in_memory_env_;
   TestingProfile profile_;
 
-  scoped_ptr<SyncEngine> remote_sync_service_;
-  scoped_ptr<LocalFileSyncService> local_sync_service_;
+  std::unique_ptr<SyncEngine> remote_sync_service_;
+  std::unique_ptr<LocalFileSyncService> local_sync_service_;
 
   int64_t pending_remote_changes_;
   int64_t pending_local_changes_;
 
-  scoped_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
+  std::unique_ptr<FakeDriveServiceHelper> fake_drive_service_helper_;
   std::map<std::string, CannedSyncableFileSystem*> file_systems_;
 
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<base::SequencedTaskRunner> worker_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(DriveBackendSyncTest);
 };
 
@@ skipping 1077 matching lines @@
 
   EXPECT_EQ(1u, CountApp());
   EXPECT_EQ(1u, CountLocalFile(app_id));
 
   EXPECT_EQ(2u, CountMetadata());
   EXPECT_EQ(2u, CountTracker());
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system