Rename PasswordStoreProxyMac to PasswordStoreMac.

chrome/browser/password_manager/password_store_mac_unittest.cc

 // Copyright 2015 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_proxy_mac.h"
+#include "chrome/browser/password_manager/password_store_mac.h"
 
 #include <utility>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/scoped_observer.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
@@ skipping 48 matching lines @@
 
   std::vector<std::unique_ptr<PasswordForm>> forms_;
   base::RunLoop* nested_loop_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(MockPasswordStoreConsumer);
 };
 
 class MockPasswordStoreObserver
     : public password_manager::PasswordStore::Observer {
  public:
-  explicit MockPasswordStoreObserver(PasswordStoreProxyMac* password_store)
+  explicit MockPasswordStoreObserver(PasswordStoreMac* password_store)
       : guard_(this) {
     guard_.Add(password_store);
   }
   MOCK_METHOD1(OnLoginsChanged,
                void(const password_manager::PasswordStoreChangeList& changes));
 
  private:
-  ScopedObserver<PasswordStoreProxyMac, MockPasswordStoreObserver> guard_;
+  ScopedObserver<PasswordStoreMac, MockPasswordStoreObserver> guard_;
 
   DISALLOW_COPY_AND_ASSIGN(MockPasswordStoreObserver);
 };
 
 // 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);
 };
 
