Home | History | Annotate | Download | only in profiles
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/profiles/profile_shortcut_manager_win.h"
      6 
      7 #include <shlobj.h>  // For SHChangeNotify().
      8 
      9 #include <string>
     10 #include <vector>
     11 
     12 #include "base/bind.h"
     13 #include "base/command_line.h"
     14 #include "base/files/file_enumerator.h"
     15 #include "base/files/file_util.h"
     16 #include "base/path_service.h"
     17 #include "base/prefs/pref_service.h"
     18 #include "base/strings/string16.h"
     19 #include "base/strings/string_util.h"
     20 #include "base/strings/stringprintf.h"
     21 #include "base/strings/utf_string_conversions.h"
     22 #include "base/win/shortcut.h"
     23 #include "chrome/browser/app_icon_win.h"
     24 #include "chrome/browser/browser_process.h"
     25 #include "chrome/browser/chrome_notification_types.h"
     26 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
     27 #include "chrome/browser/profiles/profile_info_cache_observer.h"
     28 #include "chrome/browser/profiles/profile_manager.h"
     29 #include "chrome/browser/shell_integration.h"
     30 #include "chrome/common/chrome_switches.h"
     31 #include "chrome/common/pref_names.h"
     32 #include "chrome/grit/chromium_strings.h"
     33 #include "chrome/installer/util/browser_distribution.h"
     34 #include "chrome/installer/util/product.h"
     35 #include "chrome/installer/util/shell_util.h"
     36 #include "content/public/browser/browser_thread.h"
     37 #include "content/public/browser/notification_service.h"
     38 #include "grit/chrome_unscaled_resources.h"
     39 #include "skia/ext/image_operations.h"
     40 #include "skia/ext/platform_canvas.h"
     41 #include "ui/base/l10n/l10n_util.h"
     42 #include "ui/base/resource/resource_bundle.h"
     43 #include "ui/gfx/icon_util.h"
     44 #include "ui/gfx/image/image.h"
     45 #include "ui/gfx/image/image_family.h"
     46 
     47 
     48 using content::BrowserThread;
     49 
     50 namespace {
     51 
     52 // Name of the badged icon file generated for a given profile.
     53 const char kProfileIconFileName[] = "Google Profile.ico";
     54 
     55 // Characters that are not allowed in Windows filenames. Taken from
     56 // http://msdn.microsoft.com/en-us/library/aa365247.aspx
     57 const base::char16 kReservedCharacters[] = L"<>:\"/\\|?*\x01\x02\x03\x04\x05"
     58     L"\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17"
     59     L"\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F";
     60 
     61 // The maximum number of characters allowed in profile shortcuts' file names.
     62 // Warning: migration code will be needed if this is changed later, since
     63 // existing shortcuts might no longer be found if the name is generated
     64 // differently than it was when a shortcut was originally created.
     65 const int kMaxProfileShortcutFileNameLength = 64;
     66 
     67 // The avatar badge size needs to be half of the shortcut icon size because
     68 // the Windows taskbar icon is 32x32 and the avatar icon overlay is 16x16. So to
     69 // get the shortcut avatar badge and the avatar icon overlay to match up, we
     70 // need to preserve those ratios when creating the shortcut icon.
     71 const int kShortcutIconSize = 48;
     72 const int kProfileAvatarBadgeSize = kShortcutIconSize / 2;
     73 
     74 const int kCurrentProfileIconVersion = 3;
     75 
     76 // 2x sized profile avatar icons. Mirrors |kDefaultAvatarIconResources| in
     77 // profile_info_cache.cc.
     78 const int kProfileAvatarIconResources2x[] = {
     79   IDR_PROFILE_AVATAR_2X_0,
     80   IDR_PROFILE_AVATAR_2X_1,
     81   IDR_PROFILE_AVATAR_2X_2,
     82   IDR_PROFILE_AVATAR_2X_3,
     83   IDR_PROFILE_AVATAR_2X_4,
     84   IDR_PROFILE_AVATAR_2X_5,
     85   IDR_PROFILE_AVATAR_2X_6,
     86   IDR_PROFILE_AVATAR_2X_7,
     87   IDR_PROFILE_AVATAR_2X_8,
     88   IDR_PROFILE_AVATAR_2X_9,
     89   IDR_PROFILE_AVATAR_2X_10,
     90   IDR_PROFILE_AVATAR_2X_11,
     91   IDR_PROFILE_AVATAR_2X_12,
     92   IDR_PROFILE_AVATAR_2X_13,
     93   IDR_PROFILE_AVATAR_2X_14,
     94   IDR_PROFILE_AVATAR_2X_15,
     95   IDR_PROFILE_AVATAR_2X_16,
     96   IDR_PROFILE_AVATAR_2X_17,
     97   IDR_PROFILE_AVATAR_2X_18,
     98   IDR_PROFILE_AVATAR_2X_19,
     99   IDR_PROFILE_AVATAR_2X_20,
    100   IDR_PROFILE_AVATAR_2X_21,
    101   IDR_PROFILE_AVATAR_2X_22,
    102   IDR_PROFILE_AVATAR_2X_23,
    103   IDR_PROFILE_AVATAR_2X_24,
    104   IDR_PROFILE_AVATAR_2X_25,
    105   IDR_PROFILE_AVATAR_2X_26,
    106 };
    107 
    108 // Badges |app_icon_bitmap| with |avatar_bitmap| at the bottom right corner and
    109 // returns the resulting SkBitmap.
    110 SkBitmap BadgeIcon(const SkBitmap& app_icon_bitmap,
    111                    const SkBitmap& avatar_bitmap,
    112                    int scale_factor) {
    113   SkBitmap source_bitmap =
    114       profiles::GetAvatarIconAsSquare(avatar_bitmap, scale_factor);
    115   int avatar_badge_size = kProfileAvatarBadgeSize;
    116   if (app_icon_bitmap.width() != kShortcutIconSize) {
    117     avatar_badge_size =
    118         app_icon_bitmap.width() * kProfileAvatarBadgeSize / kShortcutIconSize;
    119   }
    120   SkBitmap sk_icon = skia::ImageOperations::Resize(
    121       source_bitmap, skia::ImageOperations::RESIZE_LANCZOS3, avatar_badge_size,
    122       source_bitmap.height() * avatar_badge_size / source_bitmap.width());
    123 
    124   // Overlay the avatar on the icon, anchoring it to the bottom-right of the
    125   // icon.
    126   SkBitmap badged_bitmap;
    127   badged_bitmap.allocN32Pixels(app_icon_bitmap.width(),
    128                                app_icon_bitmap.height());
    129   SkCanvas offscreen_canvas(badged_bitmap);
    130   offscreen_canvas.clear(SK_ColorTRANSPARENT);
    131 
    132   offscreen_canvas.drawBitmap(app_icon_bitmap, 0, 0);
    133   offscreen_canvas.drawBitmap(sk_icon,
    134                               app_icon_bitmap.width() - sk_icon.width(),
    135                               app_icon_bitmap.height() - sk_icon.height());
    136   return badged_bitmap;
    137 }
    138 
    139 // Updates the preferences with the current icon version on icon creation
    140 // success.
    141 void OnProfileIconCreateSuccess(base::FilePath profile_path) {
    142   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    143   if (!g_browser_process->profile_manager())
    144     return;
    145   Profile* profile =
    146       g_browser_process->profile_manager()->GetProfileByPath(profile_path);
    147   if (profile) {
    148     profile->GetPrefs()->SetInteger(prefs::kProfileIconVersion,
    149                                     kCurrentProfileIconVersion);
    150   }
    151 }
    152 
    153 // Creates a desktop shortcut icon file (.ico) on the disk for a given profile,
    154 // badging the browser distribution icon with the profile avatar.
    155 // Returns a path to the shortcut icon file on disk, which is empty if this
    156 // fails. Use index 0 when assigning the resulting file as the icon. If both
    157 // given bitmaps are empty, an unbadged icon is created.
    158 // Returns the path to the created icon on success and an empty base::FilePath
    159 // on failure.
    160 // TODO(calamity): Ideally we'd just copy the app icon verbatim from the exe's
    161 // resources in the case of an unbadged icon.
    162 base::FilePath CreateOrUpdateShortcutIconForProfile(
    163     const base::FilePath& profile_path,
    164     const SkBitmap& avatar_bitmap_1x,
    165     const SkBitmap& avatar_bitmap_2x) {
    166   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
    167 
    168   if (!base::PathExists(profile_path)) {
    169     LOG(ERROR) << "Profile directory " << profile_path.value()
    170                << " did not exist when trying to create profile icon";
    171     return base::FilePath();
    172   }
    173 
    174   scoped_ptr<SkBitmap> app_icon_bitmap(GetAppIconForSize(kShortcutIconSize));
    175   if (!app_icon_bitmap)
    176     return base::FilePath();
    177 
    178   gfx::ImageFamily badged_bitmaps;
    179   if (!avatar_bitmap_1x.empty()) {
    180     badged_bitmaps.Add(gfx::Image::CreateFrom1xBitmap(
    181         BadgeIcon(*app_icon_bitmap, avatar_bitmap_1x, 1)));
    182   }
    183 
    184   scoped_ptr<SkBitmap> large_app_icon_bitmap(
    185       GetAppIconForSize(IconUtil::kLargeIconSize));
    186   if (large_app_icon_bitmap && !avatar_bitmap_2x.empty()) {
    187     badged_bitmaps.Add(gfx::Image::CreateFrom1xBitmap(
    188         BadgeIcon(*large_app_icon_bitmap, avatar_bitmap_2x, 2)));
    189   }
    190 
    191   // If we have no badged bitmaps, we should just use the default chrome icon.
    192   if (badged_bitmaps.empty()) {
    193     badged_bitmaps.Add(gfx::Image::CreateFrom1xBitmap(*app_icon_bitmap));
    194     if (large_app_icon_bitmap) {
    195       badged_bitmaps.Add(
    196           gfx::Image::CreateFrom1xBitmap(*large_app_icon_bitmap));
    197     }
    198   }
    199   // Finally, write the .ico file containing this new bitmap.
    200   const base::FilePath icon_path =
    201       profiles::internal::GetProfileIconPath(profile_path);
    202   const bool had_icon = base::PathExists(icon_path);
    203 
    204   if (!IconUtil::CreateIconFileFromImageFamily(badged_bitmaps, icon_path)) {
    205     // This can happen in theory if the profile directory is deleted between the
    206     // beginning of this function and here; however this is extremely unlikely
    207     // and this check will help catch any regression where this call would start
    208     // failing constantly.
    209     NOTREACHED();
    210     return base::FilePath();
    211   }
    212 
    213   if (had_icon) {
    214     // This invalidates the Windows icon cache and causes the icon changes to
    215     // register with the taskbar and desktop. SHCNE_ASSOCCHANGED will cause a
    216     // desktop flash and we would like to avoid that if possible.
    217     SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
    218   } else {
    219     SHChangeNotify(SHCNE_CREATE, SHCNF_PATH, icon_path.value().c_str(), NULL);
    220   }
    221   BrowserThread::PostTask(
    222       BrowserThread::UI, FROM_HERE,
    223       base::Bind(&OnProfileIconCreateSuccess, profile_path));
    224   return icon_path;
    225 }
    226 
    227 // Gets the user and system directories for desktop shortcuts. Parameters may
    228 // be NULL if a directory type is not needed. Returns true on success.
    229 bool GetDesktopShortcutsDirectories(
    230     base::FilePath* user_shortcuts_directory,
    231     base::FilePath* system_shortcuts_directory) {
    232   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
    233   if (user_shortcuts_directory &&
    234       !ShellUtil::GetShortcutPath(ShellUtil::SHORTCUT_LOCATION_DESKTOP,
    235                                   distribution, ShellUtil::CURRENT_USER,
    236                                   user_shortcuts_directory)) {
    237     NOTREACHED();
    238     return false;
    239   }
    240   if (system_shortcuts_directory &&
    241       !ShellUtil::GetShortcutPath(ShellUtil::SHORTCUT_LOCATION_DESKTOP,
    242                                   distribution, ShellUtil::SYSTEM_LEVEL,
    243                                   system_shortcuts_directory)) {
    244     NOTREACHED();
    245     return false;
    246   }
    247   return true;
    248 }
    249 
    250 // Returns the long form of |path|, which will expand any shortened components
    251 // like "foo~2" to their full names.
    252 base::FilePath ConvertToLongPath(const base::FilePath& path) {
    253   const size_t length = GetLongPathName(path.value().c_str(), NULL, 0);
    254   if (length != 0 && length != path.value().length()) {
    255     std::vector<wchar_t> long_path(length);
    256     if (GetLongPathName(path.value().c_str(), &long_path[0], length) != 0)
    257       return base::FilePath(&long_path[0]);
    258   }
    259   return path;
    260 }
    261 
    262 // Returns true if the file at |path| is a Chrome shortcut and returns its
    263 // command line in output parameter |command_line|.
    264 bool IsChromeShortcut(const base::FilePath& path,
    265                       const base::FilePath& chrome_exe,
    266                       base::string16* command_line) {
    267   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
    268 
    269   if (path.Extension() != installer::kLnkExt)
    270     return false;
    271 
    272   base::FilePath target_path;
    273   if (!base::win::ResolveShortcut(path, &target_path, command_line))
    274     return false;
    275   // One of the paths may be in short (elided) form. Compare long paths to
    276   // ensure these are still properly matched.
    277   return ConvertToLongPath(target_path) == ConvertToLongPath(chrome_exe);
    278 }
    279 
    280 // Populates |paths| with the file paths of Chrome desktop shortcuts that have
    281 // the specified |command_line|. If |include_empty_command_lines| is true,
    282 // Chrome desktop shortcuts with empty command lines will also be included.
    283 void ListDesktopShortcutsWithCommandLine(const base::FilePath& chrome_exe,
    284                                          const base::string16& command_line,
    285                                          bool include_empty_command_lines,
    286                                          std::vector<base::FilePath>* paths) {
    287   base::FilePath user_shortcuts_directory;
    288   if (!GetDesktopShortcutsDirectories(&user_shortcuts_directory, NULL))
    289     return;
    290 
    291   base::FileEnumerator enumerator(user_shortcuts_directory, false,
    292                                   base::FileEnumerator::FILES);
    293   for (base::FilePath path = enumerator.Next(); !path.empty();
    294        path = enumerator.Next()) {
    295     base::string16 shortcut_command_line;
    296     if (!IsChromeShortcut(path, chrome_exe, &shortcut_command_line))
    297       continue;
    298 
    299     // TODO(asvitkine): Change this to build a CommandLine object and ensure all
    300     // args from |command_line| are present in the shortcut's CommandLine. This
    301     // will be more robust when |command_line| contains multiple args.
    302     if ((shortcut_command_line.empty() && include_empty_command_lines) ||
    303         (shortcut_command_line.find(command_line) != base::string16::npos)) {
    304       paths->push_back(path);
    305     }
    306   }
    307 }
    308 
    309 // Renames the given desktop shortcut and informs the shell of this change.
    310 bool RenameDesktopShortcut(const base::FilePath& old_shortcut_path,
    311                            const base::FilePath& new_shortcut_path) {
    312   if (!base::Move(old_shortcut_path, new_shortcut_path))
    313     return false;
    314 
    315   // Notify the shell of the rename, which allows the icon to keep its position
    316   // on the desktop when renamed. Note: This only works if either SHCNF_FLUSH or
    317   // SHCNF_FLUSHNOWAIT is specified as a flag.
    318   SHChangeNotify(SHCNE_RENAMEITEM, SHCNF_PATH | SHCNF_FLUSHNOWAIT,
    319                  old_shortcut_path.value().c_str(),
    320                  new_shortcut_path.value().c_str());
    321   return true;
    322 }
    323 
    324 // Renames an existing Chrome desktop profile shortcut. Must be called on the
    325 // FILE thread.
    326 void RenameChromeDesktopShortcutForProfile(
    327     const base::string16& old_shortcut_filename,
    328     const base::string16& new_shortcut_filename) {
    329   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
    330 
    331   base::FilePath user_shortcuts_directory;
    332   base::FilePath system_shortcuts_directory;
    333   if (!GetDesktopShortcutsDirectories(&user_shortcuts_directory,
    334                                       &system_shortcuts_directory)) {
    335     return;
    336   }
    337 
    338   const base::FilePath old_shortcut_path =
    339       user_shortcuts_directory.Append(old_shortcut_filename);
    340   const base::FilePath new_shortcut_path =
    341       user_shortcuts_directory.Append(new_shortcut_filename);
    342 
    343   if (base::PathExists(old_shortcut_path)) {
    344     // Rename the old shortcut unless a system-level shortcut exists at the
    345     // destination, in which case the old shortcut is simply deleted.
    346     const base::FilePath possible_new_system_shortcut =
    347         system_shortcuts_directory.Append(new_shortcut_filename);
    348     if (base::PathExists(possible_new_system_shortcut))
    349       base::DeleteFile(old_shortcut_path, false);
    350     else if (!RenameDesktopShortcut(old_shortcut_path, new_shortcut_path))
    351       DLOG(ERROR) << "Could not rename Windows profile desktop shortcut.";
    352   } else {
    353     // If the shortcut does not exist, it may have been renamed by the user. In
    354     // that case, its name should not be changed.
    355     // It's also possible that a system-level shortcut exists instead - this
    356     // should only be the case for the original Chrome shortcut from an
    357     // installation. If that's the case, copy that one over - it will get its
    358     // properties updated by
    359     // |CreateOrUpdateDesktopShortcutsAndIconForProfile()|.
    360     const base::FilePath possible_old_system_shortcut =
    361         system_shortcuts_directory.Append(old_shortcut_filename);
    362     if (base::PathExists(possible_old_system_shortcut))
    363       base::CopyFile(possible_old_system_shortcut, new_shortcut_path);
    364   }
    365 }
    366 
    367 struct CreateOrUpdateShortcutsParams {
    368   CreateOrUpdateShortcutsParams(
    369       base::FilePath profile_path,
    370       ProfileShortcutManagerWin::CreateOrUpdateMode create_mode,
    371       ProfileShortcutManagerWin::NonProfileShortcutAction action)
    372       : profile_path(profile_path), create_mode(create_mode), action(action) {}
    373   ~CreateOrUpdateShortcutsParams() {}
    374 
    375   ProfileShortcutManagerWin::CreateOrUpdateMode create_mode;
    376   ProfileShortcutManagerWin::NonProfileShortcutAction action;
    377 
    378   // The path for this profile.
    379   base::FilePath profile_path;
    380   // The profile name before this update. Empty on create.
    381   base::string16 old_profile_name;
    382   // The new profile name.
    383   base::string16 profile_name;
    384   // Avatar images for this profile.
    385   SkBitmap avatar_image_1x;
    386   SkBitmap avatar_image_2x;
    387 };
    388 
    389 // Updates all desktop shortcuts for the given profile to have the specified
    390 // parameters. If |params.create_mode| is CREATE_WHEN_NONE_FOUND, a new shortcut
    391 // is created if no existing ones were found. Whether non-profile shortcuts
    392 // should be updated is specified by |params.action|. Must be called on the FILE
    393 // thread.
    394 void CreateOrUpdateDesktopShortcutsAndIconForProfile(
    395     const CreateOrUpdateShortcutsParams& params) {
    396   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
    397 
    398   const base::FilePath shortcut_icon =
    399       CreateOrUpdateShortcutIconForProfile(params.profile_path,
    400                                            params.avatar_image_1x,
    401                                            params.avatar_image_2x);
    402   if (shortcut_icon.empty() ||
    403       params.create_mode ==
    404           ProfileShortcutManagerWin::CREATE_OR_UPDATE_ICON_ONLY) {
    405     return;
    406   }
    407 
    408   base::FilePath chrome_exe;
    409   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
    410     NOTREACHED();
    411     return;
    412   }
    413 
    414   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
    415   // Ensure that the distribution supports creating shortcuts. If it doesn't,
    416   // the following code may result in NOTREACHED() being hit.
    417   DCHECK(distribution->CanCreateDesktopShortcuts());
    418 
    419   if (params.old_profile_name != params.profile_name) {
    420     const base::string16 old_shortcut_filename =
    421         profiles::internal::GetShortcutFilenameForProfile(
    422             params.old_profile_name,
    423             distribution);
    424     const base::string16 new_shortcut_filename =
    425         profiles::internal::GetShortcutFilenameForProfile(params.profile_name,
    426                                                           distribution);
    427     RenameChromeDesktopShortcutForProfile(old_shortcut_filename,
    428                                           new_shortcut_filename);
    429   }
    430 
    431   ShellUtil::ShortcutProperties properties(ShellUtil::CURRENT_USER);
    432   installer::Product product(distribution);
    433   product.AddDefaultShortcutProperties(chrome_exe, &properties);
    434 
    435   const base::string16 command_line =
    436       profiles::internal::CreateProfileShortcutFlags(params.profile_path);
    437 
    438   // Only set the profile-specific properties when |profile_name| is non empty.
    439   // If it is empty, it means the shortcut being created should be a regular,
    440   // non-profile Chrome shortcut.
    441   if (!params.profile_name.empty()) {
    442     properties.set_arguments(command_line);
    443     properties.set_icon(shortcut_icon, 0);
    444   } else {
    445     // Set the arguments explicitly to the empty string to ensure that
    446     // |ShellUtil::CreateOrUpdateShortcut| updates that part of the shortcut.
    447     properties.set_arguments(base::string16());
    448   }
    449 
    450   properties.set_app_id(
    451       ShellIntegration::GetChromiumModelIdForProfile(params.profile_path));
    452 
    453   ShellUtil::ShortcutOperation operation =
    454       ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING;
    455 
    456   std::vector<base::FilePath> shortcuts;
    457   ListDesktopShortcutsWithCommandLine(chrome_exe, command_line,
    458       params.action == ProfileShortcutManagerWin::UPDATE_NON_PROFILE_SHORTCUTS,
    459       &shortcuts);
    460   if (params.create_mode == ProfileShortcutManagerWin::CREATE_WHEN_NONE_FOUND &&
    461       shortcuts.empty()) {
    462     const base::string16 shortcut_name =
    463         profiles::internal::GetShortcutFilenameForProfile(params.profile_name,
    464                                                           distribution);
    465     shortcuts.push_back(base::FilePath(shortcut_name));
    466     operation = ShellUtil::SHELL_SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL;
    467   }
    468 
    469   for (size_t i = 0; i < shortcuts.size(); ++i) {
    470     const base::FilePath shortcut_name =
    471         shortcuts[i].BaseName().RemoveExtension();
    472     properties.set_shortcut_name(shortcut_name.value());
    473     ShellUtil::CreateOrUpdateShortcut(ShellUtil::SHORTCUT_LOCATION_DESKTOP,
    474         distribution, properties, operation);
    475   }
    476 }
    477 
    478 // Returns true if any desktop shortcuts exist with target |chrome_exe|,
    479 // regardless of their command line arguments.
    480 bool ChromeDesktopShortcutsExist(const base::FilePath& chrome_exe) {
    481   base::FilePath user_shortcuts_directory;
    482   if (!GetDesktopShortcutsDirectories(&user_shortcuts_directory, NULL))
    483     return false;
    484 
    485   base::FileEnumerator enumerator(user_shortcuts_directory, false,
    486                                   base::FileEnumerator::FILES);
    487   for (base::FilePath path = enumerator.Next(); !path.empty();
    488        path = enumerator.Next()) {
    489     if (IsChromeShortcut(path, chrome_exe, NULL))
    490       return true;
    491   }
    492 
    493   return false;
    494 }
    495 
    496 // Deletes all desktop shortcuts for the specified profile. If
    497 // |ensure_shortcuts_remain| is true, then a regular non-profile shortcut will
    498 // be created if this function would otherwise delete the last Chrome desktop
    499 // shortcut(s). Must be called on the FILE thread.
    500 void DeleteDesktopShortcuts(const base::FilePath& profile_path,
    501                             bool ensure_shortcuts_remain) {
    502   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
    503 
    504   base::FilePath chrome_exe;
    505   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
    506     NOTREACHED();
    507     return;
    508   }
    509 
    510   const base::string16 command_line =
    511       profiles::internal::CreateProfileShortcutFlags(profile_path);
    512   std::vector<base::FilePath> shortcuts;
    513   ListDesktopShortcutsWithCommandLine(chrome_exe, command_line, false,
    514                                       &shortcuts);
    515 
    516   for (size_t i = 0; i < shortcuts.size(); ++i) {
    517     // Use base::DeleteFile() instead of ShellUtil::RemoveShortcuts(), as the
    518     // latter causes non-profile taskbar shortcuts to be removed since it
    519     // doesn't consider the command-line of the shortcuts it deletes.
    520     // TODO(huangs): Refactor with ShellUtil::RemoveShortcuts().
    521     base::win::TaskbarUnpinShortcutLink(shortcuts[i].value().c_str());
    522     base::DeleteFile(shortcuts[i], false);
    523     // Notify the shell that the shortcut was deleted to ensure desktop refresh.
    524     SHChangeNotify(SHCNE_DELETE, SHCNF_PATH, shortcuts[i].value().c_str(),
    525                    NULL);
    526   }
    527 
    528   // If |ensure_shortcuts_remain| is true and deleting this profile caused the
    529   // last shortcuts to be removed, re-create a regular non-profile shortcut.
    530   const bool had_shortcuts = !shortcuts.empty();
    531   if (ensure_shortcuts_remain && had_shortcuts &&
    532       !ChromeDesktopShortcutsExist(chrome_exe)) {
    533     BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
    534     // Ensure that the distribution supports creating shortcuts. If it doesn't,
    535     // the following code may result in NOTREACHED() being hit.
    536     DCHECK(distribution->CanCreateDesktopShortcuts());
    537     installer::Product product(distribution);
    538 
    539     ShellUtil::ShortcutProperties properties(ShellUtil::CURRENT_USER);
    540     product.AddDefaultShortcutProperties(chrome_exe, &properties);
    541     properties.set_shortcut_name(
    542         profiles::internal::GetShortcutFilenameForProfile(base::string16(),
    543                                                           distribution));
    544     ShellUtil::CreateOrUpdateShortcut(
    545         ShellUtil::SHORTCUT_LOCATION_DESKTOP, distribution, properties,
    546         ShellUtil::SHELL_SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL);
    547   }
    548 }
    549 
    550 // Returns true if profile at |profile_path| has any shortcuts. Does not
    551 // consider non-profile shortcuts. Must be called on the FILE thread.
    552 bool HasAnyProfileShortcuts(const base::FilePath& profile_path) {
    553   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
    554 
    555   base::FilePath chrome_exe;
    556   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
    557     NOTREACHED();
    558     return false;
    559   }
    560 
    561   const base::string16 command_line =
    562       profiles::internal::CreateProfileShortcutFlags(profile_path);
    563   std::vector<base::FilePath> shortcuts;
    564   ListDesktopShortcutsWithCommandLine(chrome_exe, command_line, false,
    565                                       &shortcuts);
    566   return !shortcuts.empty();
    567 }
    568 
    569 // Replaces any reserved characters with spaces, and trims the resulting string
    570 // to prevent any leading and trailing spaces. Also makes sure that the
    571 // resulting filename doesn't exceed |kMaxProfileShortcutFileNameLength|.
    572 // TODO(macourteau): find a way to limit the total path's length to MAX_PATH
    573 // instead of limiting the profile's name to |kMaxProfileShortcutFileNameLength|
    574 // characters.
    575 base::string16 SanitizeShortcutProfileNameString(
    576     const base::string16& profile_name) {
    577   base::string16 sanitized = profile_name;
    578   size_t pos = sanitized.find_first_of(kReservedCharacters);
    579   while (pos != base::string16::npos) {
    580     sanitized[pos] = L' ';
    581     pos = sanitized.find_first_of(kReservedCharacters, pos + 1);
    582   }
    583 
    584   base::TrimWhitespace(sanitized, base::TRIM_LEADING, &sanitized);
    585   if (sanitized.size() > kMaxProfileShortcutFileNameLength)
    586     sanitized.erase(kMaxProfileShortcutFileNameLength);
    587   base::TrimWhitespace(sanitized, base::TRIM_TRAILING, &sanitized);
    588 
    589   return sanitized;
    590 }
    591 
    592 // Returns a copied SkBitmap for the given image that can be safely passed to
    593 // another thread.
    594 SkBitmap GetSkBitmapCopy(const gfx::Image& image) {
    595   DCHECK(!image.IsEmpty());
    596   const SkBitmap* image_bitmap = image.ToSkBitmap();
    597   SkBitmap bitmap_copy;
    598   image_bitmap->deepCopyTo(&bitmap_copy);
    599   return bitmap_copy;
    600 }
    601 
    602 // Returns a copied SkBitmap for the given resource id that can be safely passed
    603 // to another thread.
    604 SkBitmap GetImageResourceSkBitmapCopy(int resource_id) {
    605   const gfx::Image image =
    606       ResourceBundle::GetSharedInstance().GetNativeImageNamed(resource_id);
    607   return GetSkBitmapCopy(image);
    608 }
    609 
    610 }  // namespace
    611 
    612 namespace profiles {
    613 namespace internal {
    614 
    615 base::FilePath GetProfileIconPath(const base::FilePath& profile_path) {
    616   return profile_path.AppendASCII(kProfileIconFileName);
    617 }
    618 
    619 base::string16 GetShortcutFilenameForProfile(
    620     const base::string16& profile_name,
    621     BrowserDistribution* distribution) {
    622   base::string16 shortcut_name;
    623   if (!profile_name.empty()) {
    624     shortcut_name.append(SanitizeShortcutProfileNameString(profile_name));
    625     shortcut_name.append(L" - ");
    626     shortcut_name.append(l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME));
    627   } else {
    628     shortcut_name.append(
    629         distribution->GetShortcutName(BrowserDistribution::SHORTCUT_CHROME));
    630   }
    631   return shortcut_name + installer::kLnkExt;
    632 }
    633 
    634 base::string16 CreateProfileShortcutFlags(const base::FilePath& profile_path) {
    635   return base::StringPrintf(L"--%ls=\"%ls\"",
    636                             base::ASCIIToUTF16(
    637                                 switches::kProfileDirectory).c_str(),
    638                             profile_path.BaseName().value().c_str());
    639 }
    640 
    641 }  // namespace internal
    642 }  // namespace profiles
    643 
    644 // static
    645 bool ProfileShortcutManager::IsFeatureEnabled() {
    646   CommandLine* command_line = CommandLine::ForCurrentProcess();
    647   return command_line->HasSwitch(switches::kEnableProfileShortcutManager) ||
    648          (BrowserDistribution::GetDistribution()->CanCreateDesktopShortcuts() &&
    649           !command_line->HasSwitch(switches::kUserDataDir));
    650 }
    651 
    652 // static
    653 ProfileShortcutManager* ProfileShortcutManager::Create(
    654     ProfileManager* manager) {
    655   return new ProfileShortcutManagerWin(manager);
    656 }
    657 
    658 ProfileShortcutManagerWin::ProfileShortcutManagerWin(ProfileManager* manager)
    659     : profile_manager_(manager) {
    660   DCHECK_EQ(
    661       arraysize(kProfileAvatarIconResources2x),
    662       profiles::GetDefaultAvatarIconCount());
    663 
    664   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
    665                  content::NotificationService::AllSources());
    666 
    667   profile_manager_->GetProfileInfoCache().AddObserver(this);
    668 }
    669 
    670 ProfileShortcutManagerWin::~ProfileShortcutManagerWin() {
    671   profile_manager_->GetProfileInfoCache().RemoveObserver(this);
    672 }
    673 
    674 void ProfileShortcutManagerWin::CreateOrUpdateProfileIcon(
    675     const base::FilePath& profile_path) {
    676   CreateOrUpdateShortcutsForProfileAtPath(profile_path,
    677                                           CREATE_OR_UPDATE_ICON_ONLY,
    678                                           IGNORE_NON_PROFILE_SHORTCUTS);
    679 }
    680 
    681 void ProfileShortcutManagerWin::CreateProfileShortcut(
    682     const base::FilePath& profile_path) {
    683   CreateOrUpdateShortcutsForProfileAtPath(profile_path, CREATE_WHEN_NONE_FOUND,
    684                                           IGNORE_NON_PROFILE_SHORTCUTS);
    685 }
    686 
    687 void ProfileShortcutManagerWin::RemoveProfileShortcuts(
    688     const base::FilePath& profile_path) {
    689   BrowserThread::PostTask(
    690       BrowserThread::FILE, FROM_HERE,
    691       base::Bind(&DeleteDesktopShortcuts, profile_path, false));
    692 }
    693 
    694 void ProfileShortcutManagerWin::HasProfileShortcuts(
    695     const base::FilePath& profile_path,
    696     const base::Callback<void(bool)>& callback) {
    697   BrowserThread::PostTaskAndReplyWithResult(
    698       BrowserThread::FILE, FROM_HERE,
    699       base::Bind(&HasAnyProfileShortcuts, profile_path), callback);
    700 }
    701 
    702 void ProfileShortcutManagerWin::GetShortcutProperties(
    703     const base::FilePath& profile_path,
    704     CommandLine* command_line,
    705     base::string16* name,
    706     base::FilePath* icon_path) {
    707   base::FilePath chrome_exe;
    708   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
    709     NOTREACHED();
    710     return;
    711   }
    712 
    713   const ProfileInfoCache& cache = profile_manager_->GetProfileInfoCache();
    714   size_t profile_index = cache.GetIndexOfProfileWithPath(profile_path);
    715   DCHECK_LT(profile_index, cache.GetNumberOfProfiles());
    716 
    717   // The used profile name should be empty if there is only 1 profile.
    718   base::string16 shortcut_profile_name;
    719   if (cache.GetNumberOfProfiles() > 1)
    720     shortcut_profile_name = cache.GetNameOfProfileAtIndex(profile_index);
    721 
    722   *name = base::FilePath(profiles::internal::GetShortcutFilenameForProfile(
    723       shortcut_profile_name,
    724       BrowserDistribution::GetDistribution())).RemoveExtension().value();
    725 
    726   command_line->ParseFromString(L"\"" + chrome_exe.value() + L"\" " +
    727       profiles::internal::CreateProfileShortcutFlags(profile_path));
    728 
    729   *icon_path = profiles::internal::GetProfileIconPath(profile_path);
    730 }
    731 
    732 void ProfileShortcutManagerWin::OnProfileAdded(
    733     const base::FilePath& profile_path) {
    734   CreateOrUpdateProfileIcon(profile_path);
    735   if (profile_manager_->GetProfileInfoCache().GetNumberOfProfiles() == 2) {
    736     // When the second profile is added, make existing non-profile shortcuts
    737     // point to the first profile and be badged/named appropriately.
    738     CreateOrUpdateShortcutsForProfileAtPath(GetOtherProfilePath(profile_path),
    739                                             UPDATE_EXISTING_ONLY,
    740                                             UPDATE_NON_PROFILE_SHORTCUTS);
    741   }
    742 }
    743 
    744 void ProfileShortcutManagerWin::OnProfileWasRemoved(
    745     const base::FilePath& profile_path,
    746     const base::string16& profile_name) {
    747   const ProfileInfoCache& cache = profile_manager_->GetProfileInfoCache();
    748   // If there is only one profile remaining, remove the badging information
    749   // from an existing shortcut.
    750   const bool deleting_down_to_last_profile = (cache.GetNumberOfProfiles() == 1);
    751   if (deleting_down_to_last_profile) {
    752     // This is needed to unbadge the icon.
    753     CreateOrUpdateShortcutsForProfileAtPath(cache.GetPathOfProfileAtIndex(0),
    754                                             UPDATE_EXISTING_ONLY,
    755                                             IGNORE_NON_PROFILE_SHORTCUTS);
    756   }
    757 
    758   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
    759                           base::Bind(&DeleteDesktopShortcuts,
    760                                      profile_path,
    761                                      deleting_down_to_last_profile));
    762 }
    763 
    764 void ProfileShortcutManagerWin::OnProfileNameChanged(
    765     const base::FilePath& profile_path,
    766     const base::string16& old_profile_name) {
    767   CreateOrUpdateShortcutsForProfileAtPath(profile_path, UPDATE_EXISTING_ONLY,
    768                                           IGNORE_NON_PROFILE_SHORTCUTS);
    769 }
    770 
    771 void ProfileShortcutManagerWin::OnProfileAvatarChanged(
    772     const base::FilePath& profile_path) {
    773   CreateOrUpdateProfileIcon(profile_path);
    774 }
    775 
    776 base::FilePath ProfileShortcutManagerWin::GetOtherProfilePath(
    777     const base::FilePath& profile_path) {
    778   const ProfileInfoCache& cache = profile_manager_->GetProfileInfoCache();
    779   DCHECK_EQ(2U, cache.GetNumberOfProfiles());
    780   // Get the index of the current profile, in order to find the index of the
    781   // other profile.
    782   size_t current_profile_index = cache.GetIndexOfProfileWithPath(profile_path);
    783   size_t other_profile_index = (current_profile_index == 0) ? 1 : 0;
    784   return cache.GetPathOfProfileAtIndex(other_profile_index);
    785 }
    786 
    787 void ProfileShortcutManagerWin::CreateOrUpdateShortcutsForProfileAtPath(
    788     const base::FilePath& profile_path,
    789     CreateOrUpdateMode create_mode,
    790     NonProfileShortcutAction action) {
    791   DCHECK(!BrowserThread::IsThreadInitialized(BrowserThread::UI) ||
    792          BrowserThread::CurrentlyOn(BrowserThread::UI));
    793   CreateOrUpdateShortcutsParams params(profile_path, create_mode, action);
    794 
    795   ProfileInfoCache* cache = &profile_manager_->GetProfileInfoCache();
    796   size_t profile_index = cache->GetIndexOfProfileWithPath(profile_path);
    797   if (profile_index == std::string::npos)
    798     return;
    799   bool remove_badging = cache->GetNumberOfProfiles() == 1;
    800 
    801   params.old_profile_name =
    802       cache->GetShortcutNameOfProfileAtIndex(profile_index);
    803 
    804   // Exit early if the mode is to update existing profile shortcuts only and
    805   // none were ever created for this profile, per the shortcut name not being
    806   // set in the profile info cache.
    807   if (params.old_profile_name.empty() &&
    808       create_mode == UPDATE_EXISTING_ONLY &&
    809       action == IGNORE_NON_PROFILE_SHORTCUTS) {
    810     return;
    811   }
    812 
    813   if (!remove_badging) {
    814     params.profile_name = cache->GetNameOfProfileAtIndex(profile_index);
    815 
    816     // The profile might be using the Gaia avatar, which is not in the
    817     // resources array.
    818     bool has_gaia_image = false;
    819     if (cache->IsUsingGAIAPictureOfProfileAtIndex(profile_index)) {
    820       const gfx::Image* image =
    821           cache->GetGAIAPictureOfProfileAtIndex(profile_index);
    822       if (image) {
    823         params.avatar_image_1x = GetSkBitmapCopy(*image);
    824         // Gaia images are 256px, which makes them big enough to use in the
    825         // large icon case as well.
    826         DCHECK_GE(image->Width(), IconUtil::kLargeIconSize);
    827         params.avatar_image_2x = params.avatar_image_1x;
    828         has_gaia_image = true;
    829       }
    830     }
    831 
    832     // If the profile isn't using a Gaia image, or if the Gaia image did not
    833     // exist, revert to the previously used avatar icon.
    834     if (!has_gaia_image) {
    835       const size_t icon_index =
    836           cache->GetAvatarIconIndexOfProfileAtIndex(profile_index);
    837       const int resource_id_1x =
    838           profiles::GetDefaultAvatarIconResourceIDAtIndex(icon_index);
    839       const int resource_id_2x = kProfileAvatarIconResources2x[icon_index];
    840       // Make a copy of the SkBitmaps to ensure that we can safely use the image
    841       // data on the FILE thread.
    842       params.avatar_image_1x = GetImageResourceSkBitmapCopy(resource_id_1x);
    843       params.avatar_image_2x = GetImageResourceSkBitmapCopy(resource_id_2x);
    844     }
    845   }
    846   BrowserThread::PostTask(
    847       BrowserThread::FILE, FROM_HERE,
    848       base::Bind(&CreateOrUpdateDesktopShortcutsAndIconForProfile, params));
    849 
    850   cache->SetShortcutNameOfProfileAtIndex(profile_index,
    851                                          params.profile_name);
    852 }
    853 
    854 void ProfileShortcutManagerWin::Observe(
    855     int type,
    856     const content::NotificationSource& source,
    857     const content::NotificationDetails& details) {
    858   switch (type) {
    859     // This notification is triggered when a profile is loaded.
    860     case chrome::NOTIFICATION_PROFILE_CREATED: {
    861       Profile* profile =
    862           content::Source<Profile>(source).ptr()->GetOriginalProfile();
    863       if (profile->GetPrefs()->GetInteger(prefs::kProfileIconVersion) <
    864           kCurrentProfileIconVersion) {
    865         // Ensure the profile's icon file has been created.
    866         CreateOrUpdateProfileIcon(profile->GetPath());
    867       }
    868       break;
    869     }
    870     default:
    871       NOTREACHED();
    872       break;
    873   }
    874 }
    875