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

chrome/browser/chromeos/file_manager/file_manager_browsertest_base.cc

 // Copyright 2015 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/chromeos/file_manager/file_manager_browsertest_base.h"
 
 #include <stddef.h>
 
 #include <deque>
 
@@ skipping 358 matching lines @@
   DriveTestVolume() : TestVolume("drive"), integration_service_(NULL) {}
   ~DriveTestVolume() override {}
 
   void CreateEntry(const TestEntryInfo& entry) {
     const base::FilePath path =
         base::FilePath::FromUTF8Unsafe(entry.target_path);
     const std::string target_name = path.BaseName().AsUTF8Unsafe();
 
     // Obtain the parent entry.
     drive::FileError error = drive::FILE_ERROR_OK;
-    scoped_ptr<drive::ResourceEntry> parent_entry(new drive::ResourceEntry);
+    std::unique_ptr<drive::ResourceEntry> parent_entry(
+        new drive::ResourceEntry);
     integration_service_->file_system()->GetResourceEntry(
         drive::util::GetDriveMyDriveRootPath().Append(path).DirName(),
         google_apis::test_util::CreateCopyResultCallback(&error,
                                                          &parent_entry));
     content::RunAllBlockingPoolTasksUntilIdle();
     ASSERT_EQ(drive::FILE_ERROR_OK, error);
     ASSERT_TRUE(parent_entry);
 
     switch (entry.type) {
       case FILE:
         CreateFile(entry.source_file_name, parent_entry->resource_id(),
                    target_name, entry.mime_type, entry.shared_option == SHARED,
                    entry.last_modified_time);
         break;
       case DIRECTORY:
         CreateDirectory(parent_entry->resource_id(), target_name,
                         entry.last_modified_time);
         break;
     }
   }
 
   // Creates an empty directory with the given |name| and |modification_time|.
   void CreateDirectory(const std::string& parent_id,
                        const std::string& target_name,
                        const base::Time& modification_time) {
     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_id, target_name, drive::AddNewDirectoryOptions(),
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(google_apis::HTTP_CREATED, error);
     ASSERT_TRUE(entry);
 
     fake_drive_service_->SetLastModifiedTime(
         entry->file_id(), modification_time,
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
@@ skipping 12 matching lines @@
                   bool shared_with_me,
                   const base::Time& modification_time) {
     google_apis::DriveApiErrorCode error = google_apis::DRIVE_OTHER_ERROR;
 
     std::string content_data;
     if (!source_file_name.empty()) {
       base::FilePath source_file_path = GetTestFilePath(source_file_name);
       ASSERT_TRUE(base::ReadFileToString(source_file_path, &content_data));
     }
 
-    scoped_ptr<google_apis::FileResource> entry;
+    std::unique_ptr<google_apis::FileResource> entry;
     fake_drive_service_->AddNewFile(
         mime_type, content_data, parent_id, target_name, shared_with_me,
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
     base::MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(google_apis::HTTP_CREATED, error);
     ASSERT_TRUE(entry);
 
     fake_drive_service_->SetLastModifiedTime(
         entry->file_id(), modification_time,
         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
@@ skipping 119 matching lines @@
     if (entry.type == extensions::NOTIFICATION_EXTENSION_TEST_PASSED) {
       // Test succeed.
       break;
     } else if (entry.type == extensions::NOTIFICATION_EXTENSION_TEST_FAILED) {
       // Test failed.
       ADD_FAILURE() << entry.message;
       break;
     }
 
     // Parse the message value as JSON.
-    const scoped_ptr<const base::Value> value =
+    const std::unique_ptr<const base::Value> value =
         base::JSONReader::Read(entry.message);
 
     // If the message is not the expected format, just ignore it.
     const base::DictionaryValue* message_dictionary = NULL;
     std::string name;
     if (!value || !value->GetAsDictionary(&message_dictionary) ||
         !message_dictionary->GetString("name", &name))
       continue;
 
     std::string output;
@@ skipping 135 matching lines @@
 }
 
 drive::DriveIntegrationService*
 FileManagerBrowserTestBase::CreateDriveIntegrationService(Profile* profile) {
   drive_volumes_[profile->GetOriginalProfile()].reset(new DriveTestVolume());
   return drive_volumes_[profile->GetOriginalProfile()]
       ->CreateDriveIntegrationService(profile);
 }
 
 }  // namespace file_manager