Switch on-demand update checks to the less-old GoogleUpdate3 API.

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 "base/win/scoped_comptr.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::Assign;
 using ::testing::DoAll;
+using ::testing::DoubleEq;
+using ::testing::HasSubstr;
+using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::IsEmpty;
 using ::testing::Return;
+using ::testing::Sequence;
 using ::testing::SetArgPointee;
 using ::testing::StrEq;
-using ::testing::Unused;
+using ::testing::StrictMock;
 using ::testing::Values;
 using ::testing::_;
 
 namespace {
 
 class UpdateCheckCallbackReceiver {
  public:
   UpdateCheckCallbackReceiver() {}
   virtual ~UpdateCheckCallbackReceiver() {}
   virtual void OnUpdateCheckCallback(GoogleUpdateUpgradeResult result,
+                                     double progress,
                                      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,
+                           double progress,
                            GoogleUpdateErrorCode error_code,
                            const base::string16& error_message,
                            const base::string16& version) {
-    OnUpdateCheckCallback(result, error_code, error_message, version);
+    OnUpdateCheckCallback(result, progress, error_code, error_message, version);
   }
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckCallbackReceiver);
 };
 
 class MockUpdateCheckCallbackReceiver : public UpdateCheckCallbackReceiver {
  public:
   MockUpdateCheckCallbackReceiver() {}
-  MOCK_METHOD4(OnUpdateCheckCallback,
+  MOCK_METHOD5(OnUpdateCheckCallback,
                void(GoogleUpdateUpgradeResult,
+                    double,
                     GoogleUpdateErrorCode,
                     const base::string16&,
                     const base::string16&));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockUpdateCheckCallbackReceiver);
 };
 
+// An interface that exposes a factory method for creating an IGoogleUpdate3
+// instance.
 class GoogleUpdateFactory {
  public:
   virtual ~GoogleUpdateFactory() {}
-  virtual HRESULT Create(base::win::ScopedComPtr<IGoogleUpdate>* on_demand) = 0;
-};
-
+  virtual HRESULT Create(
+      base::win::ScopedComPtr<IGoogleUpdate3>* google_update) = 0;
+};
+
+// A mock factory for creating an IGoogleUpdate3 instance.
 class MockGoogleUpdateFactory : public GoogleUpdateFactory {
  public:
   MockGoogleUpdateFactory() {}
-  MOCK_METHOD1(Create, HRESULT(base::win::ScopedComPtr<IGoogleUpdate>*));
+  MOCK_METHOD1(Create, HRESULT(base::win::ScopedComPtr<IGoogleUpdate3>*));
 
  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)
+class MockCurrentState : public CComObjectRootEx<CComSingleThreadModel>,
+                         public ICurrentState {
+ public:
+  BEGIN_COM_MAP(MockCurrentState)
+    COM_INTERFACE_ENTRY(ICurrentState)
   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)));
