Reland r318288: Wait until a new profile has been created before deleting the active profile.

chrome/browser/profiles/profile_manager_browsertest.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
@@ skipping 22 matching lines @@
 #include "chromeos/chromeos_switches.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #endif
 
 namespace {
 
 const ProfileManager::CreateCallback kOnProfileSwitchDoNothing;
 
 // An observer that returns back to test code after a new profile is
 // initialized.
-void OnUnblockOnProfileCreation(Profile* profile,
+void OnUnblockOnProfileCreation(base::RunLoop* run_loop,
+                                Profile* profile,
                                 Profile::CreateStatus status) {
   if (status == Profile::CREATE_STATUS_INITIALIZED)
-    base::MessageLoop::current()->Quit();
+    run_loop->Quit();
 }
 
 void ProfileCreationComplete(Profile* profile, Profile::CreateStatus status) {
   ASSERT_NE(status, Profile::CREATE_STATUS_LOCAL_FAIL);
   ASSERT_NE(status, Profile::CREATE_STATUS_REMOTE_FAIL);
   // No browser should have been created for this profile yet.
   EXPECT_EQ(chrome::GetTotalBrowserCountForProfile(profile), 0U);
   EXPECT_EQ(chrome::GetTotalBrowserCount(), 1U);
   if (status == Profile::CREATE_STATUS_INITIALIZED)
     base::MessageLoop::current()->Quit();
@@ skipping 27 matching lines @@
   }
 
  private:
   std::string last_used_profile_name_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileRemovalObserver);
 };
 
 // The class serves to retrieve passwords from PasswordStore asynchronously. It
 // used by ProfileManagerBrowserTest.DeletePasswords on some platforms.
