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

net/url_request/url_request_http_job_unittest.cc

 // Copyright (c) 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 "net/url_request/url_request_http_job.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 
@@ skipping 69 matching lines @@
     for (const std::string& token :
          base::SplitString(encoding_headers, ", ", base::KEEP_WHITESPACE,
                            base::SPLIT_WANT_NONEMPTY)) {
       if (base::EqualsCaseInsensitiveASCII(token, "sdch"))
         return true;
     }
     return false;
   }
 
   void EnableSdch() {
-    context_.SetSdchManager(scoped_ptr<SdchManager>(new SdchManager).Pass());
+    context_.SetSdchManager(scoped_ptr<SdchManager>(new SdchManager));
   }
 
   MockNetworkLayer network_layer_;
   TestURLRequestContext context_;
   TestDelegate delegate_;
   scoped_ptr<URLRequest> req_;
 };
 
 class URLRequestHttpJobWithMockSocketsTest : public ::testing::Test {
  protected:
@@ skipping 24 matching lines @@
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 12\r\n\r\n"),
                       MockRead("Test Content")};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  scoped_ptr<URLRequest> request =
-      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate)
-          .Pass();
+  scoped_ptr<URLRequest> request = context_->CreateRequest(
+      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_TRUE(request->status().is_success());
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             network_delegate_.total_network_bytes_sent());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             network_delegate_.total_network_bytes_received());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestContentLengthSuccessfulHttp09Request) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("Test Content"),
                       MockRead(net::SYNCHRONOUS, net::OK)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  scoped_ptr<URLRequest> request =
-      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate)
-          .Pass();
+  scoped_ptr<URLRequest> request = context_->CreateRequest(
+      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_TRUE(request->status().is_success());
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             network_delegate_.total_network_bytes_sent());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             network_delegate_.total_network_bytes_received());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest, TestContentLengthFailedRequest) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 20\r\n\r\n"),
                       MockRead("Test Content"),
                       MockRead(net::SYNCHRONOUS, net::ERR_FAILED)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  scoped_ptr<URLRequest> request =
-      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate)
-          .Pass();
+  scoped_ptr<URLRequest> request = context_->CreateRequest(
+      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_EQ(URLRequestStatus::FAILED, request->status().status());
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
@@ skipping 10 matching lines @@
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 20\r\n\r\n"),
                       MockRead("Test Content"),
                       MockRead(net::SYNCHRONOUS, net::ERR_IO_PENDING)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  scoped_ptr<URLRequest> request =
-      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate)
-          .Pass();
+  scoped_ptr<URLRequest> request = context_->CreateRequest(
+      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
 
   delegate.set_cancel_in_received_data(true);
   request->Start();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(URLRequestStatus::CANCELED, request->status().status());
   EXPECT_EQ(12, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
@@ skipping 26 matching lines @@
   MockWrite final_writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead final_reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                      "Content-Length: 12\r\n\r\n"),
                             MockRead("Test Content")};
   StaticSocketDataProvider final_socket_data(
       final_reads, arraysize(final_reads), final_writes,
       arraysize(final_writes));
   socket_factory_.AddSocketDataProvider(&final_socket_data);
 
   TestDelegate delegate;
-  scoped_ptr<URLRequest> request =
-      context_->CreateRequest(GURL("http://www.redirect.com"), DEFAULT_PRIORITY,
-                              &delegate)
-          .Pass();
+  scoped_ptr<URLRequest> request = context_->CreateRequest(
+      GURL("http://www.redirect.com"), DEFAULT_PRIORITY, &delegate);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(request->status().is_success());
   EXPECT_EQ(12, request->received_response_content_length());
   // Should not include the redirect.
   EXPECT_EQ(CountWriteBytes(final_writes, arraysize(final_writes)),
             request->GetTotalSentBytes());