-  }
+  MockCurrentState() {}
+
+  // Adds an expectation for get_completionMessage that will return the given
+  // message any number of times.
+  void ExpectCompletionMessage(const base::string16& completion_message) {
+    completion_message_ = completion_message;
+    EXPECT_CALL(*this, get_completionMessage(_))
+        .WillRepeatedly(
+            ::testing::Invoke(this, &MockCurrentState::GetCompletionMessage));
+  }
+
+  HRESULT GetCompletionMessage(BSTR* completion_message) {
+    *completion_message = SysAllocString(completion_message_.c_str());
+    return S_OK;
+  }
+
+  // Adds an expectation for get_availableVersion that will return the given
+  // version any number of times.
+  void ExpectAvailableVersion(const base::string16& available_version) {
+    available_version_ = available_version;
+    EXPECT_CALL(*this, get_availableVersion(_))
+        .WillRepeatedly(
+            ::testing::Invoke(this, &MockCurrentState::GetAvailableVersion));
+  }
+
+  HRESULT GetAvailableVersion(BSTR* available_version) {
+    *available_version = SysAllocString(available_version_.c_str());
+    return S_OK;
+  }
+
+  // ICurrentState
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_stateValue,
+                             HRESULT(LONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_availableVersion,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_bytesDownloaded,
+                             HRESULT(ULONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_totalBytesToDownload,
+                             HRESULT(ULONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_downloadTimeRemainingMs,
+                             HRESULT(LONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_nextRetryTime,
+                             HRESULT(ULONGLONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_installProgress,
+                             HRESULT(LONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_installTimeRemainingMs,
+                             HRESULT(LONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_isCanceled,
+                             HRESULT(VARIANT_BOOL *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_errorCode,
+                             HRESULT(LONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_extraCode1,
+                             HRESULT(LONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_completionMessage,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_installerResultCode,
+                             HRESULT(LONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_installerResultExtraCode1,
+                             HRESULT(LONG *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_postInstallLaunchCommandLine,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_postInstallUrl,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_postInstallAction,
+                             HRESULT(LONG *));
+
+  // IDispatch
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetTypeInfoCount,
+                             HRESULT(UINT *));
+  MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetTypeInfo,
+                             HRESULT(UINT, LCID, ITypeInfo **));
+  MOCK_METHOD5_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetIDsOfNames,
+                             HRESULT(REFIID, LPOLESTR *, UINT, LCID, DISPID *));
+  MOCK_METHOD8_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             Invoke,
+                             HRESULT(DISPID, REFIID, LCID, WORD, DISPPARAMS *,
+                                     VARIANT *, EXCEPINFO *, UINT *));
 
  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);
+  base::string16 completion_message_;
+  base::string16 available_version_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockCurrentState);
+};
+
+class MockApp : public CComObjectRootEx<CComSingleThreadModel>,
+                public IApp {
+ public:
+  BEGIN_COM_MAP(MockApp)
+    COM_INTERFACE_ENTRY(IApp)
+  END_COM_MAP()
+
+  MockApp() {}
+
+  // IApp
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_currentVersion,
+                             HRESULT(IDispatch **));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_nextVersion,
+                             HRESULT(IDispatch **));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_appId,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_displayName,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_displayName,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_language,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_language,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_ap,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_ap,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_ttToken,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_ttToken,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_iid,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_iid,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_brandCode,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_brandCode,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_clientId,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_clientId,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_labels,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_labels,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_referralId,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_referralId,
+                             HRESULT(BSTR));
+  MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_command,
+                             HRESULT(BSTR, IDispatch **));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_browserType,
+                             HRESULT(UINT *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_browserType,
+                             HRESULT(UINT));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_clientInstallData,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_clientInstallData,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_serverInstallDataIndex,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_serverInstallDataIndex,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_isEulaAccepted,
+                             HRESULT(VARIANT_BOOL *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_isEulaAccepted,
+                             HRESULT(VARIANT_BOOL));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_usageStatsEnable,
+                             HRESULT(UINT *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_usageStatsEnable,
+                             HRESULT(UINT));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_installTimeDiffSec,
+                             HRESULT(UINT *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_currentState,
+                             HRESULT(IDispatch **));
+
+  // IDispatch
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetTypeInfoCount,
+                             HRESULT(UINT *));
+  MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetTypeInfo,
+                             HRESULT(UINT, LCID, ITypeInfo **));
+  MOCK_METHOD5_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetIDsOfNames,
+                             HRESULT(REFIID, LPOLESTR *, UINT, LCID, DISPID *));
+  MOCK_METHOD8_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             Invoke,
+                             HRESULT(DISPID, REFIID, LCID, WORD, DISPPARAMS *,
+                                     VARIANT *, EXCEPINFO *, UINT *));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockApp);
+};
+
+class MockAppBundle : public CComObjectRootEx<CComSingleThreadModel>,
+                      public IAppBundle {
+ public:
+  BEGIN_COM_MAP(MockAppBundle)
+    COM_INTERFACE_ENTRY(IAppBundle)
+  END_COM_MAP()
+
+  MockAppBundle() {}
+
+  // IAppBundle
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_displayName,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_displayName,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_displayLanguage,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_displayLanguage,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_installSource,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_installSource,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_originURL,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_originURL,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_offlineDirectory,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_offlineDirectory,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_sessionId,
+                             HRESULT(BSTR *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_sessionId,
+                             HRESULT(BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_sendPings,
+                             HRESULT(VARIANT_BOOL *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_sendPings,
+                             HRESULT(VARIANT_BOOL));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_priority,
+                             HRESULT(long *));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_priority,
+                             HRESULT(long));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_Count,
+                             HRESULT(long *));
+  MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_Item,
+                             HRESULT(long, IDispatch **));
+  MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_altTokens,
+                             HRESULT(ULONG_PTR, ULONG_PTR, DWORD));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             put_parentHWND,
+                             HRESULT(ULONG_PTR));
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             initialize,
+                             HRESULT());
+  MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             createApp,
+                             HRESULT(BSTR, IDispatch **));
+  MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             createInstalledApp,
+                             HRESULT(BSTR, IDispatch **));
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             createAllInstalledApps,
+                             HRESULT());
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             checkForUpdate,
+                             HRESULT());
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             download,
+                             HRESULT());
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             install,
+                             HRESULT());
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             updateAllApps,
+                             HRESULT());
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             stop,
+                             HRESULT());
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             pause,
+                             HRESULT());
+  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             resume,
+                             HRESULT());
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             isBusy,
+                             HRESULT(VARIANT_BOOL *));
+  MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             downloadPackage,
+                             HRESULT(BSTR, BSTR));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_currentState,
+                             HRESULT(VARIANT *));
+
+  // IDispatch
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetTypeInfoCount,
+                             HRESULT(UINT *));
+  MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetTypeInfo,
+                             HRESULT(UINT, LCID, ITypeInfo **));
+  MOCK_METHOD5_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetIDsOfNames,
+                             HRESULT(REFIID, LPOLESTR *, UINT, LCID, DISPID *));
+  MOCK_METHOD8_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             Invoke,
+                             HRESULT(DISPID, REFIID, LCID, WORD, DISPPARAMS *,
+                                     VARIANT *, EXCEPINFO *, UINT *));
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockAppBundle);
+};
+
+class MockGoogleUpdate : public CComObjectRootEx<CComSingleThreadModel>,
+                         public IGoogleUpdate3 {
+ public:
+  BEGIN_COM_MAP(MockGoogleUpdate)
+    COM_INTERFACE_ENTRY(IGoogleUpdate3)
+  END_COM_MAP()
+
+  MockGoogleUpdate() {}
+
+  // IGoogleUpdate3
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_Count,
+                             HRESULT(long*));
+  MOCK_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             get_Item,
+                             HRESULT(long, IDispatch**));
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             createAppBundle,
+                             HRESULT(IDispatch**));
+
+  // IDispatch
+  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetTypeInfoCount,
+                             HRESULT(UINT *));
+  MOCK_METHOD3_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetTypeInfo,
+                             HRESULT(UINT, LCID, ITypeInfo **));
+  MOCK_METHOD5_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             GetIDsOfNames,
+                             HRESULT(REFIID, LPOLESTR *, UINT, LCID, DISPID *));
+  MOCK_METHOD8_WITH_CALLTYPE(STDMETHODCALLTYPE,
+                             Invoke,
+                             HRESULT(DISPID, REFIID, LCID, WORD, DISPPARAMS *,
+                                     VARIANT *, EXCEPINFO *, UINT *));
+
+  DISALLOW_COPY_AND_ASSIGN(MockGoogleUpdate);
 };
 
 }  // namespace
 
