Password sync refactoring: implemented ProcessSyncChanges() and GetAllSyncData()

chrome/browser/password_manager/password_syncable_service_unittest.cc

 // Copyright 2014 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_syncable_service.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 77 matching lines @@
                void (const PasswordStoreChangeList&));
 };
 
 // Class to verify the arguments passed to |PasswordStore|.
 class PasswordStoreDataVerifier {
  public:
   PasswordStoreDataVerifier() {}
   ~PasswordStoreDataVerifier() {
     EXPECT_TRUE(expected_db_add_changes_.empty());
     EXPECT_TRUE(expected_db_update_changes_.empty());
+    EXPECT_TRUE(expected_db_delete_changes_.empty());
   }
 
   class TestSyncChangeProcessor;
 
   // Sets expected changes to the password database.
   void SetExpectedDBChanges(
       const SyncDataList& add_forms,
       const std::vector<autofill::PasswordForm*>& update_forms,
+      const std::vector<autofill::PasswordForm*>& delete_forms,
       MockPasswordStore* password_store);
   // Sets expected changes to TestSyncChangeProcessor.
   void SetExpectedSyncChanges(SyncChangeList list);
 
  private:
   // Checks that |change_list| matches |expected_sync_change_list_|.
   SyncError TestSyncChanges(const SyncChangeList& change_list);
 
   // Verifies that the |password| is present in the |expected_db_add_changes_|
   // list. If found |password| would be removed from
   // |expected_db_add_changes_| list.
   PasswordStoreChangeList VerifyAdd(const autofill::PasswordForm& password) {
     return VerifyChange(PasswordStoreChange::ADD, password,
                         &expected_db_add_changes_);
   }
 
-  // Verifies that the |password| is present in the
-  // |expected_db_update_changes_| list.

[Ilya Sherman, 2014/02/07 22:56:35]

Rather than removing this comment, please expand it to be more like the comment
on lines 116-118.

[vasilii, 2014/02/10 19:06:50]

Done.

   PasswordStoreChangeList VerifyUpdate(const autofill::PasswordForm& password) {
     return VerifyChange(PasswordStoreChange::UPDATE, password,
                         &expected_db_update_changes_);
   }
 
+  PasswordStoreChangeList VerifyDelete(const autofill::PasswordForm& password) {
+    return VerifyChange(PasswordStoreChange::REMOVE, password,
+                        &expected_db_delete_changes_);
+  }
+
   static PasswordStoreChangeList VerifyChange(
       PasswordStoreChange::Type type,
       const autofill::PasswordForm& password,
       std::vector<autofill::PasswordForm>* password_list);
 
   std::vector<autofill::PasswordForm> expected_db_add_changes_;
   std::vector<autofill::PasswordForm> expected_db_update_changes_;
+  std::vector<autofill::PasswordForm> expected_db_delete_changes_;
   SyncChangeList expected_sync_change_list_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordStoreDataVerifier);
 };
 
 class PasswordStoreDataVerifier::TestSyncChangeProcessor
     : public syncer::SyncChangeProcessor {
  public:
   explicit TestSyncChangeProcessor(PasswordStoreDataVerifier* verifier)
       : verifier_(verifier) {
@@ skipping 10 matching lines @@
   }
  private:
   PasswordStoreDataVerifier* verifier_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSyncChangeProcessor);
 };
 
 void PasswordStoreDataVerifier::SetExpectedDBChanges(
     const SyncDataList& add_forms,
     const std::vector<autofill::PasswordForm*>& update_forms,
+    const std::vector<autofill::PasswordForm*>& delete_forms,
     MockPasswordStore* password_store) {
   DCHECK(expected_db_add_changes_.empty());
   DCHECK(expected_db_update_changes_.empty());
   DCHECK(password_store);
 
   for (SyncDataList::const_iterator i = add_forms.begin();
        i != add_forms.end(); ++i) {
     autofill::PasswordForm form;
     PasswordFromSpecifics(GetPasswordSpecifics(*i), &form);
     expected_db_add_changes_.push_back(form);
@@ skipping 11 matching lines @@
        i != update_forms.end(); ++i) {
     expected_db_update_changes_.push_back(**i);
   }
   if (expected_db_update_changes_.empty()) {
     EXPECT_CALL(*password_store, UpdateLoginImpl(_)).Times(0);
   } else {
     EXPECT_CALL(*password_store, UpdateLoginImpl(_))
         .Times(expected_db_update_changes_.size())
         .WillRepeatedly(Invoke(this, &PasswordStoreDataVerifier::VerifyUpdate));
   }
+
+  for (std::vector<autofill::PasswordForm*>::const_iterator i =

[Ilya Sherman, 2014/02/07 22:56:35]

nit: i -> it

[vasilii, 2014/02/10 19:06:50]

Done.

+           delete_forms.begin();
+       i != delete_forms.end(); ++i) {
+    expected_db_delete_changes_.push_back(**i);
+  }
+  if (expected_db_delete_changes_.empty()) {
+    EXPECT_CALL(*password_store, RemoveLoginImpl(_)).Times(0);
+  } else {
+    EXPECT_CALL(*password_store, RemoveLoginImpl(_))
+        .Times(expected_db_delete_changes_.size())
+        .WillRepeatedly(Invoke(this, &PasswordStoreDataVerifier::VerifyDelete));
+  }
 }
 
 void PasswordStoreDataVerifier::SetExpectedSyncChanges(SyncChangeList list) {
   expected_sync_change_list_.swap(list);
 }
 
 SyncError PasswordStoreDataVerifier::TestSyncChanges(
     const SyncChangeList& change_list) {
   for (SyncChangeList::const_iterator it = change_list.begin();
       it != change_list.end(); ++it) {
@@ skipping 27 matching lines @@
     PasswordStoreChange::Type type,
     const autofill::PasswordForm& password,
     std::vector<autofill::PasswordForm>* password_list) {
   std::vector<autofill::PasswordForm>::iterator it =
       std::find(password_list->begin(), password_list->end(), password);
   EXPECT_NE(password_list->end(), it);
   password_list->erase(it);
   return PasswordStoreChangeList(1, PasswordStoreChange(type, password));
 }
 
-class PasswordSyncableServiceTest : public testing::Test {
+class PasswordSyncableServiceWrapper {
  public:
-  PasswordSyncableServiceTest() {}
-  virtual ~PasswordSyncableServiceTest() {}
+  PasswordSyncableServiceWrapper() {}
+  ~PasswordSyncableServiceWrapper() {}
 
-  virtual void SetUp() OVERRIDE {
+  void SetUp() {
     password_store_ = new MockPasswordStore;
     service_.reset(new MockPasswordSyncableService(password_store_));
   }
 
-  virtual void TearDown() OVERRIDE {
+  void TearDown() {
     password_store_->Shutdown();

[Nicolas Zea, 2014/02/07 21:16:47]

Can you move SetUp and TearDown into the constructor/destructor? Then you don't
have to have SetUp and TearDown in the test class either

[vasilii, 2014/02/10 19:06:50]

Done.

   }
 
+  MockPasswordStore* password_store() {
+    return password_store_;
+  }
+
+  scoped_ptr<MockPasswordSyncableService>& service() {

[Ilya Sherman, 2014/02/07 22:56:35]

Hmm, returning a scoped_ptr by reference is pretty unusual.  Would it make sense
to return a raw pointer here instead?

[vasilii, 2014/02/10 19:06:50]

In PasswordSyncableServiceTest.MergeDataAndPushBack I have to transfer ownership
of this object to MergeDataAndStartSyncing().

[Ilya Sherman, 2014/02/11 07:59:45]

I see.  It would be better -- in that it's less surprising to others reading the
code -- to separate the simple accessor method from the method that can transfer
ownership.  So, I'd recommend having two methods:

MockPasswordSyncableService* service();

// Document that this has the side-effect of NULLing out the service_.
scoped_ptr<syncer::SyncChangeProcessor> GetSyncChangeProcessor();

[vasilii, 2014/02/11 12:23:33]

Done.

+    return service_;
+  }
+
   PasswordStoreDataVerifier* verifier() {
     return &verifier_;
   }
 
   scoped_ptr<syncer::SyncChangeProcessor> ReleaseSyncChangeProcessor() {
     return make_scoped_ptr<syncer::SyncChangeProcessor>(
         new PasswordStoreDataVerifier::TestSyncChangeProcessor(verifier()));
   }
 
   // Sets the data that will be returned to the caller accessing password store.
   void SetPasswordStoreData(const std::vector<autofill::PasswordForm*>& forms) {
     EXPECT_CALL(*password_store_, FillAutofillableLogins(_))
-        .WillOnce(DoAll(SetArgPointee<0>(forms), Return(true)));
+        .WillOnce(DoAll(SetArgPointee<0>(forms), Return(true)))
+        .RetiresOnSaturation();
+    EXPECT_CALL(*password_store_, FillBlacklistLogins(_))
+        .WillOnce(Return(true))
+        .RetiresOnSaturation();
   }
 
  protected:
   scoped_refptr<MockPasswordStore> password_store_;
   scoped_ptr<MockPasswordSyncableService> service_;
   PasswordStoreDataVerifier verifier_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PasswordSyncableServiceWrapper);
+};
+
+class PasswordSyncableServiceTest : public testing::Test,
+                                    public PasswordSyncableServiceWrapper {
+ public:
+  PasswordSyncableServiceTest() {}
+  virtual ~PasswordSyncableServiceTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    PasswordSyncableServiceWrapper::SetUp();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    PasswordSyncableServiceWrapper::TearDown();
+  }
 };
 
 
 // Both sync and password db have data that are not present in the other.
 TEST_F(PasswordSyncableServiceTest, AdditionsInBoth) {
   autofill::PasswordForm* form1 = new autofill::PasswordForm;
   form1->signon_realm = "abc";
   std::vector<autofill::PasswordForm*> forms;
   forms.push_back(form1);
   SetPasswordStoreData(forms);
 
   SyncData sync_data = CreateSyncData("def");
   SyncDataList list;
   list.push_back(sync_data);
 
   verifier()->SetExpectedDBChanges(list,
                                    std::vector<autofill::PasswordForm*>(),
-                                   password_store_);
+                                   std::vector<autofill::PasswordForm*>(),
+                                   password_store());
   verifier()->SetExpectedSyncChanges(
       SyncChangeList(1, CreateSyncChange(*form1, SyncChange::ACTION_ADD)));
-  EXPECT_CALL(*service_, NotifyPasswordStoreOfLoginChanges(_));
+  EXPECT_CALL(*service(), NotifyPasswordStoreOfLoginChanges(_));
 
-  service_->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                     list,
-                                     ReleaseSyncChangeProcessor(),
-                                     scoped_ptr<syncer::SyncErrorFactory>());
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
+                                      list,
+                                      ReleaseSyncChangeProcessor(),
+                                      scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Sync has data that is not present in the password db.
 TEST_F(PasswordSyncableServiceTest, AdditionOnlyInSync) {
   SetPasswordStoreData(std::vector<autofill::PasswordForm*>());
 
   SyncData sync_data = CreateSyncData("def");
   SyncDataList list;
   list.push_back(sync_data);
 
   verifier()->SetExpectedDBChanges(list,
                                    std::vector<autofill::PasswordForm*>(),
-                                   password_store_);
+                                   std::vector<autofill::PasswordForm*>(),
+                                   password_store());
   verifier()->SetExpectedSyncChanges(SyncChangeList());
-  EXPECT_CALL(*service_, NotifyPasswordStoreOfLoginChanges(_));
+  EXPECT_CALL(*service(), NotifyPasswordStoreOfLoginChanges(_));
 
-  service_->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                     list,
-                                     ReleaseSyncChangeProcessor(),
-                                     scoped_ptr<syncer::SyncErrorFactory>());
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
+                                      list,
+                                      ReleaseSyncChangeProcessor(),
+                                      scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Passwords db has data that is not present in sync.
 TEST_F(PasswordSyncableServiceTest, AdditionOnlyInPasswordStore) {
   autofill::PasswordForm* form1 = new autofill::PasswordForm;
   form1->signon_realm = "abc";
   std::vector<autofill::PasswordForm*> forms;
   forms.push_back(form1);
   SetPasswordStoreData(forms);
 
   verifier()->SetExpectedDBChanges(SyncDataList(),
                                    std::vector<autofill::PasswordForm*>(),
-                                   password_store_);
+                                   std::vector<autofill::PasswordForm*>(),
+                                   password_store());
   verifier()->SetExpectedSyncChanges(
       SyncChangeList(1, CreateSyncChange(*form1, SyncChange::ACTION_ADD)));
   EXPECT_CALL(*service_,
               NotifyPasswordStoreOfLoginChanges(PasswordStoreChangeList()));
 
