Revert 45640 - Send out notifications when logins are changed through Passwor...

chrome/browser/password_manager/password_store_mac.cc

 // Copyright (c) 2009 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 <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/mac_util.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
-#include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/keychain_mac.h"
 #include "chrome/browser/password_manager/login_database.h"
-#include "chrome/browser/password_manager/password_store_change.h"
 
 using webkit_glue::PasswordForm;
 
 // Utility class to handle the details of constructing and running a keychain
 // search from a set of attributes.
 class KeychainSearch {
  public:
   explicit KeychainSearch(const MacKeychain& keychain);
   ~KeychainSearch();
 
@@ skipping 680 matching lines @@
 #pragma mark -
 
 PasswordStoreMac::PasswordStoreMac(MacKeychain* keychain,
                                    LoginDatabase* login_db)
     : keychain_(keychain), login_metadata_db_(login_db) {
   DCHECK(keychain_.get());
   DCHECK(login_metadata_db_.get());
 }
 
 PasswordStoreMac::~PasswordStoreMac() {
-  if (thread_.get()) {
-    thread_->message_loop()->DeleteSoon(FROM_HERE,
-                                        notification_service_.release());
-    thread_->message_loop()->RunAllPending();
-  }
 }
 
 bool PasswordStoreMac::Init() {
   thread_.reset(new base::Thread("Chrome_PasswordStore_Thread"));
 
   if (!thread_->Start()) {
     thread_.reset(NULL);
     return false;
   }
-  ScheduleTask(NewRunnableMethod(this,
-                                 &PasswordStoreMac::CreateNotificationService));
   return PasswordStore::Init();
 }
 
 void PasswordStoreMac::ScheduleTask(Task* task) {
   if (thread_.get()) {
     thread_->message_loop()->PostTask(FROM_HERE, task);
   }
 }
 
 void PasswordStoreMac::AddLoginImpl(const PasswordForm& form) {
   if (AddToKeychainIfNecessary(form)) {
-    if (login_metadata_db_->AddLogin(form)) {
-      PasswordStoreChangeList changes;
-      changes.push_back(PasswordStoreChange(PasswordStoreChange::ADD, form));
-      NotificationService::current()->Notify(
-          NotificationType::LOGINS_CHANGED,
-          NotificationService::AllSources(),
-          Details<PasswordStoreChangeList>(&changes));
-    }
+    login_metadata_db_->AddLogin(form);
   }
 }
 
 void PasswordStoreMac::UpdateLoginImpl(const PasswordForm& form) {
   // 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)) {
     int update_count = 0;
-    if (login_metadata_db_->UpdateLogin(form, &update_count)) {
-      // Update will catch any database entries that we already had, but we
-      // could also be updating a keychain-only form, in which case we need to
-      // add.
-      PasswordStoreChangeList changes;
-      if (update_count == 0) {
-        if (login_metadata_db_->AddLogin(form)) {
-          changes.push_back(PasswordStoreChange(PasswordStoreChange::ADD,
-                                                form));
-        }
-      } else {
-        changes.push_back(PasswordStoreChange(PasswordStoreChange::UPDATE,
-                                              form));
-      }
-      if (!changes.empty()) {
-        NotificationService::current()->Notify(
-            NotificationType::LOGINS_CHANGED,
-            NotificationService::AllSources(),
-            Details<PasswordStoreChangeList>(&changes));
-      }
+    login_metadata_db_->UpdateLogin(form, &update_count);
+    // Update will catch any database entries that we already had, but we could
+    // also be updating a keychain-only form, in which case we need to add.
+    if (update_count == 0) {
+      login_metadata_db_->AddLogin(form);
     }
   }
 }
 
 void PasswordStoreMac::RemoveLoginImpl(const PasswordForm& form) {
-  if (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);
-    PasswordForm* owned_password_form =
-        owned_keychain_adapter.PasswordExactlyMatchingForm(form);
-    if (owned_password_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);
-      }
+  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);
+  PasswordForm* owned_password_form =
+      owned_keychain_adapter.PasswordExactlyMatchingForm(form);
+  if (owned_password_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);
     }
-
-    PasswordStoreChangeList changes;
-    changes.push_back(PasswordStoreChange(PasswordStoreChange::REMOVE, form));
-    NotificationService::current()->Notify(
-        NotificationType::LOGINS_CHANGED,
-        NotificationService::AllSources(),
-        Details<PasswordStoreChangeList>(&changes));
   }
 }
 
 void PasswordStoreMac::RemoveLoginsCreatedBetweenImpl(
     const base::Time& delete_begin, const base::Time& delete_end) {
-  std::vector<PasswordForm*> forms;
-  if (login_metadata_db_->GetLoginsCreatedBetween(delete_begin, delete_end,
-                                                  &forms)) {
-    if (login_metadata_db_->RemoveLoginsCreatedBetween(delete_begin,
-                                                       delete_end)) {
-      // We can't delete from the Keychain by date because we may be sharing
-      // items with database entries that weren't in the delete range. Instead,
-      // we find all the Keychain items we own but aren't using any more and
-      // delete those.
-      std::vector<PasswordForm*> orphan_keychain_forms =
-          GetUnusedKeychainForms();
-      // This is inefficient, since we have to re-look-up each keychain item
-      // one at a time to delete it even though the search step already had a
-      // list of Keychain item references. If this turns out to be noticeably
-      // slow we'll need to rearchitect to allow the search and deletion steps
-      // to share.
-      RemoveKeychainForms(orphan_keychain_forms);
-      STLDeleteElements(&orphan_keychain_forms);
+  login_metadata_db_->RemoveLoginsCreatedBetween(delete_begin, delete_end);
 
-      PasswordStoreChangeList changes;
-      for (std::vector<PasswordForm*>::const_iterator it = forms.begin();
-           it != forms.end(); ++it) {
-        changes.push_back(PasswordStoreChange(PasswordStoreChange::REMOVE,
-                                              **it));
-      }
-      NotificationService::current()->Notify(
-          NotificationType::LOGINS_CHANGED,
-          NotificationService::AllSources(),
-          Details<PasswordStoreChangeList>(&changes));
-    }
-  }
+  // We can't delete from the Keychain by date because we may be sharing items
+  // with database entries that weren't in the delete range. Instead, we find
+  // all the Keychain items we own but aren't using any more and delete those.
+  std::vector<PasswordForm*> orphan_keychain_forms = GetUnusedKeychainForms();
+  // This is inefficient, since we have to re-look-up each keychain item one at
+  // a time to delete it even though the search step already had a list of
+  // Keychain item references. If this turns out to be noticeably slow we'll
+  // need to rearchitect to allow the search and deletion steps to share.
+  RemoveKeychainForms(orphan_keychain_forms);
+  STLDeleteElements(&orphan_keychain_forms);
 }
 
 void PasswordStoreMac::GetLoginsImpl(GetLoginsRequest* request,
                                      const webkit_glue::PasswordForm& form) {
   MacKeychainPasswordFormAdapter keychain_adapter(keychain_.get());
   std::vector<PasswordForm*> keychain_forms =
       keychain_adapter.PasswordsFillingForm(form);
 
   std::vector<PasswordForm*> database_forms;
   login_metadata_db_->GetLogins(form, &database_forms);
@@ skipping 96 matching lines @@
 
 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::CreateNotificationService() {
-  notification_service_.reset(new NotificationService);
-}