Integrate PasswordStoreProxyMac instead of PasswordStoreMac.

chrome/browser/password_manager/password_store_mac_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 "chrome/browser/password_manager/password_store_mac.h"
 
 #include "base/basictypes.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/scoped_observer.h"
 #include "base/stl_util.h"
@@ skipping 58 matching lines @@
     OnGetPasswordStoreResultsConstRef(results.get());
   }
 };
 
 class MockPasswordStoreObserver : public PasswordStore::Observer {
  public:
   MOCK_METHOD1(OnLoginsChanged,
                void(const password_manager::PasswordStoreChangeList& changes));
 };
 
-// A mock LoginDatabase that simulates a failing Init() method.
-class BadLoginDatabase : public password_manager::LoginDatabase {
- public:
-  BadLoginDatabase() : password_manager::LoginDatabase(base::FilePath()) {}
-  ~BadLoginDatabase() override {}
-
-  // LoginDatabase:
-  bool Init() override { return false; }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(BadLoginDatabase);
-};
-
 // A LoginDatabase that simulates an Init() method that takes a long time.
 class SlowToInitLoginDatabase : public password_manager::LoginDatabase {
  public:
   // Creates an instance whose Init() method will block until |event| is
   // signaled. |event| must outlive |this|.
   SlowToInitLoginDatabase(const base::FilePath& db_path,
                           base::WaitableEvent* event)
       : password_manager::LoginDatabase(db_path), event_(event) {}
   ~SlowToInitLoginDatabase() override {}
 
   // LoginDatabase:
   bool Init() override {
     event_->Wait();
     return password_manager::LoginDatabase::Init();
   }
 
  private:
   base::WaitableEvent* event_;
 
   DISALLOW_COPY_AND_ASSIGN(SlowToInitLoginDatabase);
 };
 
-class TestPasswordStoreMac : public PasswordStoreMac {
- public:
-  TestPasswordStoreMac(
-      scoped_refptr<base::SingleThreadTaskRunner> main_thread_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> db_thread_runner,
-      scoped_ptr<crypto::AppleKeychain> keychain,
-      scoped_ptr<password_manager::LoginDatabase> login_db)
-      : PasswordStoreMac(main_thread_runner,
-                         db_thread_runner,
-                         keychain.Pass(),
-                         login_db.Pass()) {}
-
-  using PasswordStoreMac::GetBackgroundTaskRunner;
-
- private:
-  ~TestPasswordStoreMac() override {}
-
-  DISALLOW_COPY_AND_ASSIGN(TestPasswordStoreMac);
-};
-
 #pragma mark -
 
 // Macro to simplify calling CheckFormsAgainstExpectations with a useful label.
 #define CHECK_FORMS(forms, expectations, i) \
     CheckFormsAgainstExpectations(forms, expectations, #forms, i)
 
 // Ensures that the data in |forms| match |expectations|, causing test failures
 // for any discrepencies.
 // TODO(stuartmorgan): This is current order-dependent; ideally it shouldn't
 // matter if |forms| and |expectations| are scrambled.
@@ skipping 1059 matching lines @@
 class PasswordStoreMacTest : public testing::Test {
  public:
   PasswordStoreMacTest() : ui_thread_(BrowserThread::UI, &message_loop_) {}
 
   void SetUp() override {
     ASSERT_TRUE(db_dir_.CreateUniqueTempDir());
 
     // Ensure that LoginDatabase will use the mock keychain if it needs to
     // encrypt/decrypt a password.
     OSCrypt::UseMockKeychain(true);
-    scoped_ptr<password_manager::LoginDatabase> login_db(
+    login_db_.reset(
         new password_manager::LoginDatabase(test_login_db_file_path()));
-    CreateAndInitPasswordStore(login_db.Pass());
+    thread_.reset(new base::Thread("Chrome_PasswordStore_Thread"));
+    ASSERT_TRUE(thread_->Start());
+    ASSERT_TRUE(thread_->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&PasswordStoreMacTest::InitLoginDatabase,
+                              base::Unretained(login_db_.get()))));
+    CreateAndInitPasswordStore(login_db_.get());
     // Make sure deferred initialization is performed before some tests start
     // accessing the |login_db| directly.
     FinishAsyncProcessing();
   }
 
   void TearDown() override {
     ClosePasswordStore();
+    thread_.reset();
+    login_db_.reset();
     // Whatever a test did, PasswordStoreMac stores only empty password values
     // in LoginDatabase. The empty valus do not require encryption and therefore
     // OSCrypt shouldn't call the Keychain. The histogram doesn't cover the
     // internet passwords.
     EXPECT_FALSE(histogram_tester_.GetHistogramSamplesSinceCreation(
         "OSX.Keychain.Access"));
   }
 
-  void CreateAndInitPasswordStore(
-      scoped_ptr<password_manager::LoginDatabase> login_db) {
-    store_ = new TestPasswordStoreMac(
-        base::ThreadTaskRunnerHandle::Get(),
-        base::ThreadTaskRunnerHandle::Get(),
-        make_scoped_ptr<AppleKeychain>(new MockAppleKeychain), login_db.Pass());
-    ASSERT_TRUE(store_->Init(syncer::SyncableService::StartSyncFlare()));
+  static void InitLoginDatabase(password_manager::LoginDatabase* login_db) {
+    ASSERT_TRUE(login_db->Init());
+  }
+
+  void CreateAndInitPasswordStore(password_manager::LoginDatabase* login_db) {
+    store_ = new PasswordStoreMac(
+        base::ThreadTaskRunnerHandle::Get(), nullptr,
+        make_scoped_ptr<AppleKeychain>(new MockAppleKeychain), login_db);
+    store_->InitWithTaskRunner(thread_->task_runner());
   }
 
   void ClosePasswordStore() {
     if (!store_)
       return;
 
     store_->Shutdown();
-    EXPECT_FALSE(store_->GetBackgroundTaskRunner());
-    base::MessageLoop::current()->RunUntilIdle();
     store_ = nullptr;
   }
 
   // Verifies that the given |form| can be properly stored so that it can be
   // retrieved by FillMatchingLogins() and GetAutofillableLogins(), and then it
   // can be properly removed.
   void VerifyCredentialLifecycle(const PasswordForm& form) {
     // Run everything twice to make sure no garbage is left behind that would
     // prevent storing the form a second time.
     for (size_t iteration = 0; iteration < 2; ++iteration) {
@@ skipping 55 matching lines @@
   void FinishAsyncProcessing() {
     // Do a store-level query to wait for all the previously enqueued operations
     // to finish.
     MockPasswordStoreConsumer consumer;
     store_->GetLogins(PasswordForm(), PasswordStore::ALLOW_PROMPT, &consumer);
     EXPECT_CALL(consumer, OnGetPasswordStoreResultsConstRef(_))
         .WillOnce(QuitUIMessageLoop());
     base::MessageLoop::current()->Run();
   }
 
-  TestPasswordStoreMac* store() { return store_.get(); }
+  PasswordStoreMac* store() { return store_.get(); }
 
  protected:
   base::MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
+  // Thread that the synchronous methods are run on.
+  scoped_ptr<base::Thread> thread_;
 
   base::ScopedTempDir db_dir_;
-  scoped_refptr<TestPasswordStoreMac> store_;
+  scoped_ptr<password_manager::LoginDatabase> login_db_;
+  scoped_refptr<PasswordStoreMac> store_;
   base::HistogramTester histogram_tester_;
 };
 
 TEST_F(PasswordStoreMacTest, TestStoreUpdate) {
   // Insert a password into both the database and the keychain.
   // This is done manually, rather than through store_->AddLogin, because the
   // Mock Keychain isn't smart enough to be able to support update generically,
   // so some.domain.com triggers special handling to test it that make inserting
   // fail.
   PasswordFormData joint_data = {
@@ skipping 146 matching lines @@
   EXPECT_EQ(0u, matching_items.size());
   EXPECT_TRUE(login_db()->GetLogins(m_form, &matching_items));
   EXPECT_EQ(0u, matching_items.size());
 }
 
 namespace {
 
 class PasswordsChangeObserver :
     public password_manager::PasswordStore::Observer {
 public:
-  PasswordsChangeObserver(TestPasswordStoreMac* store) : observer_(this) {
+ PasswordsChangeObserver(PasswordStoreMac* store) : observer_(this) {
     observer_.Add(store);
   }
 
   void WaitAndVerify(PasswordStoreMacTest* test) {
     test->FinishAsyncProcessing();
     ::testing::Mock::VerifyAndClearExpectations(this);
   }
 
   // password_manager::PasswordStore::Observer:
   MOCK_METHOD1(OnLoginsChanged,
@@ skipping 169 matching lines @@
 }
 
 // Open the store and immediately write to it and try to read it back, without
 // first waiting for the initialization to finish. If tasks are processed in
 // order, read/write operations will correctly be performed only after the
 // initialization has finished.
 TEST_F(PasswordStoreMacTest, StoreIsUsableImmediatelyAfterConstruction) {
   ClosePasswordStore();
 
   base::WaitableEvent event(false, false);
-  CreateAndInitPasswordStore(make_scoped_ptr<password_manager::LoginDatabase>(
-      new SlowToInitLoginDatabase(test_login_db_file_path(), &event)));
+  login_db_.reset(
+      new SlowToInitLoginDatabase(test_login_db_file_path(), &event));
+  ASSERT_TRUE(thread_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&PasswordStoreMacTest::InitLoginDatabase,
+                            base::Unretained(login_db_.get()))));
+  CreateAndInitPasswordStore(login_db_.get());
 
   PasswordFormData www_form_data = {
       PasswordForm::SCHEME_HTML, "http://www.facebook.com/",
       "http://www.facebook.com/index.html", "login", L"username", L"password",
       L"submit", L"not_joe_user", L"12345", true, false, 1};
   scoped_ptr<PasswordForm> form =
       CreatePasswordFormFromDataForTesting(www_form_data);
   store()->AddLogin(*form);
 
   MockPasswordStoreConsumer mock_consumer;
   store()->GetLogins(*form, PasswordStore::ALLOW_PROMPT, &mock_consumer);
 
   // Now the read/write tasks are scheduled, let the DB initialization proceed.
   event.Signal();
 
   EXPECT_CALL(mock_consumer, OnGetPasswordStoreResultsConstRef(SizeIs(1u)))
       .WillOnce(QuitUIMessageLoop());
   base::MessageLoop::current()->Run();
   EXPECT_TRUE(login_db());
 }
 
-// Verify that operations on a PasswordStore with a bad database cause no
-// explosions, but fail without side effect, return no data and trigger no
-// notifications.
-TEST_F(PasswordStoreMacTest, OperationsOnABadDatabaseSilentlyFail) {
-  ClosePasswordStore();
-  CreateAndInitPasswordStore(
-      make_scoped_ptr<password_manager::LoginDatabase>(new BadLoginDatabase));
-  FinishAsyncProcessing();
-  EXPECT_FALSE(login_db());
-
-  testing::StrictMock<MockPasswordStoreObserver> mock_observer;
-  store()->AddObserver(&mock_observer);
-
-  // Add a new autofillable login + a blacklisted login.
-  PasswordFormData www_form_data = {
-      PasswordForm::SCHEME_HTML, "http://www.facebook.com/",
-      "http://www.facebook.com/index.html", "login", L"username", L"password",
-      L"submit", L"not_joe_user", L"12345", true, false, 1};
-  scoped_ptr<PasswordForm> form =
-      CreatePasswordFormFromDataForTesting(www_form_data);
-  scoped_ptr<PasswordForm> blacklisted_form(new PasswordForm(*form));
-  blacklisted_form->signon_realm = "http://foo.example.com";
-  blacklisted_form->origin = GURL("http://foo.example.com/origin");
-  blacklisted_form->action = GURL("http://foo.example.com/action");
-  blacklisted_form->blacklisted_by_user = true;
-  store()->AddLogin(*form);
-  store()->AddLogin(*blacklisted_form);
-  FinishAsyncProcessing();
-
-  // Get all logins; autofillable logins; blacklisted logins.
-  MockPasswordStoreConsumer mock_consumer;
-  store()->GetLogins(*form, PasswordStore::DISALLOW_PROMPT, &mock_consumer);
-  ON_CALL(mock_consumer, OnGetPasswordStoreResultsConstRef(_))
-      .WillByDefault(QuitUIMessageLoop());
-  EXPECT_CALL(mock_consumer, OnGetPasswordStoreResultsConstRef(IsEmpty()));
-  base::MessageLoop::current()->Run();
-
-  store()->GetAutofillableLogins(&mock_consumer);
-  EXPECT_CALL(mock_consumer, OnGetPasswordStoreResultsConstRef(IsEmpty()));
-  base::MessageLoop::current()->Run();
-
-  store()->GetBlacklistLogins(&mock_consumer);
-  EXPECT_CALL(mock_consumer, OnGetPasswordStoreResultsConstRef(IsEmpty()));
-  base::MessageLoop::current()->Run();
-
-  // Report metrics.
-  store()->ReportMetrics("Test Username", true);
-  FinishAsyncProcessing();
-
-  // Change the login.
-  form->password_value = base::ASCIIToUTF16("a different password");
-  store()->UpdateLogin(*form);
-  FinishAsyncProcessing();
-
-  // Delete one login; a range of logins.
-  store()->RemoveLogin(*form);
-  store()->RemoveLoginsCreatedBetween(base::Time(), base::Time::Max());
-  store()->RemoveLoginsSyncedBetween(base::Time(), base::Time::Max());
-  FinishAsyncProcessing();
-
-  // Verify no notifications are fired during shutdown either.
-  ClosePasswordStore();
-}
-
 // Add a facebook form to the store but not to the keychain. The form is to be
 // implicitly deleted. However, the observers shouldn't get notified about
 // deletion of non-existent forms like m.facebook.com.
 TEST_F(PasswordStoreMacTest, SilentlyRemoveOrphanedForm) {
   testing::StrictMock<MockPasswordStoreObserver> mock_observer;
   store()->AddObserver(&mock_observer);
 
   // 1. Add a password for www.facebook.com to the LoginDatabase.
   PasswordFormData www_form_data = {
     PasswordForm::SCHEME_HTML, "http://www.facebook.com/",
@@ skipping 51 matching lines @@
 // Verify that federated credentials can be stored, retrieved and deleted.
 TEST_F(PasswordStoreMacTest, StoringAndRetrievingFederatedCredentials) {
   PasswordForm form;
   form.signon_realm = "android://7x7IDboo8u9YKraUsbmVkuf1@net.rateflix.app/";
   form.federation_url = GURL(password_manager::kTestingFederationUrlSpec);
   form.username_value = base::UTF8ToUTF16("randomusername");
   form.password_value = base::UTF8ToUTF16("");  // No password.
 
   VerifyCredentialLifecycle(form);
 }