Implementing unified Chrome / App Launcher flow, and migrating old stand-alone App Launcher.

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 11 matching lines @@
 #include "base/path_service.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/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/launcher_support/chrome_launcher_support.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/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/google_update_constants.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
@@ skipping 130 matching lines @@
 
   if (installer_state.RequiresActiveSetup()) {
     // Make a copy of setup.exe with a different name so that Active Setup
     // doesn't require an admin on XP thanks to Application Compatibility.
     base::FilePath active_setup_exe(installer_dir.Append(kActiveSetupExe));
     install_list->AddCopyTreeWorkItem(
         setup_path.value(), active_setup_exe.value(), temp_path.value(),
         WorkItem::ALWAYS);
   }
 
-  // If only the App Host (not even the Chrome Binaries) is being installed,
-  // this must be a user-level App Host piggybacking on system-level Chrome
-  // Binaries. Only setup.exe is required, and only for uninstall.
-  if (installer_state.products().size() != 1 ||
-      !installer_state.FindProduct(BrowserDistribution::CHROME_APP_HOST)) {
-    base::FilePath archive_dst(installer_dir.Append(archive_path.BaseName()));
-    if (archive_path != archive_dst) {
-      // In the past, we copied rather than moved for system level installs so
-      // that the permissions of %ProgramFiles% would be picked up.  Now that
-      // |temp_path| is in %ProgramFiles% for system level installs (and in
-      // %LOCALAPPDATA% otherwise), there is no need to do this for the archive.
-      // Setup.exe, on the other hand, is created elsewhere so it must always be
-      // copied.
-      if (temp_path.IsParent(archive_path)) {
-        install_list->AddMoveTreeWorkItem(archive_path.value(),
-                                          archive_dst.value(),
-                                          temp_path.value(),
-                                          WorkItem::ALWAYS_MOVE);
-      } else {
-        // This may occur when setup is run out of an existing installation
-        // directory. For example, when quick-enabling user-level App Launcher
-        // from system-level Binaries. We can't (and don't want to) remove the
-        // system-level archive.
-        install_list->AddCopyTreeWorkItem(archive_path.value(),
-                                          archive_dst.value(),
-                                          temp_path.value(),
-                                          WorkItem::ALWAYS);
-      }
+  base::FilePath archive_dst(installer_dir.Append(archive_path.BaseName()));
+  if (archive_path != archive_dst) {
+    // In the past, we copied rather than moved for system level installs so
+    // that the permissions of %ProgramFiles% would be picked up.  Now that
+    // |temp_path| is in %ProgramFiles% for system level installs (and in
+    // %LOCALAPPDATA% otherwise), there is no need to do this for the archive.
+    // Setup.exe, on the other hand, is created elsewhere so it must always be
+    // copied.
+    if (temp_path.IsParent(archive_path)) {
+      install_list->AddMoveTreeWorkItem(archive_path.value(),
+                                        archive_dst.value(),
+                                        temp_path.value(),
+                                        WorkItem::ALWAYS_MOVE);
+    } else {
+      // This may occur when setup is run out of an existing installation
+      // directory. For example, when quick-enabling user-level App Launcher
+      // from system-level Binaries. We can't (and don't want to) remove the
+      // system-level archive.
+      install_list->AddCopyTreeWorkItem(archive_path.value(),
+                                        archive_dst.value(),
+                                        temp_path.value(),
+                                        WorkItem::ALWAYS);
     }
   }
 }
 
 string16 GetRegCommandKey(BrowserDistribution* dist,
                           const wchar_t* name) {
   string16 cmd_key(dist->GetVersionKey());
   cmd_key.append(1, base::FilePath::kSeparators[0])
       .append(google_update::kRegCommandsKey)
       .append(1, base::FilePath::kSeparators[0])
@@ skipping 39 matching lines @@
 }
 
 void AddInstallAppCommandWorkItems(const InstallerState& installer_state,
                                    const InstallationState& machine_state,
                                    const Version& new_version,
                                    const Product& product,
                                    WorkItemList* work_item_list) {
   DCHECK(product.is_chrome_app_host());
   AddCommandWithParameterWorkItems(installer_state, machine_state, new_version,
                                    product, kCmdInstallApp,
-                                   installer::kChromeAppHostExe,
+                                   installer::kChromeExe,
                                    ::switches::kInstallFromWebstore,
                                    work_item_list);
 }
 
 void AddInstallExtensionCommandWorkItem(const InstallerState& installer_state,
                                         const InstallationState& machine_state,
                                         const base::FilePath& setup_path,
                                         const Version& new_version,
                                         const Product& product,
                                         WorkItemList* work_item_list) {
@@ skipping 48 matching lines @@
   cmd_line.AppendSwitch(switches::kMultiInstall);
   if (installer_state.verbose_logging())
     cmd_line.AppendSwitch(switches::kVerboseLogging);
   return cmd_line;
 }
 
 // Adds work items to add the "quick-enable-application-host" command to the
 // multi-installer binaries' version key on the basis of the current operation
 // (represented in |installer_state|) and the pre-existing machine configuration
 // (represented in |machine_state|).
 void AddQuickEnableApplicationLauncherWorkItems(

[gab, 2013/05/15 22:42:20]

Can the app launcher even still be quick enabled? If it's part of Chrome how
does that make sense?

[huangs, 2013/05/17 20:59:24]

This is kept for compatibility for the "non-Chrome flow".

This can be deleted as an independent task when/if the time comes (would need to
change validator and validator unittests as well).

     const InstallerState& installer_state,
     const InstallationState& machine_state,
     const base::FilePath& setup_path,
     const Version& new_version,
     WorkItemList* work_item_list) {
   DCHECK(work_item_list);
 
   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) {
     string16 cmd_key(GetRegCommandKey(
                          BrowserDistribution::GetSpecificDistribution(
                              BrowserDistribution::CHROME_BINARIES),
                          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);

[gab, 2013/05/15 22:42:20]

what did this do?

[huangs, 2013/05/17 20:59:24]

Installs Google Update at user-level (even if Chrome is at system-level)
whenever quick-enable-application-host occurs.

     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(), cmd_key, work_item_list);
   }
 }
 
 void AddProductSpecificWorkItems(const InstallationState& original_state,
                                  const InstallerState& installer_state,
@@ skipping 278 matching lines @@
     scoped_ptr<WorkItemList> no_rollback_list(
         WorkItem::CreateNoRollbackWorkItemList());
     AddUninstallDelegateExecuteWorkItems(
         HKEY_CURRENT_USER, google_chrome_delegate_execute_path,
         no_rollback_list.get());
     list->AddWorkItem(no_rollback_list.release());
     VLOG(1) << "Added deletion items for bad Canary registrations.";
   }
 }
 
