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

chrome/browser/download/download_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 "chrome/browser/download/download_browsertest.h"
+
 #include <stdint.h>
-
 #include <sstream>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/test/test_file_util.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
-#include "chrome/browser/download/download_browsertest.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_item_model.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_request_limiter.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/download/download_target_determiner.h"
 #include "chrome/browser/download/download_test_file_activity_observer.h"
@@ skipping 219 matching lines @@
       scoped_ptr<std::vector<history::DownloadRow> >* results) {
     history::HistoryService* hs = HistoryServiceFactory::GetForProfile(
         profile_, ServiceAccessType::EXPLICIT_ACCESS);
     DCHECK(hs);
     hs->QueryDownloads(
         base::Bind(&DownloadsHistoryDataCollector::OnQueryDownloadsComplete,
                    base::Unretained(this)));
 
     content::RunMessageLoop();
     if (result_valid_) {
-      *results = results_.Pass();
+      *results = std::move(results_);
     }
     return result_valid_;
   }
 
  private:
   void OnQueryDownloadsComplete(
       scoped_ptr<std::vector<history::DownloadRow> > entries) {
     result_valid_ = true;
-    results_ = entries.Pass();
+    results_ = std::move(entries);
     base::MessageLoopForUI::current()->QuitWhenIdle();
   }
 
   Profile* profile_;
   scoped_ptr<std::vector<history::DownloadRow> > results_;
   bool result_valid_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadsHistoryDataCollector);
 };
 
