Switch from TestBrowserThread to TestBrowserThreadBundle in chrome.

chrome/browser/password_manager/native_backend_kwallet_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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/password_manager/native_backend_kwallet_x.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/autofill/core/common/password_form.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/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
 #include "dbus/message.h"
 #include "dbus/mock_bus.h"
 #include "dbus/mock_object_proxy.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using autofill::PasswordForm;
 using base::UTF8ToUTF16;
@@ skipping 239 matching lines @@
     const PasswordStoreChangeList* expected,
     const PasswordStoreChangeList* actual,
     bool result) {
   EXPECT_TRUE(result);
   CheckPasswordChanges(*expected, *actual);
 }
 
 class NativeBackendKWalletTest : public NativeBackendKWalletTestBase {
  protected:
   NativeBackendKWalletTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
-        db_thread_(BrowserThread::DB), klauncher_ret_(0),
-        klauncher_contacted_(false), kwallet_runnable_(true),
-        kwallet_running_(true), kwallet_enabled_(true),
-        desktop_env_(GetParam()) {
-  }
+      : test_browser_thread_bundle_(
+            content::TestBrowserThreadBundle::REAL_DB_THREAD),
+        klauncher_ret_(0),
+        klauncher_contacted_(false),
+        kwallet_runnable_(true),
+        kwallet_running_(true),
+        kwallet_enabled_(true),
+        desktop_env_(GetParam()) {}
 
   void SetUp() override;
-  void TearDown() override;
-
-  // Let the DB thread run to completion of all current tasks.
-  void RunDBThread() {
-    base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                              base::WaitableEvent::InitialState::NOT_SIGNALED);
-    BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
-                            base::BindOnce(ThreadDone, &event));
-    event.Wait();
-    // Some of the tests may post messages to the UI thread, but we don't need
-    // to run those until after the DB thread is finished. So run it here.
-    base::RunLoop().RunUntilIdle();
-  }
-  static void ThreadDone(base::WaitableEvent* event) {
-    event->Signal();
-  }
 
   // Utilities to help verify sets of expectations.
   typedef std::vector<
               std::pair<std::string,
                         std::vector<const PasswordForm*> > > ExpectationArray;
   void CheckPasswordForms(const std::string& folder,
                           const ExpectationArray& sorted_expected);
 
   enum RemoveBetweenMethod {
     CREATED,
     SYNCED,
   };
 
   // Tests RemoveLoginsCreatedBetween or RemoveLoginsSyncedBetween.
   void TestRemoveLoginsBetween(RemoveBetweenMethod date_to_test);
 
-  base::MessageLoopForUI message_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread db_thread_;
+  content::TestBrowserThreadBundle test_browser_thread_bundle_;
 
   scoped_refptr<dbus::MockBus> mock_session_bus_;
   scoped_refptr<dbus::MockObjectProxy> mock_klauncher_proxy_;
   scoped_refptr<dbus::MockObjectProxy> mock_kwallet_proxy_;
 
   int klauncher_ret_;
   std::string klauncher_error_;
   bool klauncher_contacted_;
 
   bool kwallet_runnable_;
@@ skipping 11 matching lines @@
 
  private:
   dbus::Response* KLauncherMethodCall(
       dbus::MethodCall* method_call, testing::Unused);
 
   dbus::Response* KWalletMethodCall(
       dbus::MethodCall* method_call, testing::Unused);
 };
 
 void NativeBackendKWalletTest::SetUp() {
-  ASSERT_TRUE(db_thread_.Start());
-
   dbus::Bus::Options options;
   options.bus_type = dbus::Bus::SESSION;
   mock_session_bus_ = new dbus::MockBus(options);
 
   mock_klauncher_proxy_ =
       new dbus::MockObjectProxy(mock_session_bus_.get(),
                                 "org.kde.klauncher",
                                 dbus::ObjectPath("/KLauncher"));
   EXPECT_CALL(*mock_klauncher_proxy_.get(), MockCallMethodAndBlock(_, _))
       .WillRepeatedly(
@@ skipping 29 matching lines @@
         *mock_session_bus_.get(),
         GetObjectProxy("org.kde.kwalletd",
                        dbus::ObjectPath("/modules/kwalletd")))
         .WillRepeatedly(Return(mock_kwallet_proxy_.get()));
   }
 
   EXPECT_CALL(*mock_session_bus_.get(), ShutdownAndBlock()).WillOnce(Return())
       .WillRepeatedly(Return());
 }
 
