Modernize on-demand update checks on Windows.

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 <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 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.
+    internal::SetGoogleUpdateFactory(
+        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.
+    internal::SetGoogleUpdateFactory(internal::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_;
+  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, _, _));
+  internal::CheckForUpdate(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, _, _));
+  internal::CheckForUpdate(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, _, _));
+  internal::CheckForUpdate(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, _, _));
+  internal::CheckForUpdate(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, _, _));
+  internal::CheckForUpdate(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, _, _));
+  internal::CheckForUpdate(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, _, _));
+  internal::CheckForUpdate(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, _, _));
+  internal::CheckForUpdate(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(), _));
+  internal::CheckForUpdate(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_)));
+  internal::CheckForUpdate(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_)));
+  internal::CheckForUpdate(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()));
+  internal::CheckForUpdate(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));