Linux: split GNOME Keyring integration into a separate process.

chrome/browser/password_manager/native_backend_gnome_x_unittest.cc

 // Copyright (c) 2011 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 <sys/socket.h>
 
 #include "base/basictypes.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/password_manager/keyring_proxy/gnome_keyring_loader.h"
+#include "chrome/browser/password_manager/keyring_proxy/keyring_proxy.h"
+#include "chrome/browser/password_manager/keyring_proxy/keyring_proxy_client.h"
 #include "chrome/browser/password_manager/native_backend_gnome_x.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using webkit_glue::PasswordForm;
 
 namespace {
 
 // What follows is a very simple implementation of the subset of the GNOME
 // Keyring API that we actually use. It gets substituted for the real one by
 // MockGnomeKeyringLoader, which hooks into the facility normally used to load
 // the GNOME Keyring library at runtime to avoid a static dependency on it.
+// We also use some special glue code to link directly with the main keyring
+// proxy code and thus call into the mock implementation in this process,
+// rather than in a separate proxy process. (See below.)
 
 struct MockKeyringItem {
   MockKeyringItem() {}
   MockKeyringItem(const char* keyring,
                   const std::string& display_name,
                   const std::string& password)
     : keyring(keyring ? keyring : "login"),
       display_name(display_name),
       password(password) {}
 
@@ skipping 212 matching lines @@
   }
   g_list_free(results);
   return NULL;
 }
 
 const gchar* mock_gnome_keyring_result_to_message(GnomeKeyringResult res) {
   return "mock keyring simulating failure";
 }
 
 // Inherit to get access to protected fields.
-class MockGnomeKeyringLoader : public GnomeKeyringLoader {
+class MockGnomeKeyringLoader : public keyring_proxy::GnomeKeyringLoader {
  public:
   static bool LoadMockGnomeKeyring() {
 #define GNOME_KEYRING_ASSIGN_POINTER(name) \
   gnome_keyring_##name = &mock_gnome_keyring_##name;
     GNOME_KEYRING_FOR_EACH_FUNC(GNOME_KEYRING_ASSIGN_POINTER)
 #undef GNOME_KEYRING_ASSIGN_POINTER
     keyring_loaded = true;
     // Reset the state of the mock library.
     mock_keyring_items.clear();
     mock_keyring_reject_local_ids = false;
     return true;
   }
+
+  static void ResetGnomeKeyring() { keyring_loaded = false; }
+};
+
+// Now that we can inject a mock GNOME Keyring API, we need to glue the keyring
+// proxy client directly to the proxy code, which is linked into the unit test
+// directly. We do this by creating a socket and giving one end to each, but we
+// need some slightly adapted proxy and proxy client classes to make that work.
+
+class TestKeyringProxy : public keyring_proxy::KeyringProxy {
+ public:
+  explicit TestKeyringProxy(int fd) : KeyringProxy(fd, CreateOutput(fd)) {}
+  ~TestKeyringProxy() { fclose(output_); }
+
+ private:
+  // This is a bit of a hack. We need to do this before calling the constructor
+  // for KeyringProxy, since it needs a FILE*. So we have a member method that
+  // fills in output_ for us before the body of our constructor even runs.  It's
+  // safe since there's nothing virtual involved.
+  FILE* CreateOutput(int fd) {
+    int dup_fd = dup(fd);
+    CHECK_GE(dup_fd, 0);
+    output_ = fdopen(dup_fd, "r+");
+    CHECK(output_);
+    return output_;
+  }
+
+  FILE* output_;
+};
+
+class TestKeyringProxyClient : public keyring_proxy::KeyringProxyClient {
+ public:
+  using KeyringProxyClient::ConnectForTesting;
+};
+
+class TestNativeBackendGnome : public NativeBackendGnome {
+ public:
+  using NativeBackendGnome::InitForTesting;
 };
 
 }  // anonymous namespace
 
 class NativeBackendGnomeTest : public testing::Test {
  protected:
   NativeBackendGnomeTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
-        db_thread_(BrowserThread::DB) {
+        db_thread_(BrowserThread::DB),
+        file_thread_(BrowserThread::FILE) {
   }
 
   virtual void SetUp() {
     ASSERT_TRUE(db_thread_.Start());
+    ASSERT_TRUE(file_thread_.StartIOThread());
 
     MockGnomeKeyringLoader::LoadMockGnomeKeyring();
 
+    int fds[2];
+    ASSERT_TRUE(socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) >= 0);
+    // Give one side to the proxy itself, which is linked into the unit test.
+    // We won't call its Run() method, but its events will run from the UI
+    // thread's GMainContext automatically. Its Stop() method won't work.
+    proxy_.reset(new TestKeyringProxy(fds[0]));
+    // Save the other side for test proxy clients.
+    proxy_fd_ = fds[1];
+
     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 = "Google";
 
     form_isc_.origin = GURL("http://www.isc.org/");
     form_isc_.action = GURL("http://www.isc.org/auth");
     form_isc_.username_element = UTF8ToUTF16("id");
     form_isc_.username_value = UTF8ToUTF16("janedoe");
     form_isc_.password_element = UTF8ToUTF16("passwd");
     form_isc_.password_value = UTF8ToUTF16("ihazabukkit");
     form_isc_.submit_element = UTF8ToUTF16("login");
     form_isc_.signon_realm = "ISC";
   }
 
   virtual void TearDown() {
     MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask);
     MessageLoop::current()->Run();
+    // It is important to close this file descriptor only after finishing
+    // running the UI thread's message loop, or else it will get into an
+    // infinite loop due to the proxy's Stop() method not working with the
+    // way we've linked it directly with the unit test.
+    close(proxy_fd_);
+    file_thread_.Stop();
     db_thread_.Stop();
+    // Reset keyring_loaded to false in case other tests use it. We don't want
+    // them to use our mock library accidentally.
+    MockGnomeKeyringLoader::ResetGnomeKeyring();
   }
 
