Forced ephemeral profile deletion on browser removal crash fix.

chrome/browser/profiles/profile_manager_unittest.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 <stddef.h>
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 160 matching lines @@
     ProfileAttributesStorage& storage =
         profile_manager->GetProfileAttributesStorage();
     size_t num_profiles = storage.GetNumberOfProfiles();
     base::FilePath path = temp_dir_.GetPath().AppendASCII(path_suffix);
     storage.AddProfile(path, profile_name, std::string(), base::string16(), 0,
                        std::string());
     EXPECT_EQ(num_profiles + 1u, storage.GetNumberOfProfiles());
     return profile_manager->GetProfile(path);
   }
 
+  // Helper function to set profile ephemeral at prefs and attributes storage.
+  void SetProfileEphemeral(Profile* profile) {
+    profile->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles, true);
+
+    // Update IsEphemeral in attributes storage, normally it happened via
+    // kForceEphemeralProfiles pref change event routed to
+    // ProfileImpl::UpdateIsEphemeralInStorage().
+    ProfileAttributesEntry* entry;
+    ProfileAttributesStorage& storage =
+        g_browser_process->profile_manager()->GetProfileAttributesStorage();
+    EXPECT_TRUE(
+        storage.GetProfileAttributesWithPath(profile->GetPath(), &entry));
+    entry->SetIsEphemeral(true);
+  }
+
 #if defined(OS_CHROMEOS)
   // Helper function to register an user with id |user_id| and create profile
   // with a correct path.
   void RegisterUser(const std::string& user_id) {
     chromeos::ProfileHelper* profile_helper = chromeos::ProfileHelper::Get();
     const std::string user_id_hash =
         profile_helper->GetUserIdHashByUserIdForTesting(user_id);
     user_manager::UserManager::Get()->UserLoggedIn(
         AccountId::FromUserEmail(user_id), user_id_hash, false);
     g_browser_process->profile_manager()->GetProfile(
@@ skipping 679 matching lines @@
 // There's no Browser object on Android and there's no multi-profiles on Chrome.
 TEST_F(ProfileManagerTest, EphemeralProfilesDontEndUpAsLastProfile) {
   base::FilePath dest_path = temp_dir_.GetPath();
   dest_path = dest_path.Append(FILE_PATH_LITERAL("Ephemeral Profile"));
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   TestingProfile* profile =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path));
   ASSERT_TRUE(profile);
-  profile->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles, true);
+  SetProfileEphemeral(profile);
 
   // Here the last used profile is still the "Default" profile.
   Profile* last_used_profile = profile_manager->GetLastUsedProfile();
   EXPECT_NE(profile, last_used_profile);
 
   // Create a browser for the profile.
   Browser::CreateParams profile_params(profile);
   std::unique_ptr<Browser> browser(
       chrome::CreateBrowserWithTestWindowForParams(&profile_params));
   last_used_profile = profile_manager->GetLastUsedProfile();
@@ skipping 19 matching lines @@
 
   // Successfully create the profiles.
   TestingProfile* normal_profile =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path1));
   ASSERT_TRUE(normal_profile);
 
   // Add one ephemeral profile which should not end up in this list.
   TestingProfile* ephemeral_profile1 =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path2));
   ASSERT_TRUE(ephemeral_profile1);
-  ephemeral_profile1->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles,
-                                             true);
+  SetProfileEphemeral(ephemeral_profile1);
 
   // Add second ephemeral profile but don't mark it as such yet.
   TestingProfile* ephemeral_profile2 =
       static_cast<TestingProfile*>(profile_manager->GetProfile(dest_path3));
   ASSERT_TRUE(ephemeral_profile2);
 
   // Create a browser for profile1.
   Browser::CreateParams profile1_params(normal_profile);
   std::unique_ptr<Browser> browser1(
       chrome::CreateBrowserWithTestWindowForParams(&profile1_params));
 
   // Create browsers for the ephemeral profile.
   Browser::CreateParams profile2_params(ephemeral_profile1);
   std::unique_ptr<Browser> browser2(
       chrome::CreateBrowserWithTestWindowForParams(&profile2_params));
 
   Browser::CreateParams profile3_params(ephemeral_profile2);
   std::unique_ptr<Browser> browser3(
       chrome::CreateBrowserWithTestWindowForParams(&profile3_params));
 
   std::vector<Profile*> last_opened_profiles =
       profile_manager->GetLastOpenedProfiles();
   ASSERT_EQ(2U, last_opened_profiles.size());
   EXPECT_EQ(normal_profile, last_opened_profiles[0]);
   EXPECT_EQ(ephemeral_profile2, last_opened_profiles[1]);
 
   // Mark the second profile ephemeral.
-  ephemeral_profile2->GetPrefs()->SetBoolean(prefs::kForceEphemeralProfiles,
-                                             true);
+  SetProfileEphemeral(ephemeral_profile2);
 
   // Simulate a shutdown.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_CLOSE_ALL_BROWSERS_REQUEST,
       content::NotificationService::AllSources(),
       content::NotificationService::NoDetails());
   browser1.reset();
   browser2.reset();
   browser3.reset();
 
@@ skipping 481 matching lines @@
                          dest_path2.BaseName().MaybeAsASCII());
   profile_manager->ScheduleProfileForDeletion(dest_path2,
                                               ProfileManager::CreateCallback());
   // Spin the message loop so that all the callbacks can finish running.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(dest_path3, profile_manager->GetLastUsedProfile()->GetPath());
   EXPECT_EQ(profile_name3, local_state->GetString(prefs::kProfileLastUsed));
 }
 #endif  // !defined(OS_MACOSX)