[Sync] Have SyncableService's take ownership of their SyncChangeProcessor.

chrome/browser/search_engines/template_url_service_sync_unittest.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 "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
@@ skipping 109 matching lines @@
   void set_erroneous(bool erroneous) { erroneous_ = erroneous; }
 
  private:
   // Track the changes received in ProcessSyncChanges.
   std::map<std::string, SyncChange> change_map_;
   bool erroneous_;
 
   DISALLOW_COPY_AND_ASSIGN(TestChangeProcessor);
 };
 
+class SyncChangeProcessorDelegate : public SyncChangeProcessor {
+ public:
+  explicit SyncChangeProcessorDelegate(SyncChangeProcessor* recipient)
+      : recipient_(recipient) {
+    DCHECK(recipient_);
+  }
+  virtual ~SyncChangeProcessorDelegate() {}
+
+  // SyncChangeProcessor implementation.
+  virtual SyncError ProcessSyncChanges(
+      const tracked_objects::Location& from_here,
+      const SyncChangeList& change_list) OVERRIDE {
+    return recipient_->ProcessSyncChanges(from_here, change_list);
+  }
+
+ private:
+  // The recipient of all sync changes.
+  SyncChangeProcessor* recipient_;
+};

[sky, 2012/03/22 21:45:30]

DISALLOW_COPY_AND_ASSIGN

[Nicolas Zea, 2012/03/22 23:05:29]

Done.

+
 class TemplateURLServiceSyncTest : public testing::Test {
  public:
   typedef TemplateURLService::SyncDataMap SyncDataMap;
 
-  TemplateURLServiceSyncTest() {}
+  TemplateURLServiceSyncTest()
+      : sync_processor_(new TestChangeProcessor),
+        sync_processor_delegate_(new SyncChangeProcessorDelegate(
+            sync_processor_.get())) {}
 
   virtual void SetUp() {
     profile_a_.reset(new TestingProfile);
     TemplateURLServiceFactory::GetInstance()->RegisterUserPrefsOnProfile(
         profile_a_.get());
     model_a_.reset(new TemplateURLService(profile_a_.get()));
     model_a_->Load();
     profile_b_.reset(new TestingProfile);
     TemplateURLServiceFactory::GetInstance()->RegisterUserPrefsOnProfile(
         profile_b_.get());
     model_b_.reset(new TemplateURLService(profile_b_.get()));
     model_b_->Load();
   }
 
   virtual void TearDown() { }
 
   TemplateURLService* model() { return model_a_.get(); }
   // For readability, we redefine an accessor for Model A for use in tests that
   // involve syncing two models.
   TemplateURLService* model_a() { return model_a_.get(); }
   TemplateURLService* model_b() { return model_b_.get(); }
-  TestChangeProcessor* processor() { return &processor_; }
+  TestChangeProcessor* processor() { return sync_processor_.get(); }
+  scoped_ptr<SyncChangeProcessor> PassProcessor() {
+    return sync_processor_delegate_.PassAs<SyncChangeProcessor>();
+  }
 
   // Create a TemplateURL with some test values. The caller owns the returned
   // TemplateURL*.
   TemplateURL* CreateTestTemplateURL(const string16& keyword,
                                      const std::string& url) const {
     return CreateTestTemplateURL(keyword, url, std::string());
   }
 
   TemplateURL* CreateTestTemplateURL(const string16& keyword,
                                      const std::string& url,
@@ skipping 101 matching lines @@
   }
 
  protected:
   // We keep two TemplateURLServices to test syncing between them.
   scoped_ptr<TestingProfile> profile_a_;
   scoped_ptr<TemplateURLService> model_a_;
   scoped_ptr<TestingProfile> profile_b_;
   scoped_ptr<TemplateURLService> model_b_;
 
   // Our dummy ChangeProcessor used to inspect changes pushed to Sync.
-  TestChangeProcessor processor_;
+  scoped_ptr<TestChangeProcessor> sync_processor_;
+  scoped_ptr<SyncChangeProcessorDelegate> sync_processor_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(TemplateURLServiceSyncTest);
 };
 
 }  // namespace
 
 TEST_F(TemplateURLServiceSyncTest, SerializeDeserialize) {
   // Create a TemplateURL and convert it into a sync specific type.
   scoped_ptr<TemplateURL> turl(CreateTestTemplateURL(ASCIIToUTF16("unittest"),
       "http://www.unittest.com/"));
@@ skipping 225 matching lines @@
       "http://key1.com", std::string(), 8999);
   model()->MergeSyncAndLocalURLDuplicates(sync_turl2, sync_turl, &changes);
   result = model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1"));
   ASSERT_TRUE(result);
   EXPECT_EQ(9001, result->last_modified().ToTimeT());
   EXPECT_EQ(1U, changes.size());
 }
 
 TEST_F(TemplateURLServiceSyncTest, StartSyncEmpty) {
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, SyncDataList(),
-                                    processor());
+                                    PassProcessor());
 
   EXPECT_EQ(0U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_EQ(0, processor()->change_list_size());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeIntoEmpty) {
   SyncDataList initial_data = CreateInitialSyncData();
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   // We expect the model to have accepted all of the initial sync data. Search
   // through the model using the GUIDs to ensure that they're present.
   for (SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     std::string guid = GetGUID(*iter);
     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
   }
 
   EXPECT_EQ(0, processor()->change_list_size());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeInAllNewData) {
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("google.com"),
                                      "http://google.com", "abc"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("yahoo.com"),
                                      "http://yahoo.com", "def"));
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("bing.com"),
                                      "http://bing.com", "xyz"));
   SyncDataList initial_data = CreateInitialSyncData();
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
 
   EXPECT_EQ(6U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   // We expect the model to have accepted all of the initial sync data. Search
   // through the model using the GUIDs to ensure that they're present.
   for (SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     std::string guid = GetGUID(*iter);
     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
   }
   // All the original TemplateURLs should also remain in the model.
@@ skipping 12 matching lines @@
   // been no changes since the last time we synced. Even the last_modified
   // timestamps are the same.
   SyncDataList initial_data = CreateInitialSyncData();
   for (SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     TemplateURL* converted = Deserialize(*iter);
     model()->Add(converted);
   }
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   for (SyncDataList::const_iterator iter = initial_data.begin();
       iter != initial_data.end(); ++iter) {
     std::string guid = GetGUID(*iter);
     EXPECT_TRUE(model()->GetTemplateURLForGUID(guid));
   }
   EXPECT_EQ(0, processor()->change_list_size());
 }
 
