Adding App Launcher shortcuts on install.

chrome/installer/setup/install.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.
 
 #include "chrome/installer/setup/install.h"
 
 #include <windows.h>
 #include <shlobj.h>
 #include <time.h>
 #include <winuser.h>
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/shortcut.h"
 #include "base/win/windows_version.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/install_worker.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/util/auto_launch_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/delete_after_reboot_helper.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/master_preferences.h"
@@ skipping 89 matching lines @@
   reg_path.append(installer::kChromeExe);
   VLOG(1) << "Adding Chrome to Media player list at " << reg_path;
   scoped_ptr<WorkItem> work_item(WorkItem::CreateCreateRegKeyWorkItem(
       HKEY_LOCAL_MACHINE, reg_path));
 
   // if the operation fails we log the error but still continue
   if (!work_item.get()->Do())
     LOG(ERROR) << "Could not add Chrome to media player inclusion list.";
 }
 
-// Copy master preferences file provided to installer, in the same folder
+// Copy master_preferences file provided to installer, in the same folder
 // as chrome.exe so Chrome first run can find it. This function will be called
 // only on the first install of Chrome.
 void CopyPreferenceFileForFirstRun(const InstallerState& installer_state,
                                    const FilePath& prefs_source_path) {
   FilePath prefs_dest_path(installer_state.target_path().AppendASCII(
       installer::kDefaultMasterPrefs));
   if (!file_util::CopyFile(prefs_source_path, prefs_dest_path)) {
     VLOG(1) << "Failed to copy master preferences from:"
             << prefs_source_path.value() << " gle: " << ::GetLastError();
   }
@@ skipping 132 matching lines @@
       dist->GetUninstallLinkName() + installer::kLnkExt);
   file_util::Delete(uninstall_shortcut_path, false);
 
   if (installer_state.system_install()) {
     ShellUtil::RemoveShortcut(
         ShellUtil::SHORTCUT_LOCATION_QUICK_LAUNCH, dist, chrome_exe.value(),
         ShellUtil::SYSTEM_LEVEL, NULL);
   }
 }
 
+// Returns the appropriate shortcut operations for App Launcher,
+// based on state of installation and master_preferences.
+installer::InstallShortcutOperation GetAppLauncherShortcutOperation(
+    const InstallationState& original_state,
+    const InstallerState& installer_state) {
+  const installer::ProductState* original_app_host_state =
+      original_state.GetProductState(installer_state.system_install(),
+                                     BrowserDistribution::CHROME_APP_HOST);
+  bool app_launcher_exists = original_app_host_state &&
+      CommandLine(original_app_host_state->uninstall_command())
+          .HasSwitch(installer::switches::kChromeAppLauncher);
+  if (!app_launcher_exists)
+    return installer::INSTALL_SHORTCUT_CREATE_ALL;
+
+  return installer::INSTALL_SHORTCUT_REPLACE_EXISTING;
+}
+
 }  // end namespace
 
 namespace installer {
 
 void EscapeXmlAttributeValueInSingleQuotes(string16* att_value) {
   ReplaceChars(*att_value, L"&", L"&amp;", att_value);
   ReplaceChars(*att_value, L"'", L"&apos;", att_value);
   ReplaceChars(*att_value, L"<", L"&lt;", att_value);
 }
 
@@ skipping 51 matching lines @@
               << " to " << src_path.value();
       return true;
     } else {
       PLOG(ERROR) << "Error writing " << installer::kVisualElementsManifest
                   << " to " << src_path.value();
       return false;
     }
   }
 }
 
