Convert Pass()→std::move() in //content/browser

content/browser/loader/resource_loader_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 "content/browser/loader/resource_loader.h"
 
 #include <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 424 matching lines @@
   }
 
   void SelectClientCertificate(
       WebContents* web_contents,
       net::SSLCertRequestInfo* cert_request_info,
       scoped_ptr<ClientCertificateDelegate> delegate) override {
     EXPECT_FALSE(delegate_.get());
 
     ++call_count_;
     passed_certs_ = cert_request_info->client_certs;
-    delegate_ = delegate.Pass();
+    delegate_ = std::move(delegate);
     select_certificate_run_loop_.Quit();
   }
 
   int call_count() { return call_count_; }
   net::CertificateList passed_certs() { return passed_certs_; }
 
   void ContinueWithCertificate(net::X509Certificate* cert) {
     delegate_->ContinueWithCertificate(cert);
     delegate_.reset();
   }
 
   void CancelCertificateSelection() { delegate_.reset(); }
 
  private:
   net::CertificateList passed_certs_;
   int call_count_;
   scoped_ptr<ClientCertificateDelegate> delegate_;
 
   base::RunLoop select_certificate_run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SelectCertificateBrowserClient);
 };
 
 class ResourceContextStub : public MockResourceContext {
  public:
   explicit ResourceContextStub(net::URLRequestContext* test_request_context)
       : MockResourceContext(test_request_context) {}
 
   scoped_ptr<net::ClientCertStore> CreateClientCertStore() override {
-    return dummy_cert_store_.Pass();
+    return std::move(dummy_cert_store_);
   }
 
   void SetClientCertStore(scoped_ptr<net::ClientCertStore> store) {
-    dummy_cert_store_ = store.Pass();
+    dummy_cert_store_ = std::move(store);
   }
 
  private:
   scoped_ptr<net::ClientCertStore> dummy_cert_store_;
 };
 
 // Wraps a ChunkedUploadDataStream to behave as non-chunked to enable upload
 // progress reporting.
 class NonChunkedUploadDataStream : public net::UploadDataStream {
  public:
@@ skipping 56 matching lines @@
   }
 
   virtual scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
   CreateProtocolHandler() {
     return net::URLRequestTestJob::CreateProtocolHandler();
   }
 
   virtual scoped_ptr<ResourceHandler> WrapResourceHandler(
       scoped_ptr<ResourceHandlerStub> leaf_handler,
       net::URLRequest* request) {
-    return leaf_handler.Pass();
+    return std::move(leaf_handler);
   }
 
   // Replaces loader_ with a new one for |request|.
   void SetUpResourceLoader(scoped_ptr<net::URLRequest> request) {
     raw_ptr_to_request_ = request.get();
 
     RenderFrameHost* rfh = web_contents_->GetMainFrame();
     ResourceRequestInfo::AllocateForTesting(
         request.get(), RESOURCE_TYPE_MAIN_FRAME, &resource_context_,
         rfh->GetProcess()->GetID(), rfh->GetRenderViewHost()->GetRoutingID(),
         rfh->GetRoutingID(), true /* is_main_frame */,
         false /* parent_is_main_frame */, true /* allow_download */,
         false /* is_async */, false /* is_using_lofi_ */);
     scoped_ptr<ResourceHandlerStub> resource_handler(
         new ResourceHandlerStub(request.get()));
     raw_ptr_resource_handler_ = resource_handler.get();
     loader_.reset(new ResourceLoader(
-        request.Pass(),
-        WrapResourceHandler(resource_handler.Pass(), raw_ptr_to_request_),
+        std::move(request),
+        WrapResourceHandler(std::move(resource_handler), raw_ptr_to_request_),
         this));
   }
 
   void SetUp() override {
     job_factory_.SetProtocolHandler("test", CreateProtocolHandler());
 
     browser_context_.reset(new TestBrowserContext());
     scoped_refptr<SiteInstance> site_instance =
         SiteInstance::Create(browser_context_.get());
     web_contents_.reset(
         TestWebContents::Create(browser_context_.get(), site_instance.get()));
 
     scoped_ptr<net::URLRequest> request(
         resource_context_.GetRequestContext()->CreateRequest(
             test_url(),
             net::DEFAULT_PRIORITY,
             nullptr /* delegate */));
-    SetUpResourceLoader(request.Pass());
+    SetUpResourceLoader(std::move(request));
   }
 
   void TearDown() override {
     // Destroy the WebContents and pump the event loop before destroying
     // |rvh_test_enabler_| and |thread_bundle_|. This lets asynchronous cleanup
     // tasks complete.
     web_contents_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
@@ skipping 74 matching lines @@
 
 // Tests that client certificates are requested with ClientCertStore lookup.
 TEST_F(ClientCertResourceLoaderTest, WithStoreLookup) {
   // Set up the test client cert store.
   int store_request_count;
   std::vector<std::string> store_requested_authorities;
   net::CertificateList dummy_certs(1, scoped_refptr<net::X509Certificate>(
       new net::X509Certificate("test", "test", base::Time(), base::Time())));
   scoped_ptr<ClientCertStoreStub> test_store(new ClientCertStoreStub(
       dummy_certs, &store_request_count, &store_requested_authorities));
-  resource_context_.SetClientCertStore(test_store.Pass());
+  resource_context_.SetClientCertStore(std::move(test_store));
 
   // Plug in test content browser client.
   SelectCertificateBrowserClient test_client;
   ContentBrowserClient* old_client = SetBrowserClientForTesting(&test_client);
 
   // Start the request and wait for it to pause.
   loader_->StartRequest();
   test_client.WaitForSelectCertificate();
 
   EXPECT_FALSE(raw_ptr_resource_handler_->received_response_completed());
@@ skipping 179 matching lines @@
 
     // Make a temporary file.
     CHECK(base::CreateTemporaryFile(&temp_path_));
     int flags = base::File::FLAG_WRITE | base::File::FLAG_TEMPORARY |
                 base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_ASYNC;
     base::File file(temp_path_, flags);
     CHECK(file.IsValid());
 
     // Create mock file streams and a ShareableFileReference.
     scoped_ptr<net::testing::MockFileStream> file_stream(
-        new net::testing::MockFileStream(file.Pass(),
+        new net::testing::MockFileStream(std::move(file),
                                          base::ThreadTaskRunnerHandle::Get()));
     file_stream_ = file_stream.get();
     deletable_file_ = ShareableFileReference::GetOrCreate(
         temp_path_,
         ShareableFileReference::DELETE_ON_FINAL_RELEASE,
         BrowserThread::GetMessageLoopProxyForThread(
             BrowserThread::FILE).get());
 
     // Inject them into the handler.
     scoped_ptr<RedirectToFileResourceHandler> handler(
-        new RedirectToFileResourceHandler(leaf_handler.Pass(), request));
+        new RedirectToFileResourceHandler(std::move(leaf_handler), request));
     redirect_to_file_resource_handler_ = handler.get();
     handler->SetCreateTemporaryFileStreamFunctionForTesting(
         base::Bind(&ResourceLoaderRedirectToFileTest::PostCallback,
                    base::Unretained(this),
                    base::Passed(&file_stream)));
-    return handler.Pass();
+    return std::move(handler);
   }
 
  private:
   void PostCallback(
       scoped_ptr<net::FileStream> file_stream,
       const CreateTemporaryFileStreamCallback& callback) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, base::File::FILE_OK,
                               base::Passed(&file_stream), deletable_file_));
   }