+// A test fixture that can simulate the IGoogleUpdate3 API via Google Mock.
+// Individual tests must wire up the factories by a call to one of the
+// PrepareSimulator methods. The family of Push*State methods are then used to
+// configure the set of states to be simulated.
 class GoogleUpdateWinTest : public ::testing::TestWithParam<bool> {
  public:
-  static void SetUpTestCase() { ui::win::CreateATLModuleIfNeeded(); }
+  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_(GetParam()),
-        mock_on_demand_(nullptr) {}
+        mock_app_(nullptr),
+        mock_app_bundle_(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()));
@@ skipping 27 matching lines @@
               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.
+    // Provide an IGoogleUpdate3 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"%u.%u.%u.%u",
                                       current_version.components()[0],
                                       current_version.components()[1],
                                       current_version.components()[2] + 1,
                                       current_version.components()[3]);
   }
 
   void TearDown() override {
+    ASSERT_EQ(nullptr, mock_app_);
+    ASSERT_EQ(nullptr, mock_app_bundle_);
+    ASSERT_TRUE(states_.empty());
     // Remove the test's IGoogleUpdate on-demand update class factory.
-    SetGoogleUpdateFactoryForTesting(OnDemandAppsClassFactory());
+    SetGoogleUpdateFactoryForTesting(GoogleUpdate3ClassFactory());
+    ::testing::TestWithParam<bool>::TearDown();
   }
 
