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

chrome/browser/sync/profile_sync_service_password_unittest.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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/synchronization/waitable_event.h"
 #include "base/task.h"
@@ skipping 65 matching lines @@
 ACTION_P3(MakePasswordSyncComponents, service, ps, dtc) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   PasswordModelAssociator* model_associator =
       new PasswordModelAssociator(service, ps);
   PasswordChangeProcessor* change_processor =
       new PasswordChangeProcessor(model_associator, ps, dtc);
   return ProfileSyncFactory::SyncComponents(model_associator,
                                             change_processor);
 }
 
+ACTION_P(AcquireSyncTransaction, password_test_service) {
+  // Check to make sure we can aquire a transaction (will crash if a transaction
+  // is already held by this thread, deadlock if held by another thread).
+  sync_api::WriteTransaction trans(password_test_service->GetUserShare());
+  VLOG(1) << "Sync transaction acquired.";
+}
+
 static void QuitMessageLoop() {
   MessageLoop::current()->Quit();
 }
 
 class MockPasswordStore : public PasswordStore {
  public:
   MOCK_METHOD1(RemoveLogin, void(const PasswordForm&));
   MOCK_METHOD2(GetLogins, int(const PasswordForm&, PasswordStoreConsumer*));
   MOCK_METHOD1(AddLogin, void(const PasswordForm&));
   MOCK_METHOD1(UpdateLogin, void(const PasswordForm&));
@@ skipping 34 matching lines @@
     }
 
     TestProfileSyncService::OnPassphraseAccepted();
   }
 
  private:
   Task* passphrase_accept_task_;
 };
 
 class ProfileSyncServicePasswordTest : public AbstractProfileSyncServiceTest {
+ public:
+  sync_api::UserShare* GetUserShare() {
+    return service_->GetUserShare();
+  }
  protected:
   ProfileSyncServicePasswordTest()
       : db_thread_(BrowserThread::DB) {
   }
 
   virtual void SetUp() {
     profile_.CreateRequestContext();
     password_store_ = new MockPasswordStore();
     db_thread_.Start();
 
@@ skipping 320 matching lines @@
   StartSyncService(&root_task, &node_task);
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(2U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
   EXPECT_TRUE(ComparePasswords(expected_forms[1], new_sync_forms[1]));
 }
 
+// Same as HasNativeHasEmptyNoMerge, but we attempt to aquire a sync transaction
+// every time the password store is accessed.
+TEST_F(ProfileSyncServicePasswordTest, EnsureNoTransactions) {
+  std::vector<PasswordForm*> native_forms;
+  std::vector<PasswordForm> sync_forms;
+  std::vector<PasswordForm> expected_forms;
+  {
+    PasswordForm* new_form = new PasswordForm;
+    new_form->scheme = PasswordForm::SCHEME_HTML;
+    new_form->signon_realm = "pie";
+    new_form->origin = GURL("http://pie.com");
+    new_form->action = GURL("http://pie.com/submit");
+    new_form->username_element = UTF8ToUTF16("name");
+    new_form->username_value = UTF8ToUTF16("tom");
+    new_form->password_element = UTF8ToUTF16("cork");
+    new_form->password_value = UTF8ToUTF16("password1");
+    new_form->ssl_valid = true;
+    new_form->preferred = false;
+    new_form->date_created = base::Time::FromInternalValue(1234);
+    new_form->blacklisted_by_user = false;
+
+    native_forms.push_back(new_form);
+    expected_forms.push_back(*new_form);
+  }
+
+  {
+    PasswordForm new_form;
+    new_form.scheme = PasswordForm::SCHEME_HTML;
+    new_form.signon_realm = "pie2";
+    new_form.origin = GURL("http://pie2.com");
+    new_form.action = GURL("http://pie2.com/submit");
+    new_form.username_element = UTF8ToUTF16("name2");
+    new_form.username_value = UTF8ToUTF16("tom2");
+    new_form.password_element = UTF8ToUTF16("cork2");
+    new_form.password_value = UTF8ToUTF16("password12");
+    new_form.ssl_valid = false;
+    new_form.preferred = true;
+    new_form.date_created = base::Time::FromInternalValue(12345);
+    new_form.blacklisted_by_user = false;
+    sync_forms.push_back(new_form);
+    expected_forms.push_back(new_form);
+  }
+
+  EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
+      .WillOnce(DoAll(SetArgumentPointee<0>(native_forms),
+                      AcquireSyncTransaction(this),
+                      Return(true)));
+  EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
+      .WillOnce(DoAll(AcquireSyncTransaction(this),
+                      Return(true)));
+  EXPECT_CALL(*password_store_, AddLoginImpl(_))
+      .WillOnce(AcquireSyncTransaction(this));
+
+  CreateRootTask root_task(this, syncable::PASSWORDS);
+  AddPasswordEntriesTask node_task(this, sync_forms);
+  StartSyncService(&root_task, &node_task);
+
+  std::vector<PasswordForm> new_sync_forms;
+  GetPasswordEntriesFromSyncDB(&new_sync_forms);
+
+  EXPECT_EQ(2U, new_sync_forms.size());
+  EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
+  EXPECT_TRUE(ComparePasswords(expected_forms[1], new_sync_forms[1]));
+}
+
 TEST_F(ProfileSyncServicePasswordTest, HasNativeHasSyncMergeEntry) {
   std::vector<PasswordForm*> native_forms;
   std::vector<PasswordForm> sync_forms;
   std::vector<PasswordForm> expected_forms;
   {
     PasswordForm* new_form = new PasswordForm;
     new_form->scheme = PasswordForm::SCHEME_HTML;
     new_form->signon_realm = "pie";
     new_form->origin = GURL("http://pie.com");
     new_form->action = GURL("http://pie.com/submit");
@@ skipping 52 matching lines @@
   AddPasswordEntriesTask node_task(this, sync_forms);
 
   StartSyncService(&root_task, &node_task);
 
   std::vector<PasswordForm> new_sync_forms;
   GetPasswordEntriesFromSyncDB(&new_sync_forms);
 
   EXPECT_EQ(1U, new_sync_forms.size());
   EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0]));
 }