-  void RunBothThreads() {
+  void InitNativeBackend(NativeBackendGnome* backend) {
+    int fd = dup(proxy_fd_);
+    ASSERT_GE(fd, 0);
+    TestKeyringProxyClient* client = new TestKeyringProxyClient;
+    client->ConnectForTesting(fd, true);
+    // The cast is safe because all it does is change protection.
+    static_cast<TestNativeBackendGnome*>(backend)->InitForTesting(client);
+  }
+
+  void RunAllThreads() {
     // 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::Bind(&PostQuitTask, &message_loop_));
     MessageLoop::current()->Run();
   }
 
@@ skipping 48 matching lines @@
     CheckUint32Attribute(item, "preferred", form.preferred);
     // We don't check the date created. It varies.
     CheckUint32Attribute(item, "blacklisted_by_user", form.blacklisted_by_user);
     CheckUint32Attribute(item, "scheme", form.scheme);
     CheckStringAttribute(item, "application", app_string);
   }
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
+  content::TestBrowserThread file_thread_;
 
   TestingProfile profile_;
 
+  // By its very existence, the test proxy integrates with the UI thread's
+  // message loop (via GMainContext). We don't need to access it explicitly.
+  scoped_ptr<TestKeyringProxy> proxy_;
+  // This is the file descriptor connected to the proxy, suitable for dup()ing
+  // and using to construct TestKeyringProxyClients.
+  int proxy_fd_;
+
   // Provide some test forms to avoid having to set them up in each test.
   PasswordForm form_google_;
   PasswordForm form_isc_;
 };
 
 TEST_F(NativeBackendGnomeTest, BasicAddLogin) {
   // Pretend that the migration has already taken place.
   profile_.GetPrefs()->SetBoolean(prefs::kPasswordsUseLocalProfileId, true);
 
   NativeBackendGnome backend(42, profile_.GetPrefs());
-  backend.Init();
+  InitNativeBackend(&backend);
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::AddLogin,
           base::Unretained(&backend), form_google_)));
 
-  RunBothThreads();
+  RunAllThreads();
 
   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) {
   // Pretend that the migration has already taken place.
   profile_.GetPrefs()->SetBoolean(prefs::kPasswordsUseLocalProfileId, true);
 
   NativeBackendGnome backend(42, profile_.GetPrefs());
-  backend.Init();
+  InitNativeBackend(&backend);
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::AddLogin,
           base::Unretained(&backend), form_google_)));
 
   std::vector<PasswordForm*> form_list;
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::GetAutofillableLogins,
           base::Unretained(&backend), &form_list)));
 
