Change shortcut install location to non-subdir.

chrome/installer/util/shell_util.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 defines functions that integrate Chrome in Windows shell. These
 // functions can be used by Chrome as well as Chrome installer. All of the
 // work is done by the local functions defined in anonymous namespace in
 // this class.
 
 #include "chrome/installer/util/shell_util.h"
@@ skipping 1558 matching lines @@
 }
 
 
 // If the folder specified by {|location|, |dist|, |level|} is empty, remove it.
 // Otherwise do nothing. Returns true on success, including the vacuous case
 // where no deletion occurred because directory is non-empty.
 bool RemoveShortcutFolderIfEmpty(ShellUtil::ShortcutLocation location,
                                  BrowserDistribution* dist,
                                  ShellUtil::ShellChange level) {
   // Explicitly whitelist locations, since accidental calls can be very harmful.
-  if (location != ShellUtil::SHORTCUT_LOCATION_START_MENU_CHROME_DIR &&
+  if (location !=
+          ShellUtil::SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED &&
       location != ShellUtil::SHORTCUT_LOCATION_START_MENU_CHROME_APPS_DIR &&
       location != ShellUtil::SHORTCUT_LOCATION_APP_SHORTCUTS) {
     NOTREACHED();
     return false;
   }
 
   base::FilePath shortcut_folder;
   if (!ShellUtil::GetShortcutPath(location, dist, level, &shortcut_folder)) {
     LOG(WARNING) << "Cannot find path at location " << location;
     return false;
@@ skipping 58 matching lines @@
 ShellUtil::ShortcutProperties::~ShortcutProperties() {
 }
 
 bool ShellUtil::QuickIsChromeRegisteredInHKLM(BrowserDistribution* dist,
                                               const base::FilePath& chrome_exe,
                                               const base::string16& suffix) {
   return QuickIsChromeRegistered(dist, chrome_exe, suffix,
                                  CONFIRM_SHELL_REGISTRATION_IN_HKLM);
 }
 
-bool ShellUtil::ShortcutLocationIsSupported(
-    ShellUtil::ShortcutLocation location) {
+bool ShellUtil::ShortcutLocationIsSupported(ShortcutLocation location) {
   switch (location) {
     case SHORTCUT_LOCATION_DESKTOP:  // Falls through.
     case SHORTCUT_LOCATION_QUICK_LAUNCH:  // Falls through.
     case SHORTCUT_LOCATION_START_MENU_ROOT:  // Falls through.
-    case SHORTCUT_LOCATION_START_MENU_CHROME_DIR:  // Falls through.
+    case SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED:  // Falls through.
     case SHORTCUT_LOCATION_START_MENU_CHROME_APPS_DIR:
       return true;
     case SHORTCUT_LOCATION_TASKBAR_PINS:
       return base::win::GetVersion() >= base::win::VERSION_WIN7;
     case SHORTCUT_LOCATION_APP_SHORTCUTS:
       return base::win::GetVersion() >= base::win::VERSION_WIN8;
     default:
       NOTREACHED();
       return false;
   }
 }
 
-bool ShellUtil::GetShortcutPath(ShellUtil::ShortcutLocation location,
+bool ShellUtil::GetShortcutPath(ShortcutLocation location,
                                 BrowserDistribution* dist,
                                 ShellChange level,
                                 base::FilePath* path) {
   DCHECK(path);
   int dir_key = -1;
   base::string16 folder_to_append;
   switch (location) {
     case SHORTCUT_LOCATION_DESKTOP:
       dir_key = (level == CURRENT_USER) ? base::DIR_USER_DESKTOP :
                                           base::DIR_COMMON_DESKTOP;
       break;
     case SHORTCUT_LOCATION_QUICK_LAUNCH:
       // There is no support for a system-level Quick Launch shortcut.
       DCHECK_EQ(level, CURRENT_USER);
       dir_key = base::DIR_USER_QUICK_LAUNCH;
       break;
     case SHORTCUT_LOCATION_START_MENU_ROOT:
       dir_key = (level == CURRENT_USER) ? base::DIR_START_MENU :
                                           base::DIR_COMMON_START_MENU;
       break;
-    case SHORTCUT_LOCATION_START_MENU_CHROME_DIR:
+    case SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED:
       dir_key = (level == CURRENT_USER) ? base::DIR_START_MENU :
                                           base::DIR_COMMON_START_MENU;
       folder_to_append = dist->GetStartMenuShortcutSubfolder(
           BrowserDistribution::SUBFOLDER_CHROME);
       break;
     case SHORTCUT_LOCATION_START_MENU_CHROME_APPS_DIR:
       dir_key = (level == CURRENT_USER) ? base::DIR_START_MENU :
                                           base::DIR_COMMON_START_MENU;
       folder_to_append = dist->GetStartMenuShortcutSubfolder(
           BrowserDistribution::SUBFOLDER_APPS);
@@ skipping 14 matching lines @@
     NOTREACHED() << dir_key;
     return false;
   }
 
   if (!folder_to_append.empty())
     *path = path->Append(folder_to_append);
 
   return true;
 }
 
-bool ShellUtil::CreateOrUpdateShortcut(
-    ShellUtil::ShortcutLocation location,
-    BrowserDistribution* dist,
-    const ShellUtil::ShortcutProperties& properties,
-    ShellUtil::ShortcutOperation operation) {
+bool ShellUtil::MoveExistingShortcut(ShortcutLocation old_location,
+                                     ShortcutLocation new_location,
+                                     BrowserDistribution* dist,
+                                     const ShortcutProperties& properties) {
+  // Explicitly whitelist locations to which this is applicable.
+  if (old_location != SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED ||
+      new_location != SHORTCUT_LOCATION_START_MENU_ROOT) {
+    NOTREACHED();
+    return false;
+  }
+
+  base::string16 shortcut_name(
+      ExtractShortcutNameFromProperties(dist, properties));
+
+  base::FilePath old_shortcut_path;
+  base::FilePath new_shortcut_path;
+  GetShortcutPath(old_location, dist, properties.level, &old_shortcut_path);
+  GetShortcutPath(new_location, dist, properties.level, &new_shortcut_path);
+  old_shortcut_path = old_shortcut_path.Append(shortcut_name);
+  new_shortcut_path = new_shortcut_path.Append(shortcut_name);
+
+  bool result = base::Move(old_shortcut_path, new_shortcut_path);
+  RemoveShortcutFolderIfEmpty(old_location, dist, properties.level);
+  return result;
+}
+
+bool ShellUtil::CreateOrUpdateShortcut(ShortcutLocation location,
+                                       BrowserDistribution* dist,
+                                       const ShortcutProperties& properties,
+                                       ShortcutOperation operation) {
   // Explicitly whitelist locations to which this is applicable.
   if (location != SHORTCUT_LOCATION_DESKTOP &&
       location != SHORTCUT_LOCATION_QUICK_LAUNCH &&
       location != SHORTCUT_LOCATION_START_MENU_ROOT &&
-      location != SHORTCUT_LOCATION_START_MENU_CHROME_DIR &&
+      location != SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED &&
       location != SHORTCUT_LOCATION_START_MENU_CHROME_APPS_DIR) {
     NOTREACHED();
     return false;
   }
 
   DCHECK(dist);
   // |pin_to_taskbar| is only acknowledged when first creating the shortcut.
   DCHECK(!properties.pin_to_taskbar ||
          operation == SHELL_SHORTCUT_CREATE_ALWAYS ||
          operation == SHELL_SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL);
@@ skipping 88 matching lines @@
     const base::FilePath& chrome_exe) {
   return L"\"" + chrome_exe.value() + L"\" -- %*";
 }
 
 void ShellUtil::GetRegisteredBrowsers(
     BrowserDistribution* dist,
     std::map<base::string16, base::string16>* browsers) {
   DCHECK(dist);
   DCHECK(browsers);
 
-  const base::string16 base_key(ShellUtil::kRegStartMenuInternet);
+  const base::string16 base_key(kRegStartMenuInternet);
   base::string16 client_path;
   RegKey key;
   base::string16 name;
   base::string16 command;
 
   // HKCU has precedence over HKLM for these registrations: http://goo.gl/xjczJ.
   // Look in HKCU second to override any identical values found in HKLM.
   const HKEY roots[] = { HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER };
   for (int i = 0; i < arraysize(roots); ++i) {
     const HKEY root = roots[i];
@@ skipping 119 matching lines @@
   // No spaces are allowed in the AppUserModelId according to MSDN.
   base::ReplaceChars(app_id, base::ASCIIToUTF16(" "), base::ASCIIToUTF16("_"),
                      &app_id);
   return app_id;
 }
 
 ShellUtil::DefaultState ShellUtil::GetChromeDefaultState() {
   base::FilePath app_path;
   if (!PathService::Get(base::FILE_EXE, &app_path)) {
     NOTREACHED();
-    return ShellUtil::UNKNOWN_DEFAULT;
+    return UNKNOWN_DEFAULT;
   }
 
   return GetChromeDefaultStateFromPath(app_path);
 }
 
 ShellUtil::DefaultState ShellUtil::GetChromeDefaultStateFromPath(
     const base::FilePath& chrome_exe) {
   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
   if (distribution->GetDefaultBrowserControlPolicy() ==
       BrowserDistribution::DEFAULT_BROWSER_UNSUPPORTED) {
@@ skipping 22 matching lines @@
       BrowserDistribution::DEFAULT_BROWSER_UNSUPPORTED) {
     return NOT_DEFAULT;
   }
 
   if (protocol.empty())
     return UNKNOWN_DEFAULT;
 
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED();
-    return ShellUtil::UNKNOWN_DEFAULT;
+    return UNKNOWN_DEFAULT;
   }
 
   const wchar_t* const protocols[] = { protocol.c_str() };
   return ProbeProtocolHandlers(chrome_exe,
                                protocols,
                                arraysize(protocols));
 }
 
 // static
 bool ShellUtil::CanMakeChromeDefaultUnattended() {
   return base::win::GetVersion() < base::win::VERSION_WIN8;
 }
 
 bool ShellUtil::MakeChromeDefault(BrowserDistribution* dist,
                                   int shell_change,
                                   const base::FilePath& chrome_exe,
                                   bool elevate_if_not_admin) {
-  DCHECK(!(shell_change & ShellUtil::SYSTEM_LEVEL) || IsUserAnAdmin());
+  DCHECK(!(shell_change & SYSTEM_LEVEL) || IsUserAnAdmin());
 
   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
   if (distribution->GetDefaultBrowserControlPolicy() !=
       BrowserDistribution::DEFAULT_BROWSER_FULL_CONTROL) {
     return false;
   }
 
   // Windows 8 does not permit making a browser default just like that.
   // This process needs to be routed through the system's UI. Use
   // ShowMakeChromeDefaultSystemUI instead (below).
   if (!CanMakeChromeDefaultUnattended()) {
     return false;
   }
 
-  if (!ShellUtil::RegisterChromeBrowser(
-           dist, chrome_exe, base::string16(), elevate_if_not_admin)) {
+  if (!RegisterChromeBrowser(dist, chrome_exe, base::string16(),
+                             elevate_if_not_admin)) {
     return false;
   }
 
   bool ret = true;
   // First use the new "recommended" way on Vista to make Chrome default
   // browser.
   base::string16 app_name = GetApplicationName(dist, chrome_exe);
 
   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
     // On Windows Vista and Win7 we still can set ourselves via the
     // the IApplicationAssociationRegistration interface.
     VLOG(1) << "Registering Chrome as default browser on Vista.";
     base::win::ScopedComPtr<IApplicationAssociationRegistration> pAAR;
     HRESULT hr = pAAR.CreateInstance(CLSID_ApplicationAssociationRegistration,
         NULL, CLSCTX_INPROC);
     if (SUCCEEDED(hr)) {
-      for (int i = 0; ShellUtil::kBrowserProtocolAssociations[i] != NULL; i++) {
-        hr = pAAR->SetAppAsDefault(app_name.c_str(),
-            ShellUtil::kBrowserProtocolAssociations[i], AT_URLPROTOCOL);
+      for (int i = 0; kBrowserProtocolAssociations[i] != NULL; i++) {
+        hr = pAAR->SetAppAsDefault(
+            app_name.c_str(), kBrowserProtocolAssociations[i], AT_URLPROTOCOL);
         if (!SUCCEEDED(hr)) {
           ret = false;
           LOG(ERROR) << "Failed to register as default for protocol "
-                     << ShellUtil::kBrowserProtocolAssociations[i]
-                     << " (" << hr << ")";
+                     << kBrowserProtocolAssociations[i] << " (" << hr << ")";
         }
       }
 
-      for (int i = 0; ShellUtil::kDefaultFileAssociations[i] != NULL; i++) {
-        hr = pAAR->SetAppAsDefault(app_name.c_str(),
-            ShellUtil::kDefaultFileAssociations[i], AT_FILEEXTENSION);
+      for (int i = 0; kDefaultFileAssociations[i] != NULL; i++) {
+        hr = pAAR->SetAppAsDefault(
+            app_name.c_str(), kDefaultFileAssociations[i], AT_FILEEXTENSION);
         if (!SUCCEEDED(hr)) {
           ret = false;
           LOG(ERROR) << "Failed to register as default for file extension "
-                     << ShellUtil::kDefaultFileAssociations[i]
-                     << " (" << hr << ")";
+                     << kDefaultFileAssociations[i] << " (" << hr << ")";
         }
       }
     }
   }
 
   if (!RegisterChromeAsDefaultXPStyle(dist, shell_change, chrome_exe))
     ret = false;
 
   // Send Windows notification event so that it can update icons for
   // file associations.
@@ skipping 261 matching lines @@
              base::win::GetVersion() >= base::win::VERSION_VISTA) {
     // Elevate to do the whole job
     return ElevateAndRegisterChrome(dist, chrome_exe, suffix, protocol);
   } else {
     // Admin rights are required to register capabilities before Windows 8.
     return false;
   }
 }
 
 // static
-bool ShellUtil::RemoveShortcuts(ShellUtil::ShortcutLocation location,
+bool ShellUtil::RemoveShortcuts(ShortcutLocation location,
                                 BrowserDistribution* dist,
                                 ShellChange level,
                                 const base::FilePath& target_exe) {
-  if (!ShellUtil::ShortcutLocationIsSupported(location))
+  if (!ShortcutLocationIsSupported(location))
     return true;  // Vacuous success.
 
   FilterTargetEq shortcut_filter(target_exe, false);
   // Main operation to apply to each shortcut in the directory specified.
   ShortcutOperationCallback shortcut_operation(
       location == SHORTCUT_LOCATION_TASKBAR_PINS
           ? base::Bind(&ShortcutOpUnpinFromTaskbar)
           : base::Bind(&ShortcutOpDelete));
   bool success = BatchShortcutAction(shortcut_filter.AsShortcutFilterCallback(),
                                      shortcut_operation, location, dist, level,
                                      NULL);
   // Remove chrome-specific shortcut folders if they are now empty.
   if (success &&
-      (location == SHORTCUT_LOCATION_START_MENU_CHROME_DIR ||
+      (location == SHORTCUT_LOCATION_START_MENU_CHROME_DIR_DEPRECATED ||
        location == SHORTCUT_LOCATION_START_MENU_CHROME_APPS_DIR ||
        location == SHORTCUT_LOCATION_APP_SHORTCUTS)) {
     success = RemoveShortcutFolderIfEmpty(location, dist, level);
   }
   return success;
 }
 
 // static
 bool ShellUtil::RetargetShortcutsWithArgs(
-    ShellUtil::ShortcutLocation location,
+    ShortcutLocation location,
     BrowserDistribution* dist,
     ShellChange level,
     const base::FilePath& old_target_exe,
     const base::FilePath& new_target_exe) {
-  if (!ShellUtil::ShortcutLocationIsSupported(location))
+  if (!ShortcutLocationIsSupported(location))
     return true;  // Vacuous success.
 
   FilterTargetEq shortcut_filter(old_target_exe, true);
   ShortcutOperationCallback shortcut_operation(
       base::Bind(&ShortcutOpRetarget, old_target_exe, new_target_exe));
   return BatchShortcutAction(shortcut_filter.AsShortcutFilterCallback(),
                              shortcut_operation, location, dist, level, NULL);
 }
 
 // static
 bool ShellUtil::ShortcutListMaybeRemoveUnknownArgs(
-    ShellUtil::ShortcutLocation location,
+    ShortcutLocation location,
     BrowserDistribution* dist,
     ShellChange level,
     const base::FilePath& chrome_exe,
     bool do_removal,
     const scoped_refptr<SharedCancellationFlag>& cancel,
-    std::vector<std::pair<base::FilePath, base::string16> >* shortcuts) {
-  if (!ShellUtil::ShortcutLocationIsSupported(location))
+    std::vector<std::pair<base::FilePath, base::string16>>* shortcuts) {
+  if (!ShortcutLocationIsSupported(location))
     return false;
   DCHECK(dist);
   FilterTargetEq shortcut_filter(chrome_exe, true);
   ShortcutOperationCallback shortcut_operation(
       base::Bind(&ShortcutOpListOrRemoveUnknownArgs, do_removal, shortcuts));
   return BatchShortcutAction(shortcut_filter.AsShortcutFilterCallback(),
                              shortcut_operation, location, dist, level, cancel);
 }
 
 bool ShellUtil::GetUserSpecificRegistrySuffix(base::string16* suffix) {
@@ skipping 101 matching lines @@
     RegistryEntry::GetAppDefaultRegistrationEntries(
         prog_id, ext, false, &entries);
   }
 
   return AddRegistryEntries(HKEY_CURRENT_USER, entries);
 }
 
 // static
 bool ShellUtil::DeleteFileAssociations(const base::string16& prog_id) {
   // Delete the key HKEY_CURRENT_USER\Software\Classes\PROGID.
-  base::string16 key_path(ShellUtil::kRegClasses);
+  base::string16 key_path(kRegClasses);
   key_path.push_back(base::FilePath::kSeparators[0]);
   key_path.append(prog_id);
   return InstallUtil::DeleteRegistryKey(
       HKEY_CURRENT_USER, key_path, WorkItem::kWow64Default);
 
   // TODO(mgiuca): Remove the extension association entries. This requires that
   // the extensions associated with a particular prog_id are stored in that
   // prog_id's key.
 }