Convert //content from scoped_ptr to std::unique_ptr

content/public/test/test_download_request_handler.cc

 // Copyright 2015 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_download_request_handler.h"
 
 #include <inttypes.h>
+
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_filter.h"
@@ skipping 78 matching lines @@
 
   // URLRequestJob
   void Start() override;
   void GetResponseInfo(net::HttpResponseInfo* response_info) override;
   int64_t GetTotalReceivedBytes() const override;
   bool GetMimeType(std::string* mime_type) const override;
   int GetResponseCode() const override;
   int ReadRawData(net::IOBuffer* buf, int buf_size) override;
 
  private:
-  PartialResponseJob(scoped_ptr<Parameters> parameters,
+  PartialResponseJob(std::unique_ptr<Parameters> parameters,
                      base::WeakPtr<Interceptor> interceptor,
                      net::URLRequest* url_request,
                      net::NetworkDelegate* network_delegate);
 
   ~PartialResponseJob() override;
   void ReportCompletedRequest();
   static void OnStartResponseCallbackOnPossiblyIncorrectThread(
       base::WeakPtr<PartialResponseJob> job,
       const std::string& headers,
       net::Error error);
@@ skipping 14 matching lines @@
   // It also adds an 'Accept-Ranges' header if appropriate.
   void AddCommonEntityHeaders();
 
   // Schedules NotifyHeadersComplete() to be called and sets
   // offset_of_next_read_ to begin reading. Since this interceptor is avoiding
   // network requests and hence may complete synchronously, it schedules the
   // NotifyHeadersComplete() call asynchronously in order to avoid unexpected
   // re-entrancy.
   void NotifyHeadersCompleteAndPrepareToRead();
 
-  scoped_ptr<Parameters> parameters_;
+  std::unique_ptr<Parameters> parameters_;
 
   base::WeakPtr<Interceptor> interceptor_;
   net::HttpResponseInfo response_info_;
   int64_t offset_of_next_read_ = -1;
   int64_t requested_range_begin_ = -1;
   int64_t requested_range_end_ = -1;
   int64_t read_byte_count_ = 0;
   base::WeakPtrFactory<PartialResponseJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PartialResponseJob);
@@ skipping 42 matching lines @@
 }
 
 }  // namespace
 
 // static
 net::URLRequestJob* TestDownloadRequestHandler::PartialResponseJob::Factory(
     const Parameters& parameters,
     net::URLRequest* request,
     net::NetworkDelegate* delegate,
     base::WeakPtr<Interceptor> interceptor) {
-  return new PartialResponseJob(make_scoped_ptr(new Parameters(parameters)),
+  return new PartialResponseJob(base::WrapUnique(new Parameters(parameters)),
                                 interceptor, request, delegate);
 }
 
 TestDownloadRequestHandler::PartialResponseJob::PartialResponseJob(
-    scoped_ptr<Parameters> parameters,
+    std::unique_ptr<Parameters> parameters,
     base::WeakPtr<Interceptor> interceptor,
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate)
     : net::URLRequestJob(request, network_delegate),
       parameters_(std::move(parameters)),
       interceptor_(interceptor),
       weak_factory_(this) {
   DCHECK(parameters_.get());
   DCHECK_LT(0, parameters_->size);
   DCHECK_NE(-1, parameters_->pattern_generator_seed);
@@ skipping 254 matching lines @@
       FROM_HERE, base::Bind(&PartialResponseJob::NotifyHeadersComplete,
                             weak_factory_.GetWeakPtr()));
 }
 
 // static
 base::WeakPtr<TestDownloadRequestHandler::Interceptor>
 TestDownloadRequestHandler::Interceptor::Register(
     const GURL& url,
     scoped_refptr<base::SequencedTaskRunner> client_task_runner) {
   DCHECK(url.is_valid());
-  scoped_ptr<Interceptor> interceptor(new Interceptor(url, client_task_runner));
+  std::unique_ptr<Interceptor> interceptor(
+      new Interceptor(url, client_task_runner));
   base::WeakPtr<Interceptor> weak_reference =
       interceptor->weak_ptr_factory_.GetWeakPtr();
   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
   filter->AddUrlInterceptor(url, std::move(interceptor));
   return weak_reference;
 }
 
 void TestDownloadRequestHandler::Interceptor::Unregister() {
   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
   filter->RemoveUrlHandler(url_);
@@ skipping 167 matching lines @@
   base::RunLoop run_loop;
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&Interceptor::GetAndResetCompletedRequests, interceptor_,
                  requests),
       run_loop.QuitClosure());
   run_loop.Run();
 }
 
 }  // namespace content