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 88 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:"
+    VLOG(1) << "Failed to copy master_preferences from:"
             << prefs_source_path.value() << " gle: " << ::GetLastError();
   }
 }
 
 // Returns true if the current process is running on the interactive window
 // station.  This cares not whether the input desktop is the default or not
 // (i.e., the screen saver is running, or what have you).
 bool IsInteractiveProcess() {
   static const wchar_t kWinSta0[] = L"WinSta0";
   HWINSTA window_station = ::GetProcessWindowStation();
@@ skipping 124 matching lines @@
       dist->GetUninstallLinkName() + installer::kLnkExt);
   file_util::Delete(uninstall_shortcut_path, false);
 
   if (installer_state.system_install()) {
     ShellUtil::RemoveChromeShortcut(
         ShellUtil::SHORTCUT_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) {
+  // Remove this check once we have system-level App Host.
+  DCHECK(!installer_state.system_install());
+
+  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 52 matching lines @@
       return true;
     } else {
       PLOG(ERROR) << "Error writing " << installer::kVisualElementsManifest
                   << " to " << src_path.value();
       return false;
     }
   }
 }
 
 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());
+  DCHECK(product.is_chrome() || product.is_chrome_app_host());
 
   // 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::ChromeShortcutOperation shortcut_operation;
   switch (install_operation) {
     case INSTALL_SHORTCUT_CREATE_ALL:
       shortcut_operation = ShellUtil::SHORTCUT_CREATE_ALWAYS;
       break;
     case INSTALL_SHORTCUT_CREATE_EACH_IF_NO_SYSTEM_LEVEL:
       shortcut_operation = ShellUtil::SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL;
       break;
     default:
       DCHECK(install_operation == INSTALL_SHORTCUT_REPLACE_EXISTING);
       shortcut_operation = ShellUtil::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::ChromeShortcutProperties base_properties(shortcut_level);
-  base_properties.set_chrome_exe(chrome_exe);
+  base_properties.set_chrome_exe(target);
+
+  if (product.is_chrome_app_host()) {
+    DCHECK(product.HasOption(kOptionAppHostIsLauncher));
+    // Adding command line arguments to app_host.exe.
+    // This is also done in AppListController::GetAppListCommandLine(),
+    // but we don't need the extra user data dir info appended.
+    CommandLine app_host_args(CommandLine::NO_PROGRAM);
+    app_host_args.AppendSwitch(::switches::kShowAppList);
+    // TODO(huangs): Add routine to CommandLine so we can do this directly.
+    base_properties.set_arguments(app_host_args.GetCommandLineString());
+  }
 
   if (!do_not_create_desktop_shortcut ||
       shortcut_operation == ShellUtil::SHORTCUT_REPLACE_EXISTING) {
     ShellUtil::ChromeShortcutProperties desktop_properties(base_properties);
     if (alternate_desktop_shortcut)
       desktop_properties.set_shortcut_name(dist->GetAlternateApplicationName());
     ExecuteAndLogShortcutOperation(
         ShellUtil::SHORTCUT_DESKTOP, dist, desktop_properties,
         shortcut_operation);
 
@@ skipping 106 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 =
+    const Product* app_launcher_product =
+        installer_state.FindProduct(BrowserDistribution::CHROME_APP_HOST);
+    const Product* chrome_product =
         installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER);
-    if (chrome_install) {
+
+    bool process_app_launcher_shortcuts = (app_launcher_product != NULL) &&
+        app_launcher_product->HasOption(kOptionAppHostIsLauncher);
+    bool process_chrome_shortcuts = (chrome_product != NULL);
+
+    if (process_app_launcher_shortcuts || process_chrome_shortcuts) {

[erikwright (departed), 2012/11/01 20:43:36]

personally I would say don't bother with this 'if'. Just update the state either
way. If no shortcuts need to be created, it's no big deal to enter and exit the
state without any work.

[grt (UTC plus 2), 2012/11/02 19:55:30]

+1

[huangs, 2012/11/02 21:05:10]

Done.

       installer_state.UpdateStage(installer::CREATING_SHORTCUTS);
+    }
 
-      BrowserDistribution* dist = chrome_install->distribution();
+    if (process_app_launcher_shortcuts) {
+      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);
+    }
+
+    if (process_chrome_shortcuts) {

[gab, 2012/11/02 04:19:58]

I don't like the name "process_chrome_shortcuts" as this block does more than
just shortcuts; you can keep it like this, but consider the structure I just
replied on the same lines on the previous patch set.

[huangs, 2012/11/02 21:05:10]

Got rid of the variable.  The original comment was also misleading.  So I broke
this into separate blocks (with redundant ifs), and added a short comment each.

+      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);
 
       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);
 
       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