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

chrome/browser/chromeos/file_system_provider/service.cc

 // Copyright 2014 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_system_provider/service.h"
 
 #include <stddef.h>
 
 #include "base/files/file_path.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/observer.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/registry.h"
 #include "chrome/browser/chromeos/file_system_provider/registry_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/service_factory.h"
 #include "chrome/browser/chromeos/file_system_provider/throttled_file_system.h"
@@ skipping 13 matching lines @@
 
 // Maximum number of file systems to be mounted in the same time, per profile.
 const size_t kMaxFileSystems = 16;
 
 // Default factory for provided file systems. |profile| must not be NULL.
 ProvidedFileSystemInterface* CreateProvidedFileSystem(
     Profile* profile,
     const ProvidedFileSystemInfo& file_system_info) {
   DCHECK(profile);
   return new ThrottledFileSystem(
-      make_scoped_ptr(new ProvidedFileSystem(profile, file_system_info)));
+      base::WrapUnique(new ProvidedFileSystem(profile, file_system_info)));
 }
 
 }  // namespace
 
 ProvidingExtensionInfo::ProvidingExtensionInfo() {
 }
 
 ProvidingExtensionInfo::~ProvidingExtensionInfo() {
 }
 
@@ skipping 44 matching lines @@
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
 void Service::SetFileSystemFactoryForTesting(
     const FileSystemFactoryCallback& factory_callback) {
   DCHECK(!factory_callback.is_null());
   file_system_factory_ = factory_callback;
 }
 
-void Service::SetRegistryForTesting(scoped_ptr<RegistryInterface> registry) {
+void Service::SetRegistryForTesting(
+    std::unique_ptr<RegistryInterface> registry) {
   DCHECK(registry);
   registry_.reset(registry.release());
 }
 
 base::File::Error Service::MountFileSystem(const std::string& extension_id,
                                            const MountOptions& options) {
   return MountFileSystemInternal(extension_id, options, MOUNT_CONTEXT_USER);
 }
 
 base::File::Error Service::MountFileSystemInternal(
@@ skipping 156 matching lines @@
   DCHECK(event_router);
 
   if (!event_router->ExtensionHasEventListener(
           extension_id, extensions::api::file_system_provider::
                             OnMountRequested::kEventName)) {
     return false;
   }
 
   event_router->DispatchEventToExtension(
       extension_id,
-      make_scoped_ptr(new extensions::Event(
+      base::WrapUnique(new extensions::Event(
           extensions::events::FILE_SYSTEM_PROVIDER_ON_MOUNT_REQUESTED,
           extensions::api::file_system_provider::OnMountRequested::kEventName,
-          scoped_ptr<base::ListValue>(new base::ListValue()))));
+          std::unique_ptr<base::ListValue>(new base::ListValue()))));
 
   return true;
 }
 
 std::vector<ProvidedFileSystemInfo> Service::GetProvidedFileSystemInfoList() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::vector<ProvidedFileSystemInfo> result;
   for (ProvidedFileSystemMap::const_iterator it = file_system_map_.begin();
        it != file_system_map_.end();
@@ skipping 75 matching lines @@
           reason == extensions::UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN
               ? UNMOUNT_REASON_SHUTDOWN
               : UNMOUNT_REASON_USER);
       DCHECK_EQ(base::File::FILE_OK, unmount_result);
     }
   }
 }
 
 void Service::OnExtensionLoaded(content::BrowserContext* browser_context,
                                 const extensions::Extension* extension) {
-  scoped_ptr<RegistryInterface::RestoredFileSystems> restored_file_systems =
-      registry_->RestoreFileSystems(extension->id());
+  std::unique_ptr<RegistryInterface::RestoredFileSystems>
+      restored_file_systems = registry_->RestoreFileSystems(extension->id());
 
   for (const auto& restored_file_system : *restored_file_systems) {
     const base::File::Error result = MountFileSystemInternal(
         restored_file_system.extension_id, restored_file_system.options,
         MOUNT_CONTEXT_RESTORE);
     if (result != base::File::FILE_OK) {
       LOG(ERROR) << "Failed to restore a provided file system from "
                  << "registry: " << restored_file_system.extension_id << ", "
                  << restored_file_system.options.file_system_id << ", "
                  << restored_file_system.options.display_name << ".";
@@ skipping 61 matching lines @@
 }
 
 void Service::OnWatcherListChanged(
     const ProvidedFileSystemInfo& file_system_info,
     const Watchers& watchers) {
   registry_->RememberFileSystem(file_system_info, watchers);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos