Use kwalletd5 in KDE 5 environments

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 <algorithm>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 19 matching lines @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using autofill::PasswordForm;
 using base::UTF8ToUTF16;
 using content::BrowserThread;
 using password_manager::PasswordStoreChange;
 using password_manager::PasswordStoreChangeList;
 using testing::_;
 using testing::Invoke;
+using testing::TestWithParam;
+using testing::Values;
 using testing::Return;
 
 namespace {
 
 // This class implements a very simple version of KWallet in memory.
 // We only provide the parts we actually use; the real version has more.
 class TestKWallet {
  public:
   typedef std::basic_string<uint8_t> Blob;  // std::string is binary-safe.
 
@@ skipping 87 matching lines @@
 
 }  // anonymous namespace
 
 // Obscure magic: we need to declare storage for this constant because we use it
 // in ways that require its address in this test, but not in the actual code.
 const int NativeBackendKWallet::kInvalidKWalletHandle;
 
 // Subclass NativeBackendKWallet to promote some members to public for testing.
 class NativeBackendKWalletStub : public NativeBackendKWallet {
  public:
-  explicit NativeBackendKWalletStub(LocalProfileId id)
-      :  NativeBackendKWallet(id) {
+  explicit NativeBackendKWalletStub(LocalProfileId id,

[vabr (Chromium), 2015/10/06 12:51:21]

Please also drop "explicit" here.

[Ed Baker, 2015/10/06 16:07:44]

Done.

+                                    base::nix::DesktopEnvironment desktop_env)
+      :  NativeBackendKWallet(id, desktop_env) {
   }
   using NativeBackendKWallet::InitWithBus;
   using NativeBackendKWallet::kInvalidKWalletHandle;
   using NativeBackendKWallet::DeserializeValue;
 };
 
 // Provide some test forms to avoid having to set them up in each test.
-class NativeBackendKWalletTestBase : public testing::Test {
+class NativeBackendKWalletTestBase :
+    public testing::TestWithParam<base::nix::DesktopEnvironment> {
  protected:
   NativeBackendKWalletTestBase() {
     old_form_google_.origin = GURL("http://www.google.com/");
     old_form_google_.action = GURL("http://www.google.com/login");
     old_form_google_.username_element = UTF8ToUTF16("user");
     old_form_google_.username_value = UTF8ToUTF16("joeschmoe");
     old_form_google_.password_element = UTF8ToUTF16("pass");
     old_form_google_.password_value = UTF8ToUTF16("seekrit");
     old_form_google_.submit_element = UTF8ToUTF16("submit");
     old_form_google_.signon_realm = "Google";
@@ skipping 87 matching lines @@
   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) {
+        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(false, false);
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
                             base::Bind(ThreadDone, &event));
@@ skipping 30 matching lines @@
   scoped_refptr<dbus::MockObjectProxy> mock_kwallet_proxy_;
 
   int klauncher_ret_;
   std::string klauncher_error_;
   bool klauncher_contacted_;
 
   bool kwallet_runnable_;
   bool kwallet_running_;
   bool kwallet_enabled_;
 
+  // Used for switching between kwalletd and kwalletd5
+  base::nix::DesktopEnvironment desktop_env_;
+
   TestKWallet wallet_;
 
   // For all method names contained in |failing_methods_|, the mocked KWallet
   // will return a null response.
   std::set<std::string> failing_methods_;
 
  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(
            Invoke(this, &NativeBackendKWalletTest::KLauncherMethodCall));
 
-  mock_kwallet_proxy_ =
-      new dbus::MockObjectProxy(mock_session_bus_.get(),
-                                "org.kde.kwalletd",
-                                dbus::ObjectPath("/modules/kwalletd"));
+  if (desktop_env_ == base::nix::DESKTOP_ENVIRONMENT_KDE5) {
+    mock_kwallet_proxy_ =
+        new dbus::MockObjectProxy(mock_session_bus_.get(),
+                                  "org.kde.kwalletd5",
+                                  dbus::ObjectPath("/modules/kwalletd5"));
+  } else {
+    mock_kwallet_proxy_ =
+        new dbus::MockObjectProxy(mock_session_bus_.get(),
+                                  "org.kde.kwalletd",
+                                  dbus::ObjectPath("/modules/kwalletd"));
+  }
   EXPECT_CALL(*mock_kwallet_proxy_.get(), MockCallMethodAndBlock(_, _))
       .WillRepeatedly(
            Invoke(this, &NativeBackendKWalletTest::KWalletMethodCall));
 
   EXPECT_CALL(
       *mock_session_bus_.get(),
       GetObjectProxy("org.kde.klauncher", dbus::ObjectPath("/KLauncher")))
       .WillRepeatedly(Return(mock_klauncher_proxy_.get()));
-  EXPECT_CALL(
-      *mock_session_bus_.get(),
-      GetObjectProxy("org.kde.kwalletd", dbus::ObjectPath("/modules/kwalletd")))
-      .WillRepeatedly(Return(mock_kwallet_proxy_.get()));
+  if (desktop_env_ == base::nix::DESKTOP_ENVIRONMENT_KDE5) {
+    EXPECT_CALL(
+        *mock_session_bus_.get(),
+        GetObjectProxy("org.kde.kwalletd5",
+                       dbus::ObjectPath("/modules/kwalletd5")))
+        .WillRepeatedly(Return(mock_kwallet_proxy_.get()));
+  } else {
+    EXPECT_CALL(
+        *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::QuitClosure());
   base::MessageLoop::current()->Run();
   db_thread_.Stop();
 }
 
 void NativeBackendKWalletTest::TestRemoveLoginsBetween(
     RemoveBetweenMethod date_to_test) {
-  NativeBackendKWalletStub backend(42);
+  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();
   base::Time next_day = now + base::TimeDelta::FromDays(1);
   if (date_to_test == CREATED) {
     form_google_.date_created = now;
@@ skipping 67 matching lines @@
   std::vector<std::string> envs;
   std::string startup_id;
   bool blind = false;
 
   EXPECT_TRUE(reader.PopString(&service_name));
   EXPECT_TRUE(reader.PopArrayOfStrings(&urls));
   EXPECT_TRUE(reader.PopArrayOfStrings(&envs));
   EXPECT_TRUE(reader.PopString(&startup_id));
   EXPECT_TRUE(reader.PopBool(&blind));
 
-  EXPECT_EQ("kwalletd", service_name);
+  if (desktop_env_ == base::nix::DESKTOP_ENVIRONMENT_KDE5)
+    EXPECT_EQ("kwalletd5", service_name);
+  else
+    EXPECT_EQ("kwalletd", service_name);
   EXPECT_TRUE(urls.empty());
   EXPECT_TRUE(envs.empty());
   EXPECT_TRUE(startup_id.empty());
   EXPECT_FALSE(blind);
 
   if (kwallet_runnable_)
     kwallet_running_ = true;
 
   scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
   dbus::MessageWriter writer(response.get());
@@ skipping 139 matching lines @@
                         value.size());
     ScopedVector<autofill::PasswordForm> forms =
         NativeBackendKWalletStub::DeserializeValue(entries[i], pickle);
     const std::vector<const PasswordForm*>& expect = sorted_expected[i].second;
     EXPECT_EQ(expect.size(), forms.size());
     for (size_t j = 0; j < forms.size() && j < expect.size(); ++j)
       CheckPasswordForm(*expect[j], *forms[j], true);
   }
 }
 
-TEST_F(NativeBackendKWalletTest, NotEnabled) {
-  NativeBackendKWalletStub kwallet(42);
+TEST_P(NativeBackendKWalletTest, NotEnabled) {
+  NativeBackendKWalletStub kwallet(42, desktop_env_);
   kwallet_enabled_ = false;
   EXPECT_FALSE(kwallet.InitWithBus(mock_session_bus_));
   EXPECT_FALSE(klauncher_contacted_);
 }
 
-TEST_F(NativeBackendKWalletTest, NotRunnable) {
-  NativeBackendKWalletStub kwallet(42);
+TEST_P(NativeBackendKWalletTest, NotRunnable) {
+  NativeBackendKWalletStub kwallet(42, desktop_env_);
   kwallet_runnable_ = false;
   kwallet_running_ = false;
   EXPECT_FALSE(kwallet.InitWithBus(mock_session_bus_));
   EXPECT_TRUE(klauncher_contacted_);
 }
 
-TEST_F(NativeBackendKWalletTest, NotRunningOrEnabled) {
-  NativeBackendKWalletStub kwallet(42);
+TEST_P(NativeBackendKWalletTest, NotRunningOrEnabled) {
+  NativeBackendKWalletStub kwallet(42, desktop_env_);
   kwallet_running_ = false;
   kwallet_enabled_ = false;
   EXPECT_FALSE(kwallet.InitWithBus(mock_session_bus_));
   EXPECT_TRUE(klauncher_contacted_);
 }
 
-TEST_F(NativeBackendKWalletTest, NotRunning) {
-  NativeBackendKWalletStub kwallet(42);
+TEST_P(NativeBackendKWalletTest, NotRunning) {
+  NativeBackendKWalletStub kwallet(42, desktop_env_);
   kwallet_running_ = false;
   EXPECT_TRUE(kwallet.InitWithBus(mock_session_bus_));
   EXPECT_TRUE(klauncher_contacted_);
 }
 
-TEST_F(NativeBackendKWalletTest, BasicStartup) {
-  NativeBackendKWalletStub kwallet(42);
+TEST_P(NativeBackendKWalletTest, BasicStartup) {
+  NativeBackendKWalletStub kwallet(42, desktop_env_);
   EXPECT_TRUE(kwallet.InitWithBus(mock_session_bus_));
   EXPECT_FALSE(klauncher_contacted_);
 }
 
-TEST_F(NativeBackendKWalletTest, BasicAddLogin) {
-  NativeBackendKWalletStub backend(42);
+TEST_P(NativeBackendKWalletTest, BasicAddLogin) {
+  NativeBackendKWalletStub backend(42, desktop_env_);
   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();
 
   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_F(NativeBackendKWalletTest, BasicUpdateLogin) {
-  NativeBackendKWalletStub backend(42);
+TEST_P(NativeBackendKWalletTest, BasicUpdateLogin) {
+  NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
 
   RunDBThread();
 
   PasswordForm new_form_google(form_google_);
@@ skipping 17 matching lines @@
   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_F(NativeBackendKWalletTest, BasicListLogins) {
-  NativeBackendKWalletStub backend(42);
+TEST_P(NativeBackendKWalletTest, BasicListLogins) {
+  NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
 
   ScopedVector<autofill::PasswordForm> form_list;
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB, FROM_HERE,
       base::Bind(&NativeBackendKWalletStub::GetAutofillableLogins,
                  base::Unretained(&backend), &form_list),
       base::Bind(&CheckTrue));
 
   RunDBThread();
 
   // 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_F(NativeBackendKWalletTest, BasicRemoveLogin) {
-  NativeBackendKWalletStub backend(42);
+TEST_P(NativeBackendKWalletTest, BasicRemoveLogin) {
+  NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   BrowserThread::PostTask(
       BrowserThread::DB, FROM_HERE,
       base::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
 
   RunDBThread();
 
   EXPECT_FALSE(wallet_.hasFolder("Chrome Form Data"));
@@ skipping 12 matching lines @@
       base::Bind(&NativeBackendKWalletStub::RemoveLogin,
                  base::Unretained(&backend), form_google_, &changes),
       base::Bind(&CheckPasswordChangesWithResult, &expected_changes, &changes));
 
   RunDBThread();
 
   expected.clear();
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
-TEST_F(NativeBackendKWalletTest, UpdateNonexistentLogin) {
-  NativeBackendKWalletStub backend(42);
+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::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
 
   RunDBThread();
 
@@ skipping 13 matching lines @@
                  &changes),
       base::Bind(&CheckPasswordChangesWithResult,
                  base::Owned(new PasswordStoreChangeList), &changes));
 
   RunDBThread();
 
   EXPECT_EQ(PasswordStoreChangeList(), changes);
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
-TEST_F(NativeBackendKWalletTest, RemoveNonexistentLogin) {
-  NativeBackendKWalletStub backend(42);
+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::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
                  base::Unretained(&backend), form_google_));
 
   RunDBThread();
 
@@ skipping 23 matching lines @@
       base::Bind(&CheckTrue));
 
   RunDBThread();
 
   // Quick check that we got something back.
   EXPECT_EQ(1u, form_list.size());
 
   CheckPasswordForms("Chrome Form Data (42)", expected);
 }
 
-TEST_F(NativeBackendKWalletTest, AddDuplicateLogin) {
-  NativeBackendKWalletStub backend(42);
+TEST_P(NativeBackendKWalletTest, AddDuplicateLogin) {
+  NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   PasswordStoreChangeList changes;
   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,
@@ skipping 18 matching lines @@
 
   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_F(NativeBackendKWalletTest, AndroidCredentials) {
-  NativeBackendKWalletStub backend(42);
+TEST_P(NativeBackendKWalletTest, AndroidCredentials) {
+  NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   PasswordForm observed_android_form;
   observed_android_form.scheme = PasswordForm::SCHEME_HTML;
   observed_android_form.signon_realm =
       "android://7x7IDboo8u9YKraUsbmVkuf1-@net.rateflix.app/";
   PasswordForm saved_android_form = observed_android_form;
   saved_android_form.username_value = base::UTF8ToUTF16("randomusername");
   saved_android_form.password_value = base::UTF8ToUTF16("password");
 
@@ skipping 17 matching lines @@
   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);
 }
 
-TEST_F(NativeBackendKWalletTest, RemoveLoginsCreatedBetween) {
+TEST_P(NativeBackendKWalletTest, RemoveLoginsCreatedBetween) {
   TestRemoveLoginsBetween(CREATED);
 }
 
-TEST_F(NativeBackendKWalletTest, RemoveLoginsSyncedBetween) {
+TEST_P(NativeBackendKWalletTest, RemoveLoginsSyncedBetween) {
   TestRemoveLoginsBetween(SYNCED);
 }
 
-TEST_F(NativeBackendKWalletTest, ReadDuplicateForms) {
-  NativeBackendKWalletStub backend(42);
+TEST_P(NativeBackendKWalletTest, ReadDuplicateForms) {
+  NativeBackendKWalletStub backend(42, desktop_env_);
   EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
 
   // 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::Bind(base::IgnoreResult(&NativeBackendKWalletStub::AddLogin),
@@ skipping 30 matching lines @@
   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);
 }
 
+// Check that if KWallet fails to respond, the backend propagates the error.
+TEST_P(NativeBackendKWalletTest, GetAllLoginsErrorHandling) {
+  NativeBackendKWalletStub backend(42, desktop_env_);
+  EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
+  // Make KWallet fail on calling readEntry.
+  failing_methods_.insert("readEntry");
+
+  // Store some non-blacklisted logins to be potentially returned.
+  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_))));
+
+  // Verify that nothing is in fact returned, because KWallet fails to respond.
+  ScopedVector<autofill::PasswordForm> form_list;
+  BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
+                          base::Bind(&CheckGetAutofillableLoginsFails,
+                                     base::Unretained(&backend), &form_list));
+  RunDBThread();
+  EXPECT_EQ(0u, form_list.size());
+}
+
+INSTANTIATE_TEST_CASE_P(,
+                        NativeBackendKWalletTest,
+                        ::testing::Values(base::nix::DESKTOP_ENVIRONMENT_KDE4,
+                                          base::nix::DESKTOP_ENVIRONMENT_KDE5));
+
 // TODO(mdm): add more basic tests here at some point.
 // (For example tests for storing >1 password per realm pickle.)
 
 class NativeBackendKWalletPickleTest : public NativeBackendKWalletTestBase {
  protected:
   // Based on |form|, fills |pickle| with data conforming to
   // |effective_version|, but marking the pickle version as |stored_version|. In
   // most cases the two versions should be the same.
   void CreateVersion1PlusPickle(const PasswordForm& form,
                                 base::Pickle* pickle,
@@ skipping 176 matching lines @@
   PasswordForm form = old_form_google_;
   form.scheme = scheme;
   CreateVersion0Pickle(size_32, form, &pickle);
   ScopedVector<autofill::PasswordForm> form_list =
       NativeBackendKWalletStub::DeserializeValue(form.signon_realm, pickle);
   EXPECT_EQ(1u, form_list.size());
   if (form_list.size() > 0)
     CheckPasswordForm(form, *form_list[0], false);
 }
 
-// Check that if KWallet fails to respond, the backend propagates the error.
-TEST_F(NativeBackendKWalletTest, GetAllLoginsErrorHandling) {
-  NativeBackendKWalletStub backend(42);
-  EXPECT_TRUE(backend.InitWithBus(mock_session_bus_));
-  // Make KWallet fail on calling readEntry.
-  failing_methods_.insert("readEntry");
-
-  // Store some non-blacklisted logins to be potentially returned.
-  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_))));
-
-  // Verify that nothing is in fact returned, because KWallet fails to respond.
-  ScopedVector<autofill::PasswordForm> form_list;
-  BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
-                          base::Bind(&CheckGetAutofillableLoginsFails,
-                                     base::Unretained(&backend), &form_list));
-  RunDBThread();
-  EXPECT_EQ(0u, form_list.size());
-}
-
 // We try both SCHEME_HTML and SCHEME_BASIC since the scheme is stored right
 // after the size in the pickle, so it's what gets read as part of the count
 // when reading 32-bit pickles on 64-bit systems. SCHEME_HTML is 0 (so we'll
 // detect errors later) while SCHEME_BASIC is 1 (so we'll detect it then). We
 // try both 32-bit and 64-bit pickles since only one will be the "other" size
 // for whatever architecture we're running on, but we want to make sure we can
 // read all combinations in any event.
 
 TEST_F(NativeBackendKWalletPickleTest, ReadsOld32BitHTMLPickles) {
   CheckVersion0Pickle(true, PasswordForm::SCHEME_HTML);
@@ skipping 24 matching lines @@
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion5Pickle) {
   CheckVersion5Pickle();
 }
 
 TEST_F(NativeBackendKWalletPickleTest, CheckVersion6Pickle) {
   CheckVersion6Pickle(false);
   CheckVersion6Pickle(true);
 }