Improve ephemeral profiles clean up code.

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"
@@ skipping 147 matching lines @@
 
 void QueueProfileDirectoryForDeletion(const base::FilePath& path) {
   ProfilesToDelete().push_back(path);
 }
 
 bool IsProfileMarkedForDeletion(const base::FilePath& profile_path) {
   return std::find(ProfilesToDelete().begin(), ProfilesToDelete().end(),
       profile_path) != ProfilesToDelete().end();
 }
 
+// Physically remove deleted profile directories from disk.
+void NukeProfileFromDisk(const base::FilePath& profile_path) {
+  // Delete both the profile directory and its corresponding cache.
+  base::FilePath cache_path;
+  chrome::GetUserCacheDirectory(profile_path, &cache_path);
+  base::DeleteFile(profile_path, true);
+  base::DeleteFile(cache_path, true);
+}
+
 #if defined(OS_CHROMEOS)
 void CheckCryptohomeIsMounted(chromeos::DBusMethodCallStatus call_status,
                               bool is_mounted) {
   if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS) {
     LOG(ERROR) << "IsMounted call failed.";
     return;
   }
   if (!is_mounted)
     LOG(ERROR) << "Cryptohome is not mounted.";
 }
@@ skipping 13 matching lines @@
     SessionServiceFactory::ShutdownForProfile(profiles[i]);
 }
 #endif
 
 // static
 void ProfileManager::NukeDeletedProfilesFromDisk() {
   for (std::vector<base::FilePath>::iterator it =
           ProfilesToDelete().begin();
        it != ProfilesToDelete().end();
        ++it) {
-    // Delete both the profile directory and its corresponding cache.
-    base::FilePath cache_path;
-    chrome::GetUserCacheDirectory(*it, &cache_path);
-    base::DeleteFile(*it, true);
-    base::DeleteFile(cache_path, true);
+    NukeProfileFromDisk(*it);
   }
   ProfilesToDelete().clear();
 }
 
 namespace {
 
 bool s_allow_get_default_profile = false;
 
 }  // namespace
 
@@ skipping 77 matching lines @@
       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());
+  registrar_.Add(
+      this,
+      chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
+      content::NotificationService::AllSources());
 
   if (ProfileShortcutManager::IsFeatureEnabled() && !user_data_dir_.empty())
     profile_shortcut_manager_.reset(ProfileShortcutManager::Create(
                                     this));
 }
 
 ProfileManager::~ProfileManager() {
 }
 
 base::FilePath ProfileManager::GetInitialProfileDir() {
@@ skipping 331 matching lines @@
       DCHECK(browser);
       Profile* profile = browser->profile();
       DCHECK(profile);
       if (!profile->IsOffTheRecord() && --browser_counts_[profile] == 0) {
         active_profiles_.erase(std::find(active_profiles_.begin(),
                                          active_profiles_.end(), profile));
         save_active_profiles = !closing_all_browsers_;
       }
       break;
     }
+    case chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED: {
+      save_active_profiles = !closing_all_browsers_;
+      break;
+    }
     default: {
       NOTREACHED();
       break;
     }
   }
 
   if (save_active_profiles) {
     PrefService* local_state = g_browser_process->local_state();
     DCHECK(local_state);
     ListPrefUpdate update(local_state, prefs::kProfilesLastActive);
@@ skipping 191 matching lines @@
   if (success) {
     DoFinalInit(profile, go_off_the_record);
     if (go_off_the_record)
       profile = profile->GetOffTheRecordProfile();
     info->created = true;
   } else {
     profile = NULL;
     profiles_info_.erase(iter);
   }
 
-  // If this was the guest profile, finish setting its incognito status.
-  if (profile->GetPath() == ProfileManager::GetGuestProfilePath())
-    SetGuestProfilePrefs(profile);
+  if (profile) {
+    // If this was the guest profile, finish setting its incognito status.
+    if (profile->GetPath() == ProfileManager::GetGuestProfilePath())
+      SetGuestProfilePrefs(profile);
 
-  // Invoke CREATED callback for incognito profiles.
-  if (profile && go_off_the_record)
-    RunCallbacks(callbacks, profile, Profile::CREATE_STATUS_CREATED);
+    // Invoke CREATED callback for incognito profiles.
+    if (go_off_the_record)
+      RunCallbacks(callbacks, profile, Profile::CREATE_STATUS_CREATED);
+  }
 
   // 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);
@@ skipping 95 matching lines @@
       prefs::kProfileAvatarIndex);
 
   std::string managed_user_id =
       profile->GetPrefs()->GetString(prefs::kManagedUserId);
 
   cache.AddProfileToCache(profile->GetPath(),
                           profile_name,
                           username,
                           icon_index,
                           managed_user_id);
+
+  if (profile->GetPrefs()->GetBoolean(prefs::kForceEphemeralProfiles)) {
+    cache.SetProfileIsEphemeralAtIndex(
+        cache.GetIndexOfProfileWithPath(profile->GetPath()), true);
+  }
 }
 
 void ProfileManager::InitProfileUserPrefs(Profile* profile) {
   ProfileInfoCache& cache = GetProfileInfoCache();
 
   if (profile->GetPath().DirName() != cache.GetUserDataDir())
     return;
 
   size_t avatar_index;
   std::string profile_name;
@@ skipping 112 matching lines @@
 #else
       // For OS_MACOSX the pref is updated in the callback to make sure that
       // it isn't used before the profile is actually loaded.
       local_state->SetString(prefs::kProfileLastUsed, last_non_managed_profile);
 #endif
     }
   }
   FinishDeletingProfile(profile_dir);
 }
 
+// static
+void ProfileManager::CleanUpStaleProfiles(
+    const std::vector<base::FilePath>& profile_paths) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  for (std::vector<base::FilePath>::const_iterator it = profile_paths.begin();
+       it != profile_paths.end(); ++it) {
+    NukeProfileFromDisk(*it);
+  }
+}
+
 void ProfileManager::OnNewActiveProfileLoaded(
     const base::FilePath& profile_to_delete_path,
     const base::FilePath& last_non_managed_profile_path,
     const CreateCallback& original_callback,
     Profile* loaded_profile,
     Profile::CreateStatus status) {
   DCHECK(status != Profile::CREATE_STATUS_LOCAL_FAIL &&
          status != Profile::CREATE_STATUS_REMOTE_FAIL);
 
   // Only run the code if the profile initialization has finished completely.
@@ skipping 83 matching lines @@
 ProfileManager::ProfileInfo::ProfileInfo(
     Profile* profile,
     bool created)
     : profile(profile),
       created(created) {
 }
 
 ProfileManager::ProfileInfo::~ProfileInfo() {
   ProfileDestroyer::DestroyProfileWhenAppropriate(profile.release());
 }