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

chrome/browser/chromeos/file_system_provider/fake_provided_file_system.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/fake_provided_file_system.h"
 
 #include <stddef.h>
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
 const char kFakeFileName[] = "hello.txt";
 const char kFakeFileText[] =
     "This is a testing file. Lorem ipsum dolor sit amet est.";
 const size_t kFakeFileSize = sizeof(kFakeFileText) - 1u;
 const char kFakeFileModificationTime[] = "Fri Apr 25 01:47:53 UTC 2014";
 const char kFakeFileMimeType[] = "text/plain";
 
 }  // namespace
 
 const base::FilePath::CharType kFakeFilePath[] =
     FILE_PATH_LITERAL("/hello.txt");
 
 FakeEntry::FakeEntry() {
 }
 
-FakeEntry::FakeEntry(scoped_ptr<EntryMetadata> metadata,
+FakeEntry::FakeEntry(std::unique_ptr<EntryMetadata> metadata,
                      const std::string& contents)
     : metadata(std::move(metadata)), contents(contents) {}
 
 FakeEntry::~FakeEntry() {
 }
 
 FakeProvidedFileSystem::FakeProvidedFileSystem(
     const ProvidedFileSystemInfo& file_system_info)
     : file_system_info_(file_system_info),
       last_file_handle_(0),
@@ skipping 10 matching lines @@
 FakeProvidedFileSystem::~FakeProvidedFileSystem() {}
 
 void FakeProvidedFileSystem::AddEntry(const base::FilePath& entry_path,
                                       bool is_directory,
                                       const std::string& name,
                                       int64_t size,
                                       base::Time modification_time,
                                       std::string mime_type,
                                       std::string contents) {
   DCHECK(entries_.find(entry_path) == entries_.end());
-  scoped_ptr<EntryMetadata> metadata(new EntryMetadata);
+  std::unique_ptr<EntryMetadata> metadata(new EntryMetadata);
 
   metadata->is_directory.reset(new bool(is_directory));
   metadata->name.reset(new std::string(name));
   metadata->size.reset(new int64_t(size));
   metadata->modification_time.reset(new base::Time(modification_time));
   metadata->mime_type.reset(new std::string(mime_type));
 
   entries_[entry_path] =
       make_linked_ptr(new FakeEntry(std::move(metadata), contents));
 }
@@ skipping 12 matching lines @@
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
 AbortCallback FakeProvidedFileSystem::GetMetadata(
     const base::FilePath& entry_path,
     ProvidedFileSystemInterface::MetadataFieldMask fields,
     const ProvidedFileSystemInterface::GetMetadataCallback& callback) {
   const Entries::const_iterator entry_it = entries_.find(entry_path);
 
   if (entry_it == entries_.end()) {
-    return PostAbortableTask(
-        base::Bind(callback,
-                   base::Passed(make_scoped_ptr<EntryMetadata>(NULL)),
-                   base::File::FILE_ERROR_NOT_FOUND));
+    return PostAbortableTask(base::Bind(
+        callback, base::Passed(base::WrapUnique<EntryMetadata>(NULL)),
+        base::File::FILE_ERROR_NOT_FOUND));
   }
 
-  scoped_ptr<EntryMetadata> metadata(new EntryMetadata);
+  std::unique_ptr<EntryMetadata> metadata(new EntryMetadata);
   if (fields & ProvidedFileSystemInterface::METADATA_FIELD_IS_DIRECTORY) {
     metadata->is_directory.reset(
         new bool(*entry_it->second->metadata->is_directory));
   }
   if (fields & ProvidedFileSystemInterface::METADATA_FIELD_NAME)
     metadata->name.reset(new std::string(*entry_it->second->metadata->name));
   if (fields & ProvidedFileSystemInterface::METADATA_FIELD_SIZE)
     metadata->size.reset(new int64_t(*entry_it->second->metadata->size));
   if (fields & ProvidedFileSystemInterface::METADATA_FIELD_MODIFICATION_TIME) {
     metadata->modification_time.reset(
@@ skipping 276 matching lines @@
 void FakeProvidedFileSystem::RemoveObserver(
     ProvidedFileSystemObserver* observer) {
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
 void FakeProvidedFileSystem::Notify(
     const base::FilePath& entry_path,
     bool recursive,
     storage::WatcherManager::ChangeType change_type,
-    scoped_ptr<ProvidedFileSystemObserver::Changes> changes,
+    std::unique_ptr<ProvidedFileSystemObserver::Changes> changes,
     const std::string& tag,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   NOTREACHED();
   callback.Run(base::File::FILE_ERROR_SECURITY);
 }
 
 void FakeProvidedFileSystem::Configure(
     const storage::AsyncFileUtil::StatusCallback& callback) {
   NOTREACHED();
   callback.Run(base::File::FILE_ERROR_SECURITY);
@@ skipping 23 matching lines @@
 }
 
 void FakeProvidedFileSystem::AbortMany(const std::vector<int>& task_ids) {
   for (size_t i = 0; i < task_ids.size(); ++i) {
     tracker_.TryCancel(task_ids[i]);
   }
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos