Refactor utility methods out of the ProfileManager

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 "chrome/browser/profiles/profile_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/deferred_sequenced_task_runner.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram.h"
-#include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/bookmark_model_loaded_observer.h"
 #include "chrome/browser/profiles/profile_destroyer.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_metrics.h"
+#include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/browser/profiles/startup_task_runner_service.h"
 #include "chrome/browser/profiles/startup_task_runner_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/sync/sync_promo_ui.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
@@ skipping 11 matching lines @@
 
 #if defined(ENABLE_MANAGED_USERS)
 #include "chrome/browser/managed_mode/managed_user_service.h"
 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
 #endif
 
 #if !defined(OS_IOS)
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/sessions/session_service_factory.h"
-#include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
-#include "chrome/browser/ui/browser_window.h"
-#include "chrome/browser/ui/startup/startup_browser_creator.h"
 #endif  // !defined (OS_IOS)
 
 #if defined(OS_WIN)
 #include "base/win/metro.h"
 #include "chrome/installer/util/browser_distribution.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/browser_process_platform_part_chromeos.h"
 #include "chrome/browser/chromeos/login/user.h"
@@ skipping 226 matching lines @@
       content::NotificationService::AllSources());
 
   if (ProfileShortcutManager::IsFeatureEnabled() && !user_data_dir_.empty())
     profile_shortcut_manager_.reset(ProfileShortcutManager::Create(
                                     this));
 }
 
 ProfileManager::~ProfileManager() {
 }
 
