Migrate app_host.exe shortcuts to chrome.exe shortcuts

chrome/browser/shell_integration_win.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/browser/shell_integration.h"
 
 #include <windows.h>
 #include <shobjidl.h>
 #include <propkey.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/shortcut.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/installer/launcher_support/chrome_launcher_support.h"
 #include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item.h"
 #include "chrome/installer/util/work_item_list.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const wchar_t kAppListAppNameSuffix[] = L"AppList";
 
+// How many seconds to delay migrating app host shortcuts.
+const int64 kMigrateAppHostShortcutsDelaySeconds = 15;

[huangs, 2013/04/19 15:21:28]

This appears unused.

+
 // Helper function for ShellIntegration::GetAppId to generates profile id
 // from profile path. "profile_id" is composed of sanitized basenames of
 // user data dir and profile dir joined by a ".".
 string16 GetProfileIdFromPath(const base::FilePath& profile_path) {
   // Return empty string if profile_path is empty
   if (profile_path.empty())
     return string16();
 
   base::FilePath default_user_data_dir;
   // Return empty string if profile_path is in default user data
@@ skipping 27 matching lines @@
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   string16 app_name(dist->GetBaseAppId());
   app_name.append(kAppListAppNameSuffix);
   return app_name;
 }
 
 // Gets expected app id for given Chrome (based on |command_line| and
 // |is_per_user_install|).
 string16 GetExpectedAppId(const CommandLine& command_line,
                           bool is_per_user_install) {
-  base::FilePath profile_path;
-  if (command_line.HasSwitch(switches::kUserDataDir)) {
-    profile_path =
-        command_line.GetSwitchValuePath(switches::kUserDataDir).AppendASCII(
-            chrome::kInitialProfile);
-  }
+  base::FilePath user_data_dir;
+  chrome::GetDefaultUserDataDirectory(&user_data_dir);
+  if (command_line.HasSwitch(switches::kUserDataDir))
+    user_data_dir = command_line.GetSwitchValuePath(switches::kUserDataDir);
+
+  base::FilePath profile_subdir;
+  profile_subdir.AppendASCII(chrome::kInitialProfile);
+  if (command_line.HasSwitch(switches::kProfileDirectory))
+    profile_subdir =
+        command_line.GetSwitchValuePath(switches::kProfileDirectory);
+
+  base::FilePath profile_path = user_data_dir.Append(profile_subdir);
 
   string16 app_name;
   if (command_line.HasSwitch(switches::kApp)) {
     app_name = UTF8ToUTF16(web_app::GenerateApplicationNameFromURL(
         GURL(command_line.GetSwitchValueASCII(switches::kApp))));
   } else if (command_line.HasSwitch(switches::kAppId)) {
     app_name = UTF8ToUTF16(web_app::GenerateApplicationNameFromExtensionId(
         command_line.GetSwitchValueASCII(switches::kAppId)));
   } else if (command_line.HasSwitch(switches::kShowAppList)) {
     app_name = GetAppListAppName();
   } else {
     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     app_name = ShellUtil::GetBrowserModelId(dist, is_per_user_install);
   }
 
   return ShellIntegration::GetAppModelIdForProfile(app_name, profile_path);
 }
 
-void MigrateChromiumShortcutsCallback() {
+// Locations to check for shortcuts migration.
+static const struct {
+  int location_id;
+  const wchar_t* sub_dir;
+} kLocations[] = {
+  {
+    base::DIR_IMPLICIT_APP_SHORTCUTS,
+    NULL
+  }, {
+    base::DIR_TASKBAR_PINS,
+    NULL
+  }, {
+    base::DIR_USER_DESKTOP,
+    NULL
+  }, {
+    base::DIR_START_MENU,
+    NULL
+  }, {
+    base::DIR_APP_DATA,
+    L"Microsoft\\Internet Explorer\\Quick Launch\\User Pinned\\StartMenu"
+  }
+};
+
+void MigrateShortcutsCallback() {
+  ShellIntegration::MigrateAppHostShortcuts();
+  ShellIntegration::MigrateChromiumShortcuts();
+}
+
+void MigrateAppHostShortcutsCallback() {
   // This should run on the file thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Get full path of chrome.
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe))
     return;
 