-class PasswordStoreProxyMacTest
-    : public testing::TestWithParam<MigrationStatus> {
+class PasswordStoreMacTest : public testing::TestWithParam<MigrationStatus> {
  public:
-  PasswordStoreProxyMacTest();
-  ~PasswordStoreProxyMacTest() override;
+  PasswordStoreMacTest();
+  ~PasswordStoreMacTest() override;
 
   void CreateAndInitPasswordStore(
       std::unique_ptr<password_manager::LoginDatabase> login_db);
 
   void ClosePasswordStore();
 
   // Do a store-level query to wait for all the previously enqueued operations
   // to finish.
   void FinishAsyncProcessing();
 
   // Add/Update/Remove |form| and verify the operation succeeded.
   void AddForm(const PasswordForm& form);
   void UpdateForm(const PasswordForm& form);
   void RemoveForm(const PasswordForm& form);
 
   base::FilePath test_login_db_file_path() const;
 
   // Returns the expected migration status after the password store was inited.
   MigrationStatus GetTargetStatus() const;
 
   password_manager::LoginDatabase* login_db() const {
     return store_->login_metadata_db();
   }
 
-  PasswordStoreProxyMac* store() { return store_.get(); }
+  PasswordStoreMac* store() { return store_.get(); }
 
  protected:
   content::TestBrowserThreadBundle ui_thread_;
 
   base::ScopedTempDir db_dir_;
-  scoped_refptr<PasswordStoreProxyMac> store_;
+  scoped_refptr<PasswordStoreMac> store_;
   sync_preferences::TestingPrefServiceSyncable testing_prefs_;
 };
 
-PasswordStoreProxyMacTest::PasswordStoreProxyMacTest() {
+PasswordStoreMacTest::PasswordStoreMacTest() {
   EXPECT_TRUE(db_dir_.CreateUniqueTempDir());
   chrome::RegisterUserProfilePrefs(testing_prefs_.registry());
   testing_prefs_.SetInteger(password_manager::prefs::kKeychainMigrationStatus,
                             static_cast<int>(GetParam()));
   // Ensure that LoginDatabase will use the mock keychain if it needs to
   // encrypt/decrypt a password.
   OSCryptMocker::SetUpWithSingleton();
 }
 
-PasswordStoreProxyMacTest::~PasswordStoreProxyMacTest() {
+PasswordStoreMacTest::~PasswordStoreMacTest() {
   ClosePasswordStore();
   OSCryptMocker::TearDown();
 }
 
-void PasswordStoreProxyMacTest::CreateAndInitPasswordStore(
+void PasswordStoreMacTest::CreateAndInitPasswordStore(
     std::unique_ptr<password_manager::LoginDatabase> login_db) {
-  store_ = new PasswordStoreProxyMac(
+  store_ = new PasswordStoreMac(
       BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
       std::move(login_db), &testing_prefs_);
   ASSERT_TRUE(store_->Init(syncer::SyncableService::StartSyncFlare(), nullptr));
 }
 
-void PasswordStoreProxyMacTest::ClosePasswordStore() {
+void PasswordStoreMacTest::ClosePasswordStore() {
   if (!store_)
     return;
   store_->ShutdownOnUIThread();
   EXPECT_FALSE(store_->GetBackgroundTaskRunner());
   store_ = nullptr;
 }
 
-void PasswordStoreProxyMacTest::FinishAsyncProcessing() {
+void PasswordStoreMacTest::FinishAsyncProcessing() {
   // Do a store-level query to wait for all the previously enqueued operations
   // to finish.
   MockPasswordStoreConsumer consumer;
   store_->GetLogins({PasswordForm::SCHEME_HTML, std::string(), GURL()},
                     &consumer);
   consumer.WaitForResult();
 }
 
-base::FilePath PasswordStoreProxyMacTest::test_login_db_file_path() const {
+base::FilePath PasswordStoreMacTest::test_login_db_file_path() const {
   return db_dir_.GetPath().Append(FILE_PATH_LITERAL("login.db"));
 }
 
-MigrationStatus PasswordStoreProxyMacTest::GetTargetStatus() const {
+MigrationStatus PasswordStoreMacTest::GetTargetStatus() const {
   if (GetParam() == MigrationStatus::NOT_STARTED ||
       GetParam() == MigrationStatus::FAILED_ONCE ||
       GetParam() == MigrationStatus::FAILED_TWICE) {
     return MigrationStatus::MIGRATION_STOPPED;
   }
   return GetParam();
 }
 
-void PasswordStoreProxyMacTest::AddForm(const PasswordForm& form) {
+void PasswordStoreMacTest::AddForm(const PasswordForm& form) {
   MockPasswordStoreObserver mock_observer(store());
 
   password_manager::PasswordStoreChangeList list;
   list.push_back(password_manager::PasswordStoreChange(
       password_manager::PasswordStoreChange::ADD, form));
   EXPECT_CALL(mock_observer, OnLoginsChanged(list));
   store()->AddLogin(form);
   FinishAsyncProcessing();
 }
 
-void PasswordStoreProxyMacTest::UpdateForm(const PasswordForm& form) {
+void PasswordStoreMacTest::UpdateForm(const PasswordForm& form) {
   MockPasswordStoreObserver mock_observer(store());
 
   password_manager::PasswordStoreChangeList list;
   list.push_back(password_manager::PasswordStoreChange(
       password_manager::PasswordStoreChange::UPDATE, form));
   EXPECT_CALL(mock_observer, OnLoginsChanged(list));
   store()->UpdateLogin(form);
   FinishAsyncProcessing();
 }
 
-void PasswordStoreProxyMacTest::RemoveForm(const PasswordForm& form) {
+void PasswordStoreMacTest::RemoveForm(const PasswordForm& form) {
   MockPasswordStoreObserver mock_observer(store());
 
   password_manager::PasswordStoreChangeList list;
   list.push_back(password_manager::PasswordStoreChange(
       password_manager::PasswordStoreChange::REMOVE, form));
   EXPECT_CALL(mock_observer, OnLoginsChanged(list));
   store()->RemoveLogin(form);
   FinishAsyncProcessing();
 }
 
 // ----------- Tests -------------
 
-TEST_P(PasswordStoreProxyMacTest, Sanity) {
+TEST_P(PasswordStoreMacTest, Sanity) {
   base::HistogramTester histogram_tester;
 
   CreateAndInitPasswordStore(base::MakeUnique<password_manager::LoginDatabase>(
       test_login_db_file_path()));
   FinishAsyncProcessing();
   ClosePasswordStore();
 
   int status = testing_prefs_.GetInteger(
       password_manager::prefs::kKeychainMigrationStatus);
   EXPECT_EQ(static_cast<int>(GetTargetStatus()), status);
   histogram_tester.ExpectUniqueSample(
       "PasswordManager.KeychainMigration.Status", status, 1);
 }
 
-TEST_P(PasswordStoreProxyMacTest, StartAndStop) {
+TEST_P(PasswordStoreMacTest, StartAndStop) {
   base::HistogramTester histogram_tester;
   // PasswordStore::ShutdownOnUIThread() immediately follows
   // PasswordStore::Init(). The message loop isn't running in between. Anyway,
   // PasswordStore should not collapse.
   CreateAndInitPasswordStore(base::MakeUnique<password_manager::LoginDatabase>(
       test_login_db_file_path()));
   ClosePasswordStore();
 
   histogram_tester.ExpectUniqueSample(
       "PasswordManager.KeychainMigration.Status",
       static_cast<int>(GetTargetStatus()), 1);
 }
 
-TEST_P(PasswordStoreProxyMacTest, OperationsOnABadDatabaseSilentlyFail) {
+TEST_P(PasswordStoreMacTest, OperationsOnABadDatabaseSilentlyFail) {
   // 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.
   CreateAndInitPasswordStore(base::MakeUnique<BadLoginDatabase>());
   FinishAsyncProcessing();
   EXPECT_FALSE(login_db());
 
   // The store should outlive the observer.
-  scoped_refptr<PasswordStoreProxyMac> store_refptr = store();
+  scoped_refptr<PasswordStoreMac> store_refptr = store();
   MockPasswordStoreObserver mock_observer(store());
   EXPECT_CALL(mock_observer, OnLoginsChanged(_)).Times(0);
 
   // Add a new autofillable login + a blacklisted login.
   password_manager::PasswordFormData www_form_data = {
       PasswordForm::SCHEME_HTML,
       "http://www.facebook.com/",
       "http://www.facebook.com/index.html",
       "login",
       L"username",
@@ skipping 42 matching lines @@
   store()->RemoveLoginsCreatedBetween(base::Time(), base::Time::Max(),
                                       base::Closure());
   store()->RemoveLoginsSyncedBetween(base::Time(), base::Time::Max());
   FinishAsyncProcessing();
 
   // Verify no notifications are fired during shutdown either.
   ClosePasswordStore();
 }
 
 INSTANTIATE_TEST_CASE_P(,
-                        PasswordStoreProxyMacTest,
+                        PasswordStoreMacTest,
                         testing::Values(MigrationStatus::NOT_STARTED,
                                         MigrationStatus::MIGRATED,
                                         MigrationStatus::FAILED_ONCE,
                                         MigrationStatus::FAILED_TWICE,
                                         MigrationStatus::MIGRATED_DELETED,
                                         MigrationStatus::MIGRATED_PARTIALLY,
                                         MigrationStatus::MIGRATION_STOPPED));
 
 }  // namespace