@@ skipping 12 matching lines @@
       ASCIIToUTF16("google.com"), "http://google.ca", "abc", 9999));
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl1_newer));
 
   scoped_ptr<TemplateURL> turl2_older(CreateTestTemplateURL(
       ASCIIToUTF16("bing.com"), "http://bing.ca", "xyz", 8888));
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*turl2_older));
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
 
   // Both were local updates, so we expect the same count.
   EXPECT_EQ(2U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
 
   // Check that the first replaced the initial Google TemplateURL.
   EXPECT_EQ(turl1, model()->GetTemplateURLForGUID("abc"));
   EXPECT_EQ("http://google.ca", turl1->url()->url());
 
   // Check that the second produced an upstream update to the Bing TemplateURL.
   EXPECT_EQ(1, processor()->change_list_size());
@@ skipping 12 matching lines @@
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com",
                                      "aaa", 100));  // dupe
 
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"),
       "http://expected.com", "bbb", 100));  // keyword conflict
 
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("unique"),
                                      "http://unique.com", "ccc"));  // add
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
 
   // The dupe results in a merge. The other two should be added to the model.
   EXPECT_EQ(5U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
 
   // The key1 duplicate results in the local copy winning. Ensure that Sync's
   // copy was not added, and the local copy is pushed upstream to Sync as an
   // update. The local copy should have received the sync data's GUID.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   // Check changes for the UPDATE.
   ASSERT_TRUE(processor()->ContainsGUID("key1"));
@@ skipping 39 matching lines @@
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com",
                                      "aaa", 10));  // dupe
 
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"),
       "http://expected.com", "bbb", 10));  // keyword conflict
 
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("unique"),
                                      "http://unique.com", "ccc", 10));  // add
 
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
 
   // The dupe results in a merge. The other two should be added to the model.
   EXPECT_EQ(5U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
 
   // The key1 duplicate results in Sync's copy winning. Ensure that Sync's
   // copy replaced the local copy.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   EXPECT_FALSE(model()->GetTemplateURLForGUID("aaa"));
 
   // The key2 keyword conflict results in Sync's copy winning, so ensure it
@@ skipping 18 matching lines @@
   EXPECT_EQ(SyncChange::ACTION_ADD,
             processor()->GetChangeByGUID("bbb").change_type());
   ASSERT_TRUE(processor()->ContainsGUID("ccc"));
   EXPECT_EQ(SyncChange::ACTION_ADD,
             processor()->GetChangeByGUID("ccc").change_type());
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessChangesEmptyModel) {
   // We initially have no data.
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, SyncDataList(),
-                                    processor());
+                                    PassProcessor());
 
   // Set up a bunch of ADDs.
   SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com", "key1")));
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com", "key2")));
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key3")));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_EQ(0, processor()->change_list_size());
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessChangesNoConflicts) {
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-                                    CreateInitialSyncData(), processor());
+                                    CreateInitialSyncData(), PassProcessor());
 
   // Process different types of changes, without conflicts.
   SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key4"), "http://key4.com", "key4")));
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
                             "key2")));
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_DELETE,
       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key3")));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
 
   // Add one, remove one, update one, so the number shouldn't change.
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_EQ(0, processor()->change_list_size());
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   const TemplateURL* turl = model()->GetTemplateURLForGUID("key2");
   EXPECT_TRUE(turl);
   EXPECT_EQ(ASCIIToUTF16("newkeyword"), turl->keyword());
   EXPECT_EQ("http://new.com", turl->url()->url());
   EXPECT_FALSE(model()->GetTemplateURLForGUID("key3"));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key4"));
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithConflictsSyncWins) {
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-                                    CreateInitialSyncData(), processor());
+                                    CreateInitialSyncData(), PassProcessor());
 
   // Process different types of changes, with conflicts. Note that all this data
   // has a newer timestamp, so Sync will win in these scenarios.
   SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://new.com", "aaa")));
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key1")));
 
   model()->ProcessSyncChanges(FROM_HERE, changes);