+// As of M29, App Launcher is unified with Chrome. Here we delete a number of
+// legacy install artifacts for the product, before new artifacts are installed.
+void MigrateLegacyAppLauncher(const InstallerState& installer_state,
+                              const base::FilePath& temp_path,
+                              WorkItemList* install_list) {
+  VLOG(1) << "Migrating legacy App Launcher that used app_host.exe.";
+  HKEY reg_root = HKEY_CURRENT_USER;

[gab, 2013/05/15 22:42:20]

inline below

[huangs, 2013/05/17 20:59:24]

Done.

+
+  if (!installer_state.system_install()) {
+    // Delete Add/Remove entry. Skip this for system-level install, since in
+    // this case it's up to the self-destruct flow to call uninstall.

[gab, 2013/05/15 22:42:20]

App launcher was never installed at system-level, right?

[huangs, 2013/05/17 20:59:24]

This is |installer_state|. The new App Launcher may be in system level.  The
purpose of this check is avoid system-level install meddling with user-level.

+    string16 legacy_app_host_uninstall_reg_path(
+        L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"
+        L"Google Chrome App Launcher");
+    install_list->AddDeleteRegKeyWorkItem(reg_root,
+                                          legacy_app_host_uninstall_reg_path);
+  }
+
+  // Delete app_host.exe at the install level.
+  base::FilePath app_host_exe(

[gab, 2013/05/15 22:42:20]

Did app_host.exe live beside chrome.exe or in the version folder? If it lived in
the version folder than you don't need to do anything.

[huangs, 2013/05/17 20:59:24]

app_host.exe lives besides chrome.exe (or by itself if user-level Chrome
self-destructed; there was code to explicitly leave app_host.exe alone).

+      chrome_launcher_support::GetAppHostPathForInstallationLevel(
+          installer_state.system_install() ?
+          chrome_launcher_support::SYSTEM_LEVEL_INSTALLATION :
+          chrome_launcher_support::USER_LEVEL_INSTALLATION));
+  if (!app_host_exe.empty())
+    install_list->AddDeleteTreeWorkItem(app_host_exe, temp_path);
+}
+
 }  // namespace
 
 // This method adds work items to create (or update) Chrome uninstall entry in
 // either the Control Panel->Add/Remove Programs list or in the Omaha client
 // state key if running under an MSI installer.
 void AddUninstallShortcutWorkItems(const InstallerState& installer_state,
                                    const base::FilePath& setup_path,
                                    const Version& new_version,
                                    const Product& product,
                                    WorkItemList* install_list) {
@@ skipping 492 matching lines @@
                          const Version& new_version,
                          WorkItemList* install_list) {
   DCHECK(install_list);
 
   const base::FilePath& target_path = installer_state.target_path();
 
   // A temp directory that work items need and the actual install directory.
   install_list->AddCreateDirWorkItem(temp_path);
   install_list->AddCreateDirWorkItem(target_path);
 
+  // User-level App Launcher may be an old version that uses app_host.exe,
+  // which needs to be migrated.
+  if (installer_state.FindProduct(BrowserDistribution::CHROME_BINARIES)) {
+    if (installer_state.need_to_migrate_legacy_app_launcher()) {

[gab, 2013/05/15 22:42:20]

Use && rather than 2 ifs

[huangs, 2013/05/17 20:59:24]

Done.

+      MigrateLegacyAppLauncher(installer_state, temp_path, install_list);
+    }
+  }
+
   if (installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER) ||
       installer_state.FindProduct(BrowserDistribution::CHROME_FRAME) ||
       installer_state.FindProduct(BrowserDistribution::CHROME_BINARIES)) {
     AddChromeWorkItems(original_state,
                        installer_state,
                        setup_path,
                        archive_path,
                        src_path,
                        temp_path,
                        current_version,
                        new_version,
                        install_list);
   }
 
