text: // 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 <queue>
  
  #include "base/base_paths.h"
  #include "base/memory/ref_counted.h"
  #include "base/path_service.h"
  #include "base/strings/string_number_conversions.h"
  #include "base/strings/stringprintf.h"
  #include "base/strings/utf_string_conversions.h"
  #include "base/test/scoped_path_override.h"
  #include "base/test/test_reg_util_win.h"
  #include "base/test/test_simple_task_runner.h"
  #include "base/thread_task_runner_handle.h"
  #include "base/version.h"
  #include "base/win/registry.h"
  #include "chrome/installer/util/browser_distribution.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"
  #include "ui/base/win/atl_module.h"
  #include "version.h"
  
  using ::testing::DoAll;
  using ::testing::Invoke;
  using ::testing::IsEmpty;
  using ::testing::Return;
  using ::testing::SetArgPointee;
  using ::testing::StrEq;
  using ::testing::Unused;
  using ::testing::Values;
  using ::testing::_;
  
  namespace {
  
  class UpdateCheckCallbackReceiver {
   public:
    UpdateCheckCallbackReceiver() {}
    virtual ~UpdateCheckCallbackReceiver() {}
    virtual void OnUpdateCheckCallback(GoogleUpdateUpgradeResult result,
                                       GoogleUpdateErrorCode error_code,
                                       const base::string16& error_message,
                                       const base::string16& version) = 0;
    UpdateCheckCallback GetCallback() {
      return base::Bind(&UpdateCheckCallbackReceiver::UpdateCheckCallback,
                        base::Unretained(this));
    }
  
   private:
    void UpdateCheckCallback(GoogleUpdateUpgradeResult result,
                             GoogleUpdateErrorCode error_code,
                             const base::string16& error_message,
                             const base::string16& version) {
      OnUpdateCheckCallback(result, error_code, error_message, version);
    }
  
    DISALLOW_COPY_AND_ASSIGN(UpdateCheckCallbackReceiver);
  };
  
  class MockUpdateCheckCallbackReceiver : public UpdateCheckCallbackReceiver {
   public:
    MockUpdateCheckCallbackReceiver() {}
    MOCK_METHOD4(OnUpdateCheckCallback,
                 void(GoogleUpdateUpgradeResult,
                      GoogleUpdateErrorCode,
                      const base::string16&,
                      const base::string16&));
  
   private:
    DISALLOW_COPY_AND_ASSIGN(MockUpdateCheckCallbackReceiver);
  };
  
  class GoogleUpdateFactory {
   public:
    virtual ~GoogleUpdateFactory() {}
    virtual HRESULT Create(base::win::ScopedComPtr<IGoogleUpdate>* on_demand) = 0;
  };
  
  class MockGoogleUpdateFactory : public GoogleUpdateFactory {
   public:
    MockGoogleUpdateFactory() {}
    MOCK_METHOD1(Create, HRESULT(base::win::ScopedComPtr<IGoogleUpdate>*));
  
   private:
    DISALLOW_COPY_AND_ASSIGN(MockGoogleUpdateFactory);
  };
  
  // A mock IGoogleUpdate on-demand update class that can run an IJobObserver
  // through a set of states.
  class MockOnDemand : public CComObjectRootEx<CComSingleThreadModel>,
                       public IGoogleUpdate {
   public:
    BEGIN_COM_MAP(MockOnDemand)
      COM_INTERFACE_ENTRY(IGoogleUpdate)
    END_COM_MAP()
  
    MockOnDemand() : task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
  
    MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
                               CheckForUpdate,
                               HRESULT(const wchar_t*, IJobObserver*));
    MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
                               Update,
                               HRESULT(const wchar_t*, IJobObserver*));
  
    void OnCheckRunUpToDateSequence(const base::char16* app_guid) {
      EXPECT_CALL(*this, CheckForUpdate(StrEq(app_guid), _))
          .WillOnce(DoAll(Invoke(this, &MockOnDemand::BeginUpToDateSequence),
                          Return(S_OK)));
    }
  
    void OnCheckRunUpdateAvailableSequence(const base::char16* app_guid,
                                           const base::string16& new_version) {
      new_version_ = new_version;
      EXPECT_CALL(*this, CheckForUpdate(StrEq(app_guid), _))
          .WillOnce(
              DoAll(Invoke(this, &MockOnDemand::BeginUpdateAvailableSequence),
                    Return(S_OK)));
    }
  
    void OnUpdateRunInstallUpdateSequence(const base::char16* app_guid,
                                          const base::string16& new_version) {
      new_version_ = new_version;
      EXPECT_CALL(*this, Update(StrEq(app_guid), _))
          .WillOnce(DoAll(Invoke(this, &MockOnDemand::BeginInstallUpdateSequence),
                          Return(S_OK)));
    }
  
    void OnUpdateRunUpdateErrorSequence(const base::char16* app_guid,
                                        const base::char16* error_text) {
      error_text_ = error_text;
      EXPECT_CALL(*this, Update(StrEq(app_guid), _))
          .WillOnce(DoAll(Invoke(this, &MockOnDemand::BeginUpdateErrorSequence),
                          Return(S_OK)));
    }
  
   private:
    enum State {
      STATE_CHECKING,
      STATE_COMPLETE_SUCCESS,
      STATE_UPDATE_AVAILABLE,
      STATE_WAITING_TO_DOWNLOAD,
      STATE_DOWNLOADING_25,
      STATE_DOWNLOADING_100,
      STATE_WAITING_TO_INSTALL,
      STATE_INSTALLING,
      STATE_COMPLETE_ERROR,
    };
  
    void BeginUpToDateSequence(Unused, IJobObserver* job_observer_ptr) {
      job_observer_ = job_observer_ptr;
      states_.push(STATE_CHECKING);
      states_.push(STATE_COMPLETE_SUCCESS);
      task_runner_->PostTask(
          FROM_HERE, base::Bind(&MockOnDemand::Advance, base::Unretained(this)));
    }
  
    void BeginUpdateAvailableSequence(Unused, IJobObserver* job_observer_ptr) {
      job_observer_ = job_observer_ptr;
      states_.push(STATE_CHECKING);
      states_.push(STATE_UPDATE_AVAILABLE);
      states_.push(STATE_COMPLETE_SUCCESS);
      task_runner_->PostTask(
          FROM_HERE, base::Bind(&MockOnDemand::Advance, base::Unretained(this)));
    }
  
    void BeginInstallUpdateSequence(Unused, IJobObserver* job_observer_ptr) {
      job_observer_ = job_observer_ptr;
      states_.push(STATE_CHECKING);
      states_.push(STATE_UPDATE_AVAILABLE);
      states_.push(STATE_WAITING_TO_DOWNLOAD);
      states_.push(STATE_DOWNLOADING_25);
      states_.push(STATE_DOWNLOADING_100);
      states_.push(STATE_WAITING_TO_INSTALL);
      states_.push(STATE_INSTALLING);
      states_.push(STATE_COMPLETE_SUCCESS);
      task_runner_->PostTask(
          FROM_HERE, base::Bind(&MockOnDemand::Advance, base::Unretained(this)));
    }
  
    void BeginUpdateErrorSequence(Unused, IJobObserver* job_observer_ptr) {
      job_observer_ = job_observer_ptr;
      states_.push(STATE_CHECKING);
      states_.push(STATE_UPDATE_AVAILABLE);
      states_.push(STATE_WAITING_TO_DOWNLOAD);
      states_.push(STATE_DOWNLOADING_25);
      states_.push(STATE_DOWNLOADING_100);
      states_.push(STATE_WAITING_TO_INSTALL);
      states_.push(STATE_INSTALLING);
      states_.push(STATE_COMPLETE_ERROR);
      task_runner_->PostTask(
          FROM_HERE, base::Bind(&MockOnDemand::Advance, base::Unretained(this)));
    }
  
    // Advance to the next state. If this state is non-terminal, a task is posted
    // to advance to the next state a bit later.
    void Advance() {
      ASSERT_FALSE(states_.empty());
      switch (states_.front()) {
        case STATE_CHECKING:
          EXPECT_EQ(S_OK, job_observer_->OnCheckingForUpdate());
          break;
        case STATE_COMPLETE_SUCCESS:
          EXPECT_EQ(S_OK,
                    job_observer_->OnComplete(COMPLETION_CODE_SUCCESS, nullptr));
          break;
        case STATE_UPDATE_AVAILABLE:
          EXPECT_EQ(S_OK, job_observer_->OnUpdateAvailable(new_version_.c_str()));
          break;
        case STATE_WAITING_TO_DOWNLOAD:
          EXPECT_EQ(S_OK, job_observer_->OnWaitingToDownload());
          break;
        case STATE_DOWNLOADING_25:
          EXPECT_EQ(S_OK, job_observer_->OnDownloading(47, 25));
          break;
        case STATE_DOWNLOADING_100:
          EXPECT_EQ(S_OK, job_observer_->OnDownloading(42, 100));
          break;
        case STATE_WAITING_TO_INSTALL:
          EXPECT_EQ(S_OK, job_observer_->OnWaitingToInstall());
          break;
        case STATE_INSTALLING:
          EXPECT_EQ(S_OK, job_observer_->OnInstalling());
          break;
        case STATE_COMPLETE_ERROR:
          EXPECT_EQ(S_OK, job_observer_->OnComplete(COMPLETION_CODE_ERROR,
                                                    error_text_.c_str()));
          break;
      }
      states_.pop();
      if (states_.empty()) {
        // Drop the reference to the observer when the terminal state is reached.
        job_observer_ = nullptr;
      } else {
        task_runner_->PostTask(FROM_HERE, base::Bind(&MockOnDemand::Advance,
                                                     base::Unretained(this)));
      }
    }
  
    // The task runner on which the state machine runs.
    scoped_refptr<base::TaskRunner> task_runner_;
  
    // The new version for a successful update check or update.
    base::string16 new_version_;
  
    // Error text to be supplied for an unsuccessful update check or update.
    base::string16 error_text_;
  
    // The set of states to be run on an IJobObserver.
    std::queue<State> states_;
  
    // The IJobObserver given to either CheckForUpdate() or Update() that is being
    // driven through the desired state transitions.
    base::win::ScopedComPtr<IJobObserver> job_observer_;
  
    DISALLOW_COPY_AND_ASSIGN(MockOnDemand);
  };
  
  }  // namespace
  
  class GoogleUpdateWinTest : public ::testing::TestWithParam<bool> {
   public:
    static void SetUpTestCase() { ui::win::CreateATLModuleIfNeeded(); }
  
   protected:
    GoogleUpdateWinTest()
        : task_runner_(new base::TestSimpleTaskRunner()),
          task_runner_handle_(task_runner_),
          system_level_(GetParam()),
          mock_on_demand_(nullptr) {}
  
    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(installer::GetChromeInstallPath(
          system_level_, BrowserDistribution::GetDistribution()));
      file_exe_override_.reset(new base::ScopedPathOverride(
          base::FILE_EXE, install_dir.Append(file_exe.BaseName()),
          true /* is_absolute */, false /* create */));
  
      // Override these paths so that they can be found after the registry
      // override manager is in place.
      base::FilePath temp;
      PathService::Get(base::DIR_PROGRAM_FILES, &temp);
      program_files_override_.reset(
          new base::ScopedPathOverride(base::DIR_PROGRAM_FILES, temp));
      PathService::Get(base::DIR_PROGRAM_FILESX86, &temp);
      program_files_x86_override_.reset(
          new base::ScopedPathOverride(base::DIR_PROGRAM_FILESX86, temp));
      PathService::Get(base::DIR_LOCAL_APP_DATA, &temp);
      local_app_data_override_.reset(
          new base::ScopedPathOverride(base::DIR_LOCAL_APP_DATA, temp));
  
      // Override the registry so that tests can freely push state to it.
      registry_override_manager_.OverrideRegistry(HKEY_CURRENT_USER);
      registry_override_manager_.OverrideRegistry(HKEY_LOCAL_MACHINE);
  
      // Chrome is installed as multi-install.
      const HKEY root = system_level_ ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
      base::win::RegKey key(root, kClients, KEY_WRITE | KEY_WOW64_32KEY);
      ASSERT_EQ(ERROR_SUCCESS,
                key.CreateKey(kChromeGuid, KEY_WRITE | KEY_WOW64_32KEY));
      ASSERT_EQ(ERROR_SUCCESS,
                key.WriteValue(
                    L"pv", base::ASCIIToUTF16(CHROME_VERSION_STRING).c_str()));
      ASSERT_EQ(ERROR_SUCCESS,
                key.Create(root, kClientState, KEY_WRITE | KEY_WOW64_32KEY));
      ASSERT_EQ(ERROR_SUCCESS,
                key.CreateKey(kChromeGuid, KEY_WRITE | KEY_WOW64_32KEY));
      ASSERT_EQ(ERROR_SUCCESS,
                key.WriteValue(L"UninstallArguments",
                               L"--uninstall --multi-install --chrome"));
  
      // Provide an IGoogleUpdate on-demand update class factory so that this test
      // can provide a mocked-out instance.
      SetGoogleUpdateFactoryForTesting(
          base::Bind(&GoogleUpdateFactory::Create,
                     base::Unretained(&mock_google_update_factory_)));
      // Configure the factory to return a generic failure by default.
      ON_CALL(mock_google_update_factory_, Create(_))
          .WillByDefault(Return(E_FAIL));
  
      // Create a mock IGoogleUpdate on-demand update class
      ASSERT_EQ(S_OK, CComObject<MockOnDemand>::CreateInstance(&mock_on_demand_));
      on_demand_holder_ = mock_on_demand_;
      // Configure the mock to return a generic failure by default.
      ON_CALL(*mock_on_demand_, CheckForUpdate(_, _))
          .WillByDefault(Return(E_FAIL));
      ON_CALL(*mock_on_demand_, Update(_, _)).WillByDefault(Return(E_FAIL));
  
      // Compute a newer version.
      base::Version current_version(CHROME_VERSION_STRING);
      new_version_ = base::StringPrintf(L"%hu.%hu.%hu.%hu",
                                        current_version.components()[0],
                                        current_version.components()[1],
                                        current_version.components()[2] + 1,
                                        current_version.components()[3]);
    }
  
    void TearDown() override {
      // Remove the test's IGoogleUpdate on-demand update class factory.
      SetGoogleUpdateFactoryForTesting(OnDemandAppsClassFactory());
    }
  
    // Set the default update policy in the registry.
    void SetDefaultUpdatePolicy(GoogleUpdateSettings::UpdatePolicy policy) const {
      base::win::RegKey policy_key(HKEY_LOCAL_MACHINE, kPoliciesKey,
                                   KEY_SET_VALUE);
      ASSERT_EQ(ERROR_SUCCESS, policy_key.WriteValue(kUpdateDefault, policy));
    }
  
    // Stuffs |policy| in the registry for the app identified by |app_guid|.
    void SetAppUpdatePolicy(const base::char16* app_guid,
                            GoogleUpdateSettings::UpdatePolicy policy) const {
      base::string16 value_name(L"Update");
      value_name += app_guid;
      base::win::RegKey policy_key(HKEY_LOCAL_MACHINE, kPoliciesKey,
                                   KEY_SET_VALUE);
      ASSERT_EQ(ERROR_SUCCESS, policy_key.WriteValue(value_name.c_str(), policy));
    }
  
    static const base::char16 kPoliciesKey[];
    static const base::char16 kUpdateDefault[];
    static const base::char16 kClients[];
    static const base::char16 kClientState[];
    static const base::char16 kChromeGuid[];
    static const base::char16 kChromeBinariesGuid[];
  
    scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
    base::ThreadTaskRunnerHandle task_runner_handle_;
    bool system_level_;
    scoped_ptr<base::ScopedPathOverride> file_exe_override_;
    scoped_ptr<base::ScopedPathOverride> program_files_override_;
    scoped_ptr<base::ScopedPathOverride> program_files_x86_override_;
    scoped_ptr<base::ScopedPathOverride> local_app_data_override_;
    registry_util::RegistryOverrideManager registry_override_manager_;
    MockUpdateCheckCallbackReceiver callback_receiver_;
    MockGoogleUpdateFactory mock_google_update_factory_;
    CComObject<MockOnDemand>* mock_on_demand_;
    base::win::ScopedComPtr<IGoogleUpdate> on_demand_holder_;
    base::string16 new_version_;
  
    DISALLOW_COPY_AND_ASSIGN(GoogleUpdateWinTest);
  };
  
  //  static
  const base::char16 GoogleUpdateWinTest::kPoliciesKey[] =
      L"SOFTWARE\\Policies\\Google\\Update";
  const base::char16 GoogleUpdateWinTest::kUpdateDefault[] = L"UpdateDefault";
  const base::char16 GoogleUpdateWinTest::kClients[] =
      L"Software\\Google\\Update\\Clients";
  const base::char16 GoogleUpdateWinTest::kClientState[] =
      L"Software\\Google\\Update\\ClientState";
  const base::char16 GoogleUpdateWinTest::kChromeGuid[] =
      L"{8A69D345-D564-463c-AFF1-A69D9E530F96}";
  const base::char16 GoogleUpdateWinTest::kChromeBinariesGuid[] =
      L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}";
  
  // Test that an update check fails with the proper error code if Chrome isn't in
  // one of the expected install directories.
  TEST_P(GoogleUpdateWinTest, InvalidInstallDirectory) {
    // Override FILE_EXE so that it looks like the test is running from a
    // non-standard location.
    base::FilePath file_exe;
    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(
        callback_receiver_,
        OnUpdateCheckCallback(UPGRADE_ERROR,
                              CANNOT_UPGRADE_CHROME_IN_THIS_DIRECTORY, _, _));
    BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  #if defined(GOOGLE_CHROME_BUILD)
  
  TEST_P(GoogleUpdateWinTest, AllUpdatesDisabledByPolicy) {
    // Disable updates altogether.
    SetDefaultUpdatePolicy(GoogleUpdateSettings::UPDATES_DISABLED);
  
    EXPECT_CALL(callback_receiver_,
                OnUpdateCheckCallback(UPGRADE_ERROR,
                                      GOOGLE_UPDATE_DISABLED_BY_POLICY, _, _));
    BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  TEST_P(GoogleUpdateWinTest, MultiUpdatesDisabledByPolicy) {
    // Disable updates altogether.
    SetAppUpdatePolicy(kChromeBinariesGuid,
                       GoogleUpdateSettings::UPDATES_DISABLED);
  
    EXPECT_CALL(callback_receiver_,
                OnUpdateCheckCallback(UPGRADE_ERROR,
                                      GOOGLE_UPDATE_DISABLED_BY_POLICY, _, _));
    BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  TEST_P(GoogleUpdateWinTest, AllManualUpdatesDisabledByPolicy) {
    // Disable updates altogether.
    SetDefaultUpdatePolicy(GoogleUpdateSettings::AUTO_UPDATES_ONLY);
  
    EXPECT_CALL(
        callback_receiver_,
        OnUpdateCheckCallback(UPGRADE_ERROR,
                              GOOGLE_UPDATE_DISABLED_BY_POLICY_AUTO_ONLY, _, _));
    BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  TEST_P(GoogleUpdateWinTest, MultiManualUpdatesDisabledByPolicy) {
    // Disable updates altogether.
    SetAppUpdatePolicy(kChromeBinariesGuid,
                       GoogleUpdateSettings::AUTO_UPDATES_ONLY);
  
    EXPECT_CALL(
        callback_receiver_,
        OnUpdateCheckCallback(UPGRADE_ERROR,
                              GOOGLE_UPDATE_DISABLED_BY_POLICY_AUTO_ONLY, _, _));
    BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  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(callback_receiver_,
                OnUpdateCheckCallback(
                    UPGRADE_ERROR, GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND, _, _));
    BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  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(callback_receiver_,
                OnUpdateCheckCallback(
                    UPGRADE_ERROR, GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND, _, _));
    BeginUpdateCheck(task_runner_, true, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  TEST_P(GoogleUpdateWinTest, FailUpdateCheck) {
    // The factory should be called upon: let it return the mock on-demand class.
    EXPECT_CALL(mock_google_update_factory_, Create(_))
        .WillOnce(DoAll(SetArgPointee<0>(mock_on_demand_), Return(S_OK)));
    // The mock on-demand class should be called.
    EXPECT_CALL(*mock_on_demand_, CheckForUpdate(StrEq(kChromeBinariesGuid), _));
  
    EXPECT_CALL(
        callback_receiver_,
        OnUpdateCheckCallback(UPGRADE_ERROR,
                              GOOGLE_UPDATE_ONDEMAND_CLASS_REPORTED_ERROR, _, _));
    BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  TEST_P(GoogleUpdateWinTest, UpdateCheckNoUpdate) {
    EXPECT_CALL(mock_google_update_factory_, Create(_))
        .WillOnce(DoAll(SetArgPointee<0>(mock_on_demand_), Return(S_OK)));
    mock_on_demand_->OnCheckRunUpToDateSequence(kChromeBinariesGuid);
  
    EXPECT_CALL(callback_receiver_,
                OnUpdateCheckCallback(UPGRADE_ALREADY_UP_TO_DATE,
                                      GOOGLE_UPDATE_NO_ERROR, IsEmpty(), _));
    BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  TEST_P(GoogleUpdateWinTest, UpdateCheckUpdateAvailable) {
    EXPECT_CALL(mock_google_update_factory_, Create(_))
        .WillOnce(DoAll(SetArgPointee<0>(mock_on_demand_), Return(S_OK)));
    mock_on_demand_->OnCheckRunUpdateAvailableSequence(kChromeBinariesGuid,
                                                       new_version_);
  
    EXPECT_CALL(
        callback_receiver_,
        OnUpdateCheckCallback(UPGRADE_IS_AVAILABLE, GOOGLE_UPDATE_NO_ERROR,
                              IsEmpty(), StrEq(new_version_)));
    BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  TEST_P(GoogleUpdateWinTest, UpdateInstalled) {
    EXPECT_CALL(mock_google_update_factory_, Create(_))
        .WillOnce(DoAll(SetArgPointee<0>(mock_on_demand_), Return(S_OK)));
    mock_on_demand_->OnUpdateRunInstallUpdateSequence(kChromeBinariesGuid,
                                                      new_version_);
  
    EXPECT_CALL(callback_receiver_,
                OnUpdateCheckCallback(UPGRADE_SUCCESSFUL, GOOGLE_UPDATE_NO_ERROR,
                                      IsEmpty(), StrEq(new_version_)));
    BeginUpdateCheck(task_runner_, true, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  TEST_P(GoogleUpdateWinTest, UpdateFailed) {
    static const base::char16 kError[] = L"It didn't work.";
    EXPECT_CALL(mock_google_update_factory_, Create(_))
        .WillOnce(DoAll(SetArgPointee<0>(mock_on_demand_), Return(S_OK)));
    mock_on_demand_->OnUpdateRunUpdateErrorSequence(kChromeBinariesGuid, kError);
  
    EXPECT_CALL(callback_receiver_,
                OnUpdateCheckCallback(UPGRADE_ERROR, GOOGLE_UPDATE_ERROR_UPDATING,
                                      StrEq(kError), IsEmpty()));
    BeginUpdateCheck(task_runner_, true, 0, callback_receiver_.GetCallback());
    task_runner_->RunUntilIdle();
  }
  
  #endif  // defined(GOOGLE_CHROME_BUILD)
  
  INSTANTIATE_TEST_CASE_P(UserLevel, GoogleUpdateWinTest, Values(false));
  
  INSTANTIATE_TEST_CASE_P(SystemLevel, GoogleUpdateWinTest, Values(true));
  