Add profiles to wrench menu

chrome/browser/profiles/profile_manager.cc

 // Copyright (c) 2011 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/command_line.h"
 #include "base/file_path.h"
@@ skipping 14 matching lines @@
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_type.h"
 #include "grit/generated_resources.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_job.h"
+#include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/cryptohome_library.h"
 #endif
 
 bool ProfileManagerObserver::DeleteAfterCreation() {
     return false;
 }
 
@@ skipping 199 matching lines @@
 
 void ProfileManager::CreateProfileAsync(const FilePath& user_data_dir,
                                         ProfileManagerObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProfilesInfoMap::iterator iter = profiles_info_.find(user_data_dir);
   if (iter != profiles_info_.end()) {
     ProfileInfo* info = iter->second.get();
     if (info->created) {
       // Profile has already been created. Call observer immediately.
       observer->OnProfileCreated(info->profile.get());
+      if (observer->DeleteAfterCreation())
+        delete observer;
     } else {
       // Profile is being created. Add observer to list.
       info->observers.push_back(observer);
     }
   } else {
     // Initiate asynchronous creation process.
     ProfileInfo* info =
         RegisterProfile(Profile::CreateProfileAsync(user_data_dir, this),
                         false);
     info->observers.push_back(observer);
@@ skipping 31 matching lines @@
   RegisterProfile(profile, true);
   DoFinalInit(profile);
   return true;
 }
 
 ProfileManager::ProfileInfo* ProfileManager::RegisterProfile(Profile* profile,
                                                              bool created) {
   ProfileInfo* info = new ProfileInfo(profile, created);
   ProfilesInfoMap::iterator new_elem =
       (profiles_info_.insert(std::make_pair(profile->GetPath(), info))).first;
+
   return info;
 }
 
 Profile* ProfileManager::GetProfileByPath(const FilePath& path) const {
   ProfilesInfoMap::const_iterator iter = profiles_info_.find(path);
   return (iter == profiles_info_.end()) ? NULL : iter->second->profile.get();
 }
 
 void ProfileManager::Observe(
     NotificationType type,
@@ skipping 107 matching lines @@
   NewProfileLauncher* launcher = new NewProfileLauncher();
   profile_manager->CreateProfileAsync(new_path, launcher);
 }
 
 // static
 void ProfileManager::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kProfileLastUsed, "");
   prefs->RegisterDictionaryPref(prefs::kProfileDirectoryMap);
   prefs->RegisterIntegerPref(prefs::kProfilesNumCreated, 1);
 }
+
+
+size_t ProfileManager::GetNumberOfProfiles() {
+  const DictionaryValue* path_map =
+      g_browser_process->local_state()->GetDictionary(
+          prefs::kProfileDirectoryMap);
+  return path_map ? path_map->size() : 0;
+}
+
+string16 ProfileManager::GetNameOfProfileAtIndex(size_t index) {
+  return GetSortedProfilesFromDirectoryMap()[index].second;
+}
+
+FilePath ProfileManager::GetFilePathOfProfileAtIndex(
+    size_t index,
+    const FilePath& user_data_dir) {
+  FilePath base_name = GetSortedProfilesFromDirectoryMap()[index].first;
+  return user_data_dir.Append(base_name);
+}
+
+bool ProfileManager::CompareProfilePathAndName(
+    const ProfileManager::ProfilePathAndName& pair1,
+    const ProfileManager::ProfilePathAndName& pair2) {
+  int name_compare = pair1.second.compare(pair2.second);
+  if (name_compare < 0) {
+    return true;
+  } else if (name_compare > 0) {
+    return false;
+  } else {
+    return pair1.first < pair2.first;
+  }
+}
+
+ProfileManager::ProfilePathAndNames
+ProfileManager::GetSortedProfilesFromDirectoryMap() {
+  ProfilePathAndNames profiles;
+
+  const DictionaryValue* path_map =
+      g_browser_process->local_state()->GetDictionary(
+          prefs::kProfileDirectoryMap);
+  if (!path_map)
+    return profiles;
+
+  for (DictionaryValue::key_iterator it = path_map->begin_keys();
+       it != path_map->end_keys(); ++it) {
+    std::string name_ascii;
+    path_map->GetString(*it, &name_ascii);
+    string16 name = ASCIIToUTF16(name_ascii);
+    if (name.empty())
+      name = l10n_util::GetStringUTF16(IDS_DEFAULT_PROFILE_NAME);
+#if defined(OS_POSIX)
+    FilePath file_path(*it);
+#elif defined(OS_WIN)
+    FilePath file_path(ASCIIToWide(*it));
+#endif
+
+    // Pending, need to insert it alphabetically.
+    profiles.push_back(std::pair<FilePath, string16>(file_path, name));
+  }
+
+  std::sort(profiles.begin(), profiles.end(), CompareProfilePathAndName);
+  return profiles;
+}