-  if (installer_state.FindProduct(BrowserDistribution::CHROME_APP_HOST)) {
-    install_list->AddCopyTreeWorkItem(
-        src_path.Append(installer::kChromeAppHostExe).value(),
-        target_path.Append(installer::kChromeAppHostExe).value(),
-        temp_path.value(),
-        WorkItem::ALWAYS,
-        L"");
-  }
-
   // Copy installer in install directory
   AddInstallerCopyTasks(installer_state, setup_path, archive_path, temp_path,
                         new_version, install_list);
 
   const HKEY root = installer_state.root_key();
   // Only set "lang" for user-level installs since for system-level, the install
   // language may not be related to a given user's runtime language.
   const bool add_language_identifier = !installer_state.system_install();
 
   const Products& products = installer_state.products();
   for (Products::const_iterator it = products.begin(); it < products.end();
        ++it) {
     const Product& product = **it;
 
     AddUninstallShortcutWorkItems(installer_state, setup_path, new_version,
                                   product, install_list);
 
     AddVersionKeyWorkItems(root, product.distribution(), new_version,
                            add_language_identifier, install_list);
 
     AddDelegateExecuteWorkItems(installer_state, target_path, new_version,
                                 product, install_list);
 
     AddActiveSetupWorkItems(installer_state, setup_path, new_version, product,
                             install_list);
   }
 
-  // TODO(huangs): Implement actual migration code and remove the hack below.
-  // If installing Chrome without the legacy stand-alone App Launcher (to be
-  // handled later), add "shadow" App Launcher registry keys so Google Update
-  // would recognize the "dr" value in the App Launcher ClientState key.
-  // Checking .is_multi_install() excludes Chrome Canary and stand-alone Chrome.
-  if (installer_state.is_multi_install() &&
-      installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER) &&
-      !installer_state.FindProduct(BrowserDistribution::CHROME_APP_HOST)) {
-    BrowserDistribution* shadow_app_launcher_dist =
-        BrowserDistribution::GetSpecificDistribution(
-            BrowserDistribution::CHROME_APP_HOST);
-    AddVersionKeyWorkItems(root, shadow_app_launcher_dist, new_version,
-                           add_language_identifier, install_list);
-  }
-
   // Add any remaining work items that involve special settings for
   // each product.
   AddProductSpecificWorkItems(original_state, installer_state, setup_path,
                               new_version, install_list);
 
   // Copy over brand, usagestats, and other values.
   AddGoogleUpdateWorkItems(original_state, installer_state, install_list);
 
   // Append the tasks that run after the installation.
   AppendPostInstallTasks(installer_state,
@@ skipping 461 matching lines @@
     if (installer_state.system_install())
       cmd_line.AppendSwitch(switches::kSystemLevel);
     AppCommand cmd(cmd_line.GetCommandLineString());
     cmd.set_sends_pings(true);
     cmd.set_is_web_accessible(true);
     cmd.AddWorkItems(installer_state.root_key(), cmd_key, work_item_list);
   }
 }
 
 }  // namespace installer