Change kNotSignedInProfile to kInitialProfile to better reflect its usage.

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 111 matching lines @@
         BrowserThread::FILE, FROM_HERE,
         NewRunnableFunction(&DeleteProfileDirectories, profiles_to_delete_));
     profiles_to_delete_.clear();
   }
 }
 
 FilePath ProfileManager::GetDefaultProfileDir(
     const FilePath& user_data_dir) {
   FilePath default_profile_dir(user_data_dir);
   default_profile_dir =
-      default_profile_dir.AppendASCII(chrome::kNotSignedInProfile);
+      default_profile_dir.AppendASCII(chrome::kInitialProfile);
   return default_profile_dir;
 }
 
 FilePath ProfileManager::GetProfilePrefsPath(
     const FilePath &profile_dir) {
   FilePath default_prefs_path(profile_dir);
   default_prefs_path = default_prefs_path.Append(chrome::kPreferencesFilename);
   return default_prefs_path;
 }
 
-FilePath ProfileManager::GetCurrentProfileDir() {
+FilePath ProfileManager::GetInitialProfileDir() {
   FilePath relative_profile_dir;
 #if defined(OS_CHROMEOS)
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (logged_in_) {
     FilePath profile_dir;
     // If the user has logged in, pick up the new profile.
     if (command_line.HasSwitch(switches::kLoginProfile)) {
       profile_dir = command_line.GetSwitchValuePath(switches::kLoginProfile);
     } else {
       // We should never be logged in with no profile dir.
       NOTREACHED();
       return FilePath("");
     }
     relative_profile_dir = relative_profile_dir.Append(profile_dir);
     return relative_profile_dir;
   }
 #endif
   // TODO(mirandac): should not automatically be default profile.
   relative_profile_dir =
-      relative_profile_dir.AppendASCII(chrome::kNotSignedInProfile);
+      relative_profile_dir.AppendASCII(chrome::kInitialProfile);
   return relative_profile_dir;
 }
 
 Profile* ProfileManager::GetLastUsedProfile(const FilePath& user_data_dir) {
   FilePath last_used_profile_dir(user_data_dir);
   std::string last_profile_used;
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
 
   if (local_state->HasPrefPath(prefs::kProfileLastUsed))
     last_profile_used = local_state->GetString(prefs::kProfileLastUsed);
   last_used_profile_dir = last_profile_used.empty() ?
-      last_used_profile_dir.AppendASCII(chrome::kNotSignedInProfile) :
+      last_used_profile_dir.AppendASCII(chrome::kInitialProfile) :
       last_used_profile_dir.AppendASCII(last_profile_used);
   return GetProfile(last_used_profile_dir);
 }
 
 void ProfileManager::RegisterProfileName(Profile* profile) {
   std::string profile_name = profile->GetProfileName();
   std::string dir_base = profile->GetPath().BaseName().MaybeAsASCII();
   DictionaryPrefUpdate update(g_browser_process->local_state(),
                               prefs::kProfileDirectoryMap);
   DictionaryValue* path_map = update.Get();
   // We don't check for duplicates because we should be able to overwrite
   // path->name mappings here, if the user syncs a local account to a
   // different Google account.
   path_map->SetString(dir_base, profile_name);
 }
 
 Profile* ProfileManager::GetDefaultProfile(const FilePath& user_data_dir) {
   FilePath default_profile_dir(user_data_dir);
-  default_profile_dir = default_profile_dir.Append(GetCurrentProfileDir());
+  default_profile_dir = default_profile_dir.Append(GetInitialProfileDir());
 #if defined(OS_CHROMEOS)
   if (!logged_in_) {
     Profile* profile;
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
     // 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.
@@ skipping 80 matching lines @@
 // static
 void ProfileManager::CreateDefaultProfileAsync(
     ProfileManagerObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   FilePath default_profile_dir;
   PathService::Get(chrome::DIR_USER_DATA, &default_profile_dir);
   // TODO(mirandac): current directory will not always be default in the future
   default_profile_dir = default_profile_dir.Append(
-      profile_manager->GetCurrentProfileDir());
+      profile_manager->GetInitialProfileDir());
 
   profile_manager->CreateProfileAsync(default_profile_dir,
                                       observer);
 }
 
 bool ProfileManager::AddProfile(Profile* profile) {
   DCHECK(profile);
 
   // Make sure that we're not loading a profile with the same ID as a profile
   // that's already loaded.
@@ skipping 253 matching lines @@
   cache.DeleteProfileFromCache(profile_dir);
 }
 
 // static
 bool ProfileManager::IsMultipleProfilesEnabled() {
 #if defined(TOOLKIT_VIEWS) && !defined(OS_CHROMEOS)
   return true;
 #endif
   return CommandLine::ForCurrentProcess()->HasSwitch(switches::kMultiProfiles);
 }