Switch from TestBrowserThread to TestBrowserThreadBundle in chrome.

chrome/browser/password_manager/native_backend_gnome_x_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 <stdarg.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/password_manager/native_backend_gnome_x.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/core/browser/psl_matching_helper.h"
 #include "components/password_manager/core/common/password_manager_pref_names.h"
 #include "components/prefs/pref_service.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using autofill::PasswordForm;
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
 using content::BrowserThread;
 using password_manager::PasswordStore;
 using password_manager::PasswordStoreChange;
 using password_manager::PasswordStoreChangeList;
@@ skipping 314 matching lines @@
   enum UpdateType {  // Used in CheckPSLUpdate().
     UPDATE_BY_UPDATELOGIN,
     UPDATE_BY_ADDLOGIN,
   };
   enum RemoveBetweenMethod {  // Used in CheckRemoveLoginsBetween().
     CREATED,
     SYNCED,
   };
 
   NativeBackendGnomeTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
-        db_thread_(BrowserThread::DB) {
-  }
+      : test_browser_thread_bundle_(
+            content::TestBrowserThreadBundle::REAL_DB_THREAD) {}
 
   void SetUp() override {
-    ASSERT_TRUE(db_thread_.Start());
-
     ASSERT_TRUE(MockGnomeKeyringLoader::LoadMockGnomeKeyring());
 
     form_google_.origin = GURL("http://www.google.com/");
     form_google_.action = GURL("http://www.google.com/login");
     form_google_.username_element = UTF8ToUTF16("user");
     form_google_.username_value = UTF8ToUTF16("joeschmoe");
     form_google_.password_element = UTF8ToUTF16("pass");
     form_google_.password_value = UTF8ToUTF16("seekrit");
     form_google_.submit_element = UTF8ToUTF16("submit");
     form_google_.signon_realm = "http://www.google.com/";
@@ skipping 37 matching lines @@
     form_isc_.date_synced = base::Time::Now();
 
     other_auth_.origin = GURL("http://www.example.com/");
     other_auth_.username_value = UTF8ToUTF16("username");
     other_auth_.password_value = UTF8ToUTF16("pass");
     other_auth_.signon_realm = "http://www.example.com/Realm";
     other_auth_.date_created = base::Time::Now();
     other_auth_.date_synced = base::Time::Now();
   }
 
-  void TearDown() override {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
-    base::RunLoop().Run();
-    db_thread_.Stop();
-  }
-
-  void RunBothThreads() {
-    // First we post a message to the DB thread that will run after all other
-    // messages that have been posted to the DB thread (we don't expect more
-    // to be posted), which posts a message to the UI thread to quit the loop.
-    // That way we can run both loops and be sure that the UI thread loop will
-    // quit so we can get on with the rest of the test.
-    BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
-                            base::BindOnce(&PostQuitTask, &message_loop_));
-    base::RunLoop().Run();
-  }
-
-  static void PostQuitTask(base::MessageLoop* loop) {
-    loop->task_runner()->PostTask(FROM_HERE,
-                                  base::MessageLoop::QuitWhenIdleClosure());
-  }
-
   void CheckUint32Attribute(const MockKeyringItem* item,
                             const std::string& attribute,
                             uint32_t value) {
     MockKeyringItem::attribute_map::const_iterator it =
         item->attributes.find(attribute);
     EXPECT_NE(item->attributes.end(), it);
     if (it != item->attributes.end()) {
       EXPECT_EQ(MockKeyringItem::ItemAttribute::UINT32, it->second.type);
       EXPECT_EQ(value, it->second.value_uint32);
     }
@@ skipping 82 matching lines @@
     std::vector<std::unique_ptr<PasswordForm>> form_list;
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::DB,
         FROM_HERE,
         base::Bind(&NativeBackendGnome::GetLogins,
                    base::Unretained(&backend),
                    target_form,
                    &form_list),
         base::Bind(&CheckTrue));
 
-    RunBothThreads();
+    content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
     EXPECT_EQ(1u, mock_keyring_items.size());
     if (mock_keyring_items.size() > 0)
       CheckMockKeyringItem(&mock_keyring_items[0], credentials, "chrome-321");
     mock_keyring_items.clear();
 
     if (form_list.empty())
       return false;
     EXPECT_EQ(1u, form_list.size());
     if (result)
@@ skipping 27 matching lines @@
         PasswordForm::SCHEME_HTML, kMobileURL.spec(), kMobileURL};
     std::vector<std::unique_ptr<PasswordForm>> form_list;
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::DB,
         FROM_HERE,
         base::Bind(&NativeBackendGnome::GetLogins,
                    base::Unretained(&backend),
                    m_facebook_lookup,
                    &form_list),
         base::Bind(&CheckTrue));
