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

chrome/browser/chromeos/extensions/file_system_provider/file_system_provider_api.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_system_provider/file_system_provider_api.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/request_manager.h"
 #include "chrome/browser/chromeos/file_system_provider/request_value.h"
 #include "chrome/browser/chromeos/file_system_provider/service.h"
 #include "chrome/common/extensions/api/file_system_provider.h"
 #include "chrome/common/extensions/api/file_system_provider_internal.h"
 #include "storage/browser/fileapi/watcher_manager.h"
@@ skipping 30 matching lines @@
 // are not used is since they are imperfect, eg. paths are stored as strings.
 ProvidedFileSystemObserver::Change ParseChange(
     const api::file_system_provider::Change& change) {
   ProvidedFileSystemObserver::Change result;
   result.entry_path = base::FilePath::FromUTF8Unsafe(change.entry_path);
   result.change_type = ParseChangeType(change.change_type);
   return result;
 }
 
 // Converts a list of child changes from the IDL type to a native type.
-scoped_ptr<ProvidedFileSystemObserver::Changes> ParseChanges(
+std::unique_ptr<ProvidedFileSystemObserver::Changes> ParseChanges(
     const std::vector<api::file_system_provider::Change>& changes) {
-  scoped_ptr<ProvidedFileSystemObserver::Changes> results(
+  std::unique_ptr<ProvidedFileSystemObserver::Changes> results(
       new ProvidedFileSystemObserver::Changes);
   for (const auto& change : changes) {
     results->push_back(ParseChange(change));
   }
   return results;
 }
 
 // Fills the IDL's FileSystemInfo with FSP's ProvidedFileSystemInfo and
 // Watchers.
 void FillFileSystemInfo(const ProvidedFileSystemInfo& file_system_info,
@@ skipping 32 matching lines @@
         break;
     }
     output->opened_files.push_back(std::move(opened_file_item));
   }
 }
 
 }  // namespace
 
 bool FileSystemProviderMountFunction::RunSync() {
   using api::file_system_provider::Mount::Params;
-  const scoped_ptr<Params> params(Params::Create(*args_));
+  const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // It's an error if the file system Id is empty.
   if (params->options.file_system_id.empty()) {
     SetError(FileErrorToString(base::File::FILE_ERROR_INVALID_OPERATION));
     return false;
   }
 
   // It's an error if the display name is empty.
   if (params->options.display_name.empty()) {
@@ skipping 25 matching lines @@
   if (result != base::File::FILE_OK) {
     SetError(FileErrorToString(result));
     return false;
   }
 
   return true;
 }
 
 bool FileSystemProviderUnmountFunction::RunSync() {
   using api::file_system_provider::Unmount::Params;
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   Service* const service = Service::Get(GetProfile());
   DCHECK(service);
 
   const base::File::Error result =
       service->UnmountFileSystem(extension_id(), params->options.file_system_id,
                                  Service::UNMOUNT_REASON_USER);
   if (result != base::File::FILE_OK) {
     SetError(FileErrorToString(result));
@@ skipping 27 matching lines @@
       items.push_back(std::move(item));
     }
   }
 
   SetResultList(api::file_system_provider::GetAll::Results::Create(items));
   return true;
 }
 
 bool FileSystemProviderGetFunction::RunSync() {
   using api::file_system_provider::Get::Params;
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using api::file_system_provider::FileSystemInfo;
   Service* const service = Service::Get(GetProfile());
   DCHECK(service);
 
   chromeos::file_system_provider::ProvidedFileSystemInterface* const
       file_system = service->GetProvidedFileSystem(extension_id(),
                                                    params->file_system_id);
 
   if (!file_system) {
     SetError(FileErrorToString(base::File::FILE_ERROR_NOT_FOUND));
     return false;
   }
 
   FileSystemInfo file_system_info;
   FillFileSystemInfo(file_system->GetFileSystemInfo(),
                      *file_system->GetWatchers(), file_system->GetOpenedFiles(),
                      &file_system_info);
   SetResultList(
       api::file_system_provider::Get::Results::Create(file_system_info));
   return true;
 }
 
 bool FileSystemProviderNotifyFunction::RunAsync() {
   using api::file_system_provider::Notify::Params;
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   Service* const service = Service::Get(GetProfile());
   DCHECK(service);
 
   ProvidedFileSystemInterface* const file_system =
       service->GetProvidedFileSystem(extension_id(),
                                      params->options.file_system_id);
   if (!file_system) {
     SetError(FileErrorToString(base::File::FILE_ERROR_NOT_FOUND));
     return false;
   }
 
   file_system->Notify(
       base::FilePath::FromUTF8Unsafe(params->options.observed_path),
       params->options.recursive, ParseChangeType(params->options.change_type),
       params->options.changes.get()
           ? ParseChanges(*params->options.changes.get())
-          : make_scoped_ptr(new ProvidedFileSystemObserver::Changes),
+          : base::WrapUnique(new ProvidedFileSystemObserver::Changes),
       params->options.tag.get() ? *params->options.tag.get() : "",
       base::Bind(&FileSystemProviderNotifyFunction::OnNotifyCompleted, this));
 
   return true;
 }
 
 void FileSystemProviderNotifyFunction::OnNotifyCompleted(
     base::File::Error result) {
   if (result != base::File::FILE_OK) {
     SetError(FileErrorToString(result));
     SendResponse(false);
     return;
   }
 
   SendResponse(true);
 }
 
 bool FileSystemProviderInternalUnmountRequestedSuccessFunction::RunWhenValid() {
   using api::file_system_provider_internal::UnmountRequestedSuccess::Params;
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   return FulfillRequest(
       RequestValue::CreateForUnmountSuccess(std::move(params)),
       false /* has_more */);
 }
 
 bool
 FileSystemProviderInternalGetMetadataRequestedSuccessFunction::RunWhenValid() {
   using api::file_system_provider_internal::GetMetadataRequestedSuccess::Params;
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   return FulfillRequest(
       RequestValue::CreateForGetMetadataSuccess(std::move(params)),
       false /* has_more */);
 }
 
 bool FileSystemProviderInternalGetActionsRequestedSuccessFunction::
     RunWhenValid() {
   using api::file_system_provider_internal::GetActionsRequestedSuccess::Params;
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   return FulfillRequest(
       RequestValue::CreateForGetActionsSuccess(std::move(params)),
       false /* has_more */);
 }
 
 bool FileSystemProviderInternalReadDirectoryRequestedSuccessFunction::
     RunWhenValid() {
   using api::file_system_provider_internal::ReadDirectoryRequestedSuccess::
       Params;
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const bool has_more = params->has_more;
   return FulfillRequest(
       RequestValue::CreateForReadDirectorySuccess(std::move(params)), has_more);
 }
 
 bool
 FileSystemProviderInternalReadFileRequestedSuccessFunction::RunWhenValid() {
   TRACE_EVENT0("file_system_provider", "ReadFileRequestedSuccess");
   using api::file_system_provider_internal::ReadFileRequestedSuccess::Params;
 
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const bool has_more = params->has_more;
   return FulfillRequest(
       RequestValue::CreateForReadFileSuccess(std::move(params)), has_more);
 }
 
 bool
 FileSystemProviderInternalOperationRequestedSuccessFunction::RunWhenValid() {
   using api::file_system_provider_internal::OperationRequestedSuccess::Params;
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   return FulfillRequest(
-      scoped_ptr<RequestValue>(
+      std::unique_ptr<RequestValue>(
           RequestValue::CreateForOperationSuccess(std::move(params))),
       false /* has_more */);
 }
 
 bool FileSystemProviderInternalOperationRequestedErrorFunction::RunWhenValid() {
   using api::file_system_provider_internal::OperationRequestedError::Params;
-  scoped_ptr<Params> params(Params::Create(*args_));
+  std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const base::File::Error error = ProviderErrorToFileError(params->error);
   return RejectRequest(RequestValue::CreateForOperationError(std::move(params)),
                        error);
 }
 
 }  // namespace extensions