Integrate PasswordStoreProxyMac instead of PasswordStoreMac.

chrome/browser/password_manager/password_store_mac.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 "chrome/browser/password_manager/password_store_mac_internal.h"
 
 #include <CoreServices/CoreServices.h>
 #include <set>
 #include <string>
@@ skipping 900 matching lines @@
 OSType MacKeychainPasswordFormAdapter::CreatorCodeForSearch() {
   return finds_only_owned_ ? base::mac::CreatorCodeForApplication() : 0;
 }
 
 #pragma mark -
 
 PasswordStoreMac::PasswordStoreMac(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_runner,
     scoped_refptr<base::SingleThreadTaskRunner> db_thread_runner,
     scoped_ptr<AppleKeychain> keychain,
-    scoped_ptr<password_manager::LoginDatabase> login_db)
+    password_manager::LoginDatabase* login_db)
     : password_manager::PasswordStore(main_thread_runner, db_thread_runner),
       keychain_(keychain.Pass()),
-      login_metadata_db_(login_db.Pass()) {
+      login_metadata_db_(login_db) {
   DCHECK(keychain_.get());
-  DCHECK(login_metadata_db_.get());
   login_metadata_db_->set_clear_password_values(true);
 }
 
 PasswordStoreMac::~PasswordStoreMac() {}
 
-bool PasswordStoreMac::Init(
-    const syncer::SyncableService::StartSyncFlare& flare) {
+void PasswordStoreMac::InitWithTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> background_task_runner) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  thread_.reset(new base::Thread("Chrome_PasswordStore_Thread"));
-
-  if (!thread_->Start()) {
-    thread_.reset(NULL);
-    return false;
-  }
-
-  ScheduleTask(base::Bind(&PasswordStoreMac::InitOnBackgroundThread, this));
-  return password_manager::PasswordStore::Init(flare);
-}
-
-void PasswordStoreMac::InitOnBackgroundThread() {
-  DCHECK(thread_->message_loop() == base::MessageLoop::current());
-  DCHECK(login_metadata_db_);
-  if (!login_metadata_db_->Init()) {
-    login_metadata_db_.reset();
-    LOG(ERROR) << "Could not create/open login database.";
-  }
+  db_thread_runner_ = background_task_runner;
 }
 
 void PasswordStoreMac::Shutdown() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   password_manager::PasswordStore::Shutdown();
-  thread_->Stop();
 }
 
-// Mac stores passwords in the system keychain, which can block for an
-// arbitrarily long time (most notably, it can block on user confirmation
-// from a dialog). Run tasks on a dedicated thread to avoid blocking the DB
-// thread.
-scoped_refptr<base::SingleThreadTaskRunner>
-PasswordStoreMac::GetBackgroundTaskRunner() {
-  return (thread_.get()) ? thread_->task_runner() : NULL;
+bool PasswordStoreMac::Init(
+    const syncer::SyncableService::StartSyncFlare& flare) {
+  // The class should be used inside PasswordStoreProxyMac only.
+  NOTREACHED();
+  return true;
 }
 
 void PasswordStoreMac::ReportMetricsImpl(const std::string& sync_username,
                                          bool custom_passphrase_sync_enabled) {
   if (!login_metadata_db_)
     return;
   login_metadata_db_->ReportMetrics(sync_username,
                                     custom_passphrase_sync_enabled);
 }
 
 PasswordStoreChangeList PasswordStoreMac::AddLoginImpl(
     const PasswordForm& form) {
-  DCHECK(thread_->message_loop() == base::MessageLoop::current());
+  DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   if (login_metadata_db_ && AddToKeychainIfNecessary(form))
     return login_metadata_db_->AddLogin(form);
   return PasswordStoreChangeList();
 }
 
 PasswordStoreChangeList PasswordStoreMac::UpdateLoginImpl(
     const PasswordForm& form) {
-  DCHECK(thread_->message_loop() == base::MessageLoop::current());
+  DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   if (!login_metadata_db_)
     return PasswordStoreChangeList();
 
   PasswordStoreChangeList changes = login_metadata_db_->UpdateLogin(form);
 
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_.get());
   if (changes.empty() &&
       !keychain_adapter.HasPasswordsMergeableWithForm(form)) {
     // If the password isn't in either the DB or the keychain, then it must have
     // been deleted after autofill happened, and should not be re-added.
     return changes;
   }
 
   // The keychain add will update if there is a collision and add if there
   // isn't, which is the behavior we want, so there's no separate update call.
   if (AddToKeychainIfNecessary(form) && changes.empty()) {
     changes = login_metadata_db_->AddLogin(form);
   }
   return changes;
 }
 
 PasswordStoreChangeList PasswordStoreMac::RemoveLoginImpl(
     const PasswordForm& form) {
-  DCHECK(thread_->message_loop() == base::MessageLoop::current());
+  DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   PasswordStoreChangeList changes;
   if (login_metadata_db_ && login_metadata_db_->RemoveLogin(form)) {
     // See if we own a Keychain item associated with this item. We can do an
     // exact search rather than messing around with trying to do fuzzy matching
     // because passwords that we created will always have an exact-match
     // database entry.
     // (If a user does lose their profile but not their keychain we'll treat the
     // entries we find like other imported entries anyway, so it's reasonable to
     // handle deletes on them the way we would for an imported item.)
     MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_.get());
@@ skipping 91 matching lines @@
   AppendSecondToFirst(&matched_forms, &keychain_forms);
 
   if (!database_forms.empty()) {
     RemoveDatabaseForms(&database_forms);
     NotifyLoginsChanged(FormsToRemoveChangeList(database_forms.get()));
   }
 
   return matched_forms.Pass();
 }
 
