Revert of Uniquify profile shortcut name.

chrome/browser/profiles/profile_shortcut_manager_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/profiles/profile_shortcut_manager_win.h"
 
 #include <shlobj.h>  // For SHChangeNotify().
 
-#include <algorithm>
-#include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
@@ skipping 263 matching lines @@
     return false;
 
   base::FilePath target_path;
   if (!base::win::ResolveShortcut(path, &target_path, command_line))
     return false;
   // One of the paths may be in short (elided) form. Compare long paths to
   // ensure these are still properly matched.
   return ConvertToLongPath(target_path) == ConvertToLongPath(chrome_exe);
 }
 
-// A functor checks if |path| is the Chrome desktop shortcut (|chrome_exe|)
-// that have the specified |command_line|. If |include_empty_command_lines| is
-// true Chrome desktop shortcuts with empty command lines will also be included.
-struct ChromeCommandLineFilter {
-  const base::FilePath& chrome_exe;
-  const base::string16& command_line;
-  bool include_empty_command_lines;
+// Populates |paths| with the file paths of Chrome desktop shortcuts that have
+// the specified |command_line|. If |include_empty_command_lines| is true,
+// Chrome desktop shortcuts with empty command lines will also be included.
+void ListDesktopShortcutsWithCommandLine(const base::FilePath& chrome_exe,
+                                         const base::string16& command_line,
+                                         bool include_empty_command_lines,
+                                         std::vector<base::FilePath>* paths) {
+  base::FilePath user_shortcuts_directory;
+  if (!GetDesktopShortcutsDirectories(&user_shortcuts_directory, NULL))
+    return;
 
-  ChromeCommandLineFilter(const base::FilePath& chrome_exe,
-                          const base::string16& command_line,
-                          bool include_empty_command_lines)
-      : chrome_exe(chrome_exe),
-        command_line(command_line),
-        include_empty_command_lines(include_empty_command_lines) {}
-
-  bool operator()(const base::FilePath& path) const {
+  base::FileEnumerator enumerator(user_shortcuts_directory, false,
+                                  base::FileEnumerator::FILES);
+  for (base::FilePath path = enumerator.Next(); !path.empty();
+       path = enumerator.Next()) {
     base::string16 shortcut_command_line;
     if (!IsChromeShortcut(path, chrome_exe, &shortcut_command_line))
-      return false;
+      continue;
 
     // TODO(asvitkine): Change this to build a CommandLine object and ensure all
     // args from |command_line| are present in the shortcut's CommandLine. This
     // will be more robust when |command_line| contains multiple args.
     if ((shortcut_command_line.empty() && include_empty_command_lines) ||
         (shortcut_command_line.find(command_line) != base::string16::npos)) {
-      return true;
+      paths->push_back(path);
     }
-    return false;
   }
-};
-
-// Get the file paths of desktop files and folders optionally filtered
-// by |filter|.
-std::set<base::FilePath> ListUserDesktopContents(
-    const ChromeCommandLineFilter* filter) {
-  std::set<base::FilePath> result;
-
-  base::FilePath user_shortcuts_directory;
-  if (!GetDesktopShortcutsDirectories(&user_shortcuts_directory, nullptr))
-    return result;
-
-  base::FileEnumerator enumerator(
-      user_shortcuts_directory, false,
-      base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES);
-  for (base::FilePath path = enumerator.Next(); !path.empty();
-       path = enumerator.Next()) {
-    if (!filter || (*filter)(path))
-      result.insert(path);
-  }
-  return result;
 }
 
 // Renames the given desktop shortcut and informs the shell of this change.
 bool RenameDesktopShortcut(const base::FilePath& old_shortcut_path,
                            const base::FilePath& new_shortcut_path) {
   if (!base::Move(old_shortcut_path, new_shortcut_path))
     return false;
 
   // Notify the shell of the rename, which allows the icon to keep its position
   // on the desktop when renamed. Note: This only works if either SHCNF_FLUSH or
   // SHCNF_FLUSHNOWAIT is specified as a flag.
   SHChangeNotify(SHCNE_RENAMEITEM, SHCNF_PATH | SHCNF_FLUSHNOWAIT,
                  old_shortcut_path.value().c_str(),
                  new_shortcut_path.value().c_str());
   return true;
 }
 
 // Renames an existing Chrome desktop profile shortcut. Must be called on the
 // FILE thread.
-// |profile_shortcuts| are Chrome desktop shortcuts for the profile (there can
-// be several).
-// |desktop_contents| is the collection of all user desktop shortcuts
-// (not only Chrome). It is used to make an unique shortcut for the
-// |new_profile_name| among all shortcuts.
-// This function updates |profile_shortcuts| and |desktop_contents| respectively
-// when renaming occurs.
 void RenameChromeDesktopShortcutForProfile(
-    const base::string16& old_profile_name,
-    const base::string16& new_profile_name,
-    std::set<base::FilePath>* profile_shortcuts,
-    std::set<base::FilePath>* desktop_contents) {
-  DCHECK(profile_shortcuts);
-  DCHECK(desktop_contents);
+    const base::string16& old_shortcut_filename,
+    const base::string16& new_shortcut_filename) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   base::FilePath user_shortcuts_directory;
   base::FilePath system_shortcuts_directory;
   if (!GetDesktopShortcutsDirectories(&user_shortcuts_directory,
                                       &system_shortcuts_directory)) {
     return;
   }
 
-  BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
-
-  // Get a new unique shortcut name.
-  const base::string16 new_shortcut_filename =
-      profiles::internal::GetUniqueShortcutFilenameForProfile(
-          new_profile_name, *desktop_contents, distribution);
+  const base::FilePath old_shortcut_path =
+      user_shortcuts_directory.Append(old_shortcut_filename);
   const base::FilePath new_shortcut_path =
       user_shortcuts_directory.Append(new_shortcut_filename);
 
-  if (!profile_shortcuts->empty()) {
-    // From all profile_shortcuts choose the one with a known (canonical) name.
-    profiles::internal::ShortcutFilenameMatcher matcher(old_profile_name,
-                                                        distribution);
-    auto it = std::find_if(profile_shortcuts->begin(), profile_shortcuts->end(),
-                           [&matcher](const base::FilePath& p) {
-                             return matcher.IsCanonical(p.BaseName().value());
-                           });
-    // If all profile_shortcuts were renamed by user, respect it and do not
-    // rename.
-    if (it == profile_shortcuts->end())
-      return;
-    const base::FilePath old_shortcut_path = *it;
-
+  if (base::PathExists(old_shortcut_path)) {
     // Rename the old shortcut unless a system-level shortcut exists at the
     // destination, in which case the old shortcut is simply deleted.
     const base::FilePath possible_new_system_shortcut =
         system_shortcuts_directory.Append(new_shortcut_filename);
-    if (base::PathExists(possible_new_system_shortcut)) {
-      if (base::DeleteFile(old_shortcut_path, false)) {
-        profile_shortcuts->erase(old_shortcut_path);
-        desktop_contents->erase(old_shortcut_path);
-      } else {
-        DLOG(ERROR) << "Could not delete Windows profile desktop shortcut.";
-      }
-    } else {
-      if (RenameDesktopShortcut(old_shortcut_path, new_shortcut_path)) {
-        profile_shortcuts->erase(old_shortcut_path);
-        desktop_contents->erase(old_shortcut_path);
-        profile_shortcuts->insert(new_shortcut_path);
-        desktop_contents->insert(new_shortcut_path);
-      } else {
-        DLOG(ERROR) << "Could not rename Windows profile desktop shortcut.";
-      }
-    }
+    if (base::PathExists(possible_new_system_shortcut))
+      base::DeleteFile(old_shortcut_path, false);
+    else if (!RenameDesktopShortcut(old_shortcut_path, new_shortcut_path))
+      DLOG(ERROR) << "Could not rename Windows profile desktop shortcut.";
   } else {
-    // If the shortcut does not exist, it may have been deleted by the user.
+    // If the shortcut does not exist, it may have been renamed by the user. In
+    // that case, its name should not be changed.
     // It's also possible that a system-level shortcut exists instead - this
     // should only be the case for the original Chrome shortcut from an
     // installation. If that's the case, copy that one over - it will get its
     // properties updated by
     // |CreateOrUpdateDesktopShortcutsAndIconForProfile()|.
-    const auto old_shortcut_filename =
-        profiles::internal::GetShortcutFilenameForProfile(old_profile_name,
-                                                          distribution);
     const base::FilePath possible_old_system_shortcut =
         system_shortcuts_directory.Append(old_shortcut_filename);
-    if (base::PathExists(possible_old_system_shortcut)) {
-      if (base::CopyFile(possible_old_system_shortcut, new_shortcut_path)) {
-        profile_shortcuts->insert(new_shortcut_path);
-        desktop_contents->insert(new_shortcut_path);
-      } else {
-        DLOG(ERROR) << "Could not copy Windows profile desktop shortcut.";
-      }
-    }
+    if (base::PathExists(possible_old_system_shortcut))
+      base::CopyFile(possible_old_system_shortcut, new_shortcut_path);
   }
 }
 
 struct CreateOrUpdateShortcutsParams {
   CreateOrUpdateShortcutsParams(
       base::FilePath profile_path,
       ProfileShortcutManagerWin::CreateOrUpdateMode create_mode,
       ProfileShortcutManagerWin::NonProfileShortcutAction action)
       : create_mode(create_mode), action(action), profile_path(profile_path) {}
   ~CreateOrUpdateShortcutsParams() {}
@@ skipping 35 matching lines @@
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED();
     return;
   }
 
   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
   // Ensure that the distribution supports creating shortcuts. If it doesn't,
   // the following code may result in NOTREACHED() being hit.
   DCHECK(distribution->CanCreateDesktopShortcuts());
 
-  std::set<base::FilePath> desktop_contents = ListUserDesktopContents(nullptr);
-
-  const base::string16 command_line =
-      profiles::internal::CreateProfileShortcutFlags(params.profile_path);
-  ChromeCommandLineFilter filter(
-      chrome_exe, command_line,
-      params.action == ProfileShortcutManagerWin::UPDATE_NON_PROFILE_SHORTCUTS);
-
-  std::set<base::FilePath> shortcuts;
-  // Do not call ListUserDesktopContents again (but with filter) to avoid
-  // excess work inside it. Just reuse non-filtered desktop_contents.
-  // We need both of them (desktop_contents and shortcuts) later.
-  std::copy_if(desktop_contents.begin(), desktop_contents.end(),
-               std::inserter(shortcuts, shortcuts.begin()), filter);
-
   if (params.old_profile_name != params.profile_name) {
-    RenameChromeDesktopShortcutForProfile(params.old_profile_name,
-                                          params.profile_name, &shortcuts,
-                                          &desktop_contents);
+    const base::string16 old_shortcut_filename =
+        profiles::internal::GetShortcutFilenameForProfile(
+            params.old_profile_name,
+            distribution);
+    const base::string16 new_shortcut_filename =
+        profiles::internal::GetShortcutFilenameForProfile(params.profile_name,
+                                                          distribution);
+    RenameChromeDesktopShortcutForProfile(old_shortcut_filename,
+                                          new_shortcut_filename);
   }
 
   ShellUtil::ShortcutProperties properties(ShellUtil::CURRENT_USER);
   installer::Product product(distribution);
   product.AddDefaultShortcutProperties(chrome_exe, &properties);
 
+  const base::string16 command_line =
+      profiles::internal::CreateProfileShortcutFlags(params.profile_path);
 
   // Only set the profile-specific properties when |profile_name| is non empty.
   // If it is empty, it means the shortcut being created should be a regular,
   // non-profile Chrome shortcut.
   if (!params.profile_name.empty()) {
     properties.set_arguments(command_line);
     properties.set_icon(shortcut_icon, 0);
   } else {
     // Set the arguments explicitly to the empty string to ensure that
     // |ShellUtil::CreateOrUpdateShortcut| updates that part of the shortcut.
     properties.set_arguments(base::string16());
   }
 
   properties.set_app_id(
       ShellIntegration::GetChromiumModelIdForProfile(params.profile_path));
 
   ShellUtil::ShortcutOperation operation =
       ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING;
 
+  std::vector<base::FilePath> shortcuts;
+  ListDesktopShortcutsWithCommandLine(chrome_exe, command_line,
+      params.action == ProfileShortcutManagerWin::UPDATE_NON_PROFILE_SHORTCUTS,
+      &shortcuts);
   if (params.create_mode == ProfileShortcutManagerWin::CREATE_WHEN_NONE_FOUND &&
       shortcuts.empty()) {
     const base::string16 shortcut_name =
-        profiles::internal::GetUniqueShortcutFilenameForProfile(
-            params.profile_name, desktop_contents, distribution);
-    shortcuts.insert(base::FilePath(shortcut_name));
+        profiles::internal::GetShortcutFilenameForProfile(params.profile_name,
+                                                          distribution);
+    shortcuts.push_back(base::FilePath(shortcut_name));
     operation = ShellUtil::SHELL_SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL;
   }
 
-  for (const auto& shortcut : shortcuts) {
-    const base::FilePath shortcut_name = shortcut.BaseName().RemoveExtension();
+  for (size_t i = 0; i < shortcuts.size(); ++i) {
+    const base::FilePath shortcut_name =
+        shortcuts[i].BaseName().RemoveExtension();
     properties.set_shortcut_name(shortcut_name.value());
     ShellUtil::CreateOrUpdateShortcut(ShellUtil::SHORTCUT_LOCATION_DESKTOP,
         distribution, properties, operation);
   }
 }
 
 // Returns true if any desktop shortcuts exist with target |chrome_exe|,
 // regardless of their command line arguments.
 bool ChromeDesktopShortcutsExist(const base::FilePath& chrome_exe) {
   base::FilePath user_shortcuts_directory;
@@ skipping 20 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED();
     return;
   }
 
   const base::string16 command_line =
       profiles::internal::CreateProfileShortcutFlags(profile_path);
-  ChromeCommandLineFilter filter(chrome_exe, command_line, false);
-  const std::set<base::FilePath> shortcuts = ListUserDesktopContents(&filter);
+  std::vector<base::FilePath> shortcuts;
+  ListDesktopShortcutsWithCommandLine(chrome_exe, command_line, false,
+                                      &shortcuts);
 
-  for (const auto& shortcut : shortcuts) {
+  for (size_t i = 0; i < shortcuts.size(); ++i) {
     // Use base::DeleteFile() instead of ShellUtil::RemoveShortcuts(), as the
     // latter causes non-profile taskbar shortcuts to be removed since it
     // doesn't consider the command-line of the shortcuts it deletes.
     // TODO(huangs): Refactor with ShellUtil::RemoveShortcuts().
-    base::win::UnpinShortcutFromTaskbar(shortcut);
-    base::DeleteFile(shortcut, false);
+    base::win::UnpinShortcutFromTaskbar(shortcuts[i]);
+    base::DeleteFile(shortcuts[i], false);
     // Notify the shell that the shortcut was deleted to ensure desktop refresh.
-    SHChangeNotify(SHCNE_DELETE, SHCNF_PATH, shortcut.value().c_str(), nullptr);
+    SHChangeNotify(SHCNE_DELETE, SHCNF_PATH, shortcuts[i].value().c_str(),
+                   NULL);
   }
 
   // If |ensure_shortcuts_remain| is true and deleting this profile caused the
   // last shortcuts to be removed, re-create a regular non-profile shortcut.
   const bool had_shortcuts = !shortcuts.empty();
   if (ensure_shortcuts_remain && had_shortcuts &&
       !ChromeDesktopShortcutsExist(chrome_exe)) {
     BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
     // Ensure that the distribution supports creating shortcuts. If it doesn't,
     // the following code may result in NOTREACHED() being hit.
@@ skipping 17 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED();
     return false;
   }
 
   const base::string16 command_line =
       profiles::internal::CreateProfileShortcutFlags(profile_path);
-  ChromeCommandLineFilter filter(chrome_exe, command_line, false);
-  return !ListUserDesktopContents(&filter).empty();
+  std::vector<base::FilePath> shortcuts;
+  ListDesktopShortcutsWithCommandLine(chrome_exe, command_line, false,
+                                      &shortcuts);
+  return !shortcuts.empty();
 }
 
 // Replaces any reserved characters with spaces, and trims the resulting string
 // to prevent any leading and trailing spaces. Also makes sure that the
 // resulting filename doesn't exceed |kMaxProfileShortcutFileNameLength|.
 // TODO(macourteau): find a way to limit the total path's length to MAX_PATH
 // instead of limiting the profile's name to |kMaxProfileShortcutFileNameLength|
 // characters.
 base::string16 SanitizeShortcutProfileNameString(
     const base::string16& profile_name) {
@@ skipping 47 matching lines @@
     shortcut_name.append(SanitizeShortcutProfileNameString(profile_name));
     shortcut_name.append(L" - ");
     shortcut_name.append(l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME));
   } else {
     shortcut_name.append(
         distribution->GetShortcutName(BrowserDistribution::SHORTCUT_CHROME));
   }
   return shortcut_name + installer::kLnkExt;
 }
 