+// TODO(tommi): Change this function to use WorkItemList.
 void CreateOrUpdateShortcuts(
-    const FilePath& chrome_exe,
+    const FilePath& target,
     const Product& product,
     const MasterPreferences& prefs,
     InstallShortcutLevel install_level,
     InstallShortcutOperation install_operation) {
-  // TODO(tommi): Change this function to use WorkItemList.
-  DCHECK(product.is_chrome());
-
   // Extract shortcut preferences from |prefs|.
   bool do_not_create_desktop_shortcut = false;
   bool do_not_create_quick_launch_shortcut = false;
   bool alternate_desktop_shortcut = false;
   prefs.GetBool(master_preferences::kDoNotCreateDesktopShortcut,
                 &do_not_create_desktop_shortcut);
   prefs.GetBool(master_preferences::kDoNotCreateQuickLaunchShortcut,
                 &do_not_create_quick_launch_shortcut);
   prefs.GetBool(master_preferences::kAltShortcutText,
                 &alternate_desktop_shortcut);
 
   BrowserDistribution* dist = product.distribution();
-  // Shortcuts are always installed per-user unless specified.
-  ShellUtil::ShellChange shortcut_level = (install_level == ALL_USERS ?
-      ShellUtil::SYSTEM_LEVEL : ShellUtil::CURRENT_USER);
 
   // The default operation on update is to overwrite shortcuts with the
   // currently desired properties, but do so only for shortcuts that still
   // exist.
   ShellUtil::ShortcutOperation shortcut_operation;
   switch (install_operation) {
     case INSTALL_SHORTCUT_CREATE_ALL:
       shortcut_operation = ShellUtil::SHELL_SHORTCUT_CREATE_ALWAYS;
       break;
     case INSTALL_SHORTCUT_CREATE_EACH_IF_NO_SYSTEM_LEVEL:
       shortcut_operation = ShellUtil::SHELL_SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL;
       break;
     default:
       DCHECK(install_operation == INSTALL_SHORTCUT_REPLACE_EXISTING);
       shortcut_operation = ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING;
       break;
   }
 
+  // Shortcuts are always installed per-user unless specified.
+  ShellUtil::ShellChange shortcut_level = (install_level == ALL_USERS ?
+      ShellUtil::SYSTEM_LEVEL : ShellUtil::CURRENT_USER);
+
   // |base_properties|: The basic properties to set on every shortcut installed
   // (to be refined on a per-shortcut basis).
   ShellUtil::ShortcutProperties base_properties(shortcut_level);
-  product.AddDefaultShortcutProperties(chrome_exe, &base_properties);
+  product.AddDefaultShortcutProperties(target, &base_properties);
 
   if (!do_not_create_desktop_shortcut ||
       shortcut_operation == ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING) {
     ShellUtil::ShortcutProperties desktop_properties(base_properties);
     if (alternate_desktop_shortcut)
       desktop_properties.set_shortcut_name(dist->GetAlternateApplicationName());
     ExecuteAndLogShortcutOperation(
         ShellUtil::SHORTCUT_LOCATION_DESKTOP, dist, desktop_properties,
         shortcut_operation);
 
@@ skipping 107 matching lines @@
 
     // Update the modifiers on the channel values for the product(s) being
     // installed and for the binaries in case of multi-install.
     installer_state.UpdateChannels();
 
     installer_state.UpdateStage(installer::COPYING_PREFERENCES_FILE);
 
     if (result == FIRST_INSTALL_SUCCESS && !prefs_path.empty())
       CopyPreferenceFileForFirstRun(installer_state, prefs_path);
 
-    // Currently this only creates shortcuts for Chrome, but for other products
-    // we might want to create shortcuts.
-    const Product* chrome_install =
+    installer_state.UpdateStage(installer::CREATING_SHORTCUTS);
+
+    const Product* app_launcher_product =
+        installer_state.FindProduct(BrowserDistribution::CHROME_APP_HOST);
+    // Creates shortcuts for App Launcher.
+    if (app_launcher_product &&
+        app_launcher_product->HasOption(kOptionAppHostIsLauncher)) {
+      // TODO(huangs): Remove this check once we have system-level App Host.
+      DCHECK(!installer_state.system_install());
+      const FilePath app_host_exe(
+          installer_state.target_path().Append(kChromeAppHostExe));
+      InstallShortcutOperation app_launcher_shortcut_operation =
+          GetAppLauncherShortcutOperation(original_state, installer_state);
+
+      // Always install per-user shortcuts for App Launcher.
+      CreateOrUpdateShortcuts(app_host_exe, *app_launcher_product, prefs,
+                              CURRENT_USER, app_launcher_shortcut_operation);
+    }
+
+    const Product* chrome_product =
         installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER);
-    if (chrome_install) {
-      installer_state.UpdateStage(installer::CREATING_SHORTCUTS);
-
-      BrowserDistribution* dist = chrome_install->distribution();
+    // Creates shortcuts for Chrome.
+    if (chrome_product) {
+      BrowserDistribution* dist = chrome_product->distribution();
       const FilePath chrome_exe(
           installer_state.target_path().Append(kChromeExe));
       CleanupLegacyShortcuts(installer_state, dist, chrome_exe);
 
       InstallShortcutOperation install_operation =
           INSTALL_SHORTCUT_REPLACE_EXISTING;
       if (result == installer::FIRST_INSTALL_SUCCESS ||
           result == installer::INSTALL_REPAIRED) {
         install_operation = INSTALL_SHORTCUT_CREATE_ALL;
       }
 
       if (installer_state.system_install()) {
         // Update existing all-users shortcuts for legacy installs.
-        CreateOrUpdateShortcuts(chrome_exe, *chrome_install, prefs, ALL_USERS,
+        CreateOrUpdateShortcuts(chrome_exe, *chrome_product, prefs, ALL_USERS,
                                 INSTALL_SHORTCUT_REPLACE_EXISTING);
       }
       // Always install per-user shortcuts (even on system-level installs where
       // we do so for the installing user instead of waiting for Active Setup).
-      CreateOrUpdateShortcuts(chrome_exe, *chrome_install, prefs, CURRENT_USER,
+      CreateOrUpdateShortcuts(chrome_exe, *chrome_product, prefs, CURRENT_USER,
                               install_operation);
+    }
+
+    if (chrome_product) {
+      // Register Chrome and, if requested, make Chrome the default browser.
+      installer_state.UpdateStage(installer::REGISTERING_CHROME);
 
       bool make_chrome_default = false;
       prefs.GetBool(master_preferences::kMakeChromeDefault,
                     &make_chrome_default);
 
       // If this is not the user's first Chrome install, but they have chosen
       // Chrome to become their default browser on the download page, we must
       // force it here because the master_preferences file will not get copied
       // into the build.
       bool force_chrome_default_for_user = false;
       if (result == NEW_VERSION_UPDATED ||
           result == INSTALL_REPAIRED) {
         prefs.GetBool(master_preferences::kMakeChromeDefaultForUser,
                       &force_chrome_default_for_user);
       }
 
-      installer_state.UpdateStage(installer::REGISTERING_CHROME);
-
-      RegisterChromeOnMachine(installer_state, *chrome_install,
+      RegisterChromeOnMachine(installer_state, *chrome_product,
           make_chrome_default || force_chrome_default_for_user);
 
+      // Configure auto-launch.
       if (result == FIRST_INSTALL_SUCCESS) {
         installer_state.UpdateStage(installer::CONFIGURE_AUTO_LAUNCH);
 
-        // Add auto-launch key if specified in master preferences.
+        // Add auto-launch key if specified in master_preferences.
         bool auto_launch_chrome = false;
         prefs.GetBool(
             installer::master_preferences::kAutoLaunchChrome,
             &auto_launch_chrome);
         if (auto_launch_chrome) {
           auto_launch_util::EnableForegroundStartAtLogin(
               ASCIIToUTF16(chrome::kInitialProfile),
               installer_state.target_path());
         }
       }
@@ skipping 55 matching lines @@
            INSTALL_SHORTCUT_CREATE_EACH_IF_NO_SYSTEM_LEVEL);
 
   // Read master_preferences copied beside chrome.exe at install.
   MasterPreferences prefs(installation_root.AppendASCII(kDefaultMasterPrefs));
   FilePath chrome_exe(installation_root.Append(kChromeExe));
   CreateOrUpdateShortcuts(
       chrome_exe, chrome, prefs, CURRENT_USER, install_operation);
 }
 
 }  // namespace installer