Find shortcuts that don't have a profile command line set when creating 2nd profile.

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 <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 80 matching lines @@
       offscreen_canvas->getDevice()->accessBitmap(false);
 
   // Finally, write the .ico file containing this new bitmap.
   FilePath icon_path = profile_path.AppendASCII(kProfileIconFileName);
   if (!IconUtil::CreateIconFileFromSkBitmap(final_bitmap, icon_path))
     return FilePath();
 
   return icon_path;
 }
 
-// Returns the command-line flags to launch Chrome with the given profile.
-string16 CreateProfileShortcutFlags(const FilePath& profile_path) {
-  return base::StringPrintf(L"--%ls=\"%ls\"",
-                            ASCIIToUTF16(switches::kProfileDirectory).c_str(),
-                            profile_path.BaseName().value().c_str());
-}
-
 // Gets the directory where to create desktop shortcuts.
 bool GetDesktopShortcutsDirectory(FilePath* directory) {
   const bool result =
       ShellUtil::GetShortcutPath(ShellUtil::SHORTCUT_LOCATION_DESKTOP,
                                  BrowserDistribution::GetDistribution(),
                                  ShellUtil::CURRENT_USER, directory);
   DCHECK(result);
   return result;
 }
 
-// Returns true if the file at |path| is a Chrome shortcut with the given
-// |command_line|.
-bool IsChromeShortcutWithCommandLine(const FilePath& path,
-                                     const FilePath& chrome_exe,
-                                     const string16& command_line) {
+// Returns true if the file at |path| is a Chrome shortcut and returns its
+// command line in output parameter |command_line|.
+bool IsChromeShortcut(const FilePath& path,
+                      const FilePath& chrome_exe,
+                      string16* command_line) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (path.Extension() != installer::kLnkExt)
     return false;
 
   FilePath target_path;
-  string16 command_line_args;
-  if (!base::win::ResolveShortcut(path, &target_path, &command_line_args))
+  if (!base::win::ResolveShortcut(path, &target_path, command_line))
     return false;
-
-  // 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.
-  return target_path == chrome_exe &&
-         command_line_args.find(command_line) != string16::npos;
+  return target_path == chrome_exe;
 }
 
 // Populates |paths| with the file paths of Chrome desktop shortcuts that have
 // the specified |command_line|.
 void ListDesktopShortcutsWithCommandLine(const FilePath& chrome_exe,
                                          const string16& command_line,
+                                         bool include_empty_command_lines,

[sail, 2012/11/28 05:12:31]

Yea, I think plumbing the enums here would be great.
If that's really awkward then maybe name this to better match the enum?
Something like should_update_non_profile_shortcuts

[Alexei Svitkine (slow), 2012/11/28 21:27:12]

I've plumbed them through to CreateOrUpdateDesktopShortcutsForProfile().

I've kept the name of the parameter to ListDesktopShortcutsWithCommandLine(),
since in that case, it describes the exact behavior it controls.

                                          std::vector<FilePath>* paths) {
   FilePath shortcuts_directory;
   if (!GetDesktopShortcutsDirectory(&shortcuts_directory))
     return;
 
   file_util::FileEnumerator enumerator(shortcuts_directory, false,
       file_util::FileEnumerator::FILES);
   for (FilePath path = enumerator.Next(); !path.empty();
        path = enumerator.Next()) {
-    if (IsChromeShortcutWithCommandLine(path, chrome_exe, command_line))
+    string16 shortcut_command_line;
+    if (!IsChromeShortcut(path, chrome_exe, &shortcut_command_line))
+      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) != string16::npos)) {
       paths->push_back(path);
+    }
   }
 }
 
 // Renames an existing Chrome desktop profile shortcut. Must be called on the
 // FILE thread.
 void RenameChromeDesktopShortcutForProfile(
     const string16& old_shortcut_file,
     const string16& new_shortcut_file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
@@ skipping 11 matching lines @@
   if (!file_util::Move(old_shortcut_path, new_shortcut_path))
     LOG(ERROR) << "Could not rename Windows profile desktop shortcut.";
 }
 
 // Updates all desktop shortcuts for the given profile to have the specified
 // parameters. If |create| is true, a new desktop shortcut is created if no
 // existing ones were found. Must be called on the FILE thread.
 void CreateOrUpdateDesktopShortcutsForProfile(const FilePath& profile_path,
                                               const string16& profile_name,
                                               const SkBitmap& avatar_image,
+                                              bool include_empty_command_lines,
                                               bool create) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED();
     return;
   }
 
   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
   installer::Product product(distribution);
 
   ShellUtil::ShortcutProperties properties(ShellUtil::CURRENT_USER);
   product.AddDefaultShortcutProperties(chrome_exe, &properties);
   const FilePath shortcut_icon =
       CreateChromeDesktopShortcutIconForProfile(profile_path, avatar_image);
   if (!shortcut_icon.empty())
     properties.set_icon(shortcut_icon, 0);
 