@@ skipping 573 matching lines @@
     }
 
     if (download_info.download_method == DOWNLOAD_DIRECT) {
       // Go directly to download.  Don't wait for navigation.
       scoped_refptr<content::DownloadTestItemCreationObserver>
           creation_observer(new content::DownloadTestItemCreationObserver);
 
       scoped_ptr<DownloadUrlParameters> params(
           DownloadUrlParameters::FromWebContents(web_contents, url));
       params->set_callback(creation_observer->callback());
-      DownloadManagerForBrowser(browser())->DownloadUrl(params.Pass());
+      DownloadManagerForBrowser(browser())->DownloadUrl(std::move(params));
 
       // Wait until the item is created, or we have determined that it
       // won't be.
       creation_observer->WaitForDownloadItemCreation();
 
       ASSERT_EQ(download_info.show_download_item,
                 creation_observer->succeeded());
       if (download_info.show_download_item) {
         EXPECT_EQ(content::DOWNLOAD_INTERRUPT_REASON_NONE,
                   creation_observer->interrupt_reason());
@@ skipping 295 matching lines @@
 //   S -> C: HTTP/1.1 200 OK
 //           Content-Type: foo/bar
 //           ...
 static scoped_ptr<net::test_server::HttpResponse> RespondWithContentTypeHandler(
     const net::test_server::HttpRequest& request) {
   scoped_ptr<net::test_server::BasicHttpResponse> response(
       new net::test_server::BasicHttpResponse());
   response->set_content_type(request.relative_url.substr(1));
   response->set_code(net::HTTP_OK);
   response->set_content("ooogaboogaboogabooga");
-  return response.Pass();
+  return std::move(response);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, MimeTypesToShowNotDownload) {
   embedded_test_server()->RegisterRequestHandler(
       base::Bind(&RespondWithContentTypeHandler));
   ASSERT_TRUE(embedded_test_server()->Start());
 
   // These files should all be displayed in the browser.
   const char* mime_types[] = {
     // It is unclear whether to display text/css or download it.
@@ skipping 398 matching lines @@
         content::WebContents::CreateParams(tab->GetBrowserContext()));
   ASSERT_TRUE(new_tab);
   ASSERT_TRUE(new_tab->GetController().IsInitialNavigation());
   browser()->tab_strip_model()->AppendWebContents(new_tab, true);
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 
   // Download a file in that new tab, having it open a file picker
   scoped_ptr<DownloadUrlParameters> params(
       DownloadUrlParameters::FromWebContents(new_tab, slow_download_url));
   params->set_prompt(true);
-  manager->DownloadUrl(params.Pass());
+  manager->DownloadUrl(std::move(params));
   observer->WaitForFinished();
 
   DownloadManager::DownloadVector items;
   manager->GetAllDownloads(&items);
   ASSERT_NE(0u, items.size());
   DownloadItem* item = items[0];
   EXPECT_TRUE(item != nullptr);
 
   // When the download is canceled, the second tab should close.
   EXPECT_EQ(item->GetState(), DownloadItem::CANCELLED);
@@ skipping 12 matching lines @@
   scoped_ptr<net::test_server::BasicHttpResponse> response(
       new net::test_server::BasicHttpResponse());
   size_t query_position = request.relative_url.find('?');
 
   if (query_position == std::string::npos) {
     response->set_code(net::HTTP_PERMANENT_REDIRECT);
     response->AddCustomHeader("Location",
                               "https://request-had-no-query-string");
     response->set_content_type("text/plain");
     response->set_content("Error");
-    return response.Pass();
+    return std::move(response);
   }
 
   response->set_code(net::HTTP_PERMANENT_REDIRECT);
   response->AddCustomHeader("Location",
                             request.relative_url.substr(query_position + 1));
   response->set_content_type("text/plain");
   response->set_content("It's gone!");
-  return response.Pass();
+  return std::move(response);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadHistoryCheck) {
   GURL download_url(net::URLRequestSlowDownloadJob::kKnownSizeUrl);
   base::FilePath file(net::GenerateFileName(download_url,
                                             std::string(),
                                             std::string(),
                                             std::string(),
                                             std::string(),
                                             std::string()));
@@ skipping 411 matching lines @@
       browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(web_contents);
 
   content::DownloadTestObserver* observer(
       new content::DownloadTestObserverTerminal(
           DownloadManagerForBrowser(browser()), 1,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
   scoped_ptr<DownloadUrlParameters> params(
       DownloadUrlParameters::FromWebContents(web_contents, url));
   params->set_prompt(true);
-  DownloadManagerForBrowser(browser())->DownloadUrl(params.Pass());
+  DownloadManagerForBrowser(browser())->DownloadUrl(std::move(params));
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
   EXPECT_TRUE(DidShowFileChooser());
 
   // Check state.
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   ASSERT_TRUE(CheckDownload(browser(), file, file));
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadUrlToPath) {
   GURL url(URLRequestMockHTTPJob::GetMockUrl(kDownloadTest1Path));
 
   WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_TRUE(web_contents);
 
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   base::ScopedTempDir other_directory;
   ASSERT_TRUE(other_directory.CreateUniqueTempDir());
   base::FilePath target_file_full_path
       = other_directory.path().Append(file.BaseName());
   content::DownloadTestObserver* observer(CreateWaiter(browser(), 1));
   scoped_ptr<DownloadUrlParameters> params(
       DownloadUrlParameters::FromWebContents(web_contents, url));
   params->set_file_path(target_file_full_path);
-  DownloadManagerForBrowser(browser())->DownloadUrl(params.Pass());
+  DownloadManagerForBrowser(browser())->DownloadUrl(std::move(params));
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   ASSERT_TRUE(CheckDownloadFullPaths(browser(),
                                      target_file_full_path,
                                      OriginFile(file)));
 
   // Temporary are treated as auto-opened, and after that open won't be
@@ skipping 72 matching lines @@
 // with query string ?allow-post-only, and returns a 404 response if the method
 // is not POST.
 static scoped_ptr<net::test_server::HttpResponse> FilterPostOnlyURLsHandler(
     const net::test_server::HttpRequest& request) {
   scoped_ptr<net::test_server::BasicHttpResponse> response;
   if (request.relative_url.find("?allow-post-only") != std::string::npos &&
       request.method != net::test_server::METHOD_POST) {
     response.reset(new net::test_server::BasicHttpResponse());
     response->set_code(net::HTTP_NOT_FOUND);
   }
-  return response.Pass();
+  return std::move(response);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, SavePageNonHTMLViaPost) {
   embedded_test_server()->RegisterRequestHandler(
       base::Bind(&FilterPostOnlyURLsHandler));
   embedded_test_server()->ServeFilesFromDirectory(GetTestDataDirectory());
   ASSERT_TRUE(embedded_test_server()->Start());
   EnableFileChooser(true);
   std::vector<DownloadItem*> download_items;
   GetDownloads(browser(), &download_items);
@@ skipping 368 matching lines @@
   if (request.relative_url.find("/echoreferrer") != 0)
     return scoped_ptr<net::test_server::HttpResponse>();
 
   scoped_ptr<net::test_server::BasicHttpResponse> response(
       new net::test_server::BasicHttpResponse());
   response->set_code(net::HTTP_OK);
   response->set_content_type("text/plain");
   auto referrer_header = request.headers.find(kReferrerHeader);
   if (referrer_header != request.headers.end())
     response->set_content(referrer_header->second);
-  return response.Pass();
+  return std::move(response);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, LoadURLExternallyReferrerPolicy) {
   embedded_test_server()->RegisterRequestHandler(
       base::Bind(&EchoReferrerRequestHandler));
   embedded_test_server()->ServeFilesFromDirectory(GetTestDataDirectory());
   ASSERT_TRUE(embedded_test_server()->Start());
   EnableFileChooser(true);
   std::vector<DownloadItem*> download_items;
   GetDownloads(browser(), &download_items);
@@ skipping 993 matching lines @@
       new content::DownloadTestObserverTerminal(
           download_manager, 1,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_FAIL));
 
   // Download and set IsHiddenDownload to true.
   WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   scoped_ptr<DownloadUrlParameters> params(
       DownloadUrlParameters::FromWebContents(web_contents, url));
   params->set_callback(base::Bind(&SetHiddenDownloadCallback));
-  download_manager->DownloadUrl(params.Pass());
+  download_manager->DownloadUrl(std::move(params));
   observer->WaitForFinished();
 
   // Verify that download shelf is not shown.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }
 
 // Test to make sure auto-open works.
 IN_PROC_BROWSER_TEST_F(DownloadTestWithShelf, AutoOpen) {
   base::FilePath file(FILE_PATH_LITERAL("download-autoopen.txt"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl("download-autoopen.txt"));
@@ skipping 17 matching lines @@
 
   scoped_ptr<content::DownloadTestObserver> observer(DangerousDownloadWaiter(
       browser(), 1, content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
 
   // Download shelf should close.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }