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

chrome/browser/chromeos/file_manager/external_filesystem_apitest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 145 matching lines @@
   if (!google_apis::test_util::WriteStringToFile(test_file, kTestFileContent))
     return false;
 
   test_file = test_dir.AppendASCII("empty_test_file.foo");
   if (!google_apis::test_util::WriteStringToFile(test_file, ""))
     return false;
 
   return true;
 }
 
-scoped_ptr<google_apis::FileResource> UpdateDriveEntryTime(
+std::unique_ptr<google_apis::FileResource> UpdateDriveEntryTime(
     drive::FakeDriveService* fake_drive_service,
     const std::string& resource_id,
     const std::string& last_modified,
     const std::string& last_viewed_by_me) {
   base::Time last_modified_time, last_viewed_by_me_time;
   if (!google_apis::util::GetTimeFromString(last_modified,
                                             &last_modified_time) ||
       !google_apis::util::GetTimeFromString(last_viewed_by_me,
                                             &last_viewed_by_me_time))
-    return scoped_ptr<google_apis::FileResource>();
+    return std::unique_ptr<google_apis::FileResource>();
 
   google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
-  scoped_ptr<google_apis::FileResource> entry;
+  std::unique_ptr<google_apis::FileResource> entry;
   fake_drive_service->UpdateResource(
       resource_id,
       std::string(),  // parent_resource_id
       std::string(),  // title
       last_modified_time, last_viewed_by_me_time,
       google_apis::drive::Properties(),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
   if (error != google_apis::HTTP_SUCCESS)
-    return scoped_ptr<google_apis::FileResource>();
+    return std::unique_ptr<google_apis::FileResource>();
 
   return entry;
 }
 
-scoped_ptr<google_apis::FileResource> AddFileToDriveService(
+std::unique_ptr<google_apis::FileResource> AddFileToDriveService(
     drive::FakeDriveService* fake_drive_service,
     const std::string& mime_type,
     const std::string& content,
     const std::string& parent_resource_id,
     const std::string& title,
     const std::string& last_modified,
     const std::string& last_viewed_by_me) {
   google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
-  scoped_ptr<google_apis::FileResource> entry;
+  std::unique_ptr<google_apis::FileResource> entry;
   fake_drive_service->AddNewFile(
       mime_type,
       content,
       parent_resource_id,
       title,
       false,  // shared_with_me
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
   if (error != google_apis::HTTP_CREATED)
-    return scoped_ptr<google_apis::FileResource>();
+    return std::unique_ptr<google_apis::FileResource>();
 
   return UpdateDriveEntryTime(fake_drive_service, entry->file_id(),
                               last_modified, last_viewed_by_me);
 }
 
-scoped_ptr<google_apis::FileResource> AddDirectoryToDriveService(
+std::unique_ptr<google_apis::FileResource> AddDirectoryToDriveService(
     drive::FakeDriveService* fake_drive_service,
     const std::string& parent_resource_id,
     const std::string& title,
     const std::string& last_modified,
     const std::string& last_viewed_by_me) {
   google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
-  scoped_ptr<google_apis::FileResource> entry;
+  std::unique_ptr<google_apis::FileResource> entry;
   fake_drive_service->AddNewDirectory(
       parent_resource_id, title, drive::AddNewDirectoryOptions(),
       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
   if (error != google_apis::HTTP_CREATED)
-    return scoped_ptr<google_apis::FileResource>();
+    return std::unique_ptr<google_apis::FileResource>();
 
   return UpdateDriveEntryTime(fake_drive_service, entry->file_id(),
                               last_modified, last_viewed_by_me);
 }
 
 // Sets up the drive service state.
 // The hierarchy is the same as for the local file system.
 bool InitializeDriveService(
     drive::FakeDriveService* fake_drive_service,
     std::map<std::string, std::string>* out_resource_ids) {
-  scoped_ptr<google_apis::FileResource> entry;
+  std::unique_ptr<google_apis::FileResource> entry;
 
   entry = AddDirectoryToDriveService(fake_drive_service,
                                      fake_drive_service->GetRootResourceId(),
                                      "test_dir",
                                      "2012-01-02T00:00:00.000Z",
                                      "2012-01-02T00:00:01.000Z");
   if (!entry)
     return false;
   (*out_resource_ids)[entry->title()] = entry->file_id();
 
@@ skipping 292 matching lines @@
     EXPECT_TRUE(InitializeDriveService(fake_drive_service_, &resource_ids));
 
     return new drive::DriveIntegrationService(
         profile, NULL, fake_drive_service_, "", test_cache_root_.path(), NULL);
   }
 
   base::ScopedTempDir test_cache_root_;
   drive::FakeDriveService* fake_drive_service_;
   DriveIntegrationServiceFactory::FactoryCallback
       create_drive_integration_service_;
-  scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
+  std::unique_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
       service_factory_for_test_;
 };
 
 // Tests for Drive file systems in multi-profile setting.
 class MultiProfileDriveFileSystemExtensionApiTest :
     public FileSystemExtensionApiTestBase {
  public:
   MultiProfileDriveFileSystemExtensionApiTest() : second_profile_(NULL) {}
 
   void SetUpOnMainThread() override {
@@ skipping 51 matching lines @@
   bool AddTestHostedDocuments() {
     const char kResourceId[] = "unique-id-for-multiprofile-copy-test";
     drive::FakeDriveService* const main_service =
         static_cast<drive::FakeDriveService*>(
             drive::util::GetDriveServiceByProfile(browser()->profile()));
     drive::FakeDriveService* const sub_service =
         static_cast<drive::FakeDriveService*>(
             drive::util::GetDriveServiceByProfile(second_profile_));
 
     google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
-    scoped_ptr<google_apis::FileResource> entry;
+    std::unique_ptr<google_apis::FileResource> entry;
 
     // Place a hosted document under root/test_dir of the sub profile.
     sub_service->AddNewFileWithResourceId(
         kResourceId,
         "application/vnd.google-apps.document", "",
         resource_ids_["test_dir"], "hosted_doc", true,
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     content::RunAllBlockingPoolTasksUntilIdle();
     if (error != google_apis::HTTP_CREATED)
       return false;
 
     // Place the hosted document with no parent in the main profile, for
     // simulating the situation that the document is shared to the main profile.
     error = google_apis::DRIVE_OTHER_ERROR;
     main_service->AddNewFileWithResourceId(
         kResourceId,
         "application/vnd.google-apps.document", "", "", "hosted_doc", true,
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     content::RunAllBlockingPoolTasksUntilIdle();
     return (error == google_apis::HTTP_CREATED);
   }
 
   base::ScopedTempDir tmp_dir_;
   DriveIntegrationServiceFactory::FactoryCallback
       create_drive_integration_service_;
-  scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
+  std::unique_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
       service_factory_for_test_;
   Profile* second_profile_;
   std::map<std::string, std::string> resource_ids_;
 };
 
 class LocalAndDriveFileSystemExtensionApiTest
     : public FileSystemExtensionApiTestBase {
  public:
   LocalAndDriveFileSystemExtensionApiTest() {}
   ~LocalAndDriveFileSystemExtensionApiTest() override {}
@@ skipping 53 matching lines @@
  private:
   // For local volume.
   base::ScopedTempDir local_tmp_dir_;
   base::FilePath local_mount_point_dir_;
 
   // For drive volume.
   base::ScopedTempDir test_cache_root_;
   drive::FakeDriveService* fake_drive_service_;
   DriveIntegrationServiceFactory::FactoryCallback
       create_drive_integration_service_;
-  scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
+  std::unique_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
       service_factory_for_test_;
 };
 
 //
 // LocalFileSystemExtensionApiTests.
 //
 
 IN_PROC_BROWSER_TEST_F(LocalFileSystemExtensionApiTest, FileSystemOperations) {
   EXPECT_TRUE(RunFileSystemExtensionApiTest(
       "file_browser/filesystem_operations_test",
@@ skipping 119 matching lines @@
                        AppFileHandlerMulti) {
   EXPECT_TRUE(
       RunFileSystemExtensionApiTest("file_browser/app_file_handler_multi",
                                     FILE_PATH_LITERAL("manifest.json"),
                                     "",
                                     FLAGS_NONE))
       << message_;
 }
 }  // namespace
 }  // namespace file_manager