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

chrome/browser/extensions/api/file_system/file_system_apitest_chromeos.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 "chrome/browser/extensions/api/file_system/file_system_api.h"
 
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
@@ skipping 111 matching lines @@
     service_factory_for_test_.reset(
         new drive::DriveIntegrationServiceFactory::ScopedFactoryForTest(
             &create_drive_integration_service_));
   }
 
   // Ensure the fake service's data is fetch in the local file system. This is
   // necessary because the fetch starts lazily upon the first read operation.
   void SetUpOnMainThread() override {
     PlatformAppBrowserTest::SetUpOnMainThread();
 
-    scoped_ptr<drive::ResourceEntry> entry;
+    std::unique_ptr<drive::ResourceEntry> entry;
     drive::FileError error = drive::FILE_ERROR_FAILED;
     integration_service_->file_system()->GetResourceEntry(
         base::FilePath::FromUTF8Unsafe("drive/root"),  // whatever
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     content::RunAllBlockingPoolTasksUntilIdle();
     ASSERT_EQ(drive::FILE_ERROR_OK, error);
   }
 
   void TearDown() override {
     FileSystemChooseEntryFunction::StopSkippingPickerForTest();
@@ skipping 28 matching lines @@
     ASSERT_TRUE(AddTestFile("open_existing2.txt", "Can you see me?", root));
     ASSERT_TRUE(AddTestFile("save_existing.txt", "Can you see me?", root));
     const std::string subdir = AddTestDirectory("subdir", root);
     ASSERT_FALSE(subdir.empty());
     ASSERT_TRUE(AddTestFile("open_existing.txt", "Can you see me?", subdir));
   }
 
   bool AddTestFile(const std::string& title,
                    const std::string& data,
                    const std::string& parent_id) {
-    scoped_ptr<google_apis::FileResource> entry;
+    std::unique_ptr<google_apis::FileResource> entry;
     google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
     fake_drive_service_->AddNewFile(
         "text/plain", data, parent_id, title, false,
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     content::RunAllPendingInMessageLoop();
     return error == google_apis::HTTP_CREATED && entry;
   }
 
   std::string AddTestDirectory(const std::string& title,
                                const std::string& parent_id) {
-    scoped_ptr<google_apis::FileResource> entry;
+    std::unique_ptr<google_apis::FileResource> entry;
     google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
     fake_drive_service_->AddNewDirectory(
         parent_id, title, drive::AddNewDirectoryOptions(),
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     content::RunAllPendingInMessageLoop();
     return error == google_apis::HTTP_CREATED && entry ? entry->file_id() : "";
   }
 
   base::ScopedTempDir test_cache_root_;
   drive::FakeDriveService* fake_drive_service_;
   drive::DriveIntegrationService* integration_service_;
   drive::DriveIntegrationServiceFactory::FactoryCallback
       create_drive_integration_service_;
-  scoped_ptr<drive::DriveIntegrationServiceFactory::ScopedFactoryForTest>
+  std::unique_ptr<drive::DriveIntegrationServiceFactory::ScopedFactoryForTest>
       service_factory_for_test_;
 };
 
 // This class contains chrome.filesystem.requestFileSystem API tests.
 class FileSystemApiTestForRequestFileSystem : public PlatformAppBrowserTest {
  public:
   FileSystemApiTestForRequestFileSystem() : fake_user_manager_(nullptr) {}
 
   void SetUpOnMainThread() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
@@ skipping 14 matching lines @@
         VolumeManager::Get(browser()->profile());
     ASSERT_TRUE(volume_manager);
     volume_manager->AddVolumeForTesting(
         base::FilePath("/a/b/c"), file_manager::VOLUME_TYPE_TESTING,
         chromeos::DEVICE_TYPE_UNKNOWN, false /* read_only */);
   }
 
  protected:
   base::ScopedTempDir temp_dir_;
   chromeos::FakeChromeUserManager* fake_user_manager_;
-  scoped_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
+  std::unique_ptr<chromeos::ScopedUserManagerEnabler> user_manager_enabler_;
 
   // Creates a testing file system in a testing directory.
   void CreateTestingFileSystem(const std::string& mount_point_name,
                                bool read_only) {
     const base::FilePath mount_point_path =
         temp_dir_.path().Append(mount_point_name);
     ASSERT_TRUE(base::CreateDirectory(mount_point_path));
     ASSERT_TRUE(
         base::CreateDirectory(mount_point_path.Append(kChildDirectory)));
     ASSERT_TRUE(content::BrowserContext::GetMountPoints(browser()->profile())
@@ skipping 241 matching lines @@
       profile(), extensions::api::file_system::OnVolumeListChanged::kEventName,
       kTestingExtensionId,
       base::Bind(&FileSystemApiTestForRequestFileSystem::MountFakeVolume,
                  this));
 
   ASSERT_TRUE(RunPlatformAppTest("api_test/file_system/on_volume_list_changed"))
       << message_;
 }
 
 }  // namespace extensions