-base::FilePath ProfileManager::GetDefaultProfileDir(
-    const base::FilePath& user_data_dir) {
-  base::FilePath default_profile_dir(user_data_dir);
-  default_profile_dir =
-      default_profile_dir.AppendASCII(chrome::kInitialProfile);
-  return default_profile_dir;
-}
-
-base::FilePath ProfileManager::GetProfilePrefsPath(
-    const base::FilePath &profile_dir) {
-  base::FilePath default_prefs_path(profile_dir);
-  default_prefs_path = default_prefs_path.Append(chrome::kPreferencesFilename);
-  return default_prefs_path;
-}
-
 base::FilePath ProfileManager::GetInitialProfileDir() {
   base::FilePath relative_profile_dir;
 #if defined(OS_CHROMEOS)
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (logged_in_) {
     base::FilePath profile_dir;
     // If the user has logged in, pick up the new profile.
     if (command_line.HasSwitch(chromeos::switches::kLoginProfile)) {
       profile_dir = command_line.GetSwitchValuePath(
           chromeos::switches::kLoginProfile);
@@ skipping 74 matching lines @@
   return to_return;
 }
 
 Profile* ProfileManager::GetDefaultProfile(
     const base::FilePath& user_data_dir) {
 #if defined(OS_CHROMEOS)
   base::FilePath default_profile_dir(user_data_dir);
   if (logged_in_) {
     default_profile_dir = default_profile_dir.Append(GetInitialProfileDir());
   } else {
-    default_profile_dir = GetDefaultProfileDir(user_data_dir);
+    default_profile_dir = profiles::GetDefaultProfileDir(user_data_dir);
   }
 #else
   base::FilePath default_profile_dir(user_data_dir);
   default_profile_dir = default_profile_dir.Append(GetInitialProfileDir());
 #endif
 #if defined(OS_CHROMEOS)
   if (!logged_in_) {
     Profile* profile = GetProfile(default_profile_dir);
     // For cros, return the OTR profile so we never accidentally keep
     // user data in an unencrypted profile. But doing this makes
     // many of the browser and ui tests fail. We do return the OTR profile
     // if the login-profile switch is passed so that we can test this.
     // TODO(davemoore) Fix the tests so they allow OTR profiles.
     if (ShouldGoOffTheRecord(profile))
       return profile->GetOffTheRecordProfile();
     return profile;
   }
 
   ProfileInfo* profile_info = GetProfileInfoByPath(default_profile_dir);
   // Fallback to default off-the-record profile, if user profile has not fully
   // loaded yet.
   if (profile_info && !profile_info->created)
-    default_profile_dir = GetDefaultProfileDir(user_data_dir);
+    default_profile_dir = profiles::GetDefaultProfileDir(user_data_dir);
 #endif
   return GetProfile(default_profile_dir);
 }
 
 bool ProfileManager::IsValidProfile(Profile* profile) {
   for (ProfilesInfoMap::iterator iter = profiles_info_.begin();
        iter != profiles_info_.end(); ++iter) {
     if (iter->second->created) {
       Profile* candidate = iter->second->profile.get();
       if (candidate == profile ||
@@ skipping 135 matching lines @@
     const base::FilePath& path) const {
   ProfilesInfoMap::const_iterator iter = profiles_info_.find(path);
   return (iter == profiles_info_.end()) ? NULL : iter->second.get();
 }
 
 Profile* ProfileManager::GetProfileByPath(const base::FilePath& path) const {
   ProfileInfo* profile_info = GetProfileInfoByPath(path);
   return profile_info ? profile_info->profile.get() : NULL;
 }
 
-// static
-void ProfileManager::FindOrCreateNewWindowForProfile(
-    Profile* profile,
-    chrome::startup::IsProcessStartup process_startup,
-    chrome::startup::IsFirstRun is_first_run,
-    chrome::HostDesktopType desktop_type,
-    bool always_create) {
-#if defined(OS_IOS)
-  NOTREACHED();
-#else
-  DCHECK(profile);
-
-  if (!always_create) {
-    Browser* browser = chrome::FindTabbedBrowser(profile, false, desktop_type);
-    if (browser) {
-      browser->window()->Activate();
-      return;
-    }
-  }
-
-  content::RecordAction(UserMetricsAction("NewWindow"));
-  CommandLine command_line(CommandLine::NO_PROGRAM);
-  int return_code;
-  StartupBrowserCreator browser_creator;
-  browser_creator.LaunchBrowser(command_line, profile, base::FilePath(),
-                                process_startup, is_first_run, &return_code);
-#endif  // defined(OS_IOS)
-}
-
 void ProfileManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
 #if defined(OS_CHROMEOS)
   if (type == chrome::NOTIFICATION_LOGIN_USER_CHANGED) {
     logged_in_ = true;
 
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
     if (!command_line.HasSwitch(switches::kTestType)) {
@@ skipping 244 matching lines @@
   // Invoke INITIALIZED or FAIL for all profiles.
   RunCallbacks(callbacks, profile,
                profile ? Profile::CREATE_STATUS_INITIALIZED :
                          Profile::CREATE_STATUS_LOCAL_FAIL);
 }
 
 base::FilePath ProfileManager::GenerateNextProfileDirectoryPath() {
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
 
-  DCHECK(IsMultipleProfilesEnabled());
+  DCHECK(profiles::IsMultipleProfilesEnabled());
 
   // Create the next profile in the next available directory slot.
   int next_directory = local_state->GetInteger(prefs::kProfilesNumCreated);
   std::string profile_name = chrome::kMultiProfileDirPrefix;
   profile_name.append(base::IntToString(next_directory));
   base::FilePath new_path = user_data_dir_;
 #if defined(OS_WIN)
   new_path = new_path.Append(ASCIIToUTF16(profile_name));
 #else
   new_path = new_path.Append(profile_name);
@@ skipping 25 matching lines @@
 // static
 base::FilePath ProfileManager::GetGuestProfilePath() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   base::FilePath guest_path = profile_manager->user_data_dir();
   return guest_path.Append(chrome::kGuestProfileDir);
 }
 
-// static
-void ProfileManager::RegisterPrefs(PrefRegistrySimple* registry) {
-  registry->RegisterStringPref(prefs::kProfileLastUsed, std::string());
-  registry->RegisterIntegerPref(prefs::kProfilesNumCreated, 1);
-  registry->RegisterListPref(prefs::kProfilesLastActive);
-}
-
 size_t ProfileManager::GetNumberOfProfiles() {
   return GetProfileInfoCache().GetNumberOfProfiles();
 }
 
 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;
@@ skipping 62 matching lines @@
     size_t profile_cache_index =
         cache.GetIndexOfProfileWithPath(profile->GetPath());
     // If the cache has an entry for this profile, use the cache data.
     if (profile_cache_index != std::string::npos) {
       avatar_index =
           cache.GetAvatarIconIndexOfProfileAtIndex(profile_cache_index);
       profile_name =
           UTF16ToUTF8(cache.GetNameOfProfileAtIndex(profile_cache_index));
       is_managed = cache.ProfileIsManagedAtIndex(profile_cache_index);
     } else if (profile->GetPath() ==
-               GetDefaultProfileDir(cache.GetUserDataDir())) {
+               profiles::GetDefaultProfileDir(cache.GetUserDataDir())) {
       avatar_index = 0;
       profile_name = l10n_util::GetStringUTF8(IDS_DEFAULT_PROFILE_NAME);
     } else {
       avatar_index = cache.ChooseAvatarIconIndexForNewProfile();
       profile_name = UTF16ToUTF8(cache.ChooseNameForNewProfile(avatar_index));
     }
   }
 
   if (!profile->GetPrefs()->HasPrefPath(prefs::kProfileAvatarIndex))
     profile->GetPrefs()->SetInteger(prefs::kProfileAvatarIndex, avatar_index);
@@ skipping 14 matching lines @@
        command_line.HasSwitch(chromeos::switches::kLoginProfile))) {
     go_off_the_record = true;
   }
 #endif
   return go_off_the_record;
 }
 
 void ProfileManager::ScheduleProfileForDeletion(
     const base::FilePath& profile_dir,
     const CreateCallback& callback) {
-  DCHECK(IsMultipleProfilesEnabled());
+  DCHECK(profiles::IsMultipleProfilesEnabled());
   PrefService* local_state = g_browser_process->local_state();
   ProfileInfoCache& cache = GetProfileInfoCache();
 
   if (profile_dir.BaseName().MaybeAsASCII() ==
       local_state->GetString(prefs::kProfileLastUsed)) {
     // Update the last used profile pref before closing browser windows. This
     // way the correct last used profile is set for any notification observers.
     base::FilePath last_non_managed_profile_path;
     for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
       base::FilePath cur_path = cache.GetPathOfProfileAtIndex(i);
@@ skipping 85 matching lines @@
         profile)) {
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(
           profile)->DisableForUser();
     }
   }
 
   QueueProfileDirectoryForDeletion(profile_dir);
   cache.DeleteProfileFromCache(profile_dir);
 }
 
-// static
-bool ProfileManager::IsMultipleProfilesEnabled() {
-#if defined(OS_ANDROID)
-  return false;
-#endif
-#if defined(OS_CHROMEOS)
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kMultiProfiles))
-    return false;
-#endif
-
-  return true;
-}
-
-// static
-bool ProfileManager::IsNewProfileManagementEnabled() {
-  return CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kNewProfileManagement);
-}
-
 void ProfileManager::AutoloadProfiles() {
   // If running in the background is disabled for the browser, do not autoload
   // any profiles.
   PrefService* local_state = g_browser_process->local_state();
   if (!local_state->HasPrefPath(prefs::kBackgroundModeEnabled) ||
       !local_state->GetBoolean(prefs::kBackgroundModeEnabled)) {
     return;
   }
 
   ProfileInfoCache& cache = GetProfileInfoCache();
@@ skipping 36 matching lines @@
 ProfileManager::ProfileInfo::ProfileInfo(
     Profile* profile,
     bool created)
     : profile(profile),
       created(created) {
 }
 
 ProfileManager::ProfileInfo::~ProfileInfo() {
   ProfileDestroyer::DestroyProfileWhenAppropriate(profile.release());
 }