Use task runner in version_updater_win.cc.

chrome/browser/google/google_update_win_unittest.cc

 // Copyright 2014 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/google/google_update_win.h"
 
 #include <windows.h>
 #include <atlbase.h>
 #include <atlcom.h>
 
@@ skipping 577 matching lines @@
         base::Bind(&GoogleUpdateFactory::Create,
                    base::Unretained(&mock_google_update_factory_)));
 
     // Compute a newer version.
     base::Version current_version(CHROME_VERSION_STRING);
     new_version_ = base::StringPrintf(L"%u.%u.%u.%u",
                                       current_version.components()[0],
                                       current_version.components()[1],
                                       current_version.components()[2] + 1,
                                       current_version.components()[3]);
+
+    SetUpdateDriverTaskRunnerForTesting(task_runner_.get());

[gab, 2017/07/20 15:51:03]

Also set it to nullptr in TearDown() so future tests in the same process don't
flake by unintentionally grabbing a freed SequencedTaskRunner* from the global.

   }
 
   // Creates app bundle and app mocks that will be used to simulate Google
   // Update.
   void MakeGoogleUpdateMocks(CComObject<MockAppBundle>** mock_app_bundle,
                              CComObject<MockApp>** mock_app) {
     CComObject<MockGoogleUpdate>* google_update =
         mock_google_update_factory_.MakeServerMock();
     CComObject<MockAppBundle>* app_bundle = google_update->MakeAppBundle();
     CComObject<MockApp>* app = app_bundle->MakeApp(kChromeGuid);
@@ skipping 57 matching lines @@
   base::FilePath dir_temp;
   ASSERT_TRUE(PathService::Get(base::FILE_EXE, &file_exe));
   ASSERT_TRUE(PathService::Get(base::DIR_TEMP, &dir_temp));
   file_exe_override_.reset();
   file_exe_override_.reset(new base::ScopedPathOverride(
       base::FILE_EXE, dir_temp.Append(file_exe.BaseName()),
       true /* is_absolute */, false /* create */));
 
   EXPECT_CALL(mock_update_check_delegate_,
               OnError(CANNOT_UPGRADE_CHROME_IN_THIS_DIRECTORY, _, _));
-  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+  BeginUpdateCheck(std::string(), false, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test the case where the GoogleUpdate class can't be created for an update
 // check.
 TEST_P(GoogleUpdateWinTest, NoGoogleUpdateForCheck) {
   // The factory should be called upon: let it fail.
   EXPECT_CALL(mock_google_update_factory_, Create(_));
 
   // Expect the appropriate error when the on-demand class cannot be created.
   EXPECT_CALL(mock_update_check_delegate_,
               OnError(GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND, _, _));
-  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+  BeginUpdateCheck(std::string(), false, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test the case where the GoogleUpdate class can't be created for an upgrade.
 TEST_P(GoogleUpdateWinTest, NoGoogleUpdateForUpgrade) {
   // The factory should be called upon: let it fail.
   EXPECT_CALL(mock_google_update_factory_, Create(_));
 
   // Expect the appropriate error when the on-demand class cannot be created.
   EXPECT_CALL(mock_update_check_delegate_,
               OnError(GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND, _, _));
-  BeginUpdateCheck(task_runner_, std::string(), true, 0,
+  BeginUpdateCheck(std::string(), true, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test the case where the GoogleUpdate class returns an error when an update
 // check is started.
 TEST_P(GoogleUpdateWinTest, FailUpdateCheck) {
   CComObject<MockAppBundle>* mock_app_bundle = nullptr;
   MakeGoogleUpdateMocks(&mock_app_bundle, nullptr);
 
   // checkForUpdate will fail.
   EXPECT_CALL(*mock_app_bundle, checkForUpdate())
       .WillOnce(Return(E_FAIL));
 
   EXPECT_CALL(mock_update_check_delegate_,
               OnError(GOOGLE_UPDATE_ONDEMAND_CLASS_REPORTED_ERROR, _, _));
-  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+  BeginUpdateCheck(std::string(), false, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test the case where the GoogleUpdate class reports that updates are disabled
 // by Group Policy.
 TEST_P(GoogleUpdateWinTest, UpdatesDisabledByPolicy) {
   static const HRESULT GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY = 0x80040813;
 
   CComObject<MockAppBundle>* mock_app_bundle = nullptr;
   CComObject<MockApp>* mock_app = nullptr;
   MakeGoogleUpdateMocks(&mock_app_bundle, &mock_app);
 
   // Expect the bundle to be called on to start the update.
   EXPECT_CALL(*mock_app_bundle, checkForUpdate())
       .WillOnce(Return(S_OK));
 
   mock_app->PushState(STATE_INIT);
   mock_app->PushState(STATE_CHECKING_FOR_UPDATE);
   mock_app->PushErrorState(GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY,
                            L"disabled by policy", -1);
 
   EXPECT_CALL(mock_update_check_delegate_,
               OnError(GOOGLE_UPDATE_DISABLED_BY_POLICY, _, _));
-  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+  BeginUpdateCheck(std::string(), false, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test the case where the GoogleUpdate class reports that manual updates are
 // disabled by Group Policy, but that automatic updates are enabled.
 TEST_P(GoogleUpdateWinTest, ManualUpdatesDisabledByPolicy) {
   static const HRESULT GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY_MANUAL =
       0x8004081f;
 
   CComObject<MockAppBundle>* mock_app_bundle = nullptr;
   CComObject<MockApp>* mock_app = nullptr;
   MakeGoogleUpdateMocks(&mock_app_bundle, &mock_app);
 
   // Expect the bundle to be called on to start the update.
   EXPECT_CALL(*mock_app_bundle, checkForUpdate())
       .WillOnce(Return(S_OK));
 
   mock_app->PushState(STATE_INIT);
   mock_app->PushState(STATE_CHECKING_FOR_UPDATE);
   mock_app->PushErrorState(GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY_MANUAL,
                            L"manual updates disabled by policy", -1);
 
   EXPECT_CALL(mock_update_check_delegate_,
               OnError(GOOGLE_UPDATE_DISABLED_BY_POLICY_AUTO_ONLY, _, _));
-  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+  BeginUpdateCheck(std::string(), false, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test an update check where no update is available.
 TEST_P(GoogleUpdateWinTest, UpdateCheckNoUpdate) {
   CComObject<MockAppBundle>* mock_app_bundle = nullptr;
   CComObject<MockApp>* mock_app = nullptr;
   MakeGoogleUpdateMocks(&mock_app_bundle, &mock_app);
 
   // Expect the bundle to be called on to start the update.
   EXPECT_CALL(*mock_app_bundle, checkForUpdate())
       .WillOnce(Return(S_OK));
 
   mock_app->PushState(STATE_INIT);
   mock_app->PushState(STATE_CHECKING_FOR_UPDATE);
   mock_app->PushState(STATE_NO_UPDATE);
 
   EXPECT_CALL(mock_update_check_delegate_,
               OnUpdateCheckComplete(IsEmpty()));  // new_version
-  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+  BeginUpdateCheck(std::string(), false, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test an update check where an update is available.
 TEST_P(GoogleUpdateWinTest, UpdateCheckUpdateAvailable) {
   CComObject<MockAppBundle>* mock_app_bundle = nullptr;
   CComObject<MockApp>* mock_app = nullptr;
   MakeGoogleUpdateMocks(&mock_app_bundle, &mock_app);
 
   // Expect the bundle to be called on to start the update.
   EXPECT_CALL(*mock_app_bundle, checkForUpdate())
       .WillOnce(Return(S_OK));
 
   mock_app->PushState(STATE_INIT);
   mock_app->PushState(STATE_CHECKING_FOR_UPDATE);
   mock_app->PushUpdateAvailableState(new_version_);
 
   EXPECT_CALL(mock_update_check_delegate_,
               OnUpdateCheckComplete(StrEq(new_version_)));
-  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+  BeginUpdateCheck(std::string(), false, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test a successful upgrade.
 TEST_P(GoogleUpdateWinTest, UpdateInstalled) {
   CComObject<MockAppBundle>* mock_app_bundle = nullptr;
   CComObject<MockApp>* mock_app = nullptr;
   MakeGoogleUpdateMocks(&mock_app_bundle, &mock_app);
 
@@ skipping 24 matching lines @@
                 OnUpgradeProgress(12, StrEq(new_version_)));
     EXPECT_CALL(mock_update_check_delegate_,
                 OnUpgradeProgress(37, StrEq(new_version_)));
     EXPECT_CALL(mock_update_check_delegate_,
                 OnUpgradeProgress(50, StrEq(new_version_)));
     EXPECT_CALL(mock_update_check_delegate_,
                 OnUpgradeProgress(75, StrEq(new_version_)));
     EXPECT_CALL(mock_update_check_delegate_,
                 OnUpgradeComplete(StrEq(new_version_)));
   }
-  BeginUpdateCheck(task_runner_, std::string(), true, 0,
+  BeginUpdateCheck(std::string(), true, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test a failed upgrade where Google Update reports that the installer failed.
 TEST_P(GoogleUpdateWinTest, UpdateFailed) {
   const base::string16 error(L"It didn't work.");
   static const HRESULT GOOPDATEINSTALL_E_INSTALLER_FAILED = 0x80040902;
   static const int kInstallerError = 12;
 
@@ skipping 30 matching lines @@
     EXPECT_CALL(mock_update_check_delegate_,
                 OnUpgradeProgress(37, StrEq(new_version_)));
     EXPECT_CALL(mock_update_check_delegate_,
                 OnUpgradeProgress(50, StrEq(new_version_)));
     EXPECT_CALL(mock_update_check_delegate_,
                 OnUpgradeProgress(75, StrEq(new_version_)));
     EXPECT_CALL(mock_update_check_delegate_,
                 OnError(GOOGLE_UPDATE_ERROR_UPDATING, HasSubstr(error),
                         StrEq(new_version_)));
   }
-  BeginUpdateCheck(task_runner_, std::string(), true, 0,
+  BeginUpdateCheck(std::string(), true, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 // Test that a retry after a USING_EXTERNAL_UPDATER failure succeeds.
 TEST_P(GoogleUpdateWinTest, RetryAfterExternalUpdaterError) {
   static const HRESULT GOOPDATE_E_APP_USING_EXTERNAL_UPDATER = 0xa043081d;
 
   CComObject<MockAppBundle>* mock_app_bundle =
       mock_google_update_factory_.MakeServerMock()->MakeAppBundle();
@@ skipping 20 matching lines @@
   // Expect the bundle to be called on to start the update.
   EXPECT_CALL(*mock_app_bundle, checkForUpdate()).WillOnce(Return(S_OK));
 
   mock_app->PushState(STATE_INIT);
   mock_app->PushState(STATE_CHECKING_FOR_UPDATE);
   mock_app->PushState(STATE_NO_UPDATE);
 
   // Expect the update check to succeed.
   EXPECT_CALL(mock_update_check_delegate_,
               OnUpdateCheckComplete(IsEmpty()));  // new_version
-  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+  BeginUpdateCheck(std::string(), false, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 TEST_P(GoogleUpdateWinTest, UpdateInstalledMultipleDelegates) {
   CComObject<MockAppBundle>* mock_app_bundle = nullptr;
   CComObject<MockApp>* mock_app = nullptr;
   MakeGoogleUpdateMocks(&mock_app_bundle, &mock_app);
 
   // Expect the bundle to be called on to start the update.
@@ skipping 39 matching lines @@
     EXPECT_CALL(mock_update_check_delegate_,
                 OnUpgradeProgress(75, StrEq(new_version_)));
     EXPECT_CALL(mock_update_check_delegate_2,
                 OnUpgradeProgress(75, StrEq(new_version_)));
 
     EXPECT_CALL(mock_update_check_delegate_,
                 OnUpgradeComplete(StrEq(new_version_)));
     EXPECT_CALL(mock_update_check_delegate_2,
                 OnUpgradeComplete(StrEq(new_version_)));
   }
-  BeginUpdateCheck(task_runner_, std::string(), true, 0,
+  BeginUpdateCheck(std::string(), true, 0,
                    mock_update_check_delegate_.AsWeakPtr());
-  BeginUpdateCheck(task_runner_, std::string(), true, 0,
+  BeginUpdateCheck(std::string(), true, 0,
                    mock_update_check_delegate_2.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 INSTANTIATE_TEST_CASE_P(UserLevel, GoogleUpdateWinTest, Values(false));
 
 INSTANTIATE_TEST_CASE_P(SystemLevel, GoogleUpdateWinTest, Values(true));