-void NativeBackendKWalletTest::TearDown() {
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
-  base::RunLoop().Run();
-  db_thread_.Stop();
-}
-
 void NativeBackendKWalletTest::TestRemoveLoginsBetween(
     RemoveBetweenMethod date_to_test) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   form_google_.date_synced = base::Time();
   form_isc_.date_synced = base::Time();
   form_google_.date_created = base::Time();
   form_isc_.date_created = base::Time();
   base::Time now = base::Time::Now();
@@ skipping 23 matching lines @@
       base::Time, base::Time, password_manager::PasswordStoreChangeList*) =
       date_to_test == CREATED
           ? &NativeBackendKWalletStub::RemoveLoginsCreatedBetween
           : &NativeBackendKWalletStub::RemoveLoginsSyncedBetween;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB,
       FROM_HERE,
       base::Bind(
           method, base::Unretained(&backend), base::Time(), next_day, &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_isc_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_isc_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 
   // 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));
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   CheckPasswordForms("Chrome Form Data (42)", ExpectationArray());
 }
 
 dbus::Response* NativeBackendKWalletTest::KLauncherMethodCall(
     dbus::MethodCall* method_call, testing::Unused) {
   EXPECT_EQ("org.kde.KLauncher", method_call->GetInterface());
   EXPECT_EQ("start_service_by_desktop_name", method_call->GetMember());
 
   klauncher_contacted_ = true;
@@ skipping 215 matching lines @@
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::AddLogin,
                  base::Unretained(&backend), form_google_),
       base::Bind(&CheckPasswordChanges,
                  PasswordStoreChangeList(1, PasswordStoreChange(
                      PasswordStoreChange::ADD, form_google_))));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_FALSE(wallet_.hasFolder("Chrome Form Data"));
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
 TEST_P(NativeBackendKWalletTest, BasicUpdateLogin) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   PasswordForm new_form_google(form_google_);
   new_form_google.times_used = 10;
   new_form_google.action = GURL("http://www.google.com/different/login");
 
   // Update login
   PasswordStoreChangeList changes;
   PasswordStoreChangeList expected_changes(
       1, PasswordStoreChange(PasswordStoreChange::UPDATE, new_form_google));
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::UpdateLogin,
                  base::Unretained(&backend),
                  new_form_google,
                  &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   ASSERT_EQ(1u, changes.size());
   EXPECT_EQ(PasswordStoreChange::UPDATE, changes.front().type());
   EXPECT_EQ(new_form_google, changes.front().form());
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&new_form_google);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
 TEST_P(NativeBackendKWalletTest, BasicListLogins) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                      base::Unretained(&backend), form_google_));
 
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
 
   EXPECT_FALSE(wallet_.hasFolder("Chrome Form Data"));
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
 TEST_P(NativeBackendKWalletTest, BasicRemoveLogin) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_FALSE(wallet_.hasFolder("Chrome Form Data"));
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 
   PasswordStoreChangeList changes;
   PasswordStoreChangeList expected_changes(
       1, PasswordStoreChange(PasswordStoreChange::REMOVE, form_google_));
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::RemoveLogin,
                  base::Unretained(&backend), form_google_, &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   expected.clear();
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
 TEST_P(NativeBackendKWalletTest, UpdateNonexistentLogin) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   // First add an unrelated login.
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 
   // Attempt to update a login that doesn't exist.
   PasswordStoreChangeList changes;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::UpdateLogin,
                  base::Unretained(&backend),
                  form_isc_,
                  &changes),
       base::Bind(&CheckPasswordChangesWithResult,
                  base::Owned(new PasswordStoreChangeList), &changes));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(PasswordStoreChangeList(), changes);
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
 TEST_P(NativeBackendKWalletTest, RemoveNonexistentLogin) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   // First add an unrelated login.
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_FALSE(wallet_.hasFolder("Chrome Form Data"));
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 
   // Attempt to remove a login that doesn't exist.
   PasswordStoreChangeList changes;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::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(&NativeBackendKWalletStub::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
 
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
 TEST_P(NativeBackendKWalletTest, AddDuplicateLogin) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
@@ skipping 16 matching lines @@
   changes.push_back(PasswordStoreChange(PasswordStoreChange::ADD,
                                         form_google_));
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::AddLogin,
                  base::Unretained(&backend), form_google_),
       base::Bind(&NativeBackendKWalletTest::CheckPasswordChanges,
                  changes));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_FALSE(wallet_.hasFolder("Chrome Form Data"));
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
@@ skipping 18 matching lines @@
                  PasswordStoreChangeList(1, PasswordStoreChange(
                      PasswordStoreChange::ADD, saved_android_form))));
 
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetLogins,
                  base::Unretained(&backend), observed_android_form, &form_list),
       base::Bind(&CheckTrue));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, form_list.size());
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&saved_android_form);
   ExpectationArray expected;
   expected.push_back(
       make_pair(std::string(saved_android_form.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
@@ skipping 15 matching lines @@
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWallet::AddLogin),
                      base::Unretained(&backend), form_isc_));
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWallet::AddLogin),
                      base::Unretained(&backend), form_google_));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   // Set the canonical forms to the updated value for the following comparison.
   form_google_.skip_zero_click = true;
   PasswordStoreChangeList expected_changes;
   expected_changes.push_back(
       PasswordStoreChange(PasswordStoreChange::UPDATE, form_google_));
 
   PasswordStoreChangeList changes;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(
           &NativeBackendKWallet::DisableAutoSignInForOrigins,
           base::Unretained(&backend),
           base::Bind(
               static_cast<bool (*)(const GURL&, const GURL&)>(operator==),
               form_google_.origin),
           &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   forms.clear();
   forms.push_back(&form_isc_);
   expected.push_back(make_pair(std::string(form_isc_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
@@ skipping 10 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWalletStub::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(&NativeBackendKWalletStub::AddLogin),
                      base::Unretained(&backend), form_google_));
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   // Read the raw value back. Change the |unique_string| to
   // |unique_string_replacement| so the forms become unique.
   TestKWallet::Blob value;
   ASSERT_TRUE(wallet_.readEntry("Chrome Form Data (42)",
                                 form_google_.signon_realm, &value));
   TestKWallet::Blob sample(reinterpret_cast<const uint8_t*>(unique_string));
   size_t position = value.find(sample);
   ASSERT_NE(TestKWallet::Blob::npos, position);
   value.replace(position, sample.length(),
                 reinterpret_cast<const uint8_t*>(unique_string_replacement));
   wallet_.writeEntry("Chrome Form Data (42)", form_google_.signon_realm, value);
 
   // Now test that GetAutofillableLogins returns only one form.
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(1u, form_list.size());
   EXPECT_EQ(form_google_, *form_list[0]);
 
   std::vector<const PasswordForm*> forms;
   forms.push_back(&form_google_);
   ExpectationArray expected;
   expected.push_back(make_pair(std::string(form_google_.signon_realm), forms));
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
@@ skipping 13 matching lines @@
       base::Bind(&CheckPasswordChanges,
                  PasswordStoreChangeList(1, PasswordStoreChange(
                       PasswordStoreChange::ADD, form_google_))));
 
   // Verify that nothing is in fact returned, because KWallet fails to respond.
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(&CheckGetAutofillableLoginsFails,
                      base::Unretained(&backend), &form_list));
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
   EXPECT_EQ(0u, form_list.size());
 }
 
 TEST_P(NativeBackendKWalletTest, GetAllLogins) {
   NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                      base::Unretained(&backend), form_google_));
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::BindOnce(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                      base::Unretained(&backend), form_isc_));
 
   std::vector<std::unique_ptr<PasswordForm>> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetAllLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
 
-  RunDBThread();
+  content::RunAllPendingInMessageLoop(BrowserThread::DB);
 
   EXPECT_EQ(2u, form_list.size());
   EXPECT_THAT(form_list,
               UnorderedElementsAre(Pointee(form_google_), Pointee(form_isc_)));
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         NativeBackendKWalletTest,
                         ::testing::Values(base::nix::DESKTOP_ENVIRONMENT_KDE4,
                                           base::nix::DESKTOP_ENVIRONMENT_KDE5));
@@ skipping 273 matching lines @@
   CheckVersion7Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion8Pickle) {
   CheckVersion8Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion9Pickle) {
   CheckVersion9Pickle();
 }