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

chrome/browser/prerender/prerender_browsertest.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 <stddef.h>
-
 #include <deque>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
@@ skipping 650 matching lines @@
   TestPrerenderContentsFactory() {}
 
   ~TestPrerenderContentsFactory() override {
     EXPECT_TRUE(expected_contents_queue_.empty());
   }
 
   scoped_ptr<TestPrerender> ExpectPrerenderContents(FinalStatus final_status) {
     scoped_ptr<TestPrerender> handle(new TestPrerender());
     expected_contents_queue_.push_back(
         ExpectedContents(final_status, handle->AsWeakPtr()));
-    return handle.Pass();
+    return handle;
   }
 
   PrerenderContents* CreatePrerenderContents(
       PrerenderManager* prerender_manager,
       Profile* profile,
       const GURL& url,
       const content::Referrer& referrer,
       Origin origin) override {
     ExpectedContents expected;
     if (!expected_contents_queue_.empty()) {
@@ skipping 208 matching lines @@
 
 // Makes |url| never respond on the first load, and then with the contents of
 // |file| afterwards. When the first load has been scheduled, runs |callback| on
 // the UI thread.
 void CreateHangingFirstRequestInterceptorOnIO(
     const GURL& url, const base::FilePath& file, base::Closure callback) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   scoped_ptr<net::URLRequestInterceptor> never_respond_handler(
       new HangingFirstRequestInterceptor(file, callback));
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
-      url, never_respond_handler.Pass());
+      url, std::move(never_respond_handler));
 }
 
 // Wrapper over URLRequestMockHTTPJob that exposes extra callbacks.
 class MockHTTPJob : public net::URLRequestMockHTTPJob {
  public:
   MockHTTPJob(net::URLRequest* request,
               net::NetworkDelegate* delegate,
               const base::FilePath& file)
       : net::URLRequestMockHTTPJob(
             request,
@@ skipping 85 matching lines @@
 // Makes |url| respond to requests with the contents of |file|, counting the
 // number that start in |counter|.
 void CreateCountingInterceptorOnIO(
     const GURL& url,
     const base::FilePath& file,
     const base::WeakPtr<RequestCounter>& counter) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   scoped_ptr<net::URLRequestInterceptor> request_interceptor(
       new CountingInterceptor(file, counter));
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
-      url, request_interceptor.Pass());
+      url, std::move(request_interceptor));
 }
 
 // Makes |url| respond to requests with the contents of |file|.
 void CreateMockInterceptorOnIO(const GURL& url, const base::FilePath& file) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
       url,
       net::URLRequestMockHTTPJob::CreateInterceptorForSingleFile(
           file, BrowserThread::GetBlockingPool()));
 }
@@ skipping 609 matching lines @@
 
     // Test that the referring page received the right start and load events.
     EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
     if (check_load_events_) {
       EXPECT_EQ(expected_number_of_loads, prerenders[0]->number_of_loads());
       EXPECT_EQ(expected_number_of_loads,
                 GetPrerenderLoadEventCountForLinkNumber(0));
     }
     EXPECT_FALSE(HadPrerenderEventErrors());
 
-    return prerenders.Pass();
+    return prerenders;
   }
 
   void NavigateToURLImpl(const content::OpenURLParams& params,
                          bool expect_swap_to_succeed) const {
     ASSERT_NE(static_cast<PrerenderManager*>(NULL), GetPrerenderManager());
     // Make sure in navigating we have a URL to use in the PrerenderManager.
     ASSERT_NE(static_cast<PrerenderContents*>(NULL), GetPrerenderContents());
 
     WebContents* web_contents = GetPrerenderContents()->prerender_contents();
 
@@ skipping 2236 matching lines @@
       const GURL& url,
       FinalStatus expected_final_status) {
     scoped_ptr<TestPrerender> prerender =
         ExpectPrerender(expected_final_status);
     WebContents* web_contents = GetActiveWebContents();
     GetAutocompleteActionPredictor()->StartPrerendering(
         url,
         web_contents->GetController().GetDefaultSessionStorageNamespace(),
         gfx::Size(50, 50));
     prerender->WaitForStart();
-    return prerender.Pass();
+    return prerender;
   }
 };
 
 // Checks that closing the omnibox popup cancels an omnibox prerender.
 // http://crbug.com/395152
 IN_PROC_BROWSER_TEST_F(PrerenderOmniboxBrowserTest,
                        DISABLED_PrerenderOmniboxCancel) {
   // Fake an omnibox prerender.
   scoped_ptr<TestPrerender> prerender = StartOmniboxPrerender(
       embedded_test_server()->GetURL("/empty.html"), FINAL_STATUS_CANCELLED);
@@ skipping 135 matching lines @@
 
   NavigateToDestURL();
   EXPECT_EQ(1U, task_manager.tasks().size());
 }
 
 }  // namespace
 
 #endif  // defined(ENABLE_TASK_MANAGER)
 
 }  // namespace prerender