@@ skipping 15 matching lines @@
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key1"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("key1"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3")));
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key3"));
   EXPECT_EQ(model()->GetTemplateURLForGUID("key3"),
             model()->GetTemplateURLForKeyword(ASCIIToUTF16("key3.com")));
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessChangesWithConflictsLocalWins) {
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-                                    CreateInitialSyncData(), processor());
+                                    CreateInitialSyncData(), PassProcessor());
 
   // Process different types of changes, with conflicts. Note that all this data
   // has an older timestamp, so the local data will win in these scenarios.
   SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_ADD,
       CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://new.com", "aaa",
                             10)));
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com", "key1",
                             10)));
@@ skipping 26 matching lines @@
             processor()->GetChangeByGUID("aaa").change_type());
   ASSERT_TRUE(processor()->ContainsGUID("key1"));
   EXPECT_EQ(SyncChange::ACTION_UPDATE,
             processor()->GetChangeByGUID("key1").change_type());
 }
 
 TEST_F(TemplateURLServiceSyncTest, ProcessTemplateURLChange) {
   // Ensure that ProcessTemplateURLChange is called and pushes the correct
   // changes to Sync whenever local changes are made to TemplateURLs.
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-                                    CreateInitialSyncData(), processor());
+                                    CreateInitialSyncData(), PassProcessor());
 
   // Add a new search engine.
   TemplateURL* new_turl =
       CreateTestTemplateURL(ASCIIToUTF16("baidu"), "http://baidu.cn", "new");
   model()->Add(new_turl);
   EXPECT_EQ(1, processor()->change_list_size());
   ASSERT_TRUE(processor()->ContainsGUID("new"));
   SyncChange change = processor()->GetChangeByGUID("new");
   EXPECT_EQ(SyncChange::ACTION_ADD, change.change_type());
   EXPECT_EQ("baidu", GetKeyword(change.sync_data()));
@@ skipping 14 matching lines @@
   model()->Remove(existing_turl);
   EXPECT_EQ(1, processor()->change_list_size());
   ASSERT_TRUE(processor()->ContainsGUID("key2"));
   change = processor()->GetChangeByGUID("key2");
   EXPECT_EQ(SyncChange::ACTION_DELETE, change.change_type());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeTwoClientsBasic) {
   // Start off B with some empty data.
   model_b()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-                                      CreateInitialSyncData(), processor());
+                                      CreateInitialSyncData(), PassProcessor());
 
   // Merge A and B. All of B's data should transfer over to A, which initially
   // has no data.
+  scoped_ptr<SyncChangeProcessorDelegate> delegate_b(
+      new SyncChangeProcessorDelegate(model_b()));
   model_a()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-      model_b()->GetAllSyncData(syncable::SEARCH_ENGINES), model_b());
+      model_b()->GetAllSyncData(syncable::SEARCH_ENGINES),
+      delegate_b.PassAs<SyncChangeProcessor>());
 
   // They should be consistent.
   AssertEquals(model_a()->GetAllSyncData(syncable::SEARCH_ENGINES),
                model_b()->GetAllSyncData(syncable::SEARCH_ENGINES));
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeTwoClientsDupesAndConflicts) {
   // Start off B with some empty data.
   model_b()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-                                      CreateInitialSyncData(), processor());
