Convert //content from scoped_ptr to std::unique_ptr

content/public/test/test_file_error_injector.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 "content/public/test/test_file_error_injector.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "content/browser/download/download_file_factory.h"
 #include "content/browser/download/download_file_impl.h"
 #include "content/browser/download/download_interrupt_reasons_impl.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "url/gurl.h"
 
 namespace content {
 class ByteStreamReader;
 
 namespace {
 
 // A class that performs file operations and injects errors.
 class DownloadFileWithError: public DownloadFileImpl {
  public:
-  DownloadFileWithError(scoped_ptr<DownloadSaveInfo> save_info,
+  DownloadFileWithError(std::unique_ptr<DownloadSaveInfo> save_info,
                         const base::FilePath& default_download_directory,
-                        scoped_ptr<ByteStreamReader> byte_stream,
+                        std::unique_ptr<ByteStreamReader> byte_stream,
                         const net::BoundNetLog& bound_net_log,
                         base::WeakPtr<DownloadDestinationObserver> observer,
                         const TestFileErrorInjector::FileErrorInfo& error_info,
                         const base::Closure& ctor_callback,
                         const base::Closure& dtor_callback);
 
   ~DownloadFileWithError() override;
 
   void Initialize(const InitializeCallback& callback) override;
 
@@ skipping 46 matching lines @@
     DownloadInterruptReason overwrite_error,
     DownloadInterruptReason original_error,
     const base::FilePath& path_result) {
   original_callback.Run(
       overwrite_error,
       overwrite_error == DOWNLOAD_INTERRUPT_REASON_NONE ?
       path_result : base::FilePath());
 }
 
 DownloadFileWithError::DownloadFileWithError(
-    scoped_ptr<DownloadSaveInfo> save_info,
+    std::unique_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
-    scoped_ptr<ByteStreamReader> byte_stream,
+    std::unique_ptr<ByteStreamReader> byte_stream,
     const net::BoundNetLog& bound_net_log,
     base::WeakPtr<DownloadDestinationObserver> observer,
     const TestFileErrorInjector::FileErrorInfo& error_info,
     const base::Closure& ctor_callback,
     const base::Closure& dtor_callback)
     : DownloadFileImpl(std::move(save_info),
                        default_download_directory,
                        std::move(byte_stream),
                        bound_net_log,
                        observer),
@@ skipping 131 matching lines @@
 
 // A factory for constructing DownloadFiles that inject errors.
 class DownloadFileWithErrorFactory : public DownloadFileFactory {
  public:
   DownloadFileWithErrorFactory(const base::Closure& ctor_callback,
                                 const base::Closure& dtor_callback);
   ~DownloadFileWithErrorFactory() override;
 
   // DownloadFileFactory interface.
   DownloadFile* CreateFile(
-      scoped_ptr<DownloadSaveInfo> save_info,
+      std::unique_ptr<DownloadSaveInfo> save_info,
       const base::FilePath& default_download_directory,
-      scoped_ptr<ByteStreamReader> byte_stream,
+      std::unique_ptr<ByteStreamReader> byte_stream,
       const net::BoundNetLog& bound_net_log,
       base::WeakPtr<DownloadDestinationObserver> observer) override;
 
   bool SetError(TestFileErrorInjector::FileErrorInfo error);
 
  private:
   // Our injected error.
   TestFileErrorInjector::FileErrorInfo injected_error_;
 
   // Callback for creation and destruction.
   base::Closure construction_callback_;
   base::Closure destruction_callback_;
 };
 
 DownloadFileWithErrorFactory::DownloadFileWithErrorFactory(
     const base::Closure& ctor_callback,
     const base::Closure& dtor_callback)
     : construction_callback_(ctor_callback),
       destruction_callback_(dtor_callback) {
   injected_error_.code = TestFileErrorInjector::FILE_OPERATION_INITIALIZE;
   injected_error_.error = DOWNLOAD_INTERRUPT_REASON_NONE;
   injected_error_.operation_instance = -1;
 }
 
 DownloadFileWithErrorFactory::~DownloadFileWithErrorFactory() {}
 
 DownloadFile* DownloadFileWithErrorFactory::CreateFile(
-    scoped_ptr<DownloadSaveInfo> save_info,
+    std::unique_ptr<DownloadSaveInfo> save_info,
     const base::FilePath& default_download_directory,
-    scoped_ptr<ByteStreamReader> byte_stream,
+    std::unique_ptr<ByteStreamReader> byte_stream,
     const net::BoundNetLog& bound_net_log,
     base::WeakPtr<DownloadDestinationObserver> observer) {
   return new DownloadFileWithError(std::move(save_info),
                                    default_download_directory,
                                    std::move(byte_stream),
                                    bound_net_log,
                                    observer,
                                    injected_error_,
                                    construction_callback_,
                                    destruction_callback_);
 }
 
 bool DownloadFileWithErrorFactory::SetError(
     TestFileErrorInjector::FileErrorInfo error) {
   injected_error_ = std::move(error);
   return true;
 }
 
 TestFileErrorInjector::TestFileErrorInjector(DownloadManager* download_manager)
     :  // This code is only used for browser_tests, so a
       // DownloadManager is always a DownloadManagerImpl.
       download_manager_(static_cast<DownloadManagerImpl*>(download_manager)) {
   // Record the value of the pointer, for later validation.
   created_factory_ = new DownloadFileWithErrorFactory(
       base::Bind(&TestFileErrorInjector::RecordDownloadFileConstruction, this),
       base::Bind(&TestFileErrorInjector::RecordDownloadFileDestruction, this));
 
   // We will transfer ownership of the factory to the download manager.
-  scoped_ptr<DownloadFileFactory> download_file_factory(
-      created_factory_);
+  std::unique_ptr<DownloadFileFactory> download_file_factory(created_factory_);
 
   download_manager_->SetDownloadFileFactoryForTesting(
       std::move(download_file_factory));
 }
 
 TestFileErrorInjector::~TestFileErrorInjector() {
 }
 
 void TestFileErrorInjector::ClearError() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 75 matching lines @@
     case FILE_OPERATION_RENAME_ANNOTATE:
       return "RENAME_ANNOTATE";
     default:
       break;
   }
 
   return "Unknown";
 }
 
 }  // namespace content