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>
 
 #include <memory>
 #include <queue>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_path_override.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/test/test_reg_util_win.h"
-#include "base/test/test_simple_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "chrome/common/chrome_version.h"
 #include "chrome/install_static/test/scoped_install_details.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/helper.h"
 #include "google_update/google_update_idl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 487 matching lines @@
   static void SetUpTestCase() {
     ui::win::CreateATLModuleIfNeeded();
     // Configure all mock functions that return HRESULT to return failure.
     ::testing::DefaultValue<HRESULT>::Set(E_FAIL);
   }
 
   static void TearDownTestCase() { ::testing::DefaultValue<HRESULT>::Clear(); }
 
  protected:
   GoogleUpdateWinTest()
-      : task_runner_(new base::TestSimpleTaskRunner()),
-        task_runner_handle_(task_runner_),
-        system_level_install_(GetParam()),
+      : system_level_install_(GetParam()),
         scoped_install_details_(system_level_install_, 0) {}
 
   void SetUp() override {
     ::testing::TestWithParam<bool>::SetUp();
 
     // Override FILE_EXE so that it looks like the test is running from the
     // standard install location for this mode (system-level or user-level).
     base::FilePath file_exe;
     ASSERT_TRUE(PathService::Get(base::FILE_EXE, &file_exe));
     base::FilePath install_dir(
@@ skipping 70 matching lines @@
   void TearDown() override {
     // Remove the test's IGoogleUpdate on-demand update class factory.
     SetGoogleUpdateFactoryForTesting(GoogleUpdate3ClassFactory());
     ::testing::TestWithParam<bool>::TearDown();
   }
 
   static const base::char16 kClients[];
   static const base::char16 kClientState[];
   static const base::char16 kChromeGuid[];
 
-  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;

[gab, 2017/07/17 17:14:40]

TestSimpleTaskRunner ignores delays in delayed tasks which explains why some
tasks now fail to run.

ScopedTaskEnvironment will eventually provide a mock clock [1] but for now it
unfortunately still doesn't (work in progress)...

The simplest solution is probably to add
UpdateCheckDriver::SetTaskRunnerForTesting() and inject your
TestSimpleTaskRunner with a TODO against https://crbug.com/708584 to use
ScopedTaskEnvironment when it supports mock time.

[1]
https://docs.google.com/document/d/1QabRo8c7D9LsYY3cEcaPQbOCLo8Tu-6VLykYXyl3P...

[calamity, 2017/07/19 09:03:38]

Done.

-  base::ThreadTaskRunnerHandle task_runner_handle_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   bool system_level_install_;
   install_static::ScopedInstallDetails scoped_install_details_;
   std::unique_ptr<base::ScopedPathOverride> file_exe_override_;
   std::unique_ptr<base::ScopedPathOverride> program_files_override_;
   std::unique_ptr<base::ScopedPathOverride> program_files_x86_override_;
   std::unique_ptr<base::ScopedPathOverride> local_app_data_override_;
   registry_util::RegistryOverrideManager registry_override_manager_;
 
   // A mock object, the OnUpdateCheckCallback method of which will be invoked
   // each time the update check machinery invokes the given UpdateCheckCallback.
@@ skipping 28 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();
+  scoped_task_environment_.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();
+  scoped_task_environment_.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();
+  scoped_task_environment_.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();
+  scoped_task_environment_.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();
+  scoped_task_environment_.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();
+  scoped_task_environment_.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();
+  scoped_task_environment_.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();
+  scoped_task_environment_.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);
 
   // Expect the bundle to be called on to start the update.
   EXPECT_CALL(*mock_app_bundle, checkForUpdate())
@@ skipping 22 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();
+  scoped_task_environment_.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;
 
   CComObject<MockAppBundle>* mock_app_bundle = nullptr;
   CComObject<MockApp>* mock_app = nullptr;
@@ skipping 28 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();
+  scoped_task_environment_.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();
 
   // The first attempt will fail in createInstalledApp indicating that an update
@@ skipping 18 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();
+  scoped_task_environment_.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.
   EXPECT_CALL(*mock_app_bundle, checkForUpdate()).WillOnce(Return(S_OK));
   // Expect the bundle to be called on to start the install.
@@ skipping 37 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();
+  scoped_task_environment_.RunUntilIdle();
 }
 
 INSTANTIATE_TEST_CASE_P(UserLevel, GoogleUpdateWinTest, Values(false));
 
 INSTANTIATE_TEST_CASE_P(SystemLevel, GoogleUpdateWinTest, Values(true));