-base::string16 GetUniqueShortcutFilenameForProfile(
-    const base::string16& profile_name,
-    const std::set<base::FilePath>& excludes,
-    BrowserDistribution* distribution) {
-  std::set<base::string16> excludes_names;
-  std::transform(excludes.begin(), excludes.end(),
-                 std::inserter(excludes_names, excludes_names.begin()),
-                 [](const base::FilePath& e) { return e.BaseName().value(); });
-
-  const auto base_name =
-      GetShortcutFilenameForProfile(profile_name, distribution);
-  auto name = base_name;
-  const base::FilePath base_path(base_name);
-  for (int uniquifier = 1; excludes_names.count(name) > 0; ++uniquifier) {
-    const auto suffix = base::StringPrintf(" (%d)", uniquifier);
-    name = base_path.InsertBeforeExtensionASCII(suffix).value();
-  }
-  return name;
-}
-
-// Corresponds to GetUniqueShortcutFilenameForProfile.
-ShortcutFilenameMatcher::ShortcutFilenameMatcher(
-    const base::string16& profile_name,
-    BrowserDistribution* distribution)
-    : profile_shortcut_filename_(
-          GetShortcutFilenameForProfile(profile_name, distribution)),
-      lnk_ext_(installer::kLnkExt),
-      profile_shortcut_name_(profile_shortcut_filename_) {
-  DCHECK(profile_shortcut_name_.ends_with(lnk_ext_));
-  profile_shortcut_name_.remove_suffix(lnk_ext_.size());
-}
-
-bool ShortcutFilenameMatcher::IsCanonical(
-    const base::string16& filename) const {
-  if (filename == profile_shortcut_filename_)
-    return true;
-
-  base::StringPiece16 shortcut_suffix(filename);
-  if (!shortcut_suffix.starts_with(profile_shortcut_name_))
-    return false;
-  shortcut_suffix.remove_prefix(profile_shortcut_name_.size());
-
-  if (!shortcut_suffix.ends_with(lnk_ext_))
-    return false;
-  shortcut_suffix.remove_suffix(lnk_ext_.size());
-
-  if (shortcut_suffix.size() < 4 || !shortcut_suffix.starts_with(L" (") ||
-      !shortcut_suffix.ends_with(L")")) {
-    return false;
-  }
-  return std::all_of(shortcut_suffix.begin() + 2, shortcut_suffix.end() - 1,
-                     iswdigit);
-}
-
 base::string16 CreateProfileShortcutFlags(const base::FilePath& profile_path) {
   return base::StringPrintf(L"--%ls=\"%ls\"",
                             base::ASCIIToUTF16(
                                 switches::kProfileDirectory).c_str(),
                             profile_path.BaseName().value().c_str());
 }
 
 }  // namespace internal
 }  // namespace profiles
 
@@ skipping 221 matching lines @@
         // Ensure the profile's icon file has been created.
         CreateOrUpdateProfileIcon(profile->GetPath());
       }
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 }