+                                      CreateInitialSyncData(), PassProcessor());
 
   // Set up A so we have some interesting duplicates and conflicts.
   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key4"), "http://key4.com",
                                        "key4"));  // Added
   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key2"), "http://key2.com",
                                        "key2"));  // Merge - Copy of key2.
   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key3"), "http://key3.com",
                                        "key5", 10));  // Merge - Dupe of key3.
   model_a()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key6.com",
                                        "key6", 10));  // Conflict with key1
 
   // Merge A and B.
+  scoped_ptr<SyncChangeProcessorDelegate> delegate_b(
+      new SyncChangeProcessorDelegate(model_b()));
   model_a()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-      model_b()->GetAllSyncData(syncable::SEARCH_ENGINES), model_b());
+      model_b()->GetAllSyncData(syncable::SEARCH_ENGINES),
+      delegate_b.PassAs<SyncChangeProcessor>());
 
   // They should be consistent.
   AssertEquals(model_a()->GetAllSyncData(syncable::SEARCH_ENGINES),
                model_b()->GetAllSyncData(syncable::SEARCH_ENGINES));
 }
 
 TEST_F(TemplateURLServiceSyncTest, StopSyncing) {
   SyncError error = model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-      CreateInitialSyncData(), processor());
+      CreateInitialSyncData(), PassProcessor());
   ASSERT_FALSE(error.IsSet());
   model()->StopSyncing(syncable::SEARCH_ENGINES);
 
   SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
                             "key2")));
   error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(error.IsSet());
 
   // Ensure that the sync changes were not accepted.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("newkeyword")));
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncErrorOnInitialSync) {
   processor()->set_erroneous(true);
   SyncError error = model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-      CreateInitialSyncData(), processor());
+      CreateInitialSyncData(), PassProcessor());
   EXPECT_TRUE(error.IsSet());
 
   // Ensure that if the initial merge was erroneous, then subsequence attempts
   // to push data into the local model are rejected, since the model was never
   // successfully associated with Sync in the first place.
   SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
                             "key2")));
   processor()->set_erroneous(false);
   error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(error.IsSet());
 
   // Ensure that the sync changes were not accepted.
   EXPECT_TRUE(model()->GetTemplateURLForGUID("key2"));
   EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("newkeyword")));
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncErrorOnLaterSync) {
   // Ensure that if the SyncProcessor succeeds in the initial merge, but fails
   // in future ProcessSyncChanges, we still return an error.
   SyncError error = model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-      CreateInitialSyncData(), processor());
+      CreateInitialSyncData(), PassProcessor());
   ASSERT_FALSE(error.IsSet());
 
   SyncChangeList changes;
   changes.push_back(CreateTestSyncChange(SyncChange::ACTION_UPDATE,
       CreateTestTemplateURL(ASCIIToUTF16("newkeyword"), "http://new.com",
                             "key2")));
   processor()->set_erroneous(true);
   error = model()->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(error.IsSet());
 }
 
 TEST_F(TemplateURLServiceSyncTest, MergeTwiceWithSameSyncData) {
   // Ensure that a second merge with the same data as the first does not
   // actually update the local data.
   SyncDataList initial_data;
   initial_data.push_back(CreateInitialSyncData()[0]);
 
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("key1"), "http://key1.com",
                                      "key1", 10));  // earlier
 
   SyncError error = model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-      initial_data, processor());
+      initial_data, PassProcessor());
   ASSERT_FALSE(error.IsSet());
 
   // We should have updated the original TemplateURL with Sync's version.
   // Keep a copy of it so we can compare it after we re-merge.
   ASSERT_TRUE(model()->GetTemplateURLForGUID("key1"));
   TemplateURL updated_turl(*model()->GetTemplateURLForGUID("key1"));
   EXPECT_EQ(Time::FromTimeT(90), updated_turl.last_modified());
 
   // Modify a single field of the initial data. This should not be updated in
   // the second merge, as the last_modified timestamp remains the same.
   scoped_ptr<TemplateURL> temp_turl(Deserialize(initial_data[0]));
   temp_turl->set_short_name(ASCIIToUTF16("SomethingDifferent"));
   initial_data.clear();
   initial_data.push_back(
       TemplateURLService::CreateSyncDataFromTemplateURL(*temp_turl));
 
   // Remerge the data again. This simulates shutting down and syncing again
   // at a different time, but the cloud data has not changed.
   model()->StopSyncing(syncable::SEARCH_ENGINES);