-  // 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));
+  // Prepares the IGoogleUpdate3 simulator.
+  void PrepareSimulator(const base::char16* app_guid) {
+    // Make the installed app and configure it to call the test fixture's
+    // GetNextState method.
+    ASSERT_EQ(S_OK, CComObject<MockApp>::CreateInstance(&mock_app_));
+    ON_CALL(*mock_app_, get_currentState(_))
+        .WillByDefault(Invoke(this, &GoogleUpdateWinTest::GetNextState));
+
+    // Make the app bundle containing the app.
+    ASSERT_EQ(S_OK,
+              CComObject<MockAppBundle>::CreateInstance(
+                  &mock_app_bundle_));
+    EXPECT_CALL(*mock_app_bundle_, initialize())
+        .WillOnce(Return(S_OK));
+    // Give mock_app_bundle a ref to the app which it will return when created.
+    mock_app_->AddRef();
+    EXPECT_CALL(*mock_app_bundle_, createInstalledApp(StrEq(app_guid), _))
+        .WillOnce(DoAll(SetArgPointee<1>(mock_app_),
+                        Assign(&mock_app_, nullptr),
+                        Return(S_OK)));
+
+    // Make the updater which will return the app bundle above.
+    CComObject<MockGoogleUpdate>* mock_google_update = nullptr;
+    ASSERT_EQ(S_OK,
+              CComObject<MockGoogleUpdate>::CreateInstance(
+                  &mock_google_update));
+    // Give mock_google_update a ref to the bundle which it will return when
+    // created.
+    mock_app_bundle_->AddRef();
+    EXPECT_CALL(*mock_google_update, createAppBundle(_))
+        .WillOnce(DoAll(SetArgPointee<0>(mock_app_bundle_),
+                        Assign(&mock_app_bundle_, nullptr),
+                        Return(S_OK)));
+
+    // Give the factory this updater. Do not add a ref, as the factory will add
+    // one when it hands out its instance.
+    EXPECT_CALL(mock_google_update_factory_, Create(_))
+        .WillOnce(DoAll(SetArgPointee<0>(mock_google_update), Return(S_OK)));
   }
 
-  // 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));
+  // Prepares the IGoogleUpdate3 simulator to process an update check.
+  void PrepareSimulatorForUpdateCheck(const base::char16* app_guid) {
+    PrepareSimulator(app_guid);
+    // Expect the bundle to be called on to start the update.
+    EXPECT_CALL(*mock_app_bundle_, checkForUpdate())
+        .WillOnce(Return(S_OK));
   }
 
