Convert Pass()→std::move() in //android_webview

android_webview/browser/net/android_stream_reader_url_request_job_unittest.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 <utility>
+
 #include "android_webview/browser/input_stream.h"
-#include "android_webview/browser/net/android_stream_reader_url_request_job.h"
 #include "android_webview/browser/net/aw_url_request_job_factory.h"
 #include "android_webview/browser/net/input_stream_reader.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_test_util.h"
-
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::TestDelegate;
 using net::TestJobInterceptor;
 using net::TestNetworkDelegate;
 using net::TestURLRequestContext;
 using net::URLRequest;
 using testing::DoAll;
 using testing::Ge;
@@ skipping 115 matching lines @@
   MockInputStreamReader() : InputStreamReader(new NotImplInputStream()) {}
   ~MockInputStreamReader() {}
 
   MOCK_METHOD1(Seek, int(const net::HttpByteRange& byte_range));
   MOCK_METHOD2(ReadRawData, int(net::IOBuffer* buffer, int buffer_size));
 };
 
 
 class TestStreamReaderJob : public AndroidStreamReaderURLRequestJob {
  public:
-  TestStreamReaderJob(
-      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate,
-      scoped_ptr<Delegate> delegate,
-      scoped_ptr<InputStreamReader> stream_reader)
+  TestStreamReaderJob(net::URLRequest* request,
+                      net::NetworkDelegate* network_delegate,
+                      scoped_ptr<Delegate> delegate,
+                      scoped_ptr<InputStreamReader> stream_reader)
       : AndroidStreamReaderURLRequestJob(request,
                                          network_delegate,
-                                         delegate.Pass()),
-        stream_reader_(stream_reader.Pass()) {
+                                         std::move(delegate)),
+        stream_reader_(std::move(stream_reader)) {
     task_runner_ = base::ThreadTaskRunnerHandle::Get();
   }
 
   ~TestStreamReaderJob() override {}
 
   scoped_ptr<InputStreamReader> CreateStreamReader(
       InputStream* stream) override {
-    return stream_reader_.Pass();
+    return std::move(stream_reader_);
   }
 
  protected:
   base::TaskRunner* GetWorkerThreadRunner() override {
     return task_runner_.get();
   }
 
   scoped_ptr<InputStreamReader> stream_reader_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
@@ skipping 17 matching lines @@
 
   void SetRange(net::URLRequest* req, int first_byte, int last_byte) {
     net::HttpRequestHeaders headers;
     headers.SetHeader(net::HttpRequestHeaders::kRange,
                       net::HttpByteRange::Bounded(
                           first_byte, last_byte).GetHeaderValue());
     req->SetExtraRequestHeaders(headers);
   }
 
   void SetUpTestJob(scoped_ptr<InputStreamReader> stream_reader) {
-    SetUpTestJob(stream_reader.Pass(),
+    SetUpTestJob(std::move(stream_reader),
                  make_scoped_ptr(new StreamReaderDelegate()));
   }
 
   void SetUpTestJob(scoped_ptr<InputStreamReader> stream_reader,
                     scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>
                         stream_reader_delegate) {
     scoped_ptr<TestStreamReaderJob> test_stream_reader_job(
         new TestStreamReaderJob(req_.get(), &network_delegate_,
-                                stream_reader_delegate.Pass(),
-                                stream_reader.Pass()));
+                                std::move(stream_reader_delegate),
+                                std::move(stream_reader)));
     // The Interceptor is owned by the |factory_|.
     scoped_ptr<TestJobInterceptor> protocol_handler(new TestJobInterceptor);
     protocol_handler->set_main_intercept_job(std::move(test_stream_reader_job));
     bool set_protocol =
         factory_.SetProtocolHandler("content", std::move(protocol_handler));
     DCHECK(set_protocol);
   }
 
   base::MessageLoopForIO loop_;
   TestURLRequestContext context_;
   android_webview::AwURLRequestJobFactory factory_;
   TestDelegate url_request_delegate_;
   TestNetworkDelegate network_delegate_;
   scoped_ptr<URLRequest> req_;
 };
 
 TEST_F(AndroidStreamReaderURLRequestJobTest, ReadEmptyStream) {
   scoped_ptr<StrictMock<MockInputStreamReader> > stream_reader(
       new StrictMock<MockInputStreamReader>());
   {
     InSequence s;
     EXPECT_CALL(*stream_reader, Seek(_))
         .WillOnce(Return(0));
     EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Gt(0)))
         .WillOnce(Return(0));
   }
 