-class PasswordStoreConsumerVerifier :
-    public password_manager::PasswordStoreConsumer {
+class PasswordStoreConsumerVerifier
+    : public password_manager::PasswordStoreConsumer {
  public:
-  PasswordStoreConsumerVerifier() : called_(false) {}
-
   void OnGetPasswordStoreResults(
       ScopedVector<autofill::PasswordForm> results) override {
-    EXPECT_FALSE(called_);
-    called_ = true;
     password_entries_.swap(results);
+    run_loop_.Quit();
   }
 
-  bool IsCalled() const { return called_; }
+  void Wait() {
+    run_loop_.Run();
+  }
 
   const std::vector<autofill::PasswordForm*>& GetPasswords() const {
     return password_entries_.get();
   }
+
  private:
+  base::RunLoop run_loop_;
   ScopedVector<autofill::PasswordForm> password_entries_;
-  bool called_;
 };
 
 static base::FilePath GetFirstNonSigninProfile(const ProfileInfoCache& cache) {
 #if defined(OS_CHROMEOS)
   const base::FilePath signin_path =
       chromeos::ProfileHelper::GetSigninProfileDir();
   size_t i, profile_num = cache.GetNumberOfProfiles();
   for (i = 0; i != profile_num; ++i) {
     base::FilePath profile_path = cache.GetPathOfProfileAtIndex(i);
     if (profile_path != signin_path)
@@ skipping 29 matching lines @@
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
   ProfileRemovalObserver observer;
 
   // We should start out with 1 profile.
   ASSERT_EQ(cache.GetNumberOfProfiles(), 1U);
 
   // Delete singleton profile.
   base::FilePath singleton_profile_path = cache.GetPathOfProfileAtIndex(0);
   EXPECT_FALSE(singleton_profile_path.empty());
-  profile_manager->ScheduleProfileForDeletion(singleton_profile_path,
-                                              ProfileManager::CreateCallback());
+  base::RunLoop run_loop;
+  profile_manager->ScheduleProfileForDeletion(
+      singleton_profile_path,
+      base::Bind(&OnUnblockOnProfileCreation, &run_loop));
 
   // Spin things till profile is actually deleted.

[Mike Lerman, 2015/03/02 18:37:38]

Replace Spin with Wait

[Bernhard Bauer, 2015/03/02 21:06:45]

Done.

-  content::RunAllPendingInMessageLoop();
+  run_loop.Run();
 
   // Make sure a new profile was created automatically.
   EXPECT_EQ(cache.GetNumberOfProfiles(), 1U);
   base::FilePath new_profile_path = cache.GetPathOfProfileAtIndex(0);
-  EXPECT_NE(new_profile_path, singleton_profile_path);
+  EXPECT_NE(new_profile_path.value(), singleton_profile_path.value());
 
   // Make sure that last used profile preference is set correctly.
   Profile* last_used = ProfileManager::GetLastUsedProfile();
-  EXPECT_EQ(new_profile_path, last_used->GetPath());
+  EXPECT_EQ(new_profile_path.value(), last_used->GetPath().value());
 
   // Make sure the last used profile was set correctly before the notification
   // was sent.
   std::string last_used_profile_name =
       last_used->GetPath().BaseName().MaybeAsASCII();
   EXPECT_EQ(last_used_profile_name, observer.last_used_profile_name());
 }
 
 // Delete all profiles in a multi profile setup and make sure a new one is
 // created.
 // Crashes/CHECKs. See crbug.com/104851
 IN_PROC_BROWSER_TEST_F(ProfileManagerBrowserTest, DISABLED_DeleteAllProfiles) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 
   // Create an additional profile.
   base::FilePath new_path = profile_manager->GenerateNextProfileDirectoryPath();
-  profile_manager->CreateProfileAsync(new_path,
-                                      base::Bind(&OnUnblockOnProfileCreation),
-                                      base::string16(), base::string16(),
-                                      std::string());
+  base::RunLoop run_loop;
+  profile_manager->CreateProfileAsync(
+      new_path, base::Bind(&OnUnblockOnProfileCreation, &run_loop),
+      base::string16(), base::string16(), std::string());
 
   // Spin to allow profile creation to take place, loop is terminated
   // by OnUnblockOnProfileCreation when the profile is created.
-  content::RunMessageLoop();
+  run_loop.Run();
 
   ASSERT_EQ(cache.GetNumberOfProfiles(), 2U);
 
   // Delete all profiles.
   base::FilePath profile_path1 = cache.GetPathOfProfileAtIndex(0);
   base::FilePath profile_path2 = cache.GetPathOfProfileAtIndex(1);
   EXPECT_FALSE(profile_path1.empty());
   EXPECT_FALSE(profile_path2.empty());
   profile_manager->ScheduleProfileForDeletion(profile_path1,
                                               ProfileManager::CreateCallback());
@@ skipping 87 matching lines @@
   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
   size_t initial_profile_count = profile_manager->GetNumberOfProfiles();
   base::FilePath path_profile1 = GetFirstNonSigninProfile(cache);
 
   ASSERT_NE(0U, initial_profile_count);
   EXPECT_EQ(1U, chrome::GetTotalBrowserCount());
 
   // Create an additional profile.
   base::FilePath path_profile2 =
       profile_manager->GenerateNextProfileDirectoryPath();
-  profile_manager->CreateProfileAsync(path_profile2,
-                                      base::Bind(&OnUnblockOnProfileCreation),
-                                      base::string16(), base::string16(),
-                                      std::string());
+  base::RunLoop run_loop;
+  profile_manager->CreateProfileAsync(
+      path_profile2, base::Bind(&OnUnblockOnProfileCreation, &run_loop),
+      base::string16(), base::string16(), std::string());
 
   // Spin to allow profile creation to take place, loop is terminated

[Mike Lerman, 2015/03/02 18:37:38]

Replace "Spin" with "Wait", or somehow note that we're waiting for the callback
at the end of Profile Creation.

Both here and above, line 202.

[Bernhard Bauer, 2015/03/02 21:06:45]

Done. (I used "run the message loop", as "spin" is sometimes used to mean
spinning the message loop, and sometimes means busy-waiting ("spinlock"), and
likewise "wait" sometimes means blocking the thread, and sometimes means running
a message loop.)

   // by OnUnblockOnProfileCreation when the profile is created.
-  content::RunMessageLoop();
+  run_loop.Run();
 
   chrome::HostDesktopType desktop_type = chrome::GetActiveDesktop();
   BrowserList* browser_list = BrowserList::GetInstance(desktop_type);
   ASSERT_EQ(initial_profile_count + 1, cache.GetNumberOfProfiles());
   EXPECT_EQ(1U, browser_list->size());
 
   // Open a browser window for the first profile.
   profiles::SwitchToProfile(path_profile1, desktop_type, false,
                             kOnProfileSwitchDoNothing,
                             ProfileMetrics::SWITCH_PROFILE_ICON);
@@ skipping 111 matching lines @@
   form.blacklisted_by_user = false;
 
   scoped_refptr<password_manager::PasswordStore> password_store =
       PasswordStoreFactory::GetForProfile(
           profile, ServiceAccessType::EXPLICIT_ACCESS).get();
   ASSERT_TRUE(password_store.get());
 
   password_store->AddLogin(form);
   PasswordStoreConsumerVerifier verify_add;
   password_store->GetAutofillableLogins(&verify_add);
+  verify_add.Wait();
+  EXPECT_EQ(1u, verify_add.GetPasswords().size());
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  profile_manager->ScheduleProfileForDeletion(profile->GetPath(),
-                                              ProfileManager::CreateCallback());
-  content::RunAllPendingInMessageLoop();
+  base::RunLoop run_loop;
+  profile_manager->ScheduleProfileForDeletion(
+      profile->GetPath(), base::Bind(&OnUnblockOnProfileCreation, &run_loop));
+  run_loop.Run();
+
   PasswordStoreConsumerVerifier verify_delete;
   password_store->GetAutofillableLogins(&verify_delete);
-
-  // Run the password background thread.
-  base::RunLoop run_loop;
-  base::Closure task = base::Bind(
-      base::IgnoreResult(&content::BrowserThread::PostTask),
-      content::BrowserThread::UI,
-      FROM_HERE,
-      run_loop.QuitClosure());
-  EXPECT_TRUE(password_store->ScheduleTask(task));
-  run_loop.Run();
-
-  EXPECT_TRUE(verify_add.IsCalled());
-  EXPECT_EQ(1u, verify_add.GetPasswords().size());
-  EXPECT_TRUE(verify_delete.IsCalled());
+  verify_delete.Wait();
   EXPECT_EQ(0u, verify_delete.GetPasswords().size());
 }
 #endif  // !defined(OS_WIN) && !defined(OS_ANDROID) && !defined(OS_CHROMEOS)