-void PasswordStoreMac::GetBlacklistLoginsImpl(
-    scoped_ptr<PasswordStore::GetLoginsRequest> request) {
-  ScopedVector<PasswordForm> obtained_forms;
-  if (!FillBlacklistLogins(&obtained_forms))
-    obtained_forms.clear();
-  request->NotifyConsumerWithResults(obtained_forms.Pass());
-}
-
-void PasswordStoreMac::GetAutofillableLoginsImpl(
-    scoped_ptr<PasswordStore::GetLoginsRequest> request) {
-  ScopedVector<PasswordForm> obtained_forms;
-  if (!FillAutofillableLogins(&obtained_forms))
-    obtained_forms.clear();
-  request->NotifyConsumerWithResults(obtained_forms.Pass());
-}
-
 bool PasswordStoreMac::FillAutofillableLogins(
     ScopedVector<PasswordForm>* forms) {
-  DCHECK_EQ(thread_->message_loop(), base::MessageLoop::current());
+  DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   forms->clear();
 
   ScopedVector<PasswordForm> database_forms;
   if (!login_metadata_db_ ||
       !login_metadata_db_->GetAutofillableLogins(&database_forms))
     return false;
 
   internal_keychain_helpers::GetPasswordsForForms(*keychain_, &database_forms,
                                                   forms);
 
   if (!database_forms.empty()) {
     RemoveDatabaseForms(&database_forms);
     NotifyLoginsChanged(FormsToRemoveChangeList(database_forms.get()));
   }
 
   return true;
 }
 
 bool PasswordStoreMac::FillBlacklistLogins(ScopedVector<PasswordForm>* forms) {
-  DCHECK_EQ(thread_->message_loop(), base::MessageLoop::current());
+  DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   return login_metadata_db_ && login_metadata_db_->GetBlacklistLogins(forms);
 }
 
 void PasswordStoreMac::AddSiteStatsImpl(
     const password_manager::InteractionsStats& stats) {
-  DCHECK(thread_->message_loop() == base::MessageLoop::current());
+  DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   if (login_metadata_db_)
     login_metadata_db_->stats_table().AddRow(stats);
 }
 
 void PasswordStoreMac::RemoveSiteStatsImpl(const GURL& origin_domain) {
-  DCHECK(thread_->message_loop() == base::MessageLoop::current());
+  DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   if (login_metadata_db_)
     login_metadata_db_->stats_table().RemoveRow(origin_domain);
 }
 
 scoped_ptr<password_manager::InteractionsStats>
 PasswordStoreMac::GetSiteStatsImpl(const GURL& origin_domain) {
-  DCHECK(thread_->message_loop() == base::MessageLoop::current());
+  DCHECK(GetBackgroundTaskRunner()->BelongsToCurrentThread());
   return login_metadata_db_
              ? login_metadata_db_->stats_table().GetRow(origin_domain)
              : scoped_ptr<password_manager::InteractionsStats>();
 }
 
 bool PasswordStoreMac::AddToKeychainIfNecessary(const PasswordForm& form) {
   if (form.blacklisted_by_user || !form.federation_url.is_empty())
     return true;
   MacKeychainPasswordFormAdapter keychainAdapter(keychain_.get());
   return keychainAdapter.AddPassword(form);
@@ skipping 55 matching lines @@
   ScopedVector<PasswordForm> forms_with_keychain_entry;
   internal_keychain_helpers::GetPasswordsForForms(*keychain_, &database_forms,
                                                   &forms_with_keychain_entry);
 
   // Clean up any orphaned database entries.
   RemoveDatabaseForms(&database_forms);
 
   // Move the orphaned DB forms to the output parameter.
   AppendSecondToFirst(orphaned_forms, &database_forms);
 }