+  sync_processor_delegate_.reset(new SyncChangeProcessorDelegate(
+      sync_processor_.get()));
   error = model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-                                            initial_data, processor());
+                                            initial_data, PassProcessor());
   ASSERT_FALSE(error.IsSet());
 
   // Check that the TemplateURL was not modified.
   const TemplateURL* reupdated_turl = model()->GetTemplateURLForGUID("key1");
   ASSERT_TRUE(reupdated_turl);
   AssertEquals(updated_turl, *reupdated_turl);
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncedDefaultGUIDArrivesFirst) {
   SyncDataList initial_data = CreateInitialSyncData();
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
   model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key2"));
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
 
   // Change kSyncedDefaultSearchProviderGUID to a GUID that does not exist in
   // the model yet. Ensure that the default has not changed in any way.
   profile_a_->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, "newdefault");
@@ skipping 40 matching lines @@
   // change our default since we're not quite syncing yet.
   profile_a_->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, "key2");
 
   EXPECT_EQ(default_search, model()->GetDefaultSearchProvider());
 
   // Now sync the initial data, which will include the search engine entry
   // destined to become the new default.
   SyncDataList initial_data = CreateInitialSyncData();
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
 
   // Ensure that the new default has been set.
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   ASSERT_NE(default_search, model()->GetDefaultSearchProvider());
   ASSERT_EQ("key2", model()->GetDefaultSearchProvider()->sync_guid());
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncedDefaultAlreadySetOnStartup) {
   // Start with the default set to something in the model before we start
   // syncing.
   const char kGUID[] = "initdefault";
   model()->Add(CreateTestTemplateURL(ASCIIToUTF16("what"), "http://thewhat.com",
                                      kGUID));
   model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID(kGUID));
 
   const TemplateURL* default_search = model()->GetDefaultSearchProvider();
   ASSERT_TRUE(default_search);
 
   // Set kSyncedDefaultSearchProviderGUID to the current default.
   profile_a_->GetTestingPrefService()->SetString(
       prefs::kSyncedDefaultSearchProviderGUID, kGUID);
 
   EXPECT_EQ(default_search, model()->GetDefaultSearchProvider());
 
   // Now sync the initial data.
   SyncDataList initial_data = CreateInitialSyncData();
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
 
   // Ensure that the new entries were added and the default has not changed.
   EXPECT_EQ(4U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   ASSERT_EQ(default_search, model()->GetDefaultSearchProvider());
 }
 
 TEST_F(TemplateURLServiceSyncTest, SyncWithManagedDefaultSearch) {
   // First start off with a few entries and make sure we can set an unmanaged
   // default search provider.
   SyncDataList initial_data = CreateInitialSyncData();
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES, initial_data,
-                                    processor());
+                                    PassProcessor());
   model()->SetDefaultSearchProvider(model()->GetTemplateURLForGUID("key2"));
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   ASSERT_FALSE(model()->is_default_search_managed());
   ASSERT_TRUE(model()->GetDefaultSearchProvider());
 
   // Change the default search provider to a managed one.
   const char kName[] = "manageddefault";
   const char kSearchURL[] = "http://manageddefault.com/search?t={searchTerms}";
   const char kIconURL[] = "http://manageddefault.com/icon.jpg";
@@ skipping 35 matching lines @@
 TEST_F(TemplateURLServiceSyncTest, SyncMergeDeletesDefault) {
   // If the value from Sync is a duplicate of the local default and is newer, it
   // should safely replace the local value and set as the new default.
   TemplateURL* default_turl = CreateTestTemplateURL(ASCIIToUTF16("key1"),
       "http://key1.com", "whateverguid", 10);
   model()->Add(default_turl);
   model()->SetDefaultSearchProvider(default_turl);
 
   // The key1 entry should be a duplicate of the default.
   model()->MergeDataAndStartSyncing(syncable::SEARCH_ENGINES,
-                                    CreateInitialSyncData(), processor());
+                                    CreateInitialSyncData(), PassProcessor());
 
   EXPECT_EQ(3U, model()->GetAllSyncData(syncable::SEARCH_ENGINES).size());
   EXPECT_FALSE(model()->GetTemplateURLForGUID("whateverguid"));
   EXPECT_EQ(model()->GetDefaultSearchProvider(),
             model()->GetTemplateURLForGUID("key1"));
 }