-    RunBothThreads();
+    content::RunAllPendingInMessageLoop(BrowserThread::DB);
     EXPECT_EQ(1u, mock_keyring_items.size());
     EXPECT_EQ(1u, form_list.size());
     PasswordForm m_facebook = *form_list[0];
     form_list.clear();
     m_facebook.origin = kMobileURL;
     m_facebook.signon_realm = kMobileURL.spec();
 
     // Add the PSL-matched copy to saved logins.
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                        base::Unretained(&backend), m_facebook));
-    RunBothThreads();
+    content::RunAllPendingInMessageLoop(BrowserThread::DB);
     EXPECT_EQ(2u, mock_keyring_items.size());
 
     // Update www.facebook.com login.
     PasswordForm new_facebook(form_facebook_);
     const base::string16 kOldPassword(form_facebook_.password_value);
     const base::string16 kNewPassword(UTF8ToUTF16("new_b"));
     EXPECT_NE(kOldPassword, kNewPassword);
     new_facebook.password_value = kNewPassword;
     PasswordStoreChangeList changes;
     PasswordStoreChangeList expected_changes;
@@ skipping 19 matching lines @@
         BrowserThread::PostTaskAndReplyWithResult(
             BrowserThread::DB,
             FROM_HERE,
             base::Bind(&NativeBackendGnome::AddLogin,
                        base::Unretained(&backend),
                        new_facebook),
             base::Bind(&CheckPasswordChanges, expected_changes));
         break;
     }
 
-    RunBothThreads();
+    content::RunAllPendingInMessageLoop(BrowserThread::DB);
     EXPECT_EQ(2u, mock_keyring_items.size());
 
     // Check that m.facebook.com login was not modified by the update.
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::DB,
         FROM_HERE,
         base::Bind(&NativeBackendGnome::GetLogins,
                    base::Unretained(&backend),
                    m_facebook_lookup,
                    &form_list),
         base::Bind(&CheckTrue));
-    RunBothThreads();
+    content::RunAllPendingInMessageLoop(BrowserThread::DB);
     // There should be two results -- the exact one, and the PSL-matched one.
     EXPECT_EQ(2u, form_list.size());
     size_t index_non_psl = 0;
     if (form_list[index_non_psl]->is_public_suffix_match)
       index_non_psl = 1;
     EXPECT_EQ(kMobileURL, form_list[index_non_psl]->origin);
     EXPECT_EQ(kMobileURL.spec(), form_list[index_non_psl]->signon_realm);
     EXPECT_EQ(kOldPassword, form_list[index_non_psl]->password_value);
     form_list.clear();
 
     // Check that www.facebook.com login was modified by the update.
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&NativeBackendGnome::GetLogins, base::Unretained(&backend),
                    PasswordStore::FormDigest(form_facebook_), &form_list),
         base::Bind(&CheckTrue));
-    RunBothThreads();
+    content::RunAllPendingInMessageLoop(BrowserThread::DB);
     // There should be two results -- the exact one, and the PSL-matched one.
     EXPECT_EQ(2u, form_list.size());
     index_non_psl = 0;
     if (form_list[index_non_psl]->is_public_suffix_match)
       index_non_psl = 1;
     EXPECT_EQ(form_facebook_.origin, form_list[index_non_psl]->origin);
     EXPECT_EQ(form_facebook_.signon_realm,
               form_list[index_non_psl]->signon_realm);
     EXPECT_EQ(kNewPassword, form_list[index_non_psl]->password_value);
   }
@@ skipping 55 matching lines @@
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::DB,
         FROM_HERE,
         base::Bind(method,
                    base::Unretained(&backend),
                    base::Time(),
                    next_day,
                    &changes),
         base::Bind(
             &CheckPasswordChangesWithResult, &expected_changes, &changes));
-    RunBothThreads();
+    content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
     EXPECT_EQ(1u, mock_keyring_items.size());
     if (mock_keyring_items.size() > 0)
       CheckMockKeyringItem(&mock_keyring_items[0], form_isc_, "chrome-42");
 
     // Remove form_isc_.
     expected_changes.clear();
     expected_changes.push_back(
         PasswordStoreChange(PasswordStoreChange::REMOVE, form_isc_));
     BrowserThread::PostTaskAndReplyWithResult(
         BrowserThread::DB,
         FROM_HERE,
         base::Bind(method,
                    base::Unretained(&backend),
                    next_day,
                    base::Time(),
                    &changes),
         base::Bind(
             &CheckPasswordChangesWithResult, &expected_changes, &changes));