-  service_->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                     SyncDataList(),
-                                     ReleaseSyncChangeProcessor(),
-                                     scoped_ptr<syncer::SyncErrorFactory>());
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
+                                      SyncDataList(),
+                                      ReleaseSyncChangeProcessor(),
+                                      scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Both passwords db and sync contain the same data.
 TEST_F(PasswordSyncableServiceTest, BothInSync) {
   autofill::PasswordForm *form1 = new autofill::PasswordForm;
   form1->signon_realm = "abc";
   std::vector<autofill::PasswordForm*> forms;
   forms.push_back(form1);
   SetPasswordStoreData(forms);
 
   verifier()->SetExpectedDBChanges(SyncDataList(),
                                    std::vector<autofill::PasswordForm*>(),
-                                   password_store_);
+                                   std::vector<autofill::PasswordForm*>(),
+                                   password_store());
   verifier()->SetExpectedSyncChanges(SyncChangeList());
   EXPECT_CALL(*service_,
               NotifyPasswordStoreOfLoginChanges(PasswordStoreChangeList()));
 
-  service_->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                     SyncDataList(1, CreateSyncData("abc")),
-                                     ReleaseSyncChangeProcessor(),
-                                     scoped_ptr<syncer::SyncErrorFactory>());
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
+                                      SyncDataList(1, CreateSyncData("abc")),
+                                      ReleaseSyncChangeProcessor(),
+                                      scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Both passwords db and sync have the same data but they need to be merged
 // as some fields of the data differ.
 TEST_F(PasswordSyncableServiceTest, Merge) {
   autofill::PasswordForm *form1 = new autofill::PasswordForm;
   form1->signon_realm = "abc";
   form1->action = GURL("http://pie.com");
   form1->date_created = base::Time::Now();
   std::vector<autofill::PasswordForm*> forms;
   forms.push_back(form1);
   SetPasswordStoreData(forms);
 
   verifier()->SetExpectedDBChanges(SyncDataList(),
                                    forms,
-                                   password_store_);
+                                   std::vector<autofill::PasswordForm*>(),
+                                   password_store());
   verifier()->SetExpectedSyncChanges(
       SyncChangeList(1, CreateSyncChange(*form1, SyncChange::ACTION_UPDATE)));
 
-  EXPECT_CALL(*service_, NotifyPasswordStoreOfLoginChanges(_));
+  EXPECT_CALL(*service(), NotifyPasswordStoreOfLoginChanges(_));
 
-  service_->MergeDataAndStartSyncing(syncer::PASSWORDS,
-                                     SyncDataList(1, CreateSyncData("abc")),
-                                     ReleaseSyncChangeProcessor(),
-                                     scoped_ptr<syncer::SyncErrorFactory>());
+  service()->MergeDataAndStartSyncing(syncer::PASSWORDS,
+                                      SyncDataList(1, CreateSyncData("abc")),
+                                      ReleaseSyncChangeProcessor(),
+                                      scoped_ptr<syncer::SyncErrorFactory>());
 }
 
 // Initiate sync due to local DB changes.
 TEST_F(PasswordSyncableServiceTest, PasswordStoreChanges) {
   // Set the sync change processor first.
   SetPasswordStoreData(std::vector<autofill::PasswordForm*>());
   verifier()->SetExpectedSyncChanges(SyncChangeList());
   EXPECT_CALL(*service_,
               NotifyPasswordStoreOfLoginChanges(PasswordStoreChangeList()));
   service_->MergeDataAndStartSyncing(syncer::PASSWORDS,
                                      SyncDataList(),
                                      ReleaseSyncChangeProcessor(),
                                      scoped_ptr<syncer::SyncErrorFactory>());
 
   autofill::PasswordForm form1;
   form1.signon_realm = "abc";
   autofill::PasswordForm form2;
   form2.signon_realm = "def";
   autofill::PasswordForm form3;
   form3.signon_realm = "xyz";
 
   SyncChangeList sync_list;
   sync_list.push_back(CreateSyncChange(form1, SyncChange::ACTION_ADD));
   sync_list.push_back(CreateSyncChange(form2, SyncChange::ACTION_UPDATE));
   sync_list.push_back(CreateSyncChange(form3, SyncChange::ACTION_DELETE));
 
   verifier()->SetExpectedDBChanges(SyncDataList(),
                                    std::vector<autofill::PasswordForm*>(),
-                                   password_store_);
+                                   std::vector<autofill::PasswordForm*>(),
+                                   password_store());
   verifier()->SetExpectedSyncChanges(sync_list);
 
   PasswordStoreChangeList list;
   list.push_back(PasswordStoreChange(PasswordStoreChange::ADD, form1));
   list.push_back(PasswordStoreChange(PasswordStoreChange::UPDATE, form2));
   list.push_back(PasswordStoreChange(PasswordStoreChange::REMOVE, form3));