-  const string16 command_line = CreateProfileShortcutFlags(profile_path);
+  const string16 command_line =
+      profiles::internal::CreateProfileShortcutFlags(profile_path);
   properties.set_arguments(command_line);
 
   ShellUtil::ShortcutOperation operation =
       ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING;
 
   std::vector<FilePath> shortcuts;
-  ListDesktopShortcutsWithCommandLine(chrome_exe, command_line, &shortcuts);
+  ListDesktopShortcutsWithCommandLine(chrome_exe, command_line,
+                                      include_empty_command_lines, &shortcuts);
   if (create && shortcuts.empty()) {
     const string16 shortcut_name =
         profiles::internal::GetShortcutFilenameForProfile(profile_name,
                                                           distribution);
     shortcuts.push_back(FilePath(shortcut_name));
     operation = ShellUtil::SHELL_SHORTCUT_CREATE_ALWAYS;
   }
 
   for (size_t i = 0; i < shortcuts.size(); ++i) {
     const FilePath shortcut_name = shortcuts[i].BaseName().RemoveExtension();
     properties.set_shortcut_name(shortcut_name.value());
     ShellUtil::CreateOrUpdateShortcut(ShellUtil::SHORTCUT_LOCATION_DESKTOP,
         distribution, properties, operation);
   }
 }
 
 // Deletes all desktop shortcuts for the specified profile and also removes the
 // corresponding icon file. Must be called on the FILE thread.
 void DeleteDesktopShortcutsAndIconFile(const FilePath& profile_path,
                                        const FilePath& icon_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED();
     return;
   }
 
-  const string16 command_line = CreateProfileShortcutFlags(profile_path);
+  const string16 command_line =
+      profiles::internal::CreateProfileShortcutFlags(profile_path);
   std::vector<FilePath> shortcuts;
-  ListDesktopShortcutsWithCommandLine(chrome_exe, command_line, &shortcuts);
+  ListDesktopShortcutsWithCommandLine(chrome_exe, command_line, false,
+                                      &shortcuts);
 
   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
   for (size_t i = 0; i < shortcuts.size(); ++i) {
     const string16 shortcut_name =
         shortcuts[i].BaseName().RemoveExtension().value();
     ShellUtil::RemoveShortcut(ShellUtil::SHORTCUT_LOCATION_DESKTOP,
                               distribution, chrome_exe.value(),
                               ShellUtil::CURRENT_USER,
                               &shortcut_name);
   }
@@ skipping 10 matching lines @@
                                        BrowserDistribution* distribution) {
   string16 shortcut_name;
   if (!profile_name.empty()) {
     shortcut_name.append(profile_name);
     shortcut_name.append(L" - ");
   }
   shortcut_name.append(distribution->GetAppShortCutName());
   return shortcut_name + installer::kLnkExt;
 }
 
+string16 CreateProfileShortcutFlags(const FilePath& profile_path) {
+  return base::StringPrintf(L"--%ls=\"%ls\"",
+                            ASCIIToUTF16(switches::kProfileDirectory).c_str(),
+                            profile_path.BaseName().value().c_str());
+}
+
 }  // namespace internal
 }  // namespace profiles
 
 // static
 bool ProfileShortcutManager::IsFeatureEnabled() {
   return false;
 }
 
 // static
 ProfileShortcutManager* ProfileShortcutManager::Create(
     ProfileManager* manager) {
   return new ProfileShortcutManagerWin(manager);
 }
 
 ProfileShortcutManagerWin::ProfileShortcutManagerWin(ProfileManager* manager)
     : profile_manager_(manager) {
   profile_manager_->GetProfileInfoCache().AddObserver(this);
 }
 
 ProfileShortcutManagerWin::~ProfileShortcutManagerWin() {
   profile_manager_->GetProfileInfoCache().RemoveObserver(this);
 }
 
 void ProfileShortcutManagerWin::CreateProfileShortcut(
     const FilePath& profile_path) {
-  UpdateShortcutsForProfileAtPath(profile_path, true);
+  UpdateShortcutsForProfileAtPath(profile_path, CREATE_WHEN_NONE_FOUND,
+                                  IGNORE_NON_PROFILE_SHORTCUTS);
 }
 
 void ProfileShortcutManagerWin::OnProfileAdded(const FilePath& profile_path) {
   const size_t profile_count =
       profile_manager_->GetProfileInfoCache().GetNumberOfProfiles();
   if (profile_count == 1) {
-    UpdateShortcutsForProfileAtPath(profile_path, true);
+    UpdateShortcutsForProfileAtPath(profile_path,
+                                    CREATE_WHEN_NONE_FOUND,
+                                    UPDATE_NON_PROFILE_SHORTCUTS);
   } else if (profile_count == 2) {
-    UpdateShortcutsForProfileAtPath(GetOtherProfilePath(profile_path), false);
+    UpdateShortcutsForProfileAtPath(GetOtherProfilePath(profile_path),
+                                    UPDATE_EXISTING_ONLY,
+                                    UPDATE_NON_PROFILE_SHORTCUTS);
   }
 }
 
 void ProfileShortcutManagerWin::OnProfileWillBeRemoved(
     const FilePath& profile_path) {
 }
 
 void ProfileShortcutManagerWin::OnProfileWasRemoved(
     const FilePath& profile_path,
     const string16& profile_name) {
   const ProfileInfoCache& cache = profile_manager_->GetProfileInfoCache();
   // If there is only one profile remaining, remove the badging information
   // from an existing shortcut.
-  if (cache.GetNumberOfProfiles() == 1)
-    UpdateShortcutsForProfileAtPath(cache.GetPathOfProfileAtIndex(0), false);
+  if (cache.GetNumberOfProfiles() == 1) {
+    UpdateShortcutsForProfileAtPath(cache.GetPathOfProfileAtIndex(0),
+                                    UPDATE_EXISTING_ONLY,
+                                    IGNORE_NON_PROFILE_SHORTCUTS);
+  }
 
   const FilePath icon_path = profile_path.AppendASCII(kProfileIconFileName);
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&DeleteDesktopShortcutsAndIconFile,
                                      profile_path, icon_path));
 }
 
 void ProfileShortcutManagerWin::OnProfileNameChanged(
     const FilePath& profile_path,
     const string16& old_profile_name) {
-  UpdateShortcutsForProfileAtPath(profile_path, false);
+  UpdateShortcutsForProfileAtPath(profile_path, UPDATE_EXISTING_ONLY,
+                                  IGNORE_NON_PROFILE_SHORTCUTS);
 }
 
 void ProfileShortcutManagerWin::OnProfileAvatarChanged(
     const FilePath& profile_path) {
-  UpdateShortcutsForProfileAtPath(profile_path, false);
+  UpdateShortcutsForProfileAtPath(profile_path, UPDATE_EXISTING_ONLY,
+                                  IGNORE_NON_PROFILE_SHORTCUTS);
 }
 
 void ProfileShortcutManagerWin::StartProfileShortcutNameChange(
     const FilePath& profile_path,
     const string16& old_profile_name) {
   const ProfileInfoCache& cache = profile_manager_->GetProfileInfoCache();
   size_t profile_index = cache.GetIndexOfProfileWithPath(profile_path);
   if (profile_index == std::string::npos)
     return;
   // If the shortcut will have an appended name, get the profile name.
@@ skipping 22 matching lines @@
   // Get the index of the current profile, in order to find the index of the
   // other profile.
   size_t current_profile_index = cache.GetIndexOfProfileWithPath(profile_path);
   size_t other_profile_index = (current_profile_index == 0) ? 1 : 0;
   return profile_manager_->GetProfileInfoCache().
       GetPathOfProfileAtIndex(other_profile_index);
 }
 
 void ProfileShortcutManagerWin::UpdateShortcutsForProfileAtPath(
     const FilePath& profile_path,
-    bool create_always) {
+    CreateOrUpdateMode create_mode,
+    NonProfileShortcutAction action) {
   ProfileInfoCache* cache = &profile_manager_->GetProfileInfoCache();
   size_t profile_index = cache->GetIndexOfProfileWithPath(profile_path);
   if (profile_index == std::string::npos)
     return;
   bool remove_badging = cache->GetNumberOfProfiles() == 1;
 
   string16 old_shortcut_appended_name =
       cache->GetShortcutNameOfProfileAtIndex(profile_index);
 
   string16 new_shortcut_appended_name;
   if (!remove_badging)
     new_shortcut_appended_name = cache->GetNameOfProfileAtIndex(profile_index);
 
-  if (!create_always &&
+  if (create_mode == UPDATE_EXISTING_ONLY &&
       new_shortcut_appended_name != old_shortcut_appended_name) {
     // TODO(asvitkine): Fold this into |UpdateDesktopShortcutsForProfile()|.
     StartProfileShortcutNameChange(profile_path, old_shortcut_appended_name);
   }
 
   SkBitmap profile_avatar_bitmap_copy;
   if (!remove_badging) {
     size_t profile_icon_index =
         cache->GetAvatarIconIndexOfProfileAtIndex(profile_index);
     gfx::Image profile_avatar_image = ResourceBundle::GetSharedInstance().
         GetNativeImageNamed(
             cache->GetDefaultAvatarIconResourceIDAtIndex(profile_icon_index));
 
     DCHECK(!profile_avatar_image.IsEmpty());
     const SkBitmap* profile_avatar_bitmap = profile_avatar_image.ToSkBitmap();
     // Make a copy of the SkBitmap to ensure that we can safely use the image
     // data on the FILE thread.
     profile_avatar_bitmap->deepCopyTo(&profile_avatar_bitmap_copy,
                                       profile_avatar_bitmap->getConfig());
   }
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&CreateOrUpdateDesktopShortcutsForProfile,
                  profile_path, new_shortcut_appended_name,
-                 profile_avatar_bitmap_copy, create_always));
+                 profile_avatar_bitmap_copy,
+                 action == UPDATE_NON_PROFILE_SHORTCUTS,
+                 create_mode == CREATE_WHEN_NONE_FOUND));
 
   cache->SetShortcutNameOfProfileAtIndex(profile_index,
                                          new_shortcut_appended_name);
 }