Convert //content from scoped_ptr to std::unique_ptr

content/public/test/test_file_system_backend.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 "content/public/test/test_file_system_backend.h"
 
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 152 matching lines @@
   *error_code = base::File::FILE_OK;
   if (require_copy_or_move_validator_) {
     if (!copy_or_move_file_validator_factory_)
       *error_code = base::File::FILE_ERROR_SECURITY;
     return copy_or_move_file_validator_factory_.get();
   }
   return nullptr;
 }
 
 void TestFileSystemBackend::InitializeCopyOrMoveFileValidatorFactory(
-    scoped_ptr<storage::CopyOrMoveFileValidatorFactory> factory) {
+    std::unique_ptr<storage::CopyOrMoveFileValidatorFactory> factory) {
   if (!copy_or_move_file_validator_factory_)
     copy_or_move_file_validator_factory_ = std::move(factory);
 }
 
 FileSystemOperation* TestFileSystemBackend::CreateFileSystemOperation(
     const FileSystemURL& url,
     FileSystemContext* context,
     base::File::Error* error_code) const {
-  scoped_ptr<FileSystemOperationContext> operation_context(
+  std::unique_ptr<FileSystemOperationContext> operation_context(
       new FileSystemOperationContext(context));
   operation_context->set_update_observers(*GetUpdateObservers(url.type()));
   operation_context->set_change_observers(*GetChangeObservers(url.type()));
   return FileSystemOperation::Create(url, context,
                                      std::move(operation_context));
 }
 
 bool TestFileSystemBackend::SupportsStreaming(
     const storage::FileSystemURL& url) const {
   return false;
 }
 
 bool TestFileSystemBackend::HasInplaceCopyImplementation(
     storage::FileSystemType type) const {
   return true;
 }
 
-scoped_ptr<storage::FileStreamReader>
+std::unique_ptr<storage::FileStreamReader>
 TestFileSystemBackend::CreateFileStreamReader(
     const FileSystemURL& url,
     int64_t offset,
     int64_t max_bytes_to_read,
     const base::Time& expected_modification_time,
     FileSystemContext* context) const {
-  return scoped_ptr<storage::FileStreamReader>(
+  return std::unique_ptr<storage::FileStreamReader>(
       storage::FileStreamReader::CreateForFileSystemFile(
           context, url, offset, expected_modification_time));
 }
 
-scoped_ptr<storage::FileStreamWriter>
+std::unique_ptr<storage::FileStreamWriter>
 TestFileSystemBackend::CreateFileStreamWriter(
     const FileSystemURL& url,
     int64_t offset,
     FileSystemContext* context) const {
-  return scoped_ptr<storage::FileStreamWriter>(
-      new storage::SandboxFileStreamWriter(
-          context, url, offset, *GetUpdateObservers(url.type())));
+  return std::unique_ptr<storage::FileStreamWriter>(
+      new storage::SandboxFileStreamWriter(context, url, offset,
+                                           *GetUpdateObservers(url.type())));
 }
 
 storage::FileSystemQuotaUtil* TestFileSystemBackend::GetQuotaUtil() {
   return quota_util_.get();
 }
 
 const storage::UpdateObserverList* TestFileSystemBackend::GetUpdateObservers(
     storage::FileSystemType type) const {
   return &update_observers_;
 }
 
 const storage::ChangeObserverList* TestFileSystemBackend::GetChangeObservers(
     storage::FileSystemType type) const {
   return &change_observers_;
 }
 
 const storage::AccessObserverList* TestFileSystemBackend::GetAccessObservers(
     storage::FileSystemType type) const {
   return nullptr;
 }
 
 void TestFileSystemBackend::AddFileChangeObserver(
     storage::FileChangeObserver* observer) {
   change_observers_ =
       change_observers_.AddObserver(observer, task_runner_.get());
 }
 
 }  // namespace content