-  // Locations to check for shortcuts migration.
-  static const struct {
-    int location_id;
-    const wchar_t* sub_dir;
-  } kLocations[] = {
-    {
-      base::DIR_TASKBAR_PINS,
-      NULL
-    }, {
-      base::DIR_USER_DESKTOP,
-      NULL
-    }, {
-      base::DIR_START_MENU,
-      NULL
-    }, {
-      base::DIR_APP_DATA,
-      L"Microsoft\\Internet Explorer\\Quick Launch\\User Pinned\\StartMenu"
-    }
-  };
+  // Get the app_host.exe path.
+  bool is_per_user_install =
+      InstallUtil::IsPerUserInstall(chrome_exe.value().c_str());
+  base::FilePath app_host_exe = GetAppHostPathForInstallationLevel(

[huangs, 2013/04/19 15:21:28]

Does this code account for the case:
1. Chrome is installed in system-level,
2. (The old) App Launcher is installed at user-level?

+      is_per_user_install ? chrome_launcher_support::USER_LEVEL_INSTALLATION
+                          : chrome_launcher_support::SYSTEM_LEVEL_INSTALLATION);
 
   for (int i = 0; i < arraysize(kLocations); ++i) {
     base::FilePath path;
+    if (!PathService::Get(kLocations[i].location_id, &path)) {
+      NOTREACHED();
+      continue;
+    }
+
+    if (kLocations[i].sub_dir)
+      path = path.Append(kLocations[i].sub_dir);
+
+    // Recurse when looking for user-pinned shortcuts as they exist in
+    // subdirectories.
+    bool recursive =
+        (kLocations[i].location_id == base::DIR_IMPLICIT_APP_SHORTCUTS);
+    ShellIntegration::MigrateAppHostShortcutsInPathInternal(
+        chrome_exe, app_host_exe, path, recursive);
+  }
+}
+
+void MigrateChromiumShortcutsCallback() {
+  // This should run on the file thread.
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  // Get full path of chrome.
+  base::FilePath chrome_exe;
+  if (!PathService::Get(base::FILE_EXE, &chrome_exe))
+    return;
+
+  for (int i = 0; i < arraysize(kLocations); ++i) {
+    base::FilePath path;
     if (!PathService::Get(kLocations[i].location_id, &path)) {
       NOTREACHED();
       continue;
     }
 
     if (kLocations[i].sub_dir)
       path = path.Append(kLocations[i].sub_dir);
 
     bool check_dual_mode = (kLocations[i].location_id == base::DIR_START_MENU);
     ShellIntegration::MigrateShortcutsInPathInternal(chrome_exe, path,
@@ skipping 199 matching lines @@
 
   return ShellUtil::FormatIconLocation(
       chrome_exe.value(),
       BrowserDistribution::GetDistribution()->GetIconIndex());
 }
 
 void ShellIntegration::MigrateChromiumShortcuts() {
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return;
 
-  // This needs to happen eventually (e.g. so that the appid is fixed and the
-  // run-time Chrome icon is merged with the taskbar shortcut), but this is not
-  // urgent and shouldn't delay Chrome startup.
-  static const int64 kMigrateChromiumShortcutsDelaySeconds = 15;
-  BrowserThread::PostDelayedTask(
+  BrowserThread::PostTask(

[gab, 2013/04/19 18:34:50]

No need for a second task here given this is already called from a callback on
the file thread in your new implementation.

       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&MigrateChromiumShortcutsCallback),
-      base::TimeDelta::FromSeconds(kMigrateChromiumShortcutsDelaySeconds));
+      base::Bind(&MigrateChromiumShortcutsCallback));
 }
 
 int ShellIntegration::MigrateShortcutsInPathInternal(
     const base::FilePath& chrome_exe,
     const base::FilePath& path,
     bool check_dual_mode) {
   DCHECK(base::win::GetVersion() >= base::win::VERSION_WIN7);
 
   // Enumerate all pinned shortcuts in the given path directly.
   file_util::FileEnumerator shortcuts_enum(
@@ skipping 97 matching lines @@
     if (updated_properties.options &&
         base::win::CreateOrUpdateShortcutLink(
             shortcut, updated_properties,
             base::win::SHORTCUT_UPDATE_EXISTING)) {
       ++shortcuts_migrated;
     }
   }
   return shortcuts_migrated;
 }
 
+void ShellIntegration::MigrateShortcuts() {
+  // These migrations need to happen eventually (e.g. so that the appid is fixed
+  // and the run-time Chrome icon is merged with the taskbar shortcut), but this
+  // is not urgent and shouldn't delay Chrome startup.
+  const int64 kMigrateShortcutsDelaySeconds = 15;
+
+  BrowserThread::PostDelayedTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&MigrateShortcutsCallback),
+      base::TimeDelta::FromSeconds(kMigrateShortcutsDelaySeconds));
+}
+
+void ShellIntegration::MigrateAppHostShortcuts() {
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&MigrateAppHostShortcutsCallback));
+}
+
+int ShellIntegration::MigrateAppHostShortcutsInPathInternal(
+    const base::FilePath& chrome_exe,
+    const base::FilePath& app_host_exe,
+    const base::FilePath& path,
+    bool recursive) {
+  int shortcuts_migrated = 0;
+  base::FilePath target_path;
+  string16 arguments;
+  file_util::FileEnumerator shortcuts_enum(
+      path, recursive, file_util::FileEnumerator::FILES);
+  for (base::FilePath shortcut = shortcuts_enum.Next(); !shortcut.empty();
+       shortcut = shortcuts_enum.Next()) {
+    // TODO(gab): Use ProgramCompare instead of comparing FilePaths below once
+    // it is fixed to work with FilePaths with spaces.

[gab, 2013/04/19 18:34:50]

PS: This has been fixed, you can now use
InstallUtil::ProgramCompare::EvaluatePath() to compare paths (much better than
string comparison).

Thanks :)

+    if (shortcut.Extension() != installer::kLnkExt ||
+        !base::win::ResolveShortcut(shortcut, &target_path, &arguments) ||
+        app_host_exe != target_path) {
+      continue;
+    }
+
+    // Any properties that need to be updated on the shortcut will be stored in
+    // |updated_properties|.
+    base::win::ShortcutProperties updated_properties;
+    updated_properties.set_target(chrome_exe);
+
+    if (base::win::CreateOrUpdateShortcutLink(
+            shortcut, updated_properties,
+            base::win::SHORTCUT_UPDATE_EXISTING)) {
+      ++shortcuts_migrated;
+    }
+  }
+  return shortcuts_migrated;
+}
+
 base::FilePath ShellIntegration::GetStartMenuShortcut(
     const base::FilePath& chrome_exe) {
   static const int kFolderIds[] = {
     base::DIR_COMMON_START_MENU,
     base::DIR_START_MENU,
   };
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   string16 shortcut_name(dist->GetAppShortCutName());
   base::FilePath shortcut;
 
   // Check both the common and the per-user Start Menu folders for system-level
   // installs.
   size_t folder =
       InstallUtil::IsPerUserInstall(chrome_exe.value().c_str()) ? 1 : 0;
   for (; folder < arraysize(kFolderIds); ++folder) {
     if (!PathService::Get(kFolderIds[folder], &shortcut)) {
       NOTREACHED();
       continue;
     }
 
     shortcut = shortcut.Append(shortcut_name).Append(shortcut_name +
                                                      installer::kLnkExt);
     if (file_util::PathExists(shortcut))
       return shortcut;
   }
 
   return base::FilePath();
 }