Convert //android_webview to use std::unique_ptr

android_webview/browser/net/android_stream_reader_url_request_job.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 "android_webview/browser/net/android_stream_reader_url_request_job.h"
 
 #include <string>
 #include <utility>
 
 #include "android_webview/browser/input_stream.h"
 #include "android_webview/browser/net/input_stream_reader.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/mime_util.h"
 #include "net/http/http_response_headers.h"
@@ skipping 20 matching lines @@
 
 } // namespace
 
 // The requests posted to the worker thread might outlive the job.  Thread-safe
 // ref counting is used to ensure that the InputStream and InputStreamReader
 // members of this class are still there when the closure is run on the worker
 // thread.
 class InputStreamReaderWrapper :
     public base::RefCountedThreadSafe<InputStreamReaderWrapper> {
  public:
-  InputStreamReaderWrapper(scoped_ptr<InputStream> input_stream,
-                           scoped_ptr<InputStreamReader> input_stream_reader)
+  InputStreamReaderWrapper(
+      std::unique_ptr<InputStream> input_stream,
+      std::unique_ptr<InputStreamReader> input_stream_reader)
       : input_stream_(std::move(input_stream)),
         input_stream_reader_(std::move(input_stream_reader)) {
     DCHECK(input_stream_);
     DCHECK(input_stream_reader_);
   }
 
   InputStream* input_stream() {
     return input_stream_.get();
   }
 
   int Seek(const net::HttpByteRange& byte_range) {
     return input_stream_reader_->Seek(byte_range);
   }
 
   int ReadRawData(net::IOBuffer* buffer, int buffer_size) {
     return input_stream_reader_->ReadRawData(buffer, buffer_size);
   }
 
  private:
   friend class base::RefCountedThreadSafe<InputStreamReaderWrapper>;
   ~InputStreamReaderWrapper() {}
 
-  scoped_ptr<InputStream> input_stream_;
-  scoped_ptr<InputStreamReader> input_stream_reader_;
+  std::unique_ptr<InputStream> input_stream_;
+  std::unique_ptr<InputStreamReader> input_stream_reader_;
 
   DISALLOW_COPY_AND_ASSIGN(InputStreamReaderWrapper);
 };
 
 AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
-    scoped_ptr<Delegate> delegate)
+    std::unique_ptr<Delegate> delegate)
     : URLRequestJob(request, network_delegate),
       range_parse_result_(net::OK),
       delegate_(std::move(delegate)),
       weak_factory_(this) {
   DCHECK(delegate_);
 }
 
 AndroidStreamReaderURLRequestJob::AndroidStreamReaderURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
-    scoped_ptr<DelegateObtainer> delegate_obtainer,
+    std::unique_ptr<DelegateObtainer> delegate_obtainer,
     bool)
     : URLRequestJob(request, network_delegate),
       range_parse_result_(net::OK),
       delegate_obtainer_(std::move(delegate_obtainer)),
       weak_factory_(this) {
   DCHECK(delegate_obtainer_);
 }
 
 AndroidStreamReaderURLRequestJob::~AndroidStreamReaderURLRequestJob() {
 }
 
 namespace {
 
-typedef base::Callback<
-    void(scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>,
-         scoped_ptr<InputStream>)> OnInputStreamOpenedCallback;
+typedef base::Callback<void(
+    std::unique_ptr<AndroidStreamReaderURLRequestJob::Delegate>,
+    std::unique_ptr<InputStream>)>
+    OnInputStreamOpenedCallback;
 
 // static
 void OpenInputStreamOnWorkerThread(
     scoped_refptr<base::SingleThreadTaskRunner> job_thread_task_runner,
-    scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate> delegate,
+    std::unique_ptr<AndroidStreamReaderURLRequestJob::Delegate> delegate,
     const GURL& url,
     OnInputStreamOpenedCallback callback) {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(env);
 
-  scoped_ptr<InputStream> input_stream = delegate->OpenInputStream(env, url);
+  std::unique_ptr<InputStream> input_stream =
+      delegate->OpenInputStream(env, url);
   job_thread_task_runner->PostTask(
       FROM_HERE, base::Bind(callback, base::Passed(std::move(delegate)),
                             base::Passed(std::move(input_stream))));
 }
 
 } // namespace
 
 void AndroidStreamReaderURLRequestJob::Start() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!delegate_) {
     DCHECK(delegate_obtainer_);
     delegate_obtainer_->ObtainDelegate(
         request(),
         base::Bind(&AndroidStreamReaderURLRequestJob::DelegateObtained,
                    weak_factory_.GetWeakPtr()));
   } else {
     // Run DoStart asynchronously to avoid re-entering the delegate.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&AndroidStreamReaderURLRequestJob::DoStart,
                               weak_factory_.GetWeakPtr()));
   }
 }
 
 void AndroidStreamReaderURLRequestJob::Kill() {
   DCHECK(thread_checker_.CalledOnValidThread());
   weak_factory_.InvalidateWeakPtrs();
   URLRequestJob::Kill();
 }
 
-scoped_ptr<InputStreamReader>
+std::unique_ptr<InputStreamReader>
 AndroidStreamReaderURLRequestJob::CreateStreamReader(InputStream* stream) {
-  return make_scoped_ptr(new InputStreamReader(stream));
+  return base::WrapUnique(new InputStreamReader(stream));
 }
 
 void AndroidStreamReaderURLRequestJob::OnInputStreamOpened(
-      scoped_ptr<Delegate> returned_delegate,
-      scoped_ptr<android_webview::InputStream> input_stream) {
+    std::unique_ptr<Delegate> returned_delegate,
+    std::unique_ptr<android_webview::InputStream> input_stream) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(returned_delegate);
   delegate_ = std::move(returned_delegate);
 
   if (!input_stream) {
     bool restart_required = false;
     delegate_->OnInputStreamOpenFailed(request(), &restart_required);
     if (restart_required) {
       NotifyRestartRequired();
     } else {
       HeadersComplete(kHTTPNotFound, kHTTPNotFoundText);
     }
     return;
   }
 
-  scoped_ptr<InputStreamReader> input_stream_reader(
+  std::unique_ptr<InputStreamReader> input_stream_reader(
       CreateStreamReader(input_stream.get()));
   DCHECK(input_stream_reader);
 
   DCHECK(!input_stream_reader_wrapper_.get());
   input_stream_reader_wrapper_ = new InputStreamReaderWrapper(
       std::move(input_stream), std::move(input_stream_reader));
 
   PostTaskAndReplyWithResult(
       GetWorkerThreadRunner(),
       FROM_HERE,
@@ skipping 69 matching lines @@
 
   // Since it's possible for this call to alter the InputStream a
   // Seek or ReadRawData operation running in the background is not permitted.
   DCHECK(!request_->status().is_io_pending());
 
   return delegate_->GetCharset(
       env, request(), input_stream_reader_wrapper_->input_stream(), charset);
 }
 
 void AndroidStreamReaderURLRequestJob::DelegateObtained(
-    scoped_ptr<Delegate> delegate) {
+    std::unique_ptr<Delegate> delegate) {
   DCHECK(!delegate_);
   delegate_obtainer_.reset();
   if (delegate) {
     delegate_.swap(delegate);
     DoStart();
   } else {
     NotifyRestartRequired();
   }
 }
 
@@ skipping 90 matching lines @@
         byte_range_ = ranges[0];
     } else {
       // We don't support multiple range requests in one single URL request,
       // because we need to do multipart encoding here.
       range_parse_result_ = net::ERR_REQUEST_RANGE_NOT_SATISFIABLE;
     }
   }
 }
 
 }  // namespace android_webview