Remove duplicated code from sync related unit tests.

chrome/browser/spellchecker/spellcheck_custom_dictionary_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 <vector>
 
 #include "base/file_util.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/spellchecker/spellcheck_custom_dictionary.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/browser/spellchecker/spellcheck_service.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "sync/api/sync_change.h"
+#include "sync/api/sync_change_processor_delegator.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 // For version specific disabled tests below (http://crbug.com/230534).
 #include "base/win/windows_version.h"
@@ skipping 73 matching lines @@
       const SpellcheckCustomDictionary::Change& change) {
     return dictionary.Apply(change);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   TestingProfile profile_;
   net::TestURLFetcherFactory fetcher_factory_;
 };
 
-// A wrapper around SpellcheckCustomDictionary that does not own the wrapped
-// object. An instance of this class can be inside of a scoped pointer safely
-// while the dictionary is managed by another scoped pointer.
-class SyncChangeProcessorDelegate : public syncer::SyncChangeProcessor {
- public:
-  explicit SyncChangeProcessorDelegate(SpellcheckCustomDictionary* dictionary)
-      : dictionary_(dictionary) {}
-  virtual ~SyncChangeProcessorDelegate() {}
-
-  // Overridden from syncer::SyncChangeProcessor:
-  virtual syncer::SyncError ProcessSyncChanges(
-      const tracked_objects::Location& from_here,
-      const syncer::SyncChangeList& change_list) OVERRIDE {
-    return dictionary_->ProcessSyncChanges(from_here, change_list);
-  }
-
-  virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
-      OVERRIDE {
-    return syncer::SyncDataList();
-  }
-
- private:
-  SpellcheckCustomDictionary* dictionary_;
-  DISALLOW_COPY_AND_ASSIGN(SyncChangeProcessorDelegate);
-};
-
 // An implementation of SyncErrorFactory that does not upload the error message
 // and updates an outside error counter. This lets us know the number of error
 // messages in an instance of this class after that instance is deleted.
 class SyncErrorFactoryStub : public syncer::SyncErrorFactory {
  public:
   explicit SyncErrorFactoryStub(int* error_counter)
       : error_counter_(error_counter) {}
   virtual ~SyncErrorFactoryStub() {}
 
   // Overridden from syncer::SyncErrorFactory:
@@ skipping 328 matching lines @@
 
   SpellcheckCustomDictionary::Change change2;
   for (size_t i = 0;
        i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2;
        ++i) {
     change2.AddWord("bar" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary2, change2);
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(

[groby-ooo-7-16, 2014/02/06 19:52:04]

nit: this indentation seems wrong. I'd expect
EXPECT_FALSE(
    custom_dictionary->MergeDataAndStartSyncing(
        syncer::DICTIONARY,
        ...)
    .error()
    .IsSet());

If clang-format is happy with this, I'm happy, though :)

[maniscalco, 2014/02/06 20:05:27]

Surprised me too.  This is what I ended up with after "git cl format".

[groby-ooo-7-16, 2014/02/06 22:03:17]

Odd. Let's leave it for this CL - no need to fight the format gods - but I've
filed http://crbug.com/341587 to address the clang issue, in case you're
interested.

[groby-ooo-7-16, 2014/02/06 22:16:55]

FWIW - this is semi-expected behavior from clang-format. According to thakis,
this might be a heuristic the formatter applies to make the code more readable
by not keeping params and function calls on the same indentation. TMYK :)

+                             syncer::DICTIONARY,
+                             custom_dictionary2->GetAllSyncData(
+                                 syncer::DICTIONARY),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   WordSet words = custom_dictionary->GetWords();
   WordSet words2 = custom_dictionary2->GetWords();
   EXPECT_EQ(words.size(), words2.size());
   EXPECT_EQ(words, words2);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigBeforeSyncing) {
@@ skipping 11 matching lines @@
 
   SpellcheckCustomDictionary::Change change;
   for (size_t i = 0;
        i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1;
        ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, change);
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(
+                             syncer::DICTIONARY,
+                             custom_dictionary2->GetAllSyncData(
+                                 syncer::DICTIONARY),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
@@ skipping 25 matching lines @@
   change.AddWord("foo");
   Apply(*custom_dictionary, change);
   Apply(*custom_dictionary2, change2);
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(
+                             syncer::DICTIONARY,
+                             custom_dictionary2->GetAllSyncData(
+                                 syncer::DICTIONARY),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 1,
             custom_dictionary->GetWords().size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
@@ skipping 24 matching lines @@
   }
   Apply(*custom_dictionary, change);
   Apply(*custom_dictionary2, change2);
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary2->GetWords().size());
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      GetAllSyncDataNoLimit(custom_dictionary2),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(
+                             syncer::DICTIONARY,
+                             GetAllSyncDataNoLimit(custom_dictionary2),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 2,
             custom_dictionary->GetWords().size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
@@ skipping 19 matching lines @@
        i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1;
        ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, change);
 
   custom_dictionary2->AddWord("bar");
   custom_dictionary2->AddWord("baz");
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(
+                             syncer::DICTIONARY,
+                             custom_dictionary2->GetAllSyncData(
+                                 syncer::DICTIONARY),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
             custom_dictionary->GetWords().size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary2->GetWords().size());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
@@ skipping 16 matching lines @@
 
   SpellcheckCustomDictionary::Change change;
   for (size_t i = 0;
        i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1;
        ++i) {
     change.AddWord("foo" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, change);
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(
+                             syncer::DICTIONARY,
+                             custom_dictionary2->GetAllSyncData(
+                                 syncer::DICTIONARY),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   custom_dictionary->AddWord("bar");
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   custom_dictionary->AddWord("baz");
   EXPECT_EQ(0, error_counter);
   EXPECT_FALSE(custom_dictionary->IsSyncing());
@@ skipping 18 matching lines @@
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
   custom_dictionary->AddWord("foo");
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(
+                             syncer::DICTIONARY,
+                             custom_dictionary2->GetAllSyncData(
+                                 syncer::DICTIONARY),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   WordList custom_words;
   custom_words.push_back("bar");
   OnLoaded(*custom_dictionary, custom_words);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   EXPECT_EQ(2UL, custom_dictionary->GetWords().size());
   EXPECT_EQ(2UL, custom_dictionary2->GetWords().size());
@@ skipping 11 matching lines @@
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
   custom_dictionary->AddWord("foo");
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(
+                             syncer::DICTIONARY,
+                             custom_dictionary2->GetAllSyncData(
+                                 syncer::DICTIONARY),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   WordList custom_words;
   for (size_t i = 0;
        i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
        ++i) {
     custom_words.push_back("foo" + base::Uint64ToString(i));
   }
   OnLoaded(*custom_dictionary, custom_words);
@@ skipping 26 matching lines @@
 
   WordList to_add;
   for (size_t i = 0;
        i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2;
        ++i) {
     to_add.push_back("foo" + base::Uint64ToString(i));
   }
   Apply(*custom_dictionary, SpellcheckCustomDictionary::Change(to_add));
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(
+                             syncer::DICTIONARY,
+                             custom_dictionary2->GetAllSyncData(
+                                 syncer::DICTIONARY),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   OnLoaded(*custom_dictionary, to_add);
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
             custom_dictionary->GetWords().size());
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
@@ skipping 90 matching lines @@
   custom_dictionary2->AddWord("foo");
   custom_dictionary2->AddWord("baz");
 
   DictionaryObserverCounter observer;
   custom_dictionary->AddObserver(&observer);
 
   DictionaryObserverCounter observer2;
   custom_dictionary2->AddObserver(&observer2);
 
   int error_counter = 0;
-  EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-      syncer::DICTIONARY,
-      custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
-      scoped_ptr<syncer::SyncChangeProcessor>(
-          new SyncChangeProcessorDelegate(custom_dictionary2)),
-      scoped_ptr<syncer::SyncErrorFactory>(
-          new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+  EXPECT_FALSE(
+      custom_dictionary->MergeDataAndStartSyncing(
+                             syncer::DICTIONARY,
+                             custom_dictionary2->GetAllSyncData(
+                                 syncer::DICTIONARY),
+                             scoped_ptr<syncer::SyncChangeProcessor>(
+                                 new syncer::SyncChangeProcessorDelegator(
+                                     custom_dictionary2)),
+                             scoped_ptr<syncer::SyncErrorFactory>(
+                                 new SyncErrorFactoryStub(&error_counter)))
+          .error()
+          .IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
   EXPECT_EQ(1, observer.changes());
   EXPECT_EQ(1, observer2.changes());
 
   custom_dictionary->RemoveObserver(&observer);
   custom_dictionary2->RemoveObserver(&observer2);
 }
 
@@ skipping 21 matching lines @@
 
     SpellcheckCustomDictionary::Change change;
     for (size_t i = 0;
          i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
          ++i) {
       change.AddWord("foo" + base::Uint64ToString(i));
     }
     Apply(*custom_dictionary, change);
 
     int error_counter = 0;
-    EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
-        syncer::DICTIONARY,
-        server_custom_dictionary->GetAllSyncData(syncer::DICTIONARY),
-        scoped_ptr<syncer::SyncChangeProcessor>(
-            new SyncChangeProcessorDelegate(server_custom_dictionary)),
-        scoped_ptr<syncer::SyncErrorFactory>(
-            new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+    EXPECT_FALSE(
+        custom_dictionary->MergeDataAndStartSyncing(
+                               syncer::DICTIONARY,
+                               server_custom_dictionary->GetAllSyncData(
+                                   syncer::DICTIONARY),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       server_custom_dictionary)),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new SyncErrorFactoryStub(&error_counter)))
+            .error()
+            .IsSet());
     EXPECT_EQ(0, error_counter);
     EXPECT_TRUE(custom_dictionary->IsSyncing());
     EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
               custom_dictionary->GetWords().size());
   }
 
   // The sync server now has the maximum number of words.
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             server_custom_dictionary->GetWords().size());
 
@@ skipping 16 matching lines @@
     SpellcheckCustomDictionary::Change change;
     for (size_t i = 0;
          i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
          ++i) {
       change.AddWord("bar" + base::Uint64ToString(i));
     }
     Apply(*client_custom_dictionary, change);
 
     // Associate the server and the client.
     int error_counter = 0;
-    EXPECT_FALSE(client_custom_dictionary->MergeDataAndStartSyncing(
-        syncer::DICTIONARY,
-        server_custom_dictionary->GetAllSyncData(syncer::DICTIONARY),
-        scoped_ptr<syncer::SyncChangeProcessor>(
-            new SyncChangeProcessorDelegate(server_custom_dictionary)),
-        scoped_ptr<syncer::SyncErrorFactory>(
-            new SyncErrorFactoryStub(&error_counter))).error().IsSet());
+    EXPECT_FALSE(
+        client_custom_dictionary
+            ->MergeDataAndStartSyncing(
+                  syncer::DICTIONARY,
+                  server_custom_dictionary->GetAllSyncData(syncer::DICTIONARY),
+                  scoped_ptr<syncer::SyncChangeProcessor>(
+                      new syncer::SyncChangeProcessorDelegator(
+                          server_custom_dictionary)),
+                  scoped_ptr<syncer::SyncErrorFactory>(
+                      new SyncErrorFactoryStub(&error_counter)))
+            .error()
+            .IsSet());
     EXPECT_EQ(0, error_counter);
     EXPECT_FALSE(client_custom_dictionary->IsSyncing());
     EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2,
               client_custom_dictionary->GetWords().size());
   }
 
   // The sync server should not receive more words, because it has the maximum
   // number of words already.
   EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
             server_custom_dictionary->GetWords().size());
@@ skipping 55 matching lines @@
       SpellcheckServiceFactory::GetForContext(&profile_);
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   OnLoaded(*custom_dictionary, WordList());
   EXPECT_FALSE(custom_dictionary->HasWord("foo"));
   EXPECT_FALSE(custom_dictionary->HasWord("bar"));
   custom_dictionary->AddWord("foo");
   EXPECT_TRUE(custom_dictionary->HasWord("foo"));
   EXPECT_FALSE(custom_dictionary->HasWord("bar"));
 }