@@ skipping 150 matching lines @@
   EXPECT_EQ(test_data(), contents);
 }
 
 // Test that an HTTPS resource has the expected security info attached
 // to it.
 TEST_F(HTTPSSecurityInfoResourceLoaderTest, SecurityInfoOnHTTPSResource) {
   // Start the request and wait for it to finish.
   scoped_ptr<net::URLRequest> request(
       resource_context_.GetRequestContext()->CreateRequest(
           test_https_url(), net::DEFAULT_PRIORITY, nullptr /* delegate */));
-  SetUpResourceLoader(request.Pass());
+  SetUpResourceLoader(std::move(request));
 
   // Send the request and wait until it completes.
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitForResponseComplete();
   ASSERT_EQ(net::URLRequestStatus::SUCCESS,
             raw_ptr_to_request_->status().status());
 
   ResourceResponse* response = raw_ptr_resource_handler_->response();
   ASSERT_TRUE(response);
 
@@ skipping 18 matching lines @@
 
 // Test that an HTTPS redirect response has the expected security info
 // attached to it.
 TEST_F(HTTPSSecurityInfoResourceLoaderTest,
        SecurityInfoOnHTTPSRedirectResource) {
   // Start the request and wait for it to finish.
   scoped_ptr<net::URLRequest> request(
       resource_context_.GetRequestContext()->CreateRequest(
           test_https_redirect_url(), net::DEFAULT_PRIORITY,
           nullptr /* delegate */));
-  SetUpResourceLoader(request.Pass());
+  SetUpResourceLoader(std::move(request));
 
   // Send the request and wait until it completes.
   loader_->StartRequest();
   raw_ptr_resource_handler_->WaitForResponseComplete();
   ASSERT_EQ(net::URLRequestStatus::SUCCESS,
             raw_ptr_to_request_->status().status());
   ASSERT_TRUE(raw_ptr_resource_handler_->received_request_redirected());
 
   ResourceResponse* redirect_response =
       raw_ptr_resource_handler_->redirect_response();
@@ skipping 12 matching lines @@
   ASSERT_TRUE(
       CertStore::GetInstance()->RetrieveCert(deserialized.cert_id, &cert));
   EXPECT_TRUE(cert->Equals(GetTestCert().get()));
 
   EXPECT_EQ(kTestCertError, deserialized.cert_status);
   EXPECT_EQ(kTestConnectionStatus, deserialized.connection_status);
   EXPECT_EQ(kTestSecurityBits, deserialized.security_bits);
 }
 
 }  // namespace content