[Installer] Make recent install_worker.cc changes use AppRegistrationData

chrome/installer/setup/install_worker.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 contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <oaidl.h>
@@ skipping 13 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/install.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/setup/setup_util.h"
+#include "chrome/installer/util/app_registration_data.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/callback_work_item.h"
 #include "chrome/installer/util/conditional_work_item_list.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/firewall_manager_win.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/installation_state.h"
 #include "chrome/installer/util/installer_state.h"
 #include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/product.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
 #include "chrome/installer/util/shell_util.h"
+#include "chrome/installer/util/updating_app_registration_data.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item_list.h"
 
 using base::ASCIIToWide;
 using base::win::RegKey;
 
 namespace installer {
 
 namespace {
 
@@ skipping 120 matching lines @@
         // system-level archive.
         install_list->AddCopyTreeWorkItem(archive_path.value(),
                                           archive_dst.value(),
                                           temp_path.value(),
                                           WorkItem::ALWAYS);
       }
     }
   }
 }
 
-base::string16 GetRegCommandKey(BrowserDistribution* dist,
+base::string16 GetRegCommandKey(const AppRegistrationData& reg_data,

[grt (UTC plus 2), 2014/10/01 20:14:26]

this makes all callers' lives a bit more difficult. how about leaving the
signature of GetRegCommandKey as-is and have it delegate to
GetRegistrationDataCommandKey, or something similar?

[huangs, 2014/10/01 22:39:20]

Done.

                                 const wchar_t* name) {
-  base::string16 cmd_key(dist->GetVersionKey());
+  base::string16 cmd_key(reg_data.GetVersionKey());
   cmd_key.append(1, base::FilePath::kSeparators[0])
       .append(google_update::kRegCommandsKey)
       .append(1, base::FilePath::kSeparators[0])
       .append(name);
   return cmd_key;
 }
 
 // Adds work items to create (or delete if uninstalling) app commands to launch
 // the app with a switch. The following criteria should be true:
 //  1. The switch takes one parameter.
 //  2. The command send pings.
 //  3. The command is web accessible.
 //  4. The command is run as the user.
 void AddCommandWithParameterWorkItems(const InstallerState& installer_state,
                                       const InstallationState& machine_state,
                                       const Version& new_version,
                                       const Product& product,
                                       const wchar_t* command_key,
                                       const wchar_t* app,
                                       const char* command_with_parameter,
                                       WorkItemList* work_item_list) {
   DCHECK(command_key);
   DCHECK(app);
   DCHECK(command_with_parameter);
   DCHECK(work_item_list);
 
   base::string16 full_cmd_key(
-      GetRegCommandKey(product.distribution(), command_key));
+      GetRegCommandKey(product.distribution()->GetAppRegistrationData(),
+                       command_key));
 
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     work_item_list->AddDeleteRegKeyWorkItem(installer_state.root_key(),
                                             full_cmd_key,
                                             KEY_WOW64_32KEY)
         ->set_log_message("removing " + base::UTF16ToASCII(command_key) +
                           " command");
   } else {
     CommandLine cmd_line(installer_state.target_path().Append(app));
     cmd_line.AppendSwitchASCII(command_with_parameter, "%1");
 
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_sends_pings(true);
     cmd.set_is_web_accessible(true);
     cmd.set_is_run_as_user(true);
     cmd.AddWorkItems(installer_state.root_key(), full_cmd_key, work_item_list);
   }
 }
 
 void AddLegacyAppCommandRemovalItem(const InstallerState& installer_state,
-                                    BrowserDistribution* distribution,
+                                    const AppRegistrationData& reg_data,
                                     const wchar_t* name,
                                     WorkItemList* work_item_list) {
   // These failures are ignored because this is a clean-up operation that
   // shouldn't block an install or update on failing.
   work_item_list->AddDeleteRegKeyWorkItem(
       installer_state.root_key(),
-      GetRegCommandKey(distribution, name),
+      GetRegCommandKey(reg_data, name),
       KEY_WOW64_32KEY)->set_ignore_failure(true);
 }
 
 // A callback invoked by |work_item| that adds firewall rules for Chrome. Rules
 // are left in-place on rollback unless |remove_on_rollback| is true. This is
 // the case for new installs only. Updates and overinstalls leave the rule
 // in-place on rollback since a previous install of Chrome will be used in that
 // case.
 bool AddFirewallRulesCallback(bool system_level,
                               BrowserDistribution* dist,
@@ skipping 98 matching lines @@
 
   bool will_have_chrome_binaries =
       WillProductBePresentAfterSetup(installer_state, machine_state,
                                      BrowserDistribution::CHROME_BINARIES);
 
   // For system-level binaries there is no way to keep the command state in sync
   // with the installation/uninstallation of the Application Launcher (which is
   // always at user-level).  So we do not try to remove the command, i.e., it
   // will always be installed if the Chrome Binaries are installed.
   if (will_have_chrome_binaries) {
+    BrowserDistribution* binaries_dist =
+        BrowserDistribution::GetSpecificDistribution(
+            BrowserDistribution::CHROME_BINARIES);
     base::string16 cmd_key(
-        GetRegCommandKey(BrowserDistribution::GetSpecificDistribution(
-                             BrowserDistribution::CHROME_BINARIES),
+        GetRegCommandKey(binaries_dist->GetAppRegistrationData(),
                          kCmdQuickEnableApplicationHost));
     CommandLine cmd_line(GetGenericQuickEnableCommand(installer_state,
                                                       machine_state,
                                                       setup_path,
                                                       new_version));
     // kMultiInstall and kVerboseLogging were processed above.
     cmd_line.AppendSwitch(switches::kChromeAppLauncher);
     cmd_line.AppendSwitch(switches::kEnsureGoogleUpdatePresent);
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_sends_pings(true);
@@ skipping 12 matching lines @@
   const Products& products = installer_state.products();
   for (Products::const_iterator it = products.begin(); it < products.end();
        ++it) {
     const Product& p = **it;
     if (p.is_chrome()) {
       AddOsUpgradeWorkItems(installer_state, setup_path, new_version, p,
                             list);
       AddFirewallRulesWorkItems(
           installer_state, p.distribution(), is_new_install, list);
       AddLegacyAppCommandRemovalItem(
-          installer_state, p.distribution(), kLegacyCmdInstallExtension, list);
+          installer_state,
+          p.distribution()->GetAppRegistrationData(),
+          kLegacyCmdInstallExtension,
+          list);
 
       if (p.distribution()->AppHostIsSupported()) {
         // Unconditionally remove the "install-application" command from the app
         // hosts's key.
-        AddLegacyAppCommandRemovalItem(
-            installer_state,
-            BrowserDistribution::GetSpecificDistribution(
-                BrowserDistribution::CHROME_APP_HOST),
-            kLegacyCmdInstallApp,
-            list);
+        UpdatingAppRegistrationData app_launcher_reg_data(
+            installer::kAppLauncherGuid);
+        AddLegacyAppCommandRemovalItem(installer_state, app_launcher_reg_data,
+                                       kLegacyCmdInstallApp, list);
       }
     }
     if (p.is_chrome_binaries()) {
       AddQueryEULAAcceptanceWorkItems(
           installer_state, setup_path, new_version, p, list);
       AddQuickEnableChromeFrameWorkItems(installer_state, list);
       AddQuickEnableApplicationLauncherWorkItems(
           installer_state, original_state, setup_path, new_version, list);
     }
   }
@@ skipping 1162 matching lines @@
   }
 }
 
 void AddOsUpgradeWorkItems(const InstallerState& installer_state,
                            const base::FilePath& setup_path,
                            const Version& new_version,
                            const Product& product,
                            WorkItemList* install_list) {
   const HKEY root_key = installer_state.root_key();
   base::string16 cmd_key(
-      GetRegCommandKey(product.distribution(), kCmdOnOsUpgrade));
+      GetRegCommandKey(product.distribution()->GetAppRegistrationData(),
+                       kCmdOnOsUpgrade));
 
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     install_list->AddDeleteRegKeyWorkItem(root_key, cmd_key, KEY_WOW64_32KEY)
         ->set_log_message("Removing OS upgrade command");
   } else {
     // Register with Google Update to have setup.exe --on-os-upgrade called on
     // OS upgrade.
     CommandLine cmd_line(installer_state
         .GetInstallerDirectory(new_version)
         .Append(setup_path.BaseName()));
@@ skipping 12 matching lines @@
   }
 }
 
 void AddQueryEULAAcceptanceWorkItems(const InstallerState& installer_state,
                                      const base::FilePath& setup_path,
                                      const Version& new_version,
                                      const Product& product,
                                      WorkItemList* work_item_list) {
   const HKEY root_key = installer_state.root_key();
   base::string16 cmd_key(
-      GetRegCommandKey(product.distribution(), kCmdQueryEULAAcceptance));
+      GetRegCommandKey(product.distribution()->GetAppRegistrationData(),
+      kCmdQueryEULAAcceptance));
   if (installer_state.operation() == InstallerState::UNINSTALL) {
     work_item_list->AddDeleteRegKeyWorkItem(root_key, cmd_key, KEY_WOW64_32KEY)
         ->set_log_message("Removing query EULA acceptance command");
   } else {
     CommandLine cmd_line(installer_state
         .GetInstallerDirectory(new_version)
         .Append(setup_path.BaseName()));
     cmd_line.AppendSwitch(switches::kQueryEULAAcceptance);
     if (installer_state.system_install())
       cmd_line.AppendSwitch(installer::switches::kSystemLevel);
     if (installer_state.verbose_logging())
       cmd_line.AppendSwitch(installer::switches::kVerboseLogging);
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_is_web_accessible(true);
     cmd.set_is_run_as_user(true);
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, work_item_list);
   }
 }
 
 void AddQuickEnableChromeFrameWorkItems(const InstallerState& installer_state,
                                         WorkItemList* work_item_list) {
   DCHECK(work_item_list);
-
+  BrowserDistribution* binaries_dist =
+      BrowserDistribution::GetSpecificDistribution(
+          BrowserDistribution::CHROME_BINARIES);
   base::string16 cmd_key(
-      GetRegCommandKey(BrowserDistribution::GetSpecificDistribution(
-                           BrowserDistribution::CHROME_BINARIES),
+      GetRegCommandKey(binaries_dist->GetAppRegistrationData(),
                        kCmdQuickEnableCf));
 
   // Unconditionally remove the legacy Quick Enable command from the binaries.
   // Do this even if multi-install Chrome isn't installed to ensure that it is
   // not left behind in any case.
   work_item_list->AddDeleteRegKeyWorkItem(
                       installer_state.root_key(), cmd_key, KEY_WOW64_32KEY)
       ->set_log_message("removing " + base::UTF16ToASCII(kCmdQuickEnableCf) +
                         " command");
 }
 
 }  // namespace installer