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

chrome/browser/chromeos/extensions/file_manager/private_api_misc.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_misc.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 177 matching lines @@
   SetResult(result.ToValue().release());
 
   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
   if (logger)
     logger->Log(logging::LOG_INFO, "%s succeeded.", name());
   return true;
 }
 
 bool FileManagerPrivateSetPreferencesFunction::RunSync() {
   using extensions::api::file_manager_private::SetPreferences::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   PrefService* const service = GetProfile()->GetPrefs();
 
   if (params->change_info.cellular_disabled)
     service->SetBoolean(drive::prefs::kDisableDriveOverCellular,
                         *params->change_info.cellular_disabled);
 
   if (params->change_info.hosted_files_disabled)
     service->SetBoolean(drive::prefs::kDisableDriveHostedFiles,
                         *params->change_info.hosted_files_disabled);
 
   drive::EventLogger* logger = file_manager::util::GetLogger(GetProfile());
   if (logger)
     logger->Log(logging::LOG_INFO, "%s succeeded.", name());
   return true;
 }
 
 FileManagerPrivateInternalZipSelectionFunction::
     FileManagerPrivateInternalZipSelectionFunction() {}
 
 FileManagerPrivateInternalZipSelectionFunction::
     ~FileManagerPrivateInternalZipSelectionFunction() {}
 
 bool FileManagerPrivateInternalZipSelectionFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::ZipSelection::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // First param is the parent directory URL.
   if (params->parent_url.empty())
     return false;
 
   base::FilePath src_dir = file_manager::util::GetLocalPathFromURL(
       render_frame_host(), GetProfile(), GURL(params->parent_url));
   if (src_dir.empty())
     return false;
@@ skipping 40 matching lines @@
   return true;
 }
 
 void FileManagerPrivateInternalZipSelectionFunction::OnZipDone(bool success) {
   SetResult(new base::FundamentalValue(success));
   SendResponse(true);
 }
 
 bool FileManagerPrivateZoomFunction::RunSync() {
   using extensions::api::file_manager_private::Zoom::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   content::PageZoom zoom_type;
   switch (params->operation) {
     case api::file_manager_private::ZOOM_OPERATION_TYPE_IN:
       zoom_type = content::PAGE_ZOOM_IN;
       break;
     case api::file_manager_private::ZOOM_OPERATION_TYPE_OUT:
       zoom_type = content::PAGE_ZOOM_OUT;
       break;
@@ skipping 91 matching lines @@
 
   results_ = api::file_manager_private::GetProfiles::Results::Create(
       profiles, current_profile_id.GetUserEmail(),
       display_profile_id.is_valid() ? display_profile_id.GetUserEmail()
                                     : current_profile_id.GetUserEmail());
   return true;
 }
 
 bool FileManagerPrivateOpenInspectorFunction::RunSync() {
   using extensions::api::file_manager_private::OpenInspector::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   switch (params->type) {
     case extensions::api::file_manager_private::INSPECTION_TYPE_NORMAL:
       // Open inspector for foreground page.
       DevToolsWindow::OpenDevToolsWindow(GetSenderWebContents());
       break;
     case extensions::api::file_manager_private::INSPECTION_TYPE_CONSOLE:
       // Open inspector for foreground page and bring focus to the console.
       DevToolsWindow::OpenDevToolsWindow(GetSenderWebContents(),
@@ skipping 22 matching lines @@
 FileManagerPrivateInternalGetMimeTypeFunction::
     FileManagerPrivateInternalGetMimeTypeFunction() {
 }
 
 FileManagerPrivateInternalGetMimeTypeFunction::
     ~FileManagerPrivateInternalGetMimeTypeFunction() {
 }
 
 bool FileManagerPrivateInternalGetMimeTypeFunction::RunAsync() {
   using extensions::api::file_manager_private_internal::GetMimeType::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Convert file url to local path.
   const scoped_refptr<storage::FileSystemContext> file_system_context =
       file_manager::util::GetFileSystemContextForRenderFrameHost(
           GetProfile(), render_frame_host());
 
   storage::FileSystemURL file_system_url(
       file_system_context->CrackURL(GURL(params->url)));
 
@@ skipping 65 matching lines @@
 }
 
 FileManagerPrivateAddProvidedFileSystemFunction::
     FileManagerPrivateAddProvidedFileSystemFunction()
     : chrome_details_(this) {
 }
 
 ExtensionFunction::ResponseAction
 FileManagerPrivateAddProvidedFileSystemFunction::Run() {
   using extensions::api::file_manager_private::AddProvidedFileSystem::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using chromeos::file_system_provider::Service;
   using chromeos::file_system_provider::ProvidingExtensionInfo;
   Service* const service = Service::Get(chrome_details_.GetProfile());
 
   if (!service->RequestMount(params->extension_id))
     return RespondNow(Error("Failed to request a new mount."));
 
   return RespondNow(NoArguments());
 }
 
 FileManagerPrivateConfigureVolumeFunction::
     FileManagerPrivateConfigureVolumeFunction()
     : chrome_details_(this) {
 }
 
 ExtensionFunction::ResponseAction
 FileManagerPrivateConfigureVolumeFunction::Run() {
   using extensions::api::file_manager_private::ConfigureVolume::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using file_manager::VolumeManager;
   using file_manager::Volume;
   VolumeManager* const volume_manager =
       VolumeManager::Get(chrome_details_.GetProfile());
   base::WeakPtr<Volume> volume =
       volume_manager->FindVolumeById(params->volume_id);
   if (!volume.get())
     return RespondNow(Error("Volume not found."));
@@ skipping 33 matching lines @@
 }
 
 FileManagerPrivateInternalGetCustomActionsFunction::
     FileManagerPrivateInternalGetCustomActionsFunction()
     : chrome_details_(this) {}
 
 ExtensionFunction::ResponseAction
 FileManagerPrivateInternalGetCustomActionsFunction::Run() {
   using extensions::api::file_manager_private_internal::GetCustomActions::
       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(
           chrome_details_.GetProfile(), render_frame_host());
 
   std::vector<base::FilePath> paths;
   chromeos::file_system_provider::ProvidedFileSystemInterface* file_system =
       nullptr;
   std::string error;
@@ skipping 35 matching lines @@
 }
 
 FileManagerPrivateInternalExecuteCustomActionFunction::
     FileManagerPrivateInternalExecuteCustomActionFunction()
     : chrome_details_(this) {}
 
 ExtensionFunction::ResponseAction
 FileManagerPrivateInternalExecuteCustomActionFunction::Run() {
   using extensions::api::file_manager_private_internal::ExecuteCustomAction::
       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(
           chrome_details_.GetProfile(), render_frame_host());
 
   std::vector<base::FilePath> paths;
   chromeos::file_system_provider::ProvidedFileSystemInterface* file_system =
       nullptr;
   std::string error;
@@ skipping 16 matching lines @@
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     Respond(Error("Failed to execute the action."));
     return;
   }
 
   Respond(NoArguments());
 }
 
 }  // namespace extensions