-  static const base::char16 kPoliciesKey[];
-  static const base::char16 kUpdateDefault[];
+  // Prepares the IGoogleUpdate3 simulator to process an upgrade.
+  void PrepareSimulatorForUpgrade(const base::char16* app_guid) {
+    PrepareSimulatorForUpdateCheck(app_guid);
+    // Expect the bundle to be called on to start the install.
+    EXPECT_CALL(*mock_app_bundle_, install())
+        .WillOnce(Return(S_OK));
+  }
+
+  // Adds a MockCurrentState to the back of the sequence to be returned by the
+  // mock IApp.
+  void PushState(CurrentState state) {
+    MakeNextState(state);
+  }
+
+  // Adds a MockCurrentState to the back of the sequence to be returned by the
+  // mock IApp for an ERROR state.
+  void PushErrorState(LONG error_code,
+                      const base::string16& completion_message,
+                      LONG installer_result_code) {
+    CComObject<MockCurrentState>* mock_state = MakeNextState(STATE_ERROR);

[Peter Kasting, 2015/05/07 22:37:30]

I wonder if here and below you should just use "auto" (or auto*) for the temp
type.  Seems like the type is verbose and we don't actually care about it.

[grt (UTC plus 2), 2015/05/08 18:51:50]

Hmm. The fact that it's a mock is important. I have mixed feelings about this.
Since spelling out the whole type doesn't force line wrapping, I'm inclined to
leave it as-is.

[Peter Kasting, 2015/05/09 02:19:01]

OK.  I figure the variable name |mock_state| makes that clear and the type is
unnecessary, but if you don't agree, I'm OK with leaving it.

+    EXPECT_CALL(*mock_state, get_errorCode(_))
+        .WillRepeatedly(DoAll(SetArgPointee<0>(error_code), Return(S_OK)));
+    mock_state->ExpectCompletionMessage(completion_message);
+    if (installer_result_code != -1) {
+      EXPECT_CALL(*mock_state, get_installerResultCode(_))
+          .WillRepeatedly(DoAll(SetArgPointee<0>(installer_result_code),
+                                Return(S_OK)));
+    }
+  }
+
+  // Adds a MockCurrentState to the back of the sequence to be returned by the
+  // mock IApp for an UPDATE_AVAILABLE state.
+  void PushUpdateAvailableState(const base::string16& new_version) {
+    CComObject<MockCurrentState>* mock_state =
+        MakeNextState(STATE_UPDATE_AVAILABLE);
+    mock_state->ExpectAvailableVersion(new_version);

[Peter Kasting, 2015/05/07 22:37:29]

Nit: Just:

  MakeNextState(STATE_UPDATE_AVAILABLE)->ExpectAvailableVersion(new_version);

[grt (UTC plus 2), 2015/05/08 18:51:50]

Done.

+  }
+
+  // Adds a MockCurrentState to the back of the sequence to be returned by the
+  // mock IApp for a DOWNLOADING or INSTALLING state.
+  void PushProgressiveState(CurrentState state, int progress) {
+    CComObject<MockCurrentState>* mock_state = MakeNextState(state);
+    if (state == STATE_DOWNLOADING) {
+      const ULONG kTotalBytes = 1024;
+      ULONG bytes_down = static_cast<double>(kTotalBytes) * progress / 100.0;
+      EXPECT_CALL(*mock_state, get_totalBytesToDownload(_))
+        .WillRepeatedly(DoAll(SetArgPointee<0>(kTotalBytes), Return(S_OK)));
+      EXPECT_CALL(*mock_state, get_bytesDownloaded(_))
+        .WillRepeatedly(DoAll(SetArgPointee<0>(bytes_down), Return(S_OK)));
+    } else if (state == STATE_INSTALLING) {
+      EXPECT_CALL(*mock_state, get_installProgress(_))
+        .WillRepeatedly(DoAll(SetArgPointee<0>(progress), Return(S_OK)));
+    } else {
+      ADD_FAILURE() << "unsupported state " << state;
+    }
+  }
+
   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_;
+
+  // A mock object, the OnUpdateCheckCallback method of which will be invoked
+  // each time the update check machinery invokes the given UpdateCheckCallback.
   MockUpdateCheckCallbackReceiver callback_receiver_;
-  MockGoogleUpdateFactory mock_google_update_factory_;
-  CComObject<MockOnDemand>* mock_on_demand_;
-  base::win::ScopedComPtr<IGoogleUpdate> on_demand_holder_;
+
+  // A mock object that provides a GoogleUpdate3ClassFactory by which the test
+  // fixture's IGoogleUpdate3 simulator is provided to the update check
+  // machinery.
+  StrictMock<MockGoogleUpdateFactory> mock_google_update_factory_;
+
+  // The mock objects that simulate the IGoogleUpdate3 API.
+  CComObject<MockApp>* mock_app_;
+  CComObject<MockAppBundle>* mock_app_bundle_;
+
+  // A gmock sequence under which expectations on the MockApp are evaluated.
+  Sequence state_sequence_;
+
+  // The states returned by the MockApp when probed.
+  std::queue<CComObject<MockCurrentState>*> states_;
+
+  // The new version that the fixture will pretend is available.
   base::string16 new_version_;
 
+ private:
+  // Returns a new MockCurrentState that will be returned by the mock IApp's
+  // get_currentState method.
+  CComObject<MockCurrentState>* MakeNextState(CurrentState state) {
+    CComObject<MockCurrentState>* mock_state = nullptr;
+    EXPECT_EQ(S_OK, CComObject<MockCurrentState>::CreateInstance(&mock_state));
+    EXPECT_CALL(*mock_state, get_stateValue(_))
+        .WillRepeatedly(DoAll(SetArgPointee<0>(state), Return(S_OK)));
+    states_.push(mock_state);
+    // Tell the app to expect this state.
+    EXPECT_CALL(*mock_app_, get_currentState(_))
+        .InSequence(state_sequence_);
+    return mock_state;
+  }
+
+  // An implementation of IApp::get_currentState that advances the
+  // IGoogleUpdate3 simulator through a series of states.
+  HRESULT GetNextState(IDispatch** current_state) {
+    EXPECT_FALSE(states_.empty());
+    *current_state = states_.front();
+    (*current_state)->AddRef();

[Peter Kasting, 2015/05/07 22:37:29]

Where is this released?

[grt (UTC plus 2), 2015/05/08 18:51:50]

It is transferred to the caller. I've added explanatory comments here and in
MakeNextState above.

+    states_.pop();
+    return S_OK;
+  }
+
   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,
