Open the LoginDatabase on the DB thread, not the UI thread.

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 845 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,
-    AppleKeychain* keychain,
-    password_manager::LoginDatabase* login_db)
+    scoped_ptr<AppleKeychain> keychain,
+    scoped_ptr<password_manager::LoginDatabase> login_db)
     : password_manager::PasswordStore(main_thread_runner, db_thread_runner),
-      keychain_(keychain),
-      login_metadata_db_(login_db) {
+      keychain_(keychain.Pass()),
+      login_metadata_db_(login_db.Pass()) {
   DCHECK(keychain_.get());
   DCHECK(login_metadata_db_.get());
 }
 
 PasswordStoreMac::~PasswordStoreMac() {}
 
 bool PasswordStoreMac::Init(
     const syncer::SyncableService::StartSyncFlare& flare) {
   DCHECK(content::BrowserThread::CurrentlyOn(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.";
+  }
+}
+
 void PasswordStoreMac::Shutdown() {
   DCHECK(content::BrowserThread::CurrentlyOn(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_->message_loop_proxy() : NULL;
 }
 
 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());
-  PasswordStoreChangeList changes;
-  if (AddToKeychainIfNecessary(form)) {
-    changes = login_metadata_db_->AddLogin(form);
-  }
-  return changes;
+  if (!login_metadata_db_ && AddToKeychainIfNecessary(form))

[vabr (Chromium), 2015/01/20 15:41:35]

Good catch! :)

+    return login_metadata_db_->AddLogin(form);
+  return PasswordStoreChangeList();
 }
 
 PasswordStoreChangeList PasswordStoreMac::UpdateLoginImpl(
     const PasswordForm& form) {
   DCHECK(thread_->message_loop() == base::MessageLoop::current());
+  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());
   PasswordStoreChangeList changes;
-  if (login_metadata_db_->RemoveLogin(form)) {
+  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());
     owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
     if (owned_keychain_adapter.HasPasswordExactlyMatchingForm(form)) {
       // If we don't have other forms using it (i.e., a form differing only by
       // the names of the form elements), delete the keychain entry.
       if (!DatabaseHasFormMatchingKeychainForm(form)) {
         owned_keychain_adapter.RemovePassword(form);
       }
     }
 
     changes.push_back(PasswordStoreChange(PasswordStoreChange::REMOVE, form));
   }
   return changes;
 }
 
 PasswordStoreChangeList PasswordStoreMac::RemoveLoginsCreatedBetweenImpl(
     base::Time delete_begin,
     base::Time delete_end) {
   PasswordStoreChangeList changes;
   ScopedVector<PasswordForm> forms;
-  if (login_metadata_db_->GetLoginsCreatedBetween(delete_begin, delete_end,
-                                                  &forms.get())) {
-    if (login_metadata_db_->RemoveLoginsCreatedBetween(delete_begin,
-                                                       delete_end)) {
-      RemoveKeychainForms(forms.get());
-      CleanOrphanedForms(&forms.get());
-      changes = FormsToRemoveChangeList(forms.get());
-      LogStatsForBulkDeletion(changes.size());
-    }
+  if (login_metadata_db_ &&
+      login_metadata_db_->GetLoginsCreatedBetween(delete_begin, delete_end,
+                                                  &forms.get()) &&
+      login_metadata_db_->RemoveLoginsCreatedBetween(delete_begin,
+                                                     delete_end)) {
+    RemoveKeychainForms(forms.get());
+    CleanOrphanedForms(&forms.get());
+    changes = FormsToRemoveChangeList(forms.get());
+    LogStatsForBulkDeletion(changes.size());
   }
   return changes;
 }
 
 PasswordStoreChangeList PasswordStoreMac::RemoveLoginsSyncedBetweenImpl(
     base::Time delete_begin,
     base::Time delete_end) {
   PasswordStoreChangeList changes;
   ScopedVector<PasswordForm> forms;
-  if (login_metadata_db_->GetLoginsSyncedBetween(
-          delete_begin, delete_end, &forms.get())) {
-    if (login_metadata_db_->RemoveLoginsSyncedBetween(delete_begin,
-                                                      delete_end)) {
-      RemoveKeychainForms(forms.get());
-      CleanOrphanedForms(&forms.get());
-      changes = FormsToRemoveChangeList(forms.get());
-      LogStatsForBulkDeletionDuringRollback(changes.size());
-    }
+  if (login_metadata_db_ &&
+      login_metadata_db_->GetLoginsSyncedBetween(delete_begin, delete_end,
+                                                 &forms.get()) &&
+      login_metadata_db_->RemoveLoginsSyncedBetween(delete_begin, delete_end)) {
+    RemoveKeychainForms(forms.get());
+    CleanOrphanedForms(&forms.get());
+    changes = FormsToRemoveChangeList(forms.get());
+    LogStatsForBulkDeletionDuringRollback(changes.size());
   }
   return changes;
 }
 
 void PasswordStoreMac::GetLoginsImpl(
     const autofill::PasswordForm& form,
     AuthorizationPromptPolicy prompt_policy,
     const ConsumerCallbackRunner& callback_runner) {
   chrome::ScopedSecKeychainSetUserInteractionAllowed user_interaction_allowed(
       prompt_policy == ALLOW_PROMPT);
 
+  if (!login_metadata_db_) {
+    callback_runner.Run(std::vector<PasswordForm*>());
+    return;
+  }
+
   ScopedVector<PasswordForm> database_forms;
   login_metadata_db_->GetLogins(form, &database_forms.get());
 
   // Let's gather all signon realms we want to match with keychain entries.
   std::set<std::string> realm_set;
   realm_set.insert(form.signon_realm);
   for (std::vector<PasswordForm*>::const_iterator db_form =
            database_forms.begin();
        db_form != database_forms.end();
        ++db_form) {
@@ skipping 48 matching lines @@
 void PasswordStoreMac::GetAutofillableLoginsImpl(GetLoginsRequest* request) {
   FillAutofillableLogins(request->result());
   ForwardLoginsResult(request);
 }
 
 bool PasswordStoreMac::FillAutofillableLogins(
          std::vector<PasswordForm*>* forms) {
   DCHECK(thread_->message_loop() == base::MessageLoop::current());
 
   ScopedVector<PasswordForm> database_forms;
-  if (!login_metadata_db_->GetAutofillableLogins(&database_forms.get()))
+  if (!login_metadata_db_ ||
+      !login_metadata_db_->GetAutofillableLogins(&database_forms.get()))
     return false;
 
   std::vector<PasswordForm*> merged_forms =
       internal_keychain_helpers::GetPasswordsForForms(*keychain_,
                                                       &database_forms.get());
 
   if (!database_forms.empty()) {
     RemoveDatabaseForms(database_forms.get());
     NotifyLoginsChanged(FormsToRemoveChangeList(database_forms.get()));
   }
 
   forms->insert(forms->end(), merged_forms.begin(), merged_forms.end());
   return true;
 }
 
 bool PasswordStoreMac::FillBlacklistLogins(
          std::vector<PasswordForm*>* forms) {
   DCHECK(thread_->message_loop() == base::MessageLoop::current());
-  return login_metadata_db_->GetBlacklistLogins(forms);
+  return login_metadata_db_ && login_metadata_db_->GetBlacklistLogins(forms);
 }
 
 bool PasswordStoreMac::AddToKeychainIfNecessary(const PasswordForm& form) {
   if (form.blacklisted_by_user) {
     return true;
   }
   MacKeychainPasswordFormAdapter keychainAdapter(keychain_.get());
   return keychainAdapter.AddPassword(form);
 }
 
 bool PasswordStoreMac::DatabaseHasFormMatchingKeychainForm(
     const autofill::PasswordForm& form) {
+  DCHECK(login_metadata_db_);
   bool has_match = false;
   std::vector<PasswordForm*> database_forms;
   login_metadata_db_->GetLogins(form, &database_forms);
   for (std::vector<PasswordForm*>::iterator i = database_forms.begin();
        i != database_forms.end(); ++i) {
     // Below we filter out forms with non-empty original_signon_realm, because
     // those signal fuzzy matches, and we are only interested in exact ones.
     if ((*i)->original_signon_realm.empty() &&
         internal_keychain_helpers::FormsMatchForMerge(
             form, **i, internal_keychain_helpers::STRICT_FORM_MATCH) &&
         (*i)->origin == form.origin) {
       has_match = true;
       break;
     }
   }
   STLDeleteElements(&database_forms);
   return has_match;
 }
 
 void PasswordStoreMac::RemoveDatabaseForms(
     const std::vector<PasswordForm*>& forms) {
+  DCHECK(login_metadata_db_);
   for (std::vector<PasswordForm*>::const_iterator i = forms.begin();
        i != forms.end(); ++i) {
     login_metadata_db_->RemoveLogin(**i);
   }
 }
 
 void PasswordStoreMac::RemoveKeychainForms(
     const std::vector<PasswordForm*>& forms) {
   MacKeychainPasswordFormAdapter owned_keychain_adapter(keychain_.get());
   owned_keychain_adapter.SetFindsOnlyOwnedItems(true);
   for (std::vector<PasswordForm*>::const_iterator i = forms.begin();
        i != forms.end(); ++i) {
     owned_keychain_adapter.RemovePassword(**i);
   }
 }
 
 void PasswordStoreMac::CleanOrphanedForms(std::vector<PasswordForm*>* forms) {
   DCHECK(forms);
+  DCHECK(login_metadata_db_);
+
   std::vector<PasswordForm*> database_forms;
   login_metadata_db_->GetAutofillableLogins(&database_forms);
 
   ScopedVector<PasswordForm> merged_forms;
   merged_forms.get() = internal_keychain_helpers::GetPasswordsForForms(
       *keychain_, &database_forms);
 
   // Clean up any orphaned database entries.
   RemoveDatabaseForms(database_forms);
 
   forms->insert(forms->end(), database_forms.begin(), database_forms.end());
 }