-  RunBothThreads();
+  RunAllThreads();
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
   STLDeleteElements(&form_list);
 
   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, BasicRemoveLogin) {
   // Pretend that the migration has already taken place.
   profile_.GetPrefs()->SetBoolean(prefs::kPasswordsUseLocalProfileId, true);
 
   NativeBackendGnome backend(42, profile_.GetPrefs());
-  backend.Init();
+  InitNativeBackend(&backend);
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::AddLogin,
           base::Unretained(&backend), form_google_)));
 
-  RunBothThreads();
+  RunAllThreads();
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::RemoveLogin,
           base::Unretained(&backend), form_google_)));
 
-  RunBothThreads();
+  RunAllThreads();
 
   EXPECT_EQ(0u, mock_keyring_items.size());
 }
 
 TEST_F(NativeBackendGnomeTest, RemoveNonexistentLogin) {
   // Pretend that the migration has already taken place.
   profile_.GetPrefs()->SetBoolean(prefs::kPasswordsUseLocalProfileId, true);
 
   NativeBackendGnome backend(42, profile_.GetPrefs());
-  backend.Init();
+  InitNativeBackend(&backend);
 
   // First add an unrelated login.
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::AddLogin,
           base::Unretained(&backend), form_google_)));
 
-  RunBothThreads();
+  RunAllThreads();
 
   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.
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::RemoveLogin,
           base::Unretained(&backend), form_isc_)));
 
   // Make sure we can still get the first form back.
   std::vector<PasswordForm*> form_list;
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::GetAutofillableLogins,
           base::Unretained(&backend), &form_list)));
 
-  RunBothThreads();
+  RunAllThreads();
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
   STLDeleteElements(&form_list);
 
   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) {
   // Pretend that the migration has already taken place.
   profile_.GetPrefs()->SetBoolean(prefs::kPasswordsUseLocalProfileId, true);
 
   NativeBackendGnome backend(42, profile_.GetPrefs());
-  backend.Init();
+  InitNativeBackend(&backend);
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::AddLogin,
           base::Unretained(&backend), form_google_)));
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::AddLogin,
           base::Unretained(&backend), form_google_)));
 
-  RunBothThreads();
+  RunAllThreads();
 
   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, ListLoginsAppends) {
   // Pretend that the migration has already taken place.
   profile_.GetPrefs()->SetBoolean(prefs::kPasswordsUseLocalProfileId, true);
 
   NativeBackendGnome backend(42, profile_.GetPrefs());
-  backend.Init();
+  InitNativeBackend(&backend);
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::AddLogin,
           base::Unretained(&backend), form_google_)));
 
   // Send the same request twice with the same list both times.
   std::vector<PasswordForm*> form_list;
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::GetAutofillableLogins,
           base::Unretained(&backend), &form_list)));
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(
           &NativeBackendGnome::GetAutofillableLogins,
           base::Unretained(&backend), &form_list)));
 
-  RunBothThreads();
+  RunAllThreads();
 
   // Quick check that we got two results back.
   EXPECT_EQ(2u, form_list.size());
   STLDeleteElements(&form_list);
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome-42");
 }
 
 // TODO(mdm): add more basic (i.e. non-migration) tests here at some point.
 
 TEST_F(NativeBackendGnomeTest, MigrateOneLogin) {
   // Reject attempts to migrate so we can populate the store.
   mock_keyring_reject_local_ids = true;
 
   {
     NativeBackendGnome backend(42, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::AddLogin,
             base::Unretained(&backend), form_google_)));
 
     // Make sure we can get the form back even when migration is failing.
     std::vector<PasswordForm*> form_list;
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::GetAutofillableLogins,
             base::Unretained(&backend), &form_list)));
 
-    RunBothThreads();
+    RunAllThreads();
 
     // Quick check that we got something back.
     EXPECT_EQ(1u, form_list.size());
     STLDeleteElements(&form_list);
   }
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
 
   // Now allow the migration.
   mock_keyring_reject_local_ids = false;
 
   {
     NativeBackendGnome backend(42, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     // This should not trigger migration because there will be no results.
     std::vector<PasswordForm*> form_list;
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::GetBlacklistLogins,
             base::Unretained(&backend), &form_list)));
 