+      OnUpdateCheckCallback(UPGRADE_ERROR, _,
                             CANNOT_UPGRADE_CHROME_IN_THIS_DIRECTORY, _, _));
-  BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
+  BeginUpdateCheck(task_runner_, std::string(), 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 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(callback_receiver_,
               OnUpdateCheckCallback(
-                  UPGRADE_ERROR, GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND, _, _));
-  BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
+                  UPGRADE_ERROR, _, GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND, _,
+                  _));
+  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+                   callback_receiver_.GetCallback());
   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(callback_receiver_,
               OnUpdateCheckCallback(
-                  UPGRADE_ERROR, GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND, _, _));
-  BeginUpdateCheck(task_runner_, true, 0, callback_receiver_.GetCallback());
-  task_runner_->RunUntilIdle();
-}
-
+                  UPGRADE_ERROR, _, GOOGLE_UPDATE_ONDEMAND_CLASS_NOT_FOUND, _,
+                  _));
+  BeginUpdateCheck(task_runner_, std::string(), true, 0,
+                   callback_receiver_.GetCallback());
+  task_runner_->RunUntilIdle();
+}
+
+// Test the case where the GoogleUpdate class returns an error when an update
+// check is started.
 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), _));
+  PrepareSimulator(kChromeBinariesGuid);
+  // checkForUpdate will fail.
+  EXPECT_CALL(*mock_app_bundle_, checkForUpdate())
+      .WillOnce(Return(E_FAIL));
 
   EXPECT_CALL(
       callback_receiver_,
-      OnUpdateCheckCallback(UPGRADE_ERROR,
+      OnUpdateCheckCallback(UPGRADE_ERROR, _,
                             GOOGLE_UPDATE_ONDEMAND_CLASS_REPORTED_ERROR, _, _));
-  BeginUpdateCheck(task_runner_, false, 0, callback_receiver_.GetCallback());
-  task_runner_->RunUntilIdle();
-}
-
+  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+                   callback_receiver_.GetCallback());
+  task_runner_->RunUntilIdle();
+}
+
+// Test the case where the GoogleUpdate class reports that updates are disabled
+// by Group Policy.
+TEST_P(GoogleUpdateWinTest, UpdatesDisabledByPolicy) {
+  base::string16 message(L"disabled by policy");

[Peter Kasting, 2015/05/07 22:37:30]

Nit: I'd just inline the initializer into the PushErrorState() call below (2
places)

[grt (UTC plus 2), 2015/05/08 18:51:50]

Done here. The string is used twice in the test below, though.

+  PrepareSimulatorForUpdateCheck(kChromeBinariesGuid);
+  PushState(STATE_INIT);
+  PushState(STATE_CHECKING_FOR_UPDATE);
+  PushErrorState(0x80040813, message, -1);  // E_APP_UPDATE_DISABLED_BY_POLICY
+
+  {
+    InSequence callback_sequence;
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_CHECK_STARTED,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      IsEmpty()));  // version
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_ERROR,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_DISABLED_BY_POLICY,
+                                      HasSubstr(message),
+                                      IsEmpty()));  // version

[Peter Kasting, 2015/05/07 22:37:29]

Nit: I'd omit the "// version" here, and similar descriptors, if you've already
commented them in a previous EXPECT in the same test.  (Several places below)

[grt (UTC plus 2), 2015/05/08 18:51:50]

Done.

+  }
+  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+                   callback_receiver_.GetCallback());
+  task_runner_->RunUntilIdle();
+}
+
+// Test an update check where no update is available.
 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();