-  SetUpTestJob(stream_reader.Pass());
+  SetUpTestJob(std::move(stream_reader));
 
   req_->Start();
 
   // The TestDelegate will quit the message loop on request completion.
   base::MessageLoop::current()->Run();
 
   EXPECT_FALSE(url_request_delegate_.request_failed());
   EXPECT_EQ(1, network_delegate_.completed_requests());
   EXPECT_EQ(0, network_delegate_.error_count());
   EXPECT_EQ(200, req_->GetResponseCode());
@@ skipping 54 matching lines @@
     EXPECT_CALL(*stream_reader, Seek(_))
         .WillOnce(Return(bytes_available));
     EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read)))
         .WillOnce(Return(bytes_to_read/2));
     EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read)))
         .WillOnce(Return(bytes_to_read/2));
     EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read)))
         .WillOnce(Return(0));
   }
 
-  SetUpTestJob(stream_reader.Pass());
+  SetUpTestJob(std::move(stream_reader));
 
   SetRange(req_.get(), offset, bytes_available);
   req_->Start();
 
   base::MessageLoop::current()->Run();
 
   EXPECT_FALSE(url_request_delegate_.request_failed());
   EXPECT_EQ(bytes_to_read, url_request_delegate_.bytes_received());
   EXPECT_EQ(1, network_delegate_.completed_requests());
   EXPECT_EQ(0, network_delegate_.error_count());
@@ skipping 10 matching lines @@
   {
     InSequence s;
     EXPECT_CALL(*stream_reader, Seek(_))
         .WillOnce(Return(bytes_available_reported));
     EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read)))
         .WillOnce(Return(bytes_available));
     EXPECT_CALL(*stream_reader, ReadRawData(NotNull(), Ge(bytes_to_read)))
         .WillOnce(Return(0));
   }
 
-  SetUpTestJob(stream_reader.Pass());
+  SetUpTestJob(std::move(stream_reader));
 
   SetRange(req_.get(), offset, bytes_available_reported);
   req_->Start();
 
   base::MessageLoop::current()->Run();
 
   EXPECT_FALSE(url_request_delegate_.request_failed());
   EXPECT_EQ(bytes_to_read, url_request_delegate_.bytes_received());
   EXPECT_EQ(1, network_delegate_.completed_requests());
   EXPECT_EQ(0, network_delegate_.error_count());
 }
 
 TEST_F(AndroidStreamReaderURLRequestJobTest, DeleteJobMidWaySeek) {
   const int offset = 20;
   const int bytes_available = 128;
   base::RunLoop loop;
   scoped_ptr<StrictMock<MockInputStreamReader> > stream_reader(
       new StrictMock<MockInputStreamReader>());
   EXPECT_CALL(*stream_reader, Seek(_))
       .WillOnce(DoAll(InvokeWithoutArgs(&loop, &base::RunLoop::Quit),
                       Return(bytes_available)));
   ON_CALL(*stream_reader, ReadRawData(_, _))
       .WillByDefault(Return(0));
 
-  SetUpTestJob(stream_reader.Pass());
+  SetUpTestJob(std::move(stream_reader));
 
   SetRange(req_.get(), offset, bytes_available);
   req_->Start();
 
   loop.Run();
 
   EXPECT_EQ(0, network_delegate_.completed_requests());
   req_->Cancel();
   EXPECT_EQ(1, network_delegate_.completed_requests());
 }
 
 TEST_F(AndroidStreamReaderURLRequestJobTest, DeleteJobMidWayRead) {
   const int offset = 20;
   const int bytes_available = 128;
   base::RunLoop loop;
   scoped_ptr<StrictMock<MockInputStreamReader> > stream_reader(
       new StrictMock<MockInputStreamReader>());
   net::CompletionCallback read_completion_callback;
   EXPECT_CALL(*stream_reader, Seek(_))
       .WillOnce(Return(bytes_available));
   EXPECT_CALL(*stream_reader, ReadRawData(_, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&loop, &base::RunLoop::Quit),
                       Return(bytes_available)));
 
-  SetUpTestJob(stream_reader.Pass());
+  SetUpTestJob(std::move(stream_reader));
 
   SetRange(req_.get(), offset, bytes_available);
   req_->Start();
 
   loop.Run();
 
   EXPECT_EQ(0, network_delegate_.completed_requests());
   req_->Cancel();
   EXPECT_EQ(1, network_delegate_.completed_requests());
 }
 
 }  // namespace android_webview