Remove traces of multi-install from GoogleUpdateWinTest.

chrome/browser/google/google_update_win_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/google/google_update_win.h"
 
 #include <windows.h>
 #include <atlbase.h>
 #include <atlcom.h>
 
@@ skipping 545 matching lines @@
     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.
+    // Chrome is installed.
     const HKEY root =
         system_level_install_ ? 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"));
+              key.WriteValue(L"UninstallArguments", L"--uninstall"));
 
     // Provide an IGoogleUpdate3Web class factory so that this test can provide
     // a mocked-out instance.
     SetGoogleUpdateFactoryForTesting(
         base::Bind(&GoogleUpdateFactory::Create,
                    base::Unretained(&mock_google_update_factory_)));
 
     // Compute a newer version.
     base::Version current_version(CHROME_VERSION_STRING);
     new_version_ = base::StringPrintf(L"%u.%u.%u.%u",
                                       current_version.components()[0],
                                       current_version.components()[1],
                                       current_version.components()[2] + 1,
                                       current_version.components()[3]);
   }
 
   // Creates app bundle and app mocks that will be used to simulate Google
   // Update.
   void MakeGoogleUpdateMocks(CComObject<MockAppBundle>** mock_app_bundle,
                              CComObject<MockApp>** mock_app) {
     CComObject<MockGoogleUpdate>* google_update =
         mock_google_update_factory_.MakeServerMock();
     CComObject<MockAppBundle>* app_bundle = google_update->MakeAppBundle();
-    CComObject<MockApp>* app = app_bundle->MakeApp(kChromeBinariesGuid);
+    CComObject<MockApp>* app = app_bundle->MakeApp(kChromeGuid);
 
     if (mock_app_bundle)
       *mock_app_bundle = app_bundle;
     if (mock_app)
       *mock_app = app;
   }
 
   void TearDown() override {
     // Remove the test's IGoogleUpdate on-demand update class factory.
     SetGoogleUpdateFactoryForTesting(GoogleUpdate3ClassFactory());
     ::testing::TestWithParam<bool>::TearDown();
   }
 
   static const base::char16 kClients[];
   static const base::char16 kClientState[];
   static const base::char16 kChromeGuid[];
-  static const base::char16 kChromeBinariesGuid[];
 
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   bool system_level_install_;
   std::unique_ptr<base::ScopedPathOverride> file_exe_override_;
   std::unique_ptr<base::ScopedPathOverride> program_files_override_;
   std::unique_ptr<base::ScopedPathOverride> program_files_x86_override_;
   std::unique_ptr<base::ScopedPathOverride> local_app_data_override_;
   registry_util::RegistryOverrideManager registry_override_manager_;
 
@@ skipping 13 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(GoogleUpdateWinTest);
 };
 
 //  static
 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));
@@ skipping 245 matching lines @@
 // Test that a retry after a USING_EXTERNAL_UPDATER failure succeeds.
 TEST_P(GoogleUpdateWinTest, RetryAfterExternalUpdaterError) {
   static const HRESULT GOOPDATE_E_APP_USING_EXTERNAL_UPDATER = 0xa043081d;
 
   CComObject<MockAppBundle>* mock_app_bundle =
       mock_google_update_factory_.MakeServerMock()->MakeAppBundle();
 
   // The first attempt will fail in createInstalledApp indicating that an update
   // is already in progress.
   Sequence bundle_seq;
-  EXPECT_CALL(*mock_app_bundle, createInstalledApp(StrEq(kChromeBinariesGuid)))
+  EXPECT_CALL(*mock_app_bundle, createInstalledApp(StrEq(kChromeGuid)))
       .InSequence(bundle_seq)
       .WillOnce(Return(GOOPDATE_E_APP_USING_EXTERNAL_UPDATER));
 
   // Expect a retry on the same instance.
-  EXPECT_CALL(*mock_app_bundle, createInstalledApp(StrEq(kChromeBinariesGuid)))
+  EXPECT_CALL(*mock_app_bundle, createInstalledApp(StrEq(kChromeGuid)))
       .InSequence(bundle_seq)
       .WillOnce(Return(S_OK));
 
   // See MakeApp() for an explanation of this:
   CComObject<MockApp>* mock_app = nullptr;
   EXPECT_EQ(S_OK, CComObject<MockApp>::CreateInstance(&mock_app));
   mock_app->AddRef();
   EXPECT_CALL(*mock_app_bundle, get_appWeb(0, _))
       .WillOnce(DoAll(SetArgPointee<1>(mock_app), Return(S_OK)));
 
@@ skipping 70 matching lines @@
   BeginUpdateCheck(task_runner_, std::string(), true, 0,
                    mock_update_check_delegate_.AsWeakPtr());
   BeginUpdateCheck(task_runner_, std::string(), true, 0,
                    mock_update_check_delegate_2.AsWeakPtr());
   task_runner_->RunUntilIdle();
 }
 
 INSTANTIATE_TEST_CASE_P(UserLevel, GoogleUpdateWinTest, Values(false));
 
 INSTANTIATE_TEST_CASE_P(SystemLevel, GoogleUpdateWinTest, Values(true));