@@ skipping 10 matching lines @@
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestNetworkBytesCancelledAfterHeaders) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n\r\n")};
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  scoped_ptr<URLRequest> request =
-      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate)
-          .Pass();
+  scoped_ptr<URLRequest> request = context_->CreateRequest(
+      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
 
   delegate.set_cancel_in_response_started(true);
   request->Start();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(URLRequestStatus::CANCELED, request->status().status());
   EXPECT_EQ(0, request->received_response_content_length());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             network_delegate_.total_network_bytes_sent());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             network_delegate_.total_network_bytes_received());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestNetworkBytesCancelledImmediately) {
   StaticSocketDataProvider socket_data(nullptr, 0, nullptr, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  scoped_ptr<URLRequest> request =
-      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate)
-          .Pass();
+  scoped_ptr<URLRequest> request = context_->CreateRequest(
+      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
 
   request->Start();
   request->Cancel();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(URLRequestStatus::CANCELED, request->status().status());
   EXPECT_EQ(0, request->received_response_content_length());
   EXPECT_EQ(0, request->GetTotalSentBytes());
   EXPECT_EQ(0, request->GetTotalReceivedBytes());
   EXPECT_EQ(0, network_delegate_.total_network_bytes_received());
@@ skipping 11 matching lines @@
   ssl_socket_data_provider.SetNextProto(kProtoHTTP11);
   ssl_socket_data_provider.cert =
       ImportCertFromFile(GetTestCertsDirectory(), "unittest.selfsigned.der");
   socket_factory_.AddSSLSocketDataProvider(&ssl_socket_data_provider);
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate1;
-  scoped_ptr<URLRequest> request1 =
-      context_->CreateRequest(GURL("https://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate1).Pass();
+  scoped_ptr<URLRequest> request1 = context_->CreateRequest(
+      GURL("https://www.example.com"), DEFAULT_PRIORITY, &delegate1);
 
   request1->Start();
   ASSERT_TRUE(request1->is_pending());
   base::RunLoop().Run();
 
   EXPECT_TRUE(request1->status().is_success());
   EXPECT_EQ("test.html", delegate1.data_received());
   EXPECT_EQ(1, delegate1.received_before_network_start_count());
   EXPECT_EQ(1, manager_.GetNumberOfEntriesForTests());
 
   // Issue another request, and backoff logic should apply.
   TestDelegate delegate2;
-  scoped_ptr<URLRequest> request2 =
-      context_->CreateRequest(GURL("https://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate2).Pass();
+  scoped_ptr<URLRequest> request2 = context_->CreateRequest(
+      GURL("https://www.example.com"), DEFAULT_PRIORITY, &delegate2);
 
   request2->Start();
   ASSERT_TRUE(request2->is_pending());
   base::RunLoop().Run();
 
   EXPECT_FALSE(request2->status().is_success());
   EXPECT_EQ(ERR_TEMPORARY_BACKOFF, request2->status().error());
   EXPECT_EQ(0, delegate2.received_before_network_start_count());
 }
 
@@ skipping 27 matching lines @@
   ssl_socket_data_provider.SetNextProto(kProtoHTTP11);
   ssl_socket_data_provider.cert =
       ImportCertFromFile(GetTestCertsDirectory(), "unittest.selfsigned.der");
   socket_factory_.AddSSLSocketDataProvider(&ssl_socket_data_provider);
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate1;
-  scoped_ptr<URLRequest> request1 =
-      context_->CreateRequest(GURL("https://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate1)
-          .Pass();
+  scoped_ptr<URLRequest> request1 = context_->CreateRequest(
+      GURL("https://www.example.com"), DEFAULT_PRIORITY, &delegate1);
 
   request1->Start();
   ASSERT_TRUE(request1->is_pending());
   base::RunLoop().Run();
 
   EXPECT_TRUE(request1->status().is_success());
   EXPECT_EQ("test.html", delegate1.data_received());
   EXPECT_EQ(1, delegate1.received_before_network_start_count());
   EXPECT_EQ(1, manager_.GetNumberOfEntriesForTests());
 
   // Issue a user-initiated request, backoff logic should not apply.
   TestDelegate delegate2;
-  scoped_ptr<URLRequest> request2 =
-      context_->CreateRequest(GURL("https://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate2)
-          .Pass();
+  scoped_ptr<URLRequest> request2 = context_->CreateRequest(
+      GURL("https://www.example.com"), DEFAULT_PRIORITY, &delegate2);
   request2->SetLoadFlags(request2->load_flags() | LOAD_MAYBE_USER_GESTURE);
 
   request2->Start();
   ASSERT_TRUE(request2->is_pending());
   base::RunLoop().Run();
 
   EXPECT_NE(0, request2->load_flags() & LOAD_MAYBE_USER_GESTURE);
   EXPECT_TRUE(request2->status().is_success());
   EXPECT_EQ("test.html", delegate2.data_received());
   EXPECT_EQ(1, delegate2.received_before_network_start_count());
   EXPECT_EQ(1, manager_.GetNumberOfEntriesForTests());
 }
 
 TEST_F(URLRequestHttpJobWithMockSocketsTest, BackoffHeaderNotSecure) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead(
                           "HTTP/1.1 200 OK\r\n"
                           "Backoff: 3600\r\n"
                           "Content-Length: 9\r\n\r\n"),
                       MockRead("test.html")};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate;
-  scoped_ptr<URLRequest> request =
-      context_->CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate).Pass();
+  scoped_ptr<URLRequest> request = context_->CreateRequest(
+      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
 
   request->Start();
   ASSERT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
   EXPECT_TRUE(request->status().is_success());
   EXPECT_EQ("test.html", delegate.data_received());
   EXPECT_EQ(1, delegate.received_before_network_start_count());
   // Backoff logic does not apply to plain HTTP request.
   EXPECT_EQ(0, manager_.GetNumberOfEntriesForTests());
@@ skipping 12 matching lines @@
   ssl_socket_data_provider.SetNextProto(kProtoHTTP11);
   ssl_socket_data_provider.cert =
       ImportCertFromFile(GetTestCertsDirectory(), "unittest.selfsigned.der");
   socket_factory_.AddSSLSocketDataProvider(&ssl_socket_data_provider);
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   TestDelegate delegate1;
-  scoped_ptr<URLRequest> request1 =
-      context_->CreateRequest(GURL("https://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate1).Pass();
+  scoped_ptr<URLRequest> request1 = context_->CreateRequest(
+      GURL("https://www.example.com"), DEFAULT_PRIORITY, &delegate1);
 
   request1->Start();
   ASSERT_TRUE(request1->is_pending());
   base::RunLoop().Run();
 
   EXPECT_TRUE(request1->status().is_success());
   EXPECT_EQ("test.html", delegate1.data_received());
   EXPECT_EQ(1, delegate1.received_before_network_start_count());
   EXPECT_EQ(1, manager_.GetNumberOfEntriesForTests());
 
   // Backoff logic does not apply to a second request, since it is fetched
   // from cache.
   TestDelegate delegate2;
-  scoped_ptr<URLRequest> request2 =
-      context_->CreateRequest(GURL("https://www.example.com"), DEFAULT_PRIORITY,
-                              &delegate2).Pass();
+  scoped_ptr<URLRequest> request2 = context_->CreateRequest(
+      GURL("https://www.example.com"), DEFAULT_PRIORITY, &delegate2);
 
   request2->Start();
   ASSERT_TRUE(request2->is_pending());
   base::RunLoop().Run();
   EXPECT_TRUE(request2->was_cached());
   EXPECT_TRUE(request2->status().is_success());
   EXPECT_EQ(0, delegate2.received_before_network_start_count());
 }
 
 TEST_F(URLRequestHttpJobTest, TestCancelWhileReadingCookies) {
   context_.set_cookie_store(new DelayedCookieMonster());
 
   TestDelegate delegate;
-  scoped_ptr<URLRequest> request =
-      context_.CreateRequest(GURL("http://www.example.com"), DEFAULT_PRIORITY,
-                             &delegate)
-          .Pass();
+  scoped_ptr<URLRequest> request = context_.CreateRequest(
+      GURL("http://www.example.com"), DEFAULT_PRIORITY, &delegate);
 
   request->Start();
   request->Cancel();
   base::RunLoop().Run();
 
   DCHECK_EQ(0, delegate.received_before_network_start_count());
   EXPECT_EQ(URLRequestStatus::CANCELED, request->status().status());
 }
 
 // Make sure that SetPriority actually sets the URLRequestHttpJob's
@@ skipping 220 matching lines @@
   req_->SetLoadFlags(LOAD_DISABLE_CACHE);
   job->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(URLRequestStatus::IO_PENDING, req_->status().status());
   EXPECT_TRUE(fake_handshake_stream->initialize_stream_was_called());
 }
 
 }  // namespace
 
 }  // namespace net