-    RunBothThreads();
+    content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
     EXPECT_EQ(0u, mock_keyring_items.size());
   }
 
-  base::MessageLoopForUI message_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread db_thread_;
+  content::TestBrowserThreadBundle test_browser_thread_bundle_;
 
   // Provide some test forms to avoid having to set them up in each test.
   PasswordForm form_google_;
   PasswordForm form_facebook_;
   PasswordForm form_isc_;
   PasswordForm other_auth_;
 };
 
 TEST_F(NativeBackendGnomeTest, BasicAddLogin) {
   NativeBackendGnome backend(42);
   backend.Init();
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::AddLogin,
                  base::Unretained(&backend), form_google_),
       base::Bind(&CheckPasswordChanges,
                  PasswordStoreChangeList(1, PasswordStoreChange(
                      PasswordStoreChange::ADD, form_google_))));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 }
 
 TEST_F(NativeBackendGnomeTest, BasicListLogins) {
   NativeBackendGnome backend(42);
   backend.Init();
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
 
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 }
 
 // Save a password for www.facebook.com and see it suggested for m.facebook.com.
@@ skipping 86 matching lines @@
 TEST_F(NativeBackendGnomeTest, BasicUpdateLogin) {
   NativeBackendGnome backend(42);
   backend.Init();
 
   // First add google login.
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   PasswordForm new_form_google(form_google_);
   new_form_google.times_used = 1;
   new_form_google.action = GURL("http://www.google.com/different/login");
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 
   // Update login
   PasswordStoreChangeList changes;
   PasswordStoreChangeList expected_changes(
       1, PasswordStoreChange(PasswordStoreChange::UPDATE, new_form_google));
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::UpdateLogin,
                  base::Unretained(&backend),
                  new_form_google,
                  &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], new_form_google, "chrome-42");
 }
 
 TEST_F(NativeBackendGnomeTest, BasicRemoveLogin) {
   NativeBackendGnome backend(42);
   backend.Init();
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 
   PasswordStoreChangeList changes;
   PasswordStoreChangeList expected_changes(
       1, PasswordStoreChange(PasswordStoreChange::REMOVE, form_google_));
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::RemoveLogin,
                  base::Unretained(&backend), form_google_, &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(0u, mock_keyring_items.size());
 }
 
 // Verify fix for http://crbug.com/408783.
 TEST_F(NativeBackendGnomeTest, RemoveLoginActionMismatch) {
   NativeBackendGnome backend(42);
   backend.Init();
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 
   // Action url match not required for removal.
   form_google_.action = GURL("https://some.other.url.com/path");
 
   PasswordStoreChangeList changes;
   PasswordStoreChangeList expected_changes(
       1, PasswordStoreChange(PasswordStoreChange::REMOVE, form_google_));
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::RemoveLogin,
                  base::Unretained(&backend), form_google_, &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(0u, mock_keyring_items.size());
 }
 
 TEST_F(NativeBackendGnomeTest, RemoveNonexistentLogin) {
   NativeBackendGnome backend(42);
   backend.Init();
 
   // First add an unrelated login.
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 
   // Attempt to remove a login that doesn't exist.
   PasswordStoreChangeList changes;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::RemoveLogin,
                  base::Unretained(&backend), form_isc_, &changes),
       base::Bind(&CheckPasswordChangesWithResult,
                  base::Owned(new PasswordStoreChangeList), &changes));
 
   // Make sure we can still get the first form back.
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 }
 
 TEST_F(NativeBackendGnomeTest, UpdateNonexistentLogin) {
   NativeBackendGnome backend(42);
   backend.Init();
 
   // First add an unrelated login.
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 
   // Attempt to update a login that doesn't exist.
   PasswordStoreChangeList changes;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::UpdateLogin,
                  base::Unretained(&backend),
                  form_isc_,
                  &changes),
       base::Bind(&CheckPasswordChangesWithResult,
                  base::Owned(new PasswordStoreChangeList), &changes));
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 }
 
 TEST_F(NativeBackendGnomeTest, UpdateSameLogin) {
   NativeBackendGnome backend(42);
   backend.Init();
 
   // First add an unrelated login.
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 
   // Attempt to update the same login without changing anything.
   PasswordStoreChangeList changes;
   PasswordStoreChangeList expected_changes;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::UpdateLogin,
                  base::Unretained(&backend),
                  form_google_,
                  &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 }
 
 TEST_F(NativeBackendGnomeTest, AddDuplicateLogin) {
   NativeBackendGnome backend(42);
   backend.Init();
 
@@ skipping 13 matching lines @@
   form_google_.submit_element = UTF8ToUTF16("submit2");
   changes.push_back(PasswordStoreChange(PasswordStoreChange::ADD,
                                         form_google_));
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::AddLogin,
                  base::Unretained(&backend), form_google_),
       base::Bind(&CheckPasswordChanges, changes));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 }
 
 TEST_F(NativeBackendGnomeTest, AndroidCredentials) {
   NativeBackendGnome backend(42);
   backend.Init();
 
@@ skipping 15 matching lines @@
                      PasswordStoreChange::ADD, saved_android_form))));
 
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::GetLogins,
                  base::Unretained(&backend), observed_android_form,
                  &form_list),
       base::Bind(&CheckTrue));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, form_list.size());
   EXPECT_EQ(saved_android_form, *form_list[0]);
 }
 
 TEST_F(NativeBackendGnomeTest, RemoveLoginsCreatedBetween) {
   CheckRemoveLoginsBetween(CREATED);
 }
 
 TEST_F(NativeBackendGnomeTest, RemoveLoginsSyncedBetween) {
   CheckRemoveLoginsBetween(SYNCED);
 }
 
 TEST_F(NativeBackendGnomeTest, DisableAutoSignInForOrigins) {
   NativeBackendGnome backend(42);
   backend.Init();
   form_google_.skip_zero_click = false;
   form_facebook_.skip_zero_click = false;
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_facebook_));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(2u, mock_keyring_items.size());
   for (const auto& item : mock_keyring_items)
     CheckUint32Attribute(&item, "should_skip_zero_click", 0);
 
   // Set the canonical forms to the updated value for the following comparison.
   form_google_.skip_zero_click = true;
   form_facebook_.skip_zero_click = true;
   PasswordStoreChangeList expected_changes;
   expected_changes.push_back(
       PasswordStoreChange(PasswordStoreChange::UPDATE, form_facebook_));
 
   PasswordStoreChangeList changes;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(
           &NativeBackendGnome::DisableAutoSignInForOrigins,
           base::Unretained(&backend),
           base::Bind(
               static_cast<bool (*)(const GURL&, const GURL&)>(operator==),
               form_facebook_.origin),
           &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(2u, mock_keyring_items.size());
   CheckStringAttribute(
       &mock_keyring_items[0], "origin_url", form_google_.origin.spec());
   CheckUint32Attribute(&mock_keyring_items[0], "should_skip_zero_click", 0);
   CheckStringAttribute(
       &mock_keyring_items[1], "origin_url", form_facebook_.origin.spec());
   CheckUint32Attribute(&mock_keyring_items[1], "should_skip_zero_click", 1);
 }
 
 TEST_F(NativeBackendGnomeTest, ReadDuplicateForms) {
   NativeBackendGnome backend(42);
   backend.Init();
 
   // Add 2 slightly different password forms.
   const char unique_string[] = "unique_unique_string";
   const char unique_string_replacement[] = "uniKue_unique_string";
   form_google_.origin =
       GURL(std::string("http://www.google.com/") + unique_string);
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
   form_google_.origin =
       GURL(std::string("http://www.google.com/") + unique_string_replacement);
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_google_));
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   // Read the raw value back. Change the |unique_string| to
   // |unique_string_replacement| so the forms become unique.
   ASSERT_EQ(2u, mock_keyring_items.size());
   MockKeyringItem::attribute_map::iterator it =
       mock_keyring_items[0].attributes.find("origin_url");
   ASSERT_NE(mock_keyring_items[0].attributes.end(), it);
   size_t position = it->second.value_string.find(unique_string);
   ASSERT_NE(std::string::npos, position) << it->second.value_string;
   it->second.value_string.replace(
       position, std::string(unique_string_replacement).length(),
       unique_string_replacement);
 
   // Now test that GetAutofillableLogins returns only one form.
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, form_list.size());
   EXPECT_EQ(form_google_, *form_list[0]);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 }
 
 TEST_F(NativeBackendGnomeTest, GetAllLogins) {
@@ skipping 10 matching lines @@
       base::BindOnce(base::IgnoreResult(&NativeBackendGnome::AddLogin),
                      base::Unretained(&backend), form_facebook_));
 
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendGnome::GetAllLogins, base::Unretained(&backend),
                  &form_list),
       base::Bind(&CheckTrue));
 
-  RunBothThreads();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(2u, form_list.size());
   EXPECT_THAT(form_list, UnorderedElementsAre(Pointee(form_google_),
                                               Pointee(form_facebook_)));
 }
 
 // TODO(mdm): add more basic tests here at some point.