Use InstallDetails in setup.

chrome/installer/setup/setup_util.cc

 // Copyright (c) 2012 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.
 //
 // This file declares util functions for setup project.
 
 #include "chrome/installer/setup/setup_util.h"
 
 #include <windows.h>
 #include <stddef.h>
@@ skipping 13 matching lines @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "base/win/windows_version.h"
+#include "chrome/install_static/install_details.h"
+#include "chrome/install_static/install_modes.h"
 #include "chrome/installer/setup/installer_state.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/setup/user_hive_visitor.h"
 #include "chrome/installer/util/app_registration_data.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/non_updating_app_registration_data.h"
 #include "chrome/installer/util/updating_app_registration_data.h"
 #include "chrome/installer/util/util_constants.h"
 #include "courgette/courgette.h"
 #include "courgette/third_party/bsdiff/bsdiff.h"
 
 namespace installer {
 
 namespace {
 
 // Event log providers registry location.
 constexpr wchar_t kEventLogProvidersRegPath[] =
     L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\";
 
-// TODO(grt): use install_static::InstallDetails::Get().install_full_name() when
-// InstallDetails is initialized in the installer.
-base::string16 InstallFullName() {
-#if defined(GOOGLE_CHROME_BUILD)
-  base::string16 reg_path(L"Chrome");
-  if (InstallUtil::IsChromeSxSProcess())
-    reg_path.append(L" SxS");
-  return reg_path;
-#else
-  return base::string16(L"Chromium");
-#endif
-}
-
 // Returns true if the "lastrun" value in |root|\|key_path| (a path to Chrome's
 // ClientState key for a user) indicates that Chrome has been used within the
 // last 28 days.
 bool IsActivelyUsedIn(HKEY root, const wchar_t* key_path) {
   VLOG(1) << "IsActivelyUsedIn probing " << root << "\\" << key_path;
   int days_ago_last_run = GoogleUpdateSettings::GetLastRunTime();
   if (days_ago_last_run >= 0) {
     VLOG(1) << "Found a user that last ran Chrome " << days_ago_last_run
             << " days ago.";
     return days_ago_last_run <= 28;
@@ skipping 16 matching lines @@
   // Stop the iteration.
   *is_used = true;
   return false;
 }
 
 // "The binaries" once referred to the on-disk footprint of Chrome and/or Chrome
 // Frame when the products were configured to share such on-disk bits. Support
 // for this mode of install was dropped from ToT in December 2016. Remove any
 // stray bits in the registry leftover from such installs.
 void RemoveBinariesVersionKey(const InstallerState& installer_state) {
-  base::string16 path(MakeBinariesRegistrationData()->GetVersionKey());
+  base::string16 path(install_static::GetBinariesClientsKeyPath());
   if (base::win::RegKey(installer_state.root_key(), path.c_str(),
                         KEY_QUERY_VALUE | KEY_WOW64_32KEY)
           .Valid()) {
     const bool success = InstallUtil::DeleteRegistryKey(
         installer_state.root_key(), path, KEY_WOW64_32KEY);
     UMA_HISTOGRAM_BOOLEAN("Setup.Install.DeleteBinariesClientsKey", success);
   }
 }
 
 // Remove leftover traces of multi-install Chrome Frame, if present. Once upon a
@@ skipping 573 matching lines @@
 
   base::SparseHistogram::FactoryGet(
       std::string(kUnPackNTSTATUSMetricsName) + "_" + consumer_name,
       base::HistogramBase::kUmaTargetedHistogramFlag)
       ->Add(status);
 }
 
 void RegisterEventLogProvider(const base::FilePath& install_directory,
                               const base::Version& version) {
   base::string16 reg_path(kEventLogProvidersRegPath);
-  reg_path.append(InstallFullName());
+  reg_path.append(install_static::InstallDetails::Get().install_full_name());
   VLOG(1) << "Registering Chrome's event log provider at " << reg_path;
 
   std::unique_ptr<WorkItemList> work_item_list(WorkItem::CreateWorkItemList());
   work_item_list->set_log_message("Register event log provider");
 
   work_item_list->AddCreateRegKeyWorkItem(HKEY_LOCAL_MACHINE, reg_path,
                                           WorkItem::kWow64Default);
   // Speicifes the number of event categories defined in the dll.
   work_item_list->AddSetRegValueWorkItem(
       HKEY_LOCAL_MACHINE, reg_path, WorkItem::kWow64Default, L"CategoryCount",
@@ skipping 19 matching lines @@
   }
 
   // if the operation fails we log the error but still continue because none of
   // these are critical for the proper operation of the browser.
   if (!work_item_list->Do())
     work_item_list->Rollback();
 }
 
 void DeRegisterEventLogProvider() {
   base::string16 reg_path(kEventLogProvidersRegPath);
-  reg_path.append(InstallFullName());
+  reg_path.append(install_static::InstallDetails::Get().install_full_name());
 
   // TODO(http://crbug.com/668120): If the Event Viewer is open the provider dll
   // will fail to get deleted. This doesn't fail the uninstallation altogether
   // but leaves files behind.
   InstallUtil::DeleteRegistryKey(HKEY_LOCAL_MACHINE, reg_path,
                                  WorkItem::kWow64Default);
 }
 
 std::unique_ptr<AppRegistrationData> MakeBinariesRegistrationData() {
-#if defined(GOOGLE_CHROME_BUILD)
-  return base::MakeUnique<UpdatingAppRegistrationData>(
-      L"{4DC8B4CA-1BDA-483e-B5FA-D3C12E15B62D}");
-#else
+  if (install_static::kUseGoogleUpdateIntegration) {
+    return base::MakeUnique<UpdatingAppRegistrationData>(
+        install_static::kBinariesAppGuid);
+  }
   return base::MakeUnique<NonUpdatingAppRegistrationData>(
-      L"Software\\Chromium Binaries");
-#endif
+      base::string16(L"Software\\").append(install_static::kBinariesPathName));
 }
 
 bool AreBinariesInstalled(const InstallerState& installer_state) {
-  if (InstallUtil::IsChromeSxSProcess())
+  if (!install_static::InstallDetails::Get().supported_multi_install())
     return false;
 
   base::win::RegKey key;
   base::string16 pv;
 
   // True if the "pv" value exists and isn't empty.
   return key.Open(installer_state.root_key(),
-                  MakeBinariesRegistrationData()->GetVersionKey().c_str(),
+                  install_static::GetBinariesClientsKeyPath().c_str(),
                   KEY_QUERY_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS &&
          key.ReadValue(google_update::kRegVersionField, &pv) == ERROR_SUCCESS &&
          !pv.empty();
 }
 
 void DoLegacyCleanups(const InstallerState& installer_state,
                       InstallStatus install_status) {
   // Do no harm if the install didn't succeed.
   if (InstallUtil::GetInstallReturnCode(install_status))
     return;
 
   // The cleanups below only apply to normal Chrome, not side-by-side (canary).
-  if (InstallUtil::IsChromeSxSProcess())
+  if (!install_static::InstallDetails::Get().is_primary_mode())
     return;
 
   RemoveBinariesVersionKey(installer_state);
   RemoveMultiChromeFrame(installer_state);
   RemoveAppLauncherVersionKey(installer_state);
   RemoveAppHostExe(installer_state);
   RemoveLegacyChromeAppCommands(installer_state);
 }
 
 ScopedTokenPrivilege::ScopedTokenPrivilege(const wchar_t* privilege_name)
@@ skipping 31 matching lines @@
 }
 
 ScopedTokenPrivilege::~ScopedTokenPrivilege() {
   if (is_enabled_ && previous_privileges_.PrivilegeCount != 0) {
     ::AdjustTokenPrivileges(token_.Get(), FALSE, &previous_privileges_,
                             sizeof(TOKEN_PRIVILEGES), NULL, NULL);
   }
 }
 
 }  // namespace installer