-    RunBothThreads();
+    RunAllThreads();
 
     // Check that we got nothing back.
     EXPECT_EQ(0u, form_list.size());
     STLDeleteElements(&form_list);
   }
 
   // Check that the keyring is unmodified.
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
 
   // Check that we haven't set the persistent preference.
   EXPECT_FALSE(
       profile_.GetPrefs()->GetBoolean(prefs::kPasswordsUseLocalProfileId));
 
   {
     NativeBackendGnome backend(42, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     // Trigger the migration by looking something up.
     std::vector<PasswordForm*> form_list;
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::GetAutofillableLogins,
             base::Unretained(&backend), &form_list)));
 
-    RunBothThreads();
+    RunAllThreads();
 
     // Quick check that we got something back.
     EXPECT_EQ(1u, form_list.size());
     STLDeleteElements(&form_list);
   }
 
   EXPECT_EQ(2u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
   if (mock_keyring_items.size() > 1)
     CheckMockKeyringItem(&mock_keyring_items[1], form_google_, "chrome-42");
 
   // Check that we have set the persistent preference.
   EXPECT_TRUE(
       profile_.GetPrefs()->GetBoolean(prefs::kPasswordsUseLocalProfileId));
 }
 
 TEST_F(NativeBackendGnomeTest, MigrateToMultipleProfiles) {
   // Reject attempts to migrate so we can populate the store.
   mock_keyring_reject_local_ids = true;
 
   {
     NativeBackendGnome backend(42, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::AddLogin,
             base::Unretained(&backend), form_google_)));
 
-    RunBothThreads();
+    RunAllThreads();
   }
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
 
   // Now allow the migration.
   mock_keyring_reject_local_ids = false;
 
   {
     NativeBackendGnome backend(42, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     // Trigger the migration by looking something up.
     std::vector<PasswordForm*> form_list;
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::GetAutofillableLogins,
             base::Unretained(&backend), &form_list)));
 
-    RunBothThreads();
+    RunAllThreads();
 
     // Quick check that we got something back.
     EXPECT_EQ(1u, form_list.size());
     STLDeleteElements(&form_list);
   }
 
   EXPECT_EQ(2u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
   if (mock_keyring_items.size() > 1)
     CheckMockKeyringItem(&mock_keyring_items[1], form_google_, "chrome-42");
 
   // Check that we have set the persistent preference.
   EXPECT_TRUE(
       profile_.GetPrefs()->GetBoolean(prefs::kPasswordsUseLocalProfileId));
 
   // Normally we'd actually have a different profile. But in the test just reset
   // the profile's persistent pref; we pass in the local profile id anyway.
   profile_.GetPrefs()->SetBoolean(prefs::kPasswordsUseLocalProfileId, false);
 
   {
     NativeBackendGnome backend(24, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     // Trigger the migration by looking something up.
     std::vector<PasswordForm*> form_list;
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::GetAutofillableLogins,
             base::Unretained(&backend), &form_list)));
 
-    RunBothThreads();
+    RunAllThreads();
 
     // Quick check that we got something back.
     EXPECT_EQ(1u, form_list.size());
     STLDeleteElements(&form_list);
   }
 
   EXPECT_EQ(3u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
   if (mock_keyring_items.size() > 1)
     CheckMockKeyringItem(&mock_keyring_items[1], form_google_, "chrome-42");
   if (mock_keyring_items.size() > 2)
     CheckMockKeyringItem(&mock_keyring_items[2], form_google_, "chrome-24");
 }
 
 TEST_F(NativeBackendGnomeTest, NoMigrationWithPrefSet) {
   // Reject attempts to migrate so we can populate the store.
   mock_keyring_reject_local_ids = true;
 
   {
     NativeBackendGnome backend(42, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::AddLogin,
             base::Unretained(&backend), form_google_)));
 