-  service_->ActOnPasswordStoreChanges(list);
+  service()->ActOnPasswordStoreChanges(list);
+}
+
+// Process all types of changes from sync.
+TEST_F(PasswordSyncableServiceTest, ProcessSyncChanges) {
+  autofill::PasswordForm *form1 = new autofill::PasswordForm;

[Ilya Sherman, 2014/02/07 22:56:35]

nit: Please use a scoped_ptr here.  If for some reason you're super opposed to
using a scoped_ptr, then please swap the space and the asterisk (" *form1" -> "*
form1").

[vasilii, 2014/02/10 19:06:50]

Done.

+  form1->signon_realm = "abc";
+  form1->action = GURL("http://foo.com");
+  form1->date_created = base::Time::Now();
+  autofill::PasswordForm *form2 = new autofill::PasswordForm;

[Ilya Sherman, 2014/02/07 22:56:35]

Ditto.

[vasilii, 2014/02/10 19:06:50]

Done.

+  form2->signon_realm = "xyz";
+  form2->action = GURL("http://bar.com");
+  form2->date_created = base::Time::Now();
+  std::vector<autofill::PasswordForm*> forms;
+  forms.push_back(form1);
+  forms.push_back(form2);
+  SetPasswordStoreData(forms);
+
+  SyncData add_data = CreateSyncData("def");
+  std::vector<autofill::PasswordForm*> updated_passwords(1, form1);
+  std::vector<autofill::PasswordForm*> deleted_passwords(1, form2);
+  verifier()->SetExpectedDBChanges(SyncDataList(1, add_data),
+                                   updated_passwords,
+                                   deleted_passwords,
+                                   password_store());
+  EXPECT_CALL(*service(), NotifyPasswordStoreOfLoginChanges(_));

[Ilya Sherman, 2014/02/07 22:56:35]

nit: Please move this to be roughly right above the call that triggers this
expectation.

[vasilii, 2014/02/10 19:06:50]

Done.

+
+  SyncChangeList list;
+  list.push_back(SyncChange(FROM_HERE,
+                            syncer::SyncChange::ACTION_ADD,
+                            add_data));
+  list.push_back(SyncChange(FROM_HERE,
+                            syncer::SyncChange::ACTION_UPDATE,
+                            CreateSyncData("abc")));
+  list.push_back(CreateSyncChange(*form2, syncer::SyncChange::ACTION_DELETE));
+  service()->ProcessSyncChanges(FROM_HERE, list);
+}
+
+// Retrives sync data from the model.
+TEST_F(PasswordSyncableServiceTest, GetAllSyncData) {
+  autofill::PasswordForm *form1 = new autofill::PasswordForm;

[Ilya Sherman, 2014/02/07 22:56:35]

Ditto.

[vasilii, 2014/02/10 19:06:50]

Done.

+  form1->signon_realm = "abc";
+  form1->action = GURL("http://foo.com");
+  autofill::PasswordForm *form2 = new autofill::PasswordForm;

[Ilya Sherman, 2014/02/07 22:56:35]

Ditto.

[vasilii, 2014/02/10 19:06:50]

Done.

+  form2->signon_realm = "xyz";
+  form2->action = GURL("http://bar.com");
+  std::vector<autofill::PasswordForm*> forms;
+  forms.push_back(form1);
+  forms.push_back(form2);
+  SetPasswordStoreData(forms);
+
+  SyncDataList expected_list;
+  expected_list.push_back(SyncDataFromPassword(*form1));
+  expected_list.push_back(SyncDataFromPassword(*form2));
+
+  verifier()->SetExpectedDBChanges(SyncDataList(),
+                                   std::vector<autofill::PasswordForm*>(),
+                                   std::vector<autofill::PasswordForm*>(),
+                                   password_store());
+
+  SyncDataList actual_list = service()->GetAllSyncData(syncer::PASSWORDS);
+  EXPECT_EQ(expected_list.size(), actual_list.size());
+  for (SyncDataList::iterator i(actual_list.begin()), j(expected_list.begin());
+       i != actual_list.end() && j != expected_list.end(); ++i, ++j) {
+    PasswordsEqual(GetPasswordSpecifics(*j), GetPasswordSpecifics(*i));
+  }
+}
+
+// Creates 2 PasswordSyncableService instances, merges the content of the first
+// one to the second one and back.
+TEST_F(PasswordSyncableServiceTest, MergeDataAndPushBack) {

[Nicolas Zea, 2014/02/07 21:16:47]

Nice.

[vasilii, 2014/02/10 19:06:50]

Done.

+  autofill::PasswordForm *form1 = new autofill::PasswordForm;

[Ilya Sherman, 2014/02/07 22:56:35]

Ditto.

[vasilii, 2014/02/10 19:06:50]

Done.

+  form1->signon_realm = "abc";
+  form1->action = GURL("http://foo.com");
+  SetPasswordStoreData(std::vector<autofill::PasswordForm*>(1, form1));
+
+  PasswordSyncableServiceWrapper other_service_wrapper;
+  other_service_wrapper.SetUp();
+  autofill::PasswordForm *form2 = new autofill::PasswordForm;
+  form2->signon_realm = "xyz";
+  form2->action = GURL("http://bar.com");
+  // SetPasswordStoreData will be called twice: from GetAllSyncData() and
+  // ProcessSyncChanges().
+  other_service_wrapper.SetPasswordStoreData(
+      std::vector<autofill::PasswordForm*>(1, form2));
+  other_service_wrapper.SetPasswordStoreData(
+      std::vector<autofill::PasswordForm*>(1,
+                                           new autofill::PasswordForm(*form2)));
+
+  verifier()->SetExpectedDBChanges(
+      SyncDataList(1, SyncDataFromPassword(*form2)),
+      std::vector<autofill::PasswordForm*>(),
+      std::vector<autofill::PasswordForm*>(),
+      password_store());
+  other_service_wrapper.verifier()->SetExpectedDBChanges(
+      SyncDataList(1, SyncDataFromPassword(*form1)),
+      std::vector<autofill::PasswordForm*>(),
+      std::vector<autofill::PasswordForm*>(),
+      other_service_wrapper.password_store());
+  EXPECT_CALL(*service(), NotifyPasswordStoreOfLoginChanges(_));
+  EXPECT_CALL(*other_service_wrapper.service(),
+              NotifyPasswordStoreOfLoginChanges(_));
+
+  service()->MergeDataAndStartSyncing(
+      syncer::PASSWORDS,
+      other_service_wrapper.service()->GetAllSyncData(syncer::PASSWORDS),
+      other_service_wrapper.service().PassAs<syncer::SyncChangeProcessor>(),
+      scoped_ptr<syncer::SyncErrorFactory>());
+  other_service_wrapper.TearDown();
 }
 
 }  // namespace