[Sync] Ensure we don't hold a transaction when we access password store.

chrome/browser/sync/glue/password_change_processor.cc

 // Copyright (c) 2011 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/sync/glue/password_change_processor.h"
 
 #include <string>
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 112 matching lines @@
   }
 }
 
 void PasswordChangeProcessor::ApplyChangesFromSyncModel(
     const sync_api::BaseTransaction* trans,
     const sync_api::SyncManager::ChangeRecord* changes,
     int change_count) {
   DCHECK(expected_loop_ == MessageLoop::current());
   if (!running())
     return;
-  StopObserving();
 
   sync_api::ReadNode password_root(trans);
   if (!password_root.InitByTagLookup(kPasswordTag)) {
     error_handler()->OnUnrecoverableError(FROM_HERE,
         "Password root node lookup failed.");
     return;
   }
 
-  PasswordModelAssociator::PasswordVector new_passwords;
-  PasswordModelAssociator::PasswordVector updated_passwords;
-  PasswordModelAssociator::PasswordVector deleted_passwords;
+  DCHECK(deleted_passwords_.empty() && new_passwords_.empty() &&
+         updated_passwords_.empty());
 
   for (int i = 0; i < change_count; ++i) {
     if (sync_api::SyncManager::ChangeRecord::ACTION_DELETE ==
         changes[i].action) {
       DCHECK(changes[i].specifics.HasExtension(sync_pb::password))
           << "Password specifics data not present on delete!";
       DCHECK(changes[i].extra.get());
       sync_api::SyncManager::ExtraPasswordChangeRecordData* extra =
           changes[i].extra.get();
       const sync_pb::PasswordSpecificsData& password = extra->unencrypted();
       webkit_glue::PasswordForm form;
       PasswordModelAssociator::CopyPassword(password, &form);
-      deleted_passwords.push_back(form);
+      deleted_passwords_.push_back(form);
       model_associator_->Disassociate(changes[i].id);
       continue;
     }
 
     sync_api::ReadNode sync_node(trans);
     if (!sync_node.InitByIdLookup(changes[i].id)) {
       error_handler()->OnUnrecoverableError(FROM_HERE,
           "Password node lookup failed.");
       return;
     }
 
     // Check that the changed node is a child of the passwords folder.
     DCHECK(password_root.GetId() == sync_node.GetParentId());
     DCHECK(syncable::PASSWORDS == sync_node.GetModelType());
 
     const sync_pb::PasswordSpecificsData& password_data =
         sync_node.GetPasswordSpecifics();
     webkit_glue::PasswordForm password;
     PasswordModelAssociator::CopyPassword(password_data, &password);
 
     if (sync_api::SyncManager::ChangeRecord::ACTION_ADD == changes[i].action) {
       std::string tag(PasswordModelAssociator::MakeTag(password));
       model_associator_->Associate(&tag, sync_node.GetId());
-      new_passwords.push_back(password);
+      new_passwords_.push_back(password);
     } else {
       DCHECK(sync_api::SyncManager::ChangeRecord::ACTION_UPDATE ==
              changes[i].action);
-      updated_passwords.push_back(password);
+      updated_passwords_.push_back(password);
     }
   }
+}
 
-  if (!model_associator_->WriteToPasswordStore(&new_passwords,
-                                               &updated_passwords,
-                                               &deleted_passwords)) {
+void PasswordChangeProcessor::CommitChangesFromSyncModel() {
+  DCHECK(expected_loop_ == MessageLoop::current());
+  if (!running())
+    return;
+  StopObserving();
+
+  if (!model_associator_->WriteToPasswordStore(&new_passwords_,
+                                               &updated_passwords_,
+                                               &deleted_passwords_)) {
     error_handler()->OnUnrecoverableError(FROM_HERE, "Error writing passwords");
     return;
   }
 
+  deleted_passwords_.clear();
+  new_passwords_.clear();
+  updated_passwords_.clear();
+
   StartObserving();
 }
 
 void PasswordChangeProcessor::StartImpl(Profile* profile) {
   DCHECK(expected_loop_ == MessageLoop::current());
   observing_ = true;
 }
 
 void PasswordChangeProcessor::StopImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   observing_ = false;
 }
 
 
 void PasswordChangeProcessor::StartObserving() {
   DCHECK(expected_loop_ == MessageLoop::current());
   notification_registrar_.Add(this,
                               NotificationType::LOGINS_CHANGED,
                               Source<PasswordStore>(password_store_));
 }
 
 void PasswordChangeProcessor::StopObserving() {
   DCHECK(expected_loop_ == MessageLoop::current());
   notification_registrar_.Remove(this,
                                  NotificationType::LOGINS_CHANGED,
                                  Source<PasswordStore>(password_store_));
 }
 
 }  // namespace browser_sync