-    RunBothThreads();
+    RunAllThreads();
   }
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
 
   // Now allow migration, but also pretend that the it has already taken place.
   mock_keyring_reject_local_ids = false;
   profile_.GetPrefs()->SetBoolean(prefs::kPasswordsUseLocalProfileId, true);
 
   {
     NativeBackendGnome backend(42, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     // Trigger the migration by adding a new login.
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::AddLogin,
             base::Unretained(&backend), form_isc_)));
 
     // Look up all logins; we expect only the one we added.
     std::vector<PasswordForm*> form_list;
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::GetAutofillableLogins,
             base::Unretained(&backend), &form_list)));
 
-    RunBothThreads();
+    RunAllThreads();
 
     // Quick check that we got the right thing back.
     EXPECT_EQ(1u, form_list.size());
     if (form_list.size() > 0)
       EXPECT_EQ(form_isc_.signon_realm, form_list[0]->signon_realm);
     STLDeleteElements(&form_list);
   }
 
   EXPECT_EQ(2u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
   if (mock_keyring_items.size() > 1)
     CheckMockKeyringItem(&mock_keyring_items[1], form_isc_, "chrome-42");
 }
 
 TEST_F(NativeBackendGnomeTest, DeleteMigratedPasswordIsIsolated) {
   // Reject attempts to migrate so we can populate the store.
   mock_keyring_reject_local_ids = true;
 
   {
     NativeBackendGnome backend(42, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::AddLogin,
             base::Unretained(&backend), form_google_)));
 
-    RunBothThreads();
+    RunAllThreads();
   }
 
   EXPECT_EQ(1u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
 
   // Now allow the migration.
   mock_keyring_reject_local_ids = false;
 
   {
     NativeBackendGnome backend(42, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     // Trigger the migration by looking something up.
     std::vector<PasswordForm*> form_list;
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::GetAutofillableLogins,
             base::Unretained(&backend), &form_list)));
 
-    RunBothThreads();
+    RunAllThreads();
 
     // Quick check that we got something back.
     EXPECT_EQ(1u, form_list.size());
     STLDeleteElements(&form_list);
   }
 
   EXPECT_EQ(2u, mock_keyring_items.size());
   if (mock_keyring_items.size() > 0)
     CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
   if (mock_keyring_items.size() > 1)
     CheckMockKeyringItem(&mock_keyring_items[1], form_google_, "chrome-42");
 
   // Check that we have set the persistent preference.
   EXPECT_TRUE(
       profile_.GetPrefs()->GetBoolean(prefs::kPasswordsUseLocalProfileId));
 
   // Normally we'd actually have a different profile. But in the test just reset
   // the profile's persistent pref; we pass in the local profile id anyway.
   profile_.GetPrefs()->SetBoolean(prefs::kPasswordsUseLocalProfileId, false);
 
   {
     NativeBackendGnome backend(24, profile_.GetPrefs());
-    backend.Init();
+    InitNativeBackend(&backend);
 
     // Trigger the migration by looking something up.
     std::vector<PasswordForm*> form_list;
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::GetAutofillableLogins,
             base::Unretained(&backend), &form_list)));
 
-    RunBothThreads();
+    RunAllThreads();
 
     // Quick check that we got something back.
     EXPECT_EQ(1u, form_list.size());
     STLDeleteElements(&form_list);
 
     // There should be three passwords now.
     EXPECT_EQ(3u, mock_keyring_items.size());
     if (mock_keyring_items.size() > 0)
       CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
     if (mock_keyring_items.size() > 1)
       CheckMockKeyringItem(&mock_keyring_items[1], form_google_, "chrome-42");
     if (mock_keyring_items.size() > 2)
       CheckMockKeyringItem(&mock_keyring_items[2], form_google_, "chrome-24");
 
     // Now delete the password from this second profile.
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
         base::IgnoreReturn<bool>(base::Bind(
             &NativeBackendGnome::RemoveLogin,
             base::Unretained(&backend), form_google_)));
 
-    RunBothThreads();
+    RunAllThreads();
 
     // The other two copies of the password in different profiles should remain.
     EXPECT_EQ(2u, mock_keyring_items.size());
     if (mock_keyring_items.size() > 0)
       CheckMockKeyringItem(&mock_keyring_items[0], form_google_, "chrome");
     if (mock_keyring_items.size() > 1)
       CheckMockKeyringItem(&mock_keyring_items[1], form_google_, "chrome-42");
   }
 }