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

chrome/browser/chromeos/extensions/file_manager/private_api_tasks.cc

 // Copyright 2013 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/extensions/file_manager/private_api_tasks.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
@@ skipping 51 matching lines @@
   }
   return mime_types;
 }
 
 }  // namespace
 
 bool FileManagerPrivateInternalExecuteTaskFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::ExecuteTask::Params;
   using extensions::api::file_manager_private_internal::ExecuteTask::Results::
       Create;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   file_manager::file_tasks::TaskDescriptor task;
   if (!file_manager::file_tasks::ParseTaskID(params->task_id, &task)) {
     SetError(kInvalidTask + params->task_id);
     results_ =
         Create(extensions::api::file_manager_private::TASK_RESULT_FAILED);
     return false;
   }
 
@@ skipping 40 matching lines @@
 }
 
 FileManagerPrivateInternalGetFileTasksFunction::
     FileManagerPrivateInternalGetFileTasksFunction() {}
 
 FileManagerPrivateInternalGetFileTasksFunction::
     ~FileManagerPrivateInternalGetFileTasksFunction() {}
 
 bool FileManagerPrivateInternalGetFileTasksFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::GetFileTasks::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   if (params->urls.empty())
     return false;
 
   const scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderFrameHost(
           GetProfile(), render_frame_host());
 
   // Collect all the URLs, convert them to GURLs, and crack all the urls into
@@ skipping 12 matching lines @@
   mime_type_collector_->CollectForLocalPaths(
       local_paths_,
       base::Bind(
           &FileManagerPrivateInternalGetFileTasksFunction::OnMimeTypesCollected,
           this));
 
   return true;
 }
 
 void FileManagerPrivateInternalGetFileTasksFunction::OnMimeTypesCollected(
-    scoped_ptr<std::vector<std::string>> mime_types) {
+    std::unique_ptr<std::vector<std::string>> mime_types) {
   is_directory_collector_.reset(
       new app_file_handler_util::IsDirectoryCollector(GetProfile()));
   is_directory_collector_->CollectForEntriesPaths(
       local_paths_, base::Bind(&FileManagerPrivateInternalGetFileTasksFunction::
                                    OnAreDirectoriesAndMimeTypesCollected,
                                this, base::Passed(std::move(mime_types))));
 }
 
 void FileManagerPrivateInternalGetFileTasksFunction::
     OnAreDirectoriesAndMimeTypesCollected(
-        scoped_ptr<std::vector<std::string>> mime_types,
-        scoped_ptr<std::set<base::FilePath>> directory_paths) {
+        std::unique_ptr<std::vector<std::string>> mime_types,
+        std::unique_ptr<std::set<base::FilePath>> directory_paths) {
   std::vector<EntryInfo> entries;
   for (size_t i = 0; i < local_paths_.size(); ++i) {
     entries.push_back(EntryInfo(
         local_paths_[i], (*mime_types)[i],
         directory_paths->find(local_paths_[i]) != directory_paths->end()));
   }
 
   std::vector<file_manager::file_tasks::FullTaskDescriptor> tasks;
   file_manager::file_tasks::FindAllTypesOfTasks(
       GetProfile(), drive::util::GetDriveAppRegistryByProfile(GetProfile()),
@@ skipping 14 matching lines @@
     results.push_back(std::move(converted));
   }
 
   results_ = extensions::api::file_manager_private_internal::GetFileTasks::
       Results::Create(results);
   SendResponse(true);
 }
 
 bool FileManagerPrivateInternalSetDefaultTaskFunction::RunSync() {
   using extensions::api::file_manager_private_internal::SetDefaultTask::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderFrameHost(
           GetProfile(), render_frame_host());
 
   const std::set<std::string> suffixes =
       GetUniqueSuffixes(params->urls, file_system_context.get());
   const std::set<std::string> mime_types =
       GetUniqueMimeTypes(params->mime_types);
 
   // If there weren't any mime_types, and all the suffixes were blank,
   // then we "succeed", but don't actually associate with anything.
   // Otherwise, any time we set the default on a file with no extension
   // on the local drive, we'd fail.
   // TODO(gspencer): Fix file manager so that it never tries to set default in
   // cases where extensionless local files are part of the selection.
   if (suffixes.empty() && mime_types.empty()) {
     SetResult(new base::FundamentalValue(true));
     return true;
   }
 
   file_manager::file_tasks::UpdateDefaultTask(
       GetProfile()->GetPrefs(), params->task_id, suffixes, mime_types);
   return true;
 }
 
 }  // namespace extensions