-}
-
+  PrepareSimulatorForUpdateCheck(kChromeBinariesGuid);
+  PushState(STATE_INIT);
+  PushState(STATE_CHECKING_FOR_UPDATE);
+  PushState(STATE_NO_UPDATE);
+
+  {
+    InSequence callback_sequence;
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_CHECK_STARTED,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      IsEmpty()));  // version
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_ALREADY_UP_TO_DATE,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),
+                                      IsEmpty()));
+  }
+  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+                   callback_receiver_.GetCallback());
+  task_runner_->RunUntilIdle();
+}
+
+// Test an update check where an update is available.
 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();
-}
-
+  PrepareSimulatorForUpdateCheck(kChromeBinariesGuid);
+  PushState(STATE_INIT);
+  PushState(STATE_CHECKING_FOR_UPDATE);
+  PushUpdateAvailableState(new_version_);
+
+  {
+    InSequence callback_sequence;
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_CHECK_STARTED,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      IsEmpty()));  // version
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_IS_AVAILABLE,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),
+                                      StrEq(new_version_)));
+  }
+  BeginUpdateCheck(task_runner_, std::string(), false, 0,
+                   callback_receiver_.GetCallback());
+  task_runner_->RunUntilIdle();
+}
+
+// Test a successful upgrade.
 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();
-}
-
+  PrepareSimulatorForUpgrade(kChromeBinariesGuid);
+  PushState(STATE_INIT);
+  PushState(STATE_CHECKING_FOR_UPDATE);
+  PushUpdateAvailableState(new_version_);
+  PushState(STATE_WAITING_TO_DOWNLOAD);
+  PushProgressiveState(STATE_DOWNLOADING, 0);
+  PushProgressiveState(STATE_DOWNLOADING, 25);
+  PushProgressiveState(STATE_DOWNLOADING, 25);
+  PushProgressiveState(STATE_DOWNLOADING, 75);
+  PushState(STATE_WAITING_TO_INSTALL);
+  PushProgressiveState(STATE_INSTALLING, 50);
+  PushState(STATE_INSTALL_COMPLETE);
+
+  {
+    InSequence callback_sequence;
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      IsEmpty()));  // version
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.125),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      StrEq(new_version_)));
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.375),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      StrEq(new_version_)));
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.5),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      StrEq(new_version_)));
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.75),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      StrEq(new_version_)));
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_SUCCESSFUL,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),
+                                      StrEq(new_version_)));
+  }
+  BeginUpdateCheck(task_runner_, std::string(), true, 0,
+                   callback_receiver_.GetCallback());
+  task_runner_->RunUntilIdle();
+}
+
+// Test a failed upgrade.
 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();
-}
-
+  const base::string16 error(L"It didn't work.");
+  static const int kInstallerError = 12;
+
+  PrepareSimulatorForUpgrade(kChromeBinariesGuid);
+  PushState(STATE_INIT);
+  PushState(STATE_CHECKING_FOR_UPDATE);
+  PushUpdateAvailableState(new_version_);
+  PushState(STATE_WAITING_TO_DOWNLOAD);
+  PushProgressiveState(STATE_DOWNLOADING, 0);
+  PushProgressiveState(STATE_DOWNLOADING, 25);
+  PushProgressiveState(STATE_DOWNLOADING, 25);
+  PushProgressiveState(STATE_DOWNLOADING, 75);
+  PushState(STATE_WAITING_TO_INSTALL);
+  PushProgressiveState(STATE_INSTALLING, 50);
+  PushErrorState(0x80040902, error, kInstallerError);  // E_INSTALLER_FAILED

[Peter Kasting, 2015/05/07 22:37:30]

Nit: Seems like this comment should be on the declaration of kInstallerError?

[grt (UTC plus 2), 2015/05/08 18:51:51]

Comment rejiggered.

+
+  {
+    InSequence callback_sequence;
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      IsEmpty()));  // version
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.125),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      StrEq(new_version_)));
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.375),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      StrEq(new_version_)));
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.5),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      StrEq(new_version_)));
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_STARTED,
+                                      DoubleEq(0.75),
+                                      GOOGLE_UPDATE_NO_ERROR,
+                                      IsEmpty(),  // error_message
+                                      StrEq(new_version_)));
+    EXPECT_CALL(callback_receiver_,
+                OnUpdateCheckCallback(UPGRADE_ERROR,
+                                      DoubleEq(0.0),
+                                      GOOGLE_UPDATE_ERROR_UPDATING,
+                                      HasSubstr(error),
+                                      StrEq(new_version_)));
+  }
+  BeginUpdateCheck(task_runner_, std::string(), 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));