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"
@@ skipping 45 matching lines @@
   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)) {

[koz (OOO until 15th September), 2013/04/18 02:06:08]

I think this reads better if you use some intermediate variables here

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 = chrome::kInitialProfile;
if (command_line.HasSwitch(switches::kProfileDirectory)
  profile_subdir = command_line.GetSwitchValuePath(switches::kProfileDirectory);

base::FilePath profile_path = user_data_dir.AppendASCII(profile_subdir);

[calamity, 2013/04/18 08:24:34]

Done.

     profile_path =
-        command_line.GetSwitchValuePath(switches::kUserDataDir).AppendASCII(
-            chrome::kInitialProfile);
+        command_line.GetSwitchValuePath(switches::kUserDataDir);
+  } else {
+    chrome::GetDefaultUserDataDirectory(&profile_path);
+  }
+
+  if (command_line.HasSwitch(switches::kProfileDirectory)) {
+    profile_path = profile_path.Append(
+        command_line.GetSwitchValuePath(switches::kProfileDirectory));
+  } else {
+    profile_path = profile_path.AppendASCII(
+          chrome::kInitialProfile);
   }
 
   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() {
   // 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;
 
+  // Get the app_host.exe path.
+  bool is_per_user_install =
+      InstallUtil::IsPerUserInstall(chrome_exe.value().c_str());
+  base::FilePath app_host_exe = GetAppHostPathForInstallationLevel(
+      is_per_user_install ? chrome_launcher_support::USER_LEVEL_INSTALLATION
+                          : chrome_launcher_support::SYSTEM_LEVEL_INSTALLATION);
+
   // 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"
     }
   };
 
   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,
-                                                     check_dual_mode);
+    bool recursive =
+        (kLocations[i].location_id == base::DIR_IMPLICIT_APP_SHORTCUTS);
+    ShellIntegration::MigrateShortcutsInPathInternal(chrome_exe,
+                                                     app_host_exe,
+                                                     path,
+                                                     check_dual_mode,
+                                                     recursive);
   }
 }
 
 ShellIntegration::DefaultWebClientState
     GetDefaultWebClientStateFromShellUtilDefaultState(
         ShellUtil::DefaultState default_state) {
   switch (default_state) {
     case ShellUtil::NOT_DEFAULT:
       return ShellIntegration::NOT_DEFAULT;
     case ShellUtil::IS_DEFAULT:
@@ skipping 200 matching lines @@
   // urgent and shouldn't delay Chrome startup.
   static const int64 kMigrateChromiumShortcutsDelaySeconds = 15;
   BrowserThread::PostDelayedTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&MigrateChromiumShortcutsCallback),
       base::TimeDelta::FromSeconds(kMigrateChromiumShortcutsDelaySeconds));
 }
 
 int ShellIntegration::MigrateShortcutsInPathInternal(
     const base::FilePath& chrome_exe,
+    const base::FilePath& app_host_exe,
     const base::FilePath& path,
-    bool check_dual_mode) {
+    bool check_dual_mode,
+    bool recursive) {
   DCHECK(base::win::GetVersion() >= base::win::VERSION_WIN7);
 
+
   // Enumerate all pinned shortcuts in the given path directly.
   file_util::FileEnumerator shortcuts_enum(
-      path, false,  // not recursive
-      file_util::FileEnumerator::FILES, FILE_PATH_LITERAL("*.lnk"));
+      path, recursive,
+      file_util::FileEnumerator::FILES);
 
   bool is_per_user_install =
       InstallUtil::IsPerUserInstall(chrome_exe.value().c_str());
 
   int shortcuts_migrated = 0;
   base::FilePath target_path;
   string16 arguments;
   base::win::ScopedPropVariant propvariant;
   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.
-    if (!base::win::ResolveShortcut(shortcut, &target_path, &arguments) ||
-        chrome_exe != target_path) {
+    if (shortcut.Extension() != installer::kLnkExt ||
+        !base::win::ResolveShortcut(shortcut, &target_path, &arguments) ||
+        (chrome_exe != target_path && app_host_exe != target_path)) {
       continue;
     }
     CommandLine command_line(CommandLine::FromString(base::StringPrintf(
         L"\"%ls\" %ls", target_path.value().c_str(), arguments.c_str())));
 
     // Get the expected AppId for this Chrome shortcut.
     string16 expected_app_id(
         GetExpectedAppId(command_line, is_per_user_install));
     if (expected_app_id.empty())
       continue;
 
     // Load the shortcut.
     base::win::ScopedComPtr<IShellLink> shell_link;
     base::win::ScopedComPtr<IPersistFile> persist_file;
     if (FAILED(shell_link.CreateInstance(CLSID_ShellLink, NULL,
                                          CLSCTX_INPROC_SERVER)) ||
         FAILED(persist_file.QueryFrom(shell_link)) ||
         FAILED(persist_file->Load(shortcut.value().c_str(), STGM_READ))) {
       DLOG(WARNING) << "Failed loading shortcut at " << shortcut.value();
       continue;
     }
 
     // Any properties that need to be updated on the shortcut will be stored in
     // |updated_properties|.
     base::win::ShortcutProperties updated_properties;
 
+    // Migrate app_host.exe shortcuts to chrome.exe
+    if (target_path == app_host_exe) {
+      updated_properties.set_target(chrome_exe);
+    }
+
     // Validate the existing app id for the shortcut.
     base::win::ScopedComPtr<IPropertyStore> property_store;
     propvariant.Reset();
     if (FAILED(property_store.QueryFrom(shell_link)) ||
         property_store->GetValue(PKEY_AppUserModel_ID,
                                  propvariant.Receive()) != S_OK) {
       // When in doubt, prefer not updating the shortcut.
       NOTREACHED();
       continue;
     } else {
@@ skipping 73 matching lines @@
     }
 
     shortcut = shortcut.Append(shortcut_name).Append(shortcut_name +
                                                      installer::kLnkExt);
     if (file_util::PathExists(shortcut))
       return shortcut;
   }
 
   return base::FilePath();
 }