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

chrome/browser/extensions/api/file_system/file_system_api.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 "chrome/browser/extensions/api/file_system/file_system_api.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "apps/saved_files_service.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 177 matching lines @@
 
 const int kGraylistedPaths[] = {
   base::DIR_HOME,
 #if defined(OS_WIN)
   base::DIR_PROGRAM_FILES,
   base::DIR_PROGRAM_FILESX86,
   base::DIR_WINDOWS,
 #endif
 };
 
-typedef base::Callback<void(scoped_ptr<base::File::Info>)> FileInfoOptCallback;
+typedef base::Callback<void(std::unique_ptr<base::File::Info>)>
+    FileInfoOptCallback;
 
 // Passes optional file info to the UI thread depending on |result| and |info|.
 void PassFileInfoToUIThread(const FileInfoOptCallback& callback,
                             base::File::Error result,
                             const base::File::Info& info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-  scoped_ptr<base::File::Info> file_info(
+  std::unique_ptr<base::File::Info> file_info(
       result == base::File::FILE_OK ? new base::File::Info(info) : NULL);
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(callback, base::Passed(&file_info)));
 }
 
 // Gets a WebContents instance handle for a platform app hosted in
 // |render_frame_host|. If not found, then returns NULL.
 content::WebContents* GetWebContentsForRenderFrameHost(
@@ skipping 75 matching lines @@
 
   ConsentProviderDelegate consent_provider_delegate(profile, nullptr);
   ConsentProvider consent_provider(&consent_provider_delegate);
   api::file_system::VolumeListChangedEvent event_args;
   FillVolumeList(profile, &event_args.volumes);
   for (const auto& extension : registry->enabled_extensions()) {
     if (!consent_provider.IsGrantable(*extension.get()))
       continue;
     event_router->DispatchEventToExtension(
         extension->id(),
-        make_scoped_ptr(new Event(
+        base::WrapUnique(new Event(
             events::FILE_SYSTEM_ON_VOLUME_LIST_CHANGED,
             api::file_system::OnVolumeListChanged::kEventName,
             api::file_system::OnVolumeListChanged::Create(event_args))));
   }
 }
 
 ConsentProvider::ConsentProvider(DelegateInterface* delegate)
     : delegate_(delegate) {
   DCHECK(delegate_);
 }
@@ skipping 707 matching lines @@
     if (PathService::Get(chrome::DIR_USER_DOCUMENTS, &documents_dir)) {
       initial_path_ = documents_dir.Append(suggested_name);
     } else {
       initial_path_ = suggested_name;
     }
   }
   ShowPicker(file_type_info, picker_type);
 }
 
 bool FileSystemChooseEntryFunction::RunAsync() {
-  scoped_ptr<ChooseEntry::Params> params(ChooseEntry::Params::Create(*args_));
+  std::unique_ptr<ChooseEntry::Params> params(
+      ChooseEntry::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   base::FilePath suggested_name;
   ui::SelectFileDialog::FileTypeInfo file_type_info;
   ui::SelectFileDialog::Type picker_type =
       ui::SelectFileDialog::SELECT_OPEN_FILE;
 
   file_system::ChooseEntryOptions* options = params->options.get();
   if (options) {
     multiple_ = options->accepts_multiple && *options->accepts_multiple;
@@ skipping 117 matching lines @@
   }
 
   saved_files_service->EnqueueFileEntry(extension_->id(), entry_id);
   SendResponse(true);
   return true;
 }
 
 void FileSystemRetainEntryFunction::RetainFileEntry(
     const std::string& entry_id,
     const base::FilePath& path,
-    scoped_ptr<base::File::Info> file_info) {
+    std::unique_ptr<base::File::Info> file_info) {
   if (!file_info) {
     SendResponse(false);
     return;
   }
 
   SavedFilesService* saved_files_service = SavedFilesService::Get(GetProfile());
   saved_files_service->RegisterFileEntry(
       extension_->id(), entry_id, path, file_info->is_directory);
   saved_files_service->EnqueueFileEntry(extension_->id(), entry_id);
   SendResponse(true);
@@ skipping 48 matching lines @@
 
 bool FileSystemGetObservedEntriesFunction::RunSync() {
   NOTIMPLEMENTED();
   error_ = kUnknownIdError;
   return false;
 }
 
 #if !defined(OS_CHROMEOS)
 ExtensionFunction::ResponseAction FileSystemRequestFileSystemFunction::Run() {
   using api::file_system::RequestFileSystem::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   NOTIMPLEMENTED();
   return RespondNow(Error(kNotSupportedOnCurrentPlatformError));
 }
 
 ExtensionFunction::ResponseAction FileSystemGetVolumeListFunction::Run() {
   NOTIMPLEMENTED();
   return RespondNow(Error(kNotSupportedOnCurrentPlatformError));
 }
 #else
 
 FileSystemRequestFileSystemFunction::FileSystemRequestFileSystemFunction()
     : chrome_details_(this) {
 }
 
 FileSystemRequestFileSystemFunction::~FileSystemRequestFileSystemFunction() {
 }
 
 ExtensionFunction::ResponseAction FileSystemRequestFileSystemFunction::Run() {
   using api::file_system::RequestFileSystem::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Only kiosk apps in kiosk sessions can use this API.
   // Additionally it is enabled for whitelisted component extensions and apps.
   file_system_api::ConsentProviderDelegate consent_provider_delegate(
       chrome_details_.GetProfile(), render_frame_host());
   file_system_api::ConsentProvider consent_provider(&consent_provider_delegate);
 
   if (!consent_provider.IsGrantable(*extension()))
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
@@ skipping 160 matching lines @@
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
   std::vector<api::file_system::Volume> result_volume_list;
   FillVolumeList(chrome_details_.GetProfile(), &result_volume_list);
 
   return RespondNow(ArgumentList(
       api::file_system::GetVolumeList::Results::Create(result_volume_list)));
 }
 #endif
 
 }  // namespace extensions