Remove MessageLoop::current()->RunUntilIdle() in components.

components/password_manager/core/browser/password_store_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.
 
 // The passwords in the tests below are all empty because PasswordStoreDefault
 // does not store the actual passwords on OS X (they are stored in the Keychain
 // instead). We could special-case it, but it is easier to just have empty
 // passwords. This will not be needed anymore if crbug.com/466638 is fixed.
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/password_manager/core/browser/affiliated_match_helper.h"
 #include "components/password_manager/core/browser/affiliation_service.h"
 #include "components/password_manager/core/browser/mock_affiliated_match_helper.h"
@@ skipping 140 matching lines @@
       L"",
       true, false, cutoff - 1 },
   };
 
   // Build the forms vector and add the forms to the store.
   ScopedVector<PasswordForm> all_forms;
   for (size_t i = 0; i < arraysize(form_data); ++i) {
     all_forms.push_back(CreatePasswordFormFromDataForTesting(form_data[i]));
     store->AddLogin(*all_forms.back());
   }
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // We expect to get back only the "recent" www.google.com login.
   // Theoretically these should never actually exist since there are no longer
   // any login forms on www.google.com to save, but we technically allow them.
   // We should not get back the older saved password though.
   PasswordForm www_google;
   www_google.scheme = PasswordForm::SCHEME_HTML;
   www_google.signon_realm = "https://www.google.com";
   std::vector<PasswordForm*> www_google_expected;
   www_google_expected.push_back(all_forms[2]);
@@ skipping 25 matching lines @@
       .RetiresOnSaturation();
   EXPECT_CALL(consumer,
               OnGetPasswordStoreResultsConstRef(
                   UnorderedPasswordFormElementsAre(bar_example_expected)))
       .RetiresOnSaturation();
 
   store->GetLogins(www_google, &consumer);
   store->GetLogins(accounts_google, &consumer);
   store->GetLogins(bar_example, &consumer);
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   store->ShutdownOnUIThread();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PasswordStoreTest, StartSyncFlare) {
   scoped_refptr<PasswordStoreDefault> store(new PasswordStoreDefault(
       base::ThreadTaskRunnerHandle::Get(), base::ThreadTaskRunnerHandle::Get(),
       base::WrapUnique(new LoginDatabase(test_login_db_file_path()))));
   StartSyncFlareMock mock;
   store->Init(
       base::Bind(&StartSyncFlareMock::StartSyncFlare, base::Unretained(&mock)));
   {
     PasswordForm form;
     form.origin = GURL("http://accounts.google.com/LoginAuth");
     form.signon_realm = "http://accounts.google.com/";
     EXPECT_CALL(mock, StartSyncFlare(syncer::PASSWORDS));
     store->AddLogin(form);
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
   store->ShutdownOnUIThread();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PasswordStoreTest, GetLoginImpl) {
   /* clang-format off */
   static const PasswordFormData kTestCredential = {
       PasswordForm::SCHEME_HTML,
       kTestWebRealm1,
       kTestWebOrigin1,
       "", L"", L"username_element",  L"password_element",
       L"username_value",
@@ skipping 24 matching lines @@
   std::unique_ptr<PasswordForm> mismatching_form_5(
       new PasswordForm(*test_form));
   mismatching_form_5->username_value =
       base::ASCIIToUTF16("other_username_value");
 
   store->AddLogin(*mismatching_form_1);
   store->AddLogin(*mismatching_form_2);
   store->AddLogin(*mismatching_form_3);
   store->AddLogin(*mismatching_form_4);
   store->AddLogin(*mismatching_form_5);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(store->GetLoginImpl(*test_form));
 
   store->AddLogin(*test_form);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   std::unique_ptr<PasswordForm> returned_form = store->GetLoginImpl(*test_form);
   ASSERT_TRUE(returned_form);
   EXPECT_EQ(*test_form, *returned_form);
 
   store->ShutdownOnUIThread();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(PasswordStoreTest, UpdateLoginPrimaryKeyFields) {
   /* clang-format off */
   static const PasswordFormData kTestCredentials[] = {
       // The old credential.
       {PasswordForm::SCHEME_HTML,
        kTestWebRealm1,
        kTestWebOrigin1,
        "", L"", L"username_element_1",  L"password_element_1",
        L"username_value_1",
        L"", true, true, 1},
       // The new credential with different values for all primary key fields.
       {PasswordForm::SCHEME_HTML,
        kTestWebRealm2,
        kTestWebOrigin2,
        "", L"", L"username_element_2",  L"password_element_2",
        L"username_value_2",
        L"", true, true, 1}};
   /* clang-format on */
 
   scoped_refptr<PasswordStoreDefault> store(new PasswordStoreDefault(
       base::ThreadTaskRunnerHandle::Get(), base::ThreadTaskRunnerHandle::Get(),
       base::WrapUnique(new LoginDatabase(test_login_db_file_path()))));
   store->Init(syncer::SyncableService::StartSyncFlare());
 
   std::unique_ptr<PasswordForm> old_form(
       CreatePasswordFormFromDataForTesting(kTestCredentials[0]));
   store->AddLogin(*old_form);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   MockPasswordStoreObserver mock_observer;
   store->AddObserver(&mock_observer);
 
   std::unique_ptr<PasswordForm> new_form(
       CreatePasswordFormFromDataForTesting(kTestCredentials[1]));
   EXPECT_CALL(mock_observer, OnLoginsChanged(testing::SizeIs(2u)));
   PasswordForm old_primary_key;
   old_primary_key.signon_realm = old_form->signon_realm;
   old_primary_key.origin = old_form->origin;
   old_primary_key.username_element = old_form->username_element;
   old_primary_key.username_value = old_form->username_value;
   old_primary_key.password_element = old_form->password_element;
   store->UpdateLoginWithPrimaryKey(*new_form, old_primary_key);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   MockPasswordStoreConsumer mock_consumer;
   ScopedVector<autofill::PasswordForm> expected_forms;
   expected_forms.push_back(std::move(new_form));
   EXPECT_CALL(mock_consumer,
               OnGetPasswordStoreResultsConstRef(
                   UnorderedPasswordFormElementsAre(expected_forms.get())));
   store->GetAutofillableLogins(&mock_consumer);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   store->RemoveObserver(&mock_observer);
   store->ShutdownOnUIThread();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // Verify that RemoveLoginsCreatedBetween() fires the completion callback after
 // deletions have been performed and notifications have been sent out. Whether
 // the correct logins are removed or not is verified in detail in other tests.
 TEST_F(PasswordStoreTest, RemoveLoginsCreatedBetweenCallbackIsCalled) {
   /* clang-format off */
   static const PasswordFormData kTestCredential =
       {PasswordForm::SCHEME_HTML,
        kTestWebRealm1,
        kTestWebOrigin1,
        "", L"", L"username_element_1",  L"password_element_1",
        L"username_value_1",
        L"", true, true, 1};
   /* clang-format on */
 
   scoped_refptr<PasswordStoreDefault> store(new PasswordStoreDefault(
       base::ThreadTaskRunnerHandle::Get(), base::ThreadTaskRunnerHandle::Get(),
       base::WrapUnique(new LoginDatabase(test_login_db_file_path()))));
   store->Init(syncer::SyncableService::StartSyncFlare());
 
   std::unique_ptr<PasswordForm> test_form(
       CreatePasswordFormFromDataForTesting(kTestCredential));
   store->AddLogin(*test_form);
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   MockPasswordStoreObserver mock_observer;
   store->AddObserver(&mock_observer);
 
   EXPECT_CALL(mock_observer, OnLoginsChanged(testing::SizeIs(1u)));
   store->RemoveLoginsCreatedBetween(
       base::Time::FromDoubleT(0), base::Time::FromDoubleT(2),
       base::MessageLoop::current()->QuitWhenIdleClosure());
   base::MessageLoop::current()->Run();
   testing::Mock::VerifyAndClearExpectations(&mock_observer);
 
   store->RemoveObserver(&mock_observer);
   store->ShutdownOnUIThread();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // When no Android applications are actually affiliated with the realm of the
 // observed form, GetLoginsWithAffiliations() should still return the exact and
 // PSL matching results, but not any stored Android credentials.
 TEST_F(PasswordStoreTest, GetLoginsWithoutAffiliations) {
   /* clang-format off */
   static const PasswordFormData kTestCredentials[] = {
       // Credential that is an exact match of the observed form.
       {PasswordForm::SCHEME_HTML,
@@ skipping 23 matching lines @@
   store->Init(syncer::SyncableService::StartSyncFlare());
 
   MockAffiliatedMatchHelper* mock_helper = new MockAffiliatedMatchHelper;
   store->SetAffiliatedMatchHelper(base::WrapUnique(mock_helper));
 
   ScopedVector<PasswordForm> all_credentials;
   for (size_t i = 0; i < arraysize(kTestCredentials); ++i) {
     all_credentials.push_back(
         CreatePasswordFormFromDataForTesting(kTestCredentials[i]));
     store->AddLogin(*all_credentials.back());
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   PasswordForm observed_form;
   observed_form.scheme = PasswordForm::SCHEME_HTML;
   observed_form.origin = GURL(kTestWebOrigin1);
   observed_form.ssl_valid = true;
   observed_form.signon_realm = kTestWebRealm1;
 
   MockPasswordStoreConsumer mock_consumer;
   ScopedVector<PasswordForm> expected_results;
   expected_results.push_back(new PasswordForm(*all_credentials[0]));
   expected_results.push_back(new PasswordForm(*all_credentials[1]));
   for (PasswordForm* result : expected_results) {
     if (result->signon_realm != observed_form.signon_realm)
       result->is_public_suffix_match = true;
   }
 
   std::vector<std::string> no_affiliated_android_realms;
   mock_helper->ExpectCallToGetAffiliatedAndroidRealms(
       observed_form, no_affiliated_android_realms);
 
   EXPECT_CALL(mock_consumer,
               OnGetPasswordStoreResultsConstRef(
                   UnorderedPasswordFormElementsAre(expected_results.get())));
   store->GetLogins(observed_form, &mock_consumer);
   store->ShutdownOnUIThread();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // There are 3 Android applications affiliated with the realm of the observed
 // form, with the PasswordStore having credentials for two of these (even two
 // credentials for one). GetLoginsWithAffiliations() should return the exact,
 // and PSL matching credentials, and the credentials for these two Android
 // applications, but not for the unaffiliated Android application.
 TEST_F(PasswordStoreTest, GetLoginsWithAffiliations) {
   /* clang-format off */
   static const PasswordFormData kTestCredentials[] = {
@@ skipping 59 matching lines @@
   store->Init(syncer::SyncableService::StartSyncFlare());
 
   MockAffiliatedMatchHelper* mock_helper = new MockAffiliatedMatchHelper;
   store->SetAffiliatedMatchHelper(base::WrapUnique(mock_helper));
 
   ScopedVector<PasswordForm> all_credentials;
   for (size_t i = 0; i < arraysize(kTestCredentials); ++i) {
     all_credentials.push_back(
         CreatePasswordFormFromDataForTesting(kTestCredentials[i]));
     store->AddLogin(*all_credentials.back());
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 
   PasswordForm observed_form;
   observed_form.scheme = PasswordForm::SCHEME_HTML;
   observed_form.origin = GURL(kTestWebOrigin1);
   observed_form.ssl_valid = true;
   observed_form.signon_realm = kTestWebRealm1;
 
   MockPasswordStoreConsumer mock_consumer;
   ScopedVector<PasswordForm> expected_results;
@@ skipping 17 matching lines @@
   affiliated_android_realms.push_back(kTestAndroidRealm3);
   mock_helper->ExpectCallToGetAffiliatedAndroidRealms(
       observed_form, affiliated_android_realms);
 
   EXPECT_CALL(mock_consumer,
               OnGetPasswordStoreResultsConstRef(
                   UnorderedPasswordFormElementsAre(expected_results.get())));
 
   store->GetLogins(observed_form, &mock_consumer);
   store->ShutdownOnUIThread();
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 // This test must use passwords, which are not stored on Mac, therefore the test
 // is disabled on Mac. This should not be a huge issue as functionality in the
 // platform-independent base class is tested. See also the file-level comment.
 #if defined(OS_MACOSX)
 #define MAYBE_UpdatePasswordsStoredForAffiliatedWebsites \
   DISABLED_UpdatePasswordsStoredForAffiliatedWebsites
 #else
 #define MAYBE_UpdatePasswordsStoredForAffiliatedWebsites \
@@ skipping 131 matching lines @@
                                         base::Closure());
 
       // Set up the initial test data set.
       ScopedVector<PasswordForm> all_credentials;
       for (size_t i = 0; i < arraysize(kTestCredentials); ++i) {
         all_credentials.push_back(
             CreatePasswordFormFromDataForTesting(kTestCredentials[i]));
         all_credentials.back()->date_synced =
             all_credentials.back()->date_created;
         store->AddLogin(*all_credentials.back());
-        base::MessageLoop::current()->RunUntilIdle();
+        base::RunLoop().RunUntilIdle();
       }
 
       // The helper must be injected after the initial test data is set up,
       // otherwise it will already start propagating updates as new Android
       // credentials are added.
       MockAffiliatedMatchHelper* mock_helper = new MockAffiliatedMatchHelper;
       store->SetAffiliatedMatchHelper(base::WrapUnique(mock_helper));
       store->enable_propagating_password_changes_to_web_credentials(
           propagation_enabled);
 
@@ skipping 34 matching lines @@
       if (propagation_enabled) {
         EXPECT_CALL(mock_observer, OnLoginsChanged(testing::SizeIs(
                                        expected_number_of_propageted_updates)));
       }
       if (test_remove_and_add_login) {
         store->RemoveLoginSync(*all_credentials[0]);
         store->AddLoginSync(*expected_credentials_after_update[0]);
       } else {
         store->UpdateLoginSync(*expected_credentials_after_update[0]);
       }
-      base::MessageLoop::current()->RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
       store->RemoveObserver(&mock_observer);
 
       MockPasswordStoreConsumer mock_consumer;
       EXPECT_CALL(
           mock_consumer,
           OnGetPasswordStoreResultsConstRef(UnorderedPasswordFormElementsAre(
               expected_credentials_after_update.get())));
       store->GetAutofillableLogins(&mock_consumer);
       store->ShutdownOnUIThread();
-      base::MessageLoop::current()->RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
     }
   }
 }
 
 TEST_F(PasswordStoreTest, GetLoginsWithAffiliatedRealms) {
   /* clang-format off */
   static const PasswordFormData kTestCredentials[] = {
       {PasswordForm::SCHEME_HTML,
        kTestAndroidRealm1,
        "", "", L"", L"", L"",
@@ skipping 22 matching lines @@
     store->RemoveLoginsCreatedBetween(base::Time(), base::Time::Max(),
                                       base::Closure());
 
     ScopedVector<PasswordForm> all_credentials;
     for (size_t i = 0; i < arraysize(kTestCredentials); ++i) {
       all_credentials.push_back(
           CreatePasswordFormFromDataForTesting(kTestCredentials[i]));
       if (blacklisted)
         all_credentials.back()->blacklisted_by_user = true;
       store->AddLogin(*all_credentials.back());
-      base::MessageLoop::current()->RunUntilIdle();
+      base::RunLoop().RunUntilIdle();
     }
 
     MockPasswordStoreConsumer mock_consumer;
     ScopedVector<PasswordForm> expected_results;
     for (size_t i = 0; i < arraysize(kTestCredentials); ++i)
       expected_results.push_back(new PasswordForm(*all_credentials[i]));
 
     MockAffiliatedMatchHelper* mock_helper = new MockAffiliatedMatchHelper;
     store->SetAffiliatedMatchHelper(base::WrapUnique(mock_helper));
 
     std::vector<std::string> affiliated_web_realms;
     affiliated_web_realms.push_back(kTestWebRealm1);
     affiliated_web_realms.push_back(kTestWebRealm2);
     affiliated_web_realms.push_back(std::string());
     mock_helper->ExpectCallToInjectAffiliatedWebRealms(affiliated_web_realms);
     for (size_t i = 0; i < expected_results.size(); ++i)
       expected_results[i]->affiliated_web_realm = affiliated_web_realms[i];
 
     EXPECT_CALL(mock_consumer,
                 OnGetPasswordStoreResultsConstRef(
                     UnorderedPasswordFormElementsAre(expected_results.get())));
     if (blacklisted)
       store->GetBlacklistLoginsWithAffiliatedRealms(&mock_consumer);
     else
       store->GetAutofillableLoginsWithAffiliatedRealms(&mock_consumer);
 
     // Since GetAutofillableLoginsWithAffiliatedRealms schedules a request for
     // affiliated realms to UI thread, don't shutdown UI thread until there are
     // no tasks in the UI queue.
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     store->ShutdownOnUIThread();
-    base::MessageLoop::current()->RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
   }
 }
 
 }  // namespace password_manager