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

chrome/browser/extensions/updater/extension_updater_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 "chrome/browser/extensions/updater/extension_updater.h"
+
 #include <stddef.h>
 #include <stdint.h>
-
 #include <list>
 #include <map>
 #include <set>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.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/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/version.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/extensions/updater/chrome_extension_downloader_factory.h"
-#include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/google/google_brand.h"
 #include "chrome/test/base/scoped_testing_local_state.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/crx_file/id_util.h"
 #include "components/syncable_prefs/pref_service_syncable.h"
 #include "components/update_client/update_query_params.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
@@ skipping 323 matching lines @@
  private:
   scoped_ptr<ExtensionDownloader> CreateExtensionDownloader(
       ExtensionDownloaderDelegate* delegate) {
     scoped_ptr<ExtensionDownloader> downloader =
         ChromeExtensionDownloaderFactory::CreateForRequestContext(
             request_context(),
             downloader_delegate_override_ ? downloader_delegate_override_
                                           : delegate);
     if (enable_metrics_)
       downloader->set_enable_extra_update_metrics(true);
-    return downloader.Pass();
+    return downloader;
   }
 
   scoped_ptr<ExtensionDownloader> CreateExtensionDownloaderWithIdentity(
       ExtensionDownloaderDelegate* delegate) {
     scoped_ptr<FakeIdentityProvider> fake_identity_provider;
     fake_token_service_.reset(new FakeOAuth2TokenService());
     fake_identity_provider.reset(new FakeIdentityProvider(
           fake_token_service_.get()));
     fake_identity_provider->LogIn(kFakeAccountId);
     fake_token_service_->AddAccount(kFakeAccountId);
 
     scoped_ptr<ExtensionDownloader> downloader(
         CreateExtensionDownloader(delegate));
-    downloader->SetWebstoreIdentityProvider(fake_identity_provider.Pass());
-    return downloader.Pass();
+    downloader->SetWebstoreIdentityProvider(std::move(fake_identity_provider));
+    return downloader;
   }
 
   scoped_ptr<FakeOAuth2TokenService> fake_token_service_;
 
   ExtensionDownloaderDelegate* downloader_delegate_override_;
 
   bool enable_metrics_;
 
   DISALLOW_COPY_AND_ASSIGN(MockService);
 };
@@ skipping 543 matching lines @@
     fetch4->AddExtension("4444", "4.0", &zeroDays, kEmptyUpdateUrlData,
                          std::string());
 
     // This will start the first fetcher and queue the others. The next in queue
     // is started as each fetcher receives its response. Note that the fetchers
     // don't necessarily run in the order that they are started from here.
     GURL fetch1_url = fetch1->full_url();
     GURL fetch2_url = fetch2->full_url();
     GURL fetch3_url = fetch3->full_url();
     GURL fetch4_url = fetch4->full_url();
-    downloader.StartUpdateCheck(fetch1.Pass());
-    downloader.StartUpdateCheck(fetch2.Pass());
-    downloader.StartUpdateCheck(fetch3.Pass());
-    downloader.StartUpdateCheck(fetch4.Pass());
+    downloader.StartUpdateCheck(std::move(fetch1));
+    downloader.StartUpdateCheck(std::move(fetch2));
+    downloader.StartUpdateCheck(std::move(fetch3));
+    downloader.StartUpdateCheck(std::move(fetch4));
     RunUntilIdle();
 
     for (int i = 0; i < 4; ++i) {
       fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
       ASSERT_TRUE(fetcher);
       ASSERT_TRUE(fetcher->delegate());
       EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
       EXPECT_FALSE(fetcher->GetOriginalURL().is_empty());
 
       if (fetcher->GetOriginalURL() == fetch1_url) {
@@ skipping 101 matching lines @@
     downloader.manifests_queue_.set_backoff_policy(&kNoBackoffPolicy);
 
     GURL kUpdateUrl("http://localhost/manifest1");
 
     scoped_ptr<ManifestFetchData> fetch(CreateManifestFetchData(kUpdateUrl));
     ManifestFetchData::PingData zeroDays(0, 0, true, 0);
     fetch->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData,
                         std::string());
 
     // This will start the first fetcher.
-    downloader.StartUpdateCheck(fetch.Pass());
+    downloader.StartUpdateCheck(std::move(fetch));
     RunUntilIdle();
 
     // ExtensionDownloader should retry kMaxRetries times and then fail.
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
         "1111", ExtensionDownloaderDelegate::MANIFEST_FETCH_FAILED, _, _));
     for (int i = 0; i <= ExtensionDownloader::kMaxRetries; ++i) {
       // All fetches will fail.
       fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
       EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
       EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
       fetcher->set_url(kUpdateUrl);
       fetcher->set_status(net::URLRequestStatus());
       // Code 5xx causes ExtensionDownloader to retry.
       fetcher->set_response_code(500);
       fetcher->delegate()->OnURLFetchComplete(fetcher);
       RunUntilIdle();
     }
     Mock::VerifyAndClearExpectations(&delegate);
 
 
     // For response codes that are not in the 5xx range ExtensionDownloader
     // should not retry.
     fetch.reset(CreateManifestFetchData(kUpdateUrl));
     fetch->AddExtension("1111", "1.0", &zeroDays, kEmptyUpdateUrlData,
                         std::string());
 
     // This will start the first fetcher.
-    downloader.StartUpdateCheck(fetch.Pass());
+    downloader.StartUpdateCheck(std::move(fetch));
     RunUntilIdle();
 
     EXPECT_CALL(delegate, OnExtensionDownloadFailed(
         "1111", ExtensionDownloaderDelegate::MANIFEST_FETCH_FAILED, _, _));
     // The first fetch will fail, and require retrying.
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
     fetcher->set_url(kUpdateUrl);
     fetcher->set_status(net::URLRequestStatus());
@@ skipping 38 matching lines @@
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash;
     Version version("0.0.1");
     std::set<int> requests;
     requests.insert(0);
     scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch(
         new ExtensionDownloader::ExtensionFetch(
             id, test_url, hash, version.GetString(), requests));
-    updater.downloader_->FetchUpdatedExtension(fetch.Pass());
+    updater.downloader_->FetchUpdatedExtension(std::move(fetch));
 
     if (pending) {
       const bool kIsFromSync = true;
       const bool kMarkAcknowledged = false;
       const bool kRemoteInstall = false;
       PendingExtensionManager* pending_extension_manager =
           service->pending_extension_manager();
       pending_extension_manager->AddForTesting(
           PendingExtensionInfo(id,
                                std::string(),
@@ skipping 89 matching lines @@
 
     GURL test_url(base::StringPrintf("%s/extension.crx", url_prefix.c_str()));
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash;
   Version version("0.0.1");
     std::set<int> requests;
     requests.insert(0);
     scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch(
         new ExtensionDownloader::ExtensionFetch(
             id, test_url, hash, version.GetString(), requests));
-    updater.downloader_->FetchUpdatedExtension(fetch.Pass());
+    updater.downloader_->FetchUpdatedExtension(std::move(fetch));
 
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_EQ(kExpectedLoadFlags, fetcher->GetLoadFlags());
 
     // Fake a 403 response.
     fetcher->set_url(test_url);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(403);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
@@ skipping 172 matching lines @@
     std::string version2 = "0.1";
     std::set<int> requests;
     requests.insert(0);
     // Start two fetches
     scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch1(
         new ExtensionDownloader::ExtensionFetch(
             id1, url1, hash1, version1, requests));
     scoped_ptr<ExtensionDownloader::ExtensionFetch> fetch2(
         new ExtensionDownloader::ExtensionFetch(
             id2, url2, hash2, version2, requests));
-    updater.downloader_->FetchUpdatedExtension(fetch1.Pass());
-    updater.downloader_->FetchUpdatedExtension(fetch2.Pass());
+    updater.downloader_->FetchUpdatedExtension(std::move(fetch1));
+    updater.downloader_->FetchUpdatedExtension(std::move(fetch2));
 
     // Make the first fetch complete.
     base::FilePath extension_file_path(FILE_PATH_LITERAL("/whatever"));
 
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
 
     // We need some CrxInstallers, and CrxInstallers require a real
     // ExtensionService.  Create one on the testing profile.  Any action
@@ skipping 767 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions