Create/Delete windows profile shortcuts

chrome/browser/profiles/profile_manager.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 <set>
 
 #include "chrome/browser/profiles/profile_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 221 matching lines @@
 std::vector<Profile*> ProfileManager::GetLastOpenedProfiles() {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   return profile_manager->GetLastOpenedProfiles(
       profile_manager->user_data_dir_);
 }
 
 ProfileManager::ProfileManager(const FilePath& user_data_dir)
     : user_data_dir_(user_data_dir),
       logged_in_(false),
       will_import_(false),
+      profile_shortcut_manager_(NULL),
 #if !defined(OS_ANDROID)
       ALLOW_THIS_IN_INITIALIZER_LIST(
           browser_list_observer_(this)),
 #endif
       closing_all_browsers_(false) {
 #if defined(OS_CHROMEOS)
   registrar_.Add(
       this,
       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
       content::NotificationService::AllSources());
 #endif
   registrar_.Add(
       this,
       chrome::NOTIFICATION_BROWSER_OPENED,
       content::NotificationService::AllSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
       content::NotificationService::AllSources());
   registrar_.Add(
       this,
       chrome::NOTIFICATION_BROWSER_CLOSE_CANCELLED,
       content::NotificationService::AllSources());
+
+  if (ProfileShortcutManager::IsFeatureEnabled())
+    profile_shortcut_manager_.reset(ProfileShortcutManager::Create());
 }
 
 ProfileManager::~ProfileManager() {
-#if defined(OS_WIN)
-  if (profile_shortcut_manager_.get())
-    profile_info_cache_->RemoveObserver(profile_shortcut_manager_.get());
-#endif
 }
 
 FilePath ProfileManager::GetDefaultProfileDir(
     const FilePath& user_data_dir) {
   FilePath default_profile_dir(user_data_dir);
   default_profile_dir =
       default_profile_dir.AppendASCII(chrome::kInitialProfile);
   return default_profile_dir;
 }
 
@@ skipping 161 matching lines @@
         RegisterProfile(CreateProfileAsyncHelper(profile_path, this), false);
     ProfileInfoCache& cache = GetProfileInfoCache();
     // Get the icon index from the user's icon url
     size_t icon_index;
     std::string icon_url_std = UTF16ToASCII(icon_url);
     if (cache.IsDefaultAvatarIconUrl(icon_url_std, &icon_index)) {
       // add profile to cache with user selected name and avatar
       cache.AddProfileToCache(profile_path, name, string16(), icon_index);
     }
     info->callbacks.push_back(callback);
+    if (profile_shortcut_manager_.get() && !name.empty() &&
+        !icon_url.empty()) {
+      BrowserThread::PostTask(
+          BrowserThread::FILE, FROM_HERE,
+          base::Bind(&ProfileShortcutManager::CreateChromeDesktopShortcut,
+          base::Unretained(profile_shortcut_manager_.get()), profile_path, name,
+          ResourceBundle::GetSharedInstance().GetNativeImageNamed(
+              cache.GetDefaultAvatarIconResourceIDAtIndex(icon_index))));
+    }
   }
 }
 
 // static
 void ProfileManager::CreateDefaultProfileAsync(const CreateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   FilePath default_profile_dir = profile_manager->user_data_dir_;
   // TODO(mirandac): current directory will not always be default in the future
@@ skipping 199 matching lines @@
                            last_active->GetPath().BaseName().MaybeAsASCII());
   }
 }
 #endif  // !defined(OS_ANDROID)
 
 void ProfileManager::DoFinalInit(Profile* profile, bool go_off_the_record) {
   DoFinalInitForServices(profile, go_off_the_record);
   InitProfileUserPrefs(profile);
   AddProfileToCache(profile);
   DoFinalInitLogging(profile);
-#if defined(OS_WIN)
-  CreateDesktopShortcut(profile);
-#endif
 
   ProfileMetrics::LogNumberOfProfiles(this, ProfileMetrics::ADD_PROFILE_EVENT);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_ADDED,
       content::Source<Profile>(profile),
       content::NotificationService::NoDetails());
 
 }
 
 void ProfileManager::DoFinalInitForServices(Profile* profile,
@@ skipping 29 matching lines @@
   return Profile::CreateProfile(path, NULL, Profile::CREATE_MODE_SYNCHRONOUS);
 }
 
 Profile* ProfileManager::CreateProfileAsyncHelper(const FilePath& path,
                                                   Delegate* delegate) {
   return Profile::CreateProfile(path,
                                 delegate,
                                 Profile::CREATE_MODE_ASYNCHRONOUS);
 }
 
-#if defined(OS_WIN)
-ProfileShortcutManagerWin* ProfileManager::CreateShortcutManager() {
-  return new ProfileShortcutManagerWin();
-}
-#endif
-
 void ProfileManager::OnProfileCreated(Profile* profile,
                                       bool success,
                                       bool is_new_profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ProfilesInfoMap::iterator iter = profiles_info_.find(profile->GetPath());
   DCHECK(iter != profiles_info_.end());
   ProfileInfo* info = iter->second.get();
 
   std::vector<CreateCallback> callbacks;
@@ skipping 80 matching lines @@
     return false;
   } else {
     return pair1.first < pair2.first;
   }
 }
 
 ProfileInfoCache& ProfileManager::GetProfileInfoCache() {
   if (!profile_info_cache_.get()) {
     profile_info_cache_.reset(new ProfileInfoCache(
         g_browser_process->local_state(), user_data_dir_));
-#if defined(OS_WIN)
-    BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-    ProfileShortcutManagerWin* shortcut_manager = CreateShortcutManager();
-    const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-    if (dist && dist->CanCreateDesktopShortcuts() && shortcut_manager &&
-        !command_line.HasSwitch(switches::kDisableDesktopShortcuts)) {
-      profile_shortcut_manager_.reset(shortcut_manager);
-      profile_info_cache_->AddObserver(profile_shortcut_manager_.get());
-    }
-#endif
   }
   return *profile_info_cache_.get();
 }
 
 void ProfileManager::AddProfileToCache(Profile* profile) {
   ProfileInfoCache& cache = GetProfileInfoCache();
   if (profile->GetPath().DirName() != cache.GetUserDataDir())
     return;
 
   if (cache.GetIndexOfProfileWithPath(profile->GetPath()) != std::string::npos)
     return;
 
   string16 username = UTF8ToUTF16(profile->GetPrefs()->GetString(
       prefs::kGoogleServicesUsername));
 
   // Profile name and avatar are set by InitProfileUserPrefs and stored in the
   // profile. Use those values to setup the cache entry.
   string16 profile_name = UTF8ToUTF16(profile->GetPrefs()->GetString(
       prefs::kProfileName));
 
   size_t icon_index = profile->GetPrefs()->GetInteger(
       prefs::kProfileAvatarIndex);
 
   cache.AddProfileToCache(profile->GetPath(),
                           profile_name,
                           username,
                           icon_index);
 }
 
-#if defined(OS_WIN)
-void ProfileManager::CreateDesktopShortcut(Profile* profile) {
-  // TODO(sail): Disable creating new shortcuts for now.
-  return;
-
-  // Some distributions and tests cannot create desktop shortcuts, in which case
-  // profile_shortcut_manager_ will not be set.
-  if (!profile_shortcut_manager_.get())
-    return;
-
-  bool shortcut_created =
-      profile->GetPrefs()->GetBoolean(prefs::kProfileShortcutCreated);
-  if (!shortcut_created && GetNumberOfProfiles() > 1) {
-    profile_shortcut_manager_->AddProfileShortcut(profile->GetPath());
-
-    // We only ever create the shortcut for a profile once, so set a pref
-    // reminding us to skip this in the future.
-    profile->GetPrefs()->SetBoolean(prefs::kProfileShortcutCreated, true);
-  }
-}
-#endif
-
 void ProfileManager::InitProfileUserPrefs(Profile* profile) {
   ProfileInfoCache& cache = GetProfileInfoCache();
 
   if (profile->GetPath().DirName() != cache.GetUserDataDir())
     return;
 
   // Initialize the user preferences (name and avatar) only if the profile
   // doesn't have default preferenc values for them.
   if (HasAnyDefaultUserPrefs(profile)) {
     size_t profile_cache_index =
@@ skipping 70 matching lines @@
     if (ProfileSyncServiceFactory::GetInstance()->HasProfileSyncService(
         profile)) {
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(
           profile)->DisableForUser();
     }
   }
 
   QueueProfileDirectoryForDeletion(profile_dir);
   cache.DeleteProfileFromCache(profile_dir);
 
+  // Delete possible shortcuts for this profile
+  if (profile_shortcut_manager_.get())
+    profile_shortcut_manager_->DeleteChromeDesktopShortcut(profile_dir);
+
   ProfileMetrics::LogNumberOfProfiles(this,
                                       ProfileMetrics::DELETE_PROFILE_EVENT);
 }
 
 // static
 bool ProfileManager::IsMultipleProfilesEnabled() {
 #if defined(OS_CHROMEOS)
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kMultiProfiles))
     return false;
 #endif
@@ skipping 35 matching lines @@
 void ProfileManager::RunCallbacks(const std::vector<CreateCallback>& callbacks,
                                   Profile* profile,
                                   Profile::CreateStatus status) {
   for (size_t i = 0; i < callbacks.size(); ++i)
     callbacks[i].Run(profile, status);
 }
 
 ProfileManager::ProfileInfo::~ProfileInfo() {
   ProfileDestroyer::DestroyProfileWhenAppropriate(profile.release());
 }