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;

[sail, 2011/06/13 19:00:02]

I think this was a leak in the old code. Let me know if this make sense.

[Miranda Callahan, 2011/06/13 22:08:11]

Ah, good catch -- yes, this was skipped before.

     } 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() {

[Miranda Callahan, 2011/06/13 22:08:11]

Is there any reason to not keep these in sorted order, if you always want to
refer to them in sorted order? Would it make more sense to just sort on insert,
and not have to call the sort function every time we refer to the set of
profiles?

[sail, 2011/06/13 23:08:46]

Do you mean keeping a cache of the profiles as a member variable? I was worried
about the extra complexity of keeping the cache in sync. Currently this is very
inexpensive since we don't have many profiles. Using a cache would definitely be
something we could do later.

+  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;
+}