Remove duplicated code from sync related unit tests.

chrome/browser/themes/theme_syncable_service_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 "chrome/browser/themes/theme_syncable_service.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/api_permission_set.h"
 #include "extensions/common/permissions/permission_set.h"
+#include "sync/api/fake_sync_change_processor.h"
+#include "sync/api/sync_change_processor_delegator.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/protocol/theme_specifics.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #endif
 
 using std::string;
 
 namespace {
 
 static const char kCustomThemeName[] = "name";
 static const char kCustomThemeUrl[] = "http://update.url/foo";
 
 #if defined(OS_WIN)
 const base::FilePath::CharType kExtensionFilePath[] =
     FILE_PATH_LITERAL("c:\\foo");
 #elif defined(OS_POSIX)
 const base::FilePath::CharType kExtensionFilePath[] = FILE_PATH_LITERAL("/oo");
 #endif
 
-class FakeSyncChangeProcessor : public syncer::SyncChangeProcessor {
- public:
-  FakeSyncChangeProcessor() : change_output_(NULL) {}
-
-  // syncer::SyncChangeProcessor implementation.
-  virtual syncer::SyncError ProcessSyncChanges(
-        const tracked_objects::Location& from_here,
-        const syncer::SyncChangeList& change_list) OVERRIDE {
-    change_output_->insert(change_output_->end(), change_list.begin(),
-                           change_list.end());
-    return syncer::SyncError();
-  }
-
-  virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
-      OVERRIDE {
-    return syncer::SyncDataList();
-  }
-
-  void SetChangeOutput(syncer::SyncChangeList *change_output) {
-    change_output_ = change_output;
-  }
-
- private:
-  syncer::SyncChangeList *change_output_;
-};
-
 class FakeThemeService : public ThemeService {
  public:
   FakeThemeService() :
     using_native_theme_(false),
     using_default_theme_(false),
     theme_extension_(NULL),
     is_dirty_(false) {}
 
   // ThemeService implementation
   virtual void SetTheme(const extensions::Extension* extension) OVERRIDE {
@@ skipping 85 matching lines @@
         file_thread_(content::BrowserThread::FILE, &loop_),
         fake_theme_service_(NULL) {}
 
   virtual ~ThemeSyncableServiceTest() {}
 
   virtual void SetUp() {
     profile_.reset(new TestingProfile);
     fake_theme_service_ = BuildForProfile(profile_.get());
     theme_sync_service_.reset(new ThemeSyncableService(profile_.get(),
                                                        fake_theme_service_));
-    fake_change_processor_.reset(new FakeSyncChangeProcessor);
+    fake_change_processor_.reset(new syncer::FakeSyncChangeProcessor);
     SetUpExtension();
   }
 
   virtual void TearDown() {
     profile_.reset();
     loop_.RunUntilIdle();
   }
 
   void SetUpExtension() {
     CommandLine command_line(CommandLine::NO_PROGRAM);
@@ skipping 55 matching lines @@
 #if defined OS_CHROMEOS
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::ScopedTestUserManager test_user_manager_;
 #endif
 
   scoped_ptr<TestingProfile> profile_;
   FakeThemeService* fake_theme_service_;
   scoped_refptr<extensions::Extension> theme_extension_;
   scoped_ptr<ThemeSyncableService> theme_sync_service_;
-  scoped_ptr<syncer::SyncChangeProcessor> fake_change_processor_;
+  scoped_ptr<syncer::FakeSyncChangeProcessor> fake_change_processor_;
 };
 
 class PolicyInstalledThemeTest : public ThemeSyncableServiceTest {
   virtual extensions::Manifest::Location GetThemeLocation() OVERRIDE {
     return extensions::Manifest::EXTERNAL_POLICY_DOWNLOAD;
   }
 };
 
 TEST_F(ThemeSyncableServiceTest, AreThemeSpecificsEqual) {
   sync_pb::ThemeSpecifics a, b;
@@ skipping 41 matching lines @@
 
   b.set_use_system_theme_by_default(true);
   EXPECT_TRUE(ThemeSyncableService::AreThemeSpecificsEqual(a, b, false));
   EXPECT_TRUE(ThemeSyncableService::AreThemeSpecificsEqual(a, b, true));
 }
 
 TEST_F(ThemeSyncableServiceTest, SetCurrentThemeDefaultTheme) {
   // Set up theme service to use custom theme.
   fake_theme_service_->SetTheme(theme_extension_.get());
 
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, MakeThemeDataList(sync_pb::ThemeSpecifics()),
-      fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               MakeThemeDataList(sync_pb::ThemeSpecifics()),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
   EXPECT_FALSE(error.IsSet()) << error.message();
   EXPECT_TRUE(fake_theme_service_->UsingDefaultTheme());
 }
 
 TEST_F(ThemeSyncableServiceTest, SetCurrentThemeSystemTheme) {
   sync_pb::ThemeSpecifics theme_specifics;
   theme_specifics.set_use_system_theme_by_default(true);
 
   // Set up theme service to use custom theme.
   fake_theme_service_->SetTheme(theme_extension_.get());
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, MakeThemeDataList(theme_specifics),
-      fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               MakeThemeDataList(theme_specifics),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
   EXPECT_FALSE(error.IsSet()) << error.message();
   EXPECT_TRUE(fake_theme_service_->UsingNativeTheme());
 }
 
 TEST_F(ThemeSyncableServiceTest, SetCurrentThemeCustomTheme) {
   sync_pb::ThemeSpecifics theme_specifics;
   theme_specifics.set_use_custom_theme(true);
   theme_specifics.set_custom_theme_id(theme_extension_->id());
   theme_specifics.set_custom_theme_name(kCustomThemeName);
   theme_specifics.set_custom_theme_name(kCustomThemeUrl);
 
   // Set up theme service to use default theme.
   fake_theme_service_->UseDefaultTheme();
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, MakeThemeDataList(theme_specifics),
-      fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               MakeThemeDataList(theme_specifics),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
   EXPECT_FALSE(error.IsSet()) << error.message();
   EXPECT_EQ(fake_theme_service_->theme_extension(), theme_extension_.get());
 }
 
 TEST_F(ThemeSyncableServiceTest, DontResetThemeWhenSpecificsAreEqual) {
   // Set up theme service to use default theme and expect no changes.
   fake_theme_service_->UseDefaultTheme();
   fake_theme_service_->MarkClean();
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, MakeThemeDataList(sync_pb::ThemeSpecifics()),
-      fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               MakeThemeDataList(sync_pb::ThemeSpecifics()),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
   EXPECT_FALSE(error.IsSet()) << error.message();
   EXPECT_FALSE(fake_theme_service_->is_dirty());
 }
 
 TEST_F(ThemeSyncableServiceTest, UpdateThemeSpecificsFromCurrentTheme) {
   // Set up theme service to use custom theme.
   fake_theme_service_->SetTheme(theme_extension_.get());
 
-  syncer::SyncChangeList change_list;
-  static_cast<FakeSyncChangeProcessor*>(fake_change_processor_.get())->
-      SetChangeOutput(&change_list);
-
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, syncer::SyncDataList(), fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               syncer::SyncDataList(),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
   EXPECT_FALSE(error.IsSet()) << error.message();
-
-  ASSERT_EQ(1u, change_list.size());
-  EXPECT_TRUE(change_list[0].IsValid());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change_list[0].change_type());
-  EXPECT_EQ(syncer::THEMES, change_list[0].sync_data().GetDataType());
+  const syncer::SyncChangeList& changes = fake_change_processor_->changes();
+  ASSERT_EQ(1u, changes.size());
+  EXPECT_TRUE(changes[0].IsValid());
+  EXPECT_EQ(syncer::SyncChange::ACTION_ADD, changes[0].change_type());
+  EXPECT_EQ(syncer::THEMES, changes[0].sync_data().GetDataType());
 
   const sync_pb::ThemeSpecifics& theme_specifics =
-      change_list[0].sync_data().GetSpecifics().theme();
+      changes[0].sync_data().GetSpecifics().theme();
   EXPECT_TRUE(theme_specifics.use_custom_theme());
   EXPECT_EQ(theme_extension_->id(), theme_specifics.custom_theme_id());
   EXPECT_EQ(theme_extension_->name(), theme_specifics.custom_theme_name());
   EXPECT_EQ(
       extensions::ManifestURL::GetUpdateURL(theme_extension_.get()).spec(),
       theme_specifics.custom_theme_update_url());
 }
 
 TEST_F(ThemeSyncableServiceTest, GetAllSyncData) {
   // Set up theme service to use custom theme.
@@ skipping 12 matching lines @@
       extensions::ManifestURL::GetUpdateURL(theme_extension_.get()).spec(),
       theme_specifics.custom_theme_update_url());
 }
 
 TEST_F(ThemeSyncableServiceTest, ProcessSyncThemeChange) {
   // Set up theme service to use default theme.
   fake_theme_service_->UseDefaultTheme();
   fake_theme_service_->MarkClean();
 
   // Start syncing.
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, MakeThemeDataList(sync_pb::ThemeSpecifics()),
-      fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               MakeThemeDataList(sync_pb::ThemeSpecifics()),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
   EXPECT_FALSE(error.IsSet()) << error.message();
   // Don't expect theme change initially because specifics are equal.
   EXPECT_FALSE(fake_theme_service_->is_dirty());
 
   // Change specifics to use custom theme and update.
   sync_pb::ThemeSpecifics theme_specifics;
   theme_specifics.set_use_custom_theme(true);
   theme_specifics.set_custom_theme_id(theme_extension_->id());
   theme_specifics.set_custom_theme_name(kCustomThemeName);
   theme_specifics.set_custom_theme_name(kCustomThemeUrl);
   sync_pb::EntitySpecifics entity_specifics;
   entity_specifics.mutable_theme()->CopyFrom(theme_specifics);
   syncer::SyncChangeList change_list;
   change_list.push_back(syncer::SyncChange(
       FROM_HERE,
       syncer::SyncChange::ACTION_UPDATE,
       syncer::SyncData::CreateRemoteData(
           1, entity_specifics, base::Time())));
   error = theme_sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
   EXPECT_FALSE(error.IsSet()) << error.message();
   EXPECT_EQ(fake_theme_service_->theme_extension(), theme_extension_.get());
 }
 
 TEST_F(ThemeSyncableServiceTest, OnThemeChangeByUser) {
-  syncer::SyncChangeList change_list;
-  static_cast<FakeSyncChangeProcessor*>(fake_change_processor_.get())->
-      SetChangeOutput(&change_list);
-
   // Set up theme service to use default theme.
   fake_theme_service_->UseDefaultTheme();
 
   // Start syncing.
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, MakeThemeDataList(sync_pb::ThemeSpecifics()),
-      fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               MakeThemeDataList(sync_pb::ThemeSpecifics()),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
   EXPECT_FALSE(error.IsSet()) << error.message();
-  EXPECT_EQ(0u, change_list.size());
+  const syncer::SyncChangeList& changes = fake_change_processor_->changes();
+  EXPECT_EQ(0u, changes.size());
 
   // Change current theme to custom theme and notify theme_sync_service_.
   fake_theme_service_->SetTheme(theme_extension_.get());
   theme_sync_service_->OnThemeChange();
-  EXPECT_EQ(1u, change_list.size());
+  EXPECT_EQ(1u, changes.size());
   const sync_pb::ThemeSpecifics& change_specifics =
-      change_list[0].sync_data().GetSpecifics().theme();
+      changes[0].sync_data().GetSpecifics().theme();
   EXPECT_TRUE(change_specifics.use_custom_theme());
   EXPECT_EQ(theme_extension_->id(), change_specifics.custom_theme_id());
   EXPECT_EQ(theme_extension_->name(), change_specifics.custom_theme_name());
   EXPECT_EQ(
       extensions::ManifestURL::GetUpdateURL(theme_extension_.get()).spec(),
       change_specifics.custom_theme_update_url());
 }
 
 TEST_F(ThemeSyncableServiceTest, StopSync) {
-  syncer::SyncChangeList change_list;
-  static_cast<FakeSyncChangeProcessor*>(fake_change_processor_.get())->
-      SetChangeOutput(&change_list);
-
   // Set up theme service to use default theme.
   fake_theme_service_->UseDefaultTheme();
 
   // Start syncing.
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, MakeThemeDataList(sync_pb::ThemeSpecifics()),
-      fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               MakeThemeDataList(sync_pb::ThemeSpecifics()),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
   EXPECT_FALSE(error.IsSet()) << error.message();
-  EXPECT_EQ(0u, change_list.size());
+  const syncer::SyncChangeList& changes = fake_change_processor_->changes();
+  EXPECT_EQ(0u, changes.size());
 
   // Stop syncing.
   theme_sync_service_->StopSyncing(syncer::THEMES);
 
   // Change current theme to custom theme and notify theme_sync_service_.
   // No change is output because sync has stopped.
   fake_theme_service_->SetTheme(theme_extension_.get());
   theme_sync_service_->OnThemeChange();
-  EXPECT_EQ(0u, change_list.size());
+  EXPECT_EQ(0u, changes.size());
 
   // ProcessSyncChanges() should return error when sync has stopped.
-  error = theme_sync_service_->ProcessSyncChanges(FROM_HERE, change_list);
+  error = theme_sync_service_->ProcessSyncChanges(FROM_HERE, changes);
   EXPECT_TRUE(error.IsSet());
   EXPECT_EQ(syncer::THEMES, error.model_type());
   EXPECT_EQ("datatype error was encountered: Theme syncable service is not "
                 "started.",
             error.message());
 }
 
 TEST_F(ThemeSyncableServiceTest, RestoreSystemThemeBitWhenChangeToCustomTheme) {
-  syncer::SyncChangeList change_list;
-  static_cast<FakeSyncChangeProcessor*>(fake_change_processor_.get())->
-      SetChangeOutput(&change_list);
-
   // Initialize to use system theme.
   fake_theme_service_->UseDefaultTheme();
   sync_pb::ThemeSpecifics theme_specifics;
   theme_specifics.set_use_system_theme_by_default(true);
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, MakeThemeDataList(theme_specifics),
-      fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               MakeThemeDataList(theme_specifics),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
 
   // Change to custom theme and notify theme_sync_service_.
   // use_system_theme_by_default bit should be preserved.
   fake_theme_service_->SetTheme(theme_extension_.get());
   theme_sync_service_->OnThemeChange();
-  EXPECT_EQ(1u, change_list.size());
+  const syncer::SyncChangeList& changes = fake_change_processor_->changes();
+  EXPECT_EQ(1u, changes.size());
   const sync_pb::ThemeSpecifics& change_specifics =
-      change_list[0].sync_data().GetSpecifics().theme();
+      changes[0].sync_data().GetSpecifics().theme();
   EXPECT_TRUE(change_specifics.use_system_theme_by_default());
 }
 
 #if defined(TOOLKIT_GTK)
 TEST_F(ThemeSyncableServiceTest,
        GtkUpdateSystemThemeBitWhenChangeBetweenSystemAndDefault) {
-  syncer::SyncChangeList change_list;
-  static_cast<FakeSyncChangeProcessor*>(fake_change_processor_.get())->
-      SetChangeOutput(&change_list);
-
   // Initialize to use native theme.
   fake_theme_service_->SetNativeTheme();
   fake_theme_service_->MarkClean();
   sync_pb::ThemeSpecifics theme_specifics;
   theme_specifics.set_use_system_theme_by_default(true);
   syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
       syncer::THEMES, MakeThemeDataList(theme_specifics),
       fake_change_processor_.Pass(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
           error();
   EXPECT_FALSE(fake_theme_service_->is_dirty());
 
   // Change to default theme and notify theme_sync_service_.
   // use_system_theme_by_default bit should be false.
   fake_theme_service_->UseDefaultTheme();
   theme_sync_service_->OnThemeChange();
-  EXPECT_EQ(1u, change_list.size());
-  EXPECT_FALSE(change_list[0].sync_data().GetSpecifics().theme()
-               .use_system_theme_by_default());
+  const syncer::SyncChangeList& changes = fake_change_processor_->changes();
+  EXPECT_EQ(1u, changes.size());
+  EXPECT_FALSE(changes[0]
+                   .sync_data()
+                   .GetSpecifics()
+                   .theme()
+                   .use_system_theme_by_default());
 
   // Change to native theme and notify theme_sync_service_.
   // use_system_theme_by_default bit should be true.
-  change_list.clear();
+  changes.clear();
   fake_theme_service_->SetNativeTheme();
   theme_sync_service_->OnThemeChange();
-  EXPECT_EQ(1u, change_list.size());
-  EXPECT_TRUE(change_list[0].sync_data().GetSpecifics().theme()
-              .use_system_theme_by_default());
+  EXPECT_EQ(1u, changes.size());
+  EXPECT_TRUE(changes[0]
+                  .sync_data()
+                  .GetSpecifics()
+                  .theme()
+                  .use_system_theme_by_default());
 }
 #endif
 
 #ifndef TOOLKIT_GTK
 TEST_F(ThemeSyncableServiceTest,
        NonGtkPreserveSystemThemeBitWhenChangeToDefaultTheme) {
-  syncer::SyncChangeList change_list;
-  static_cast<FakeSyncChangeProcessor*>(fake_change_processor_.get())->
-      SetChangeOutput(&change_list);
-
   // Set up theme service to use default theme.
   fake_theme_service_->UseDefaultTheme();
 
   // Initialize to use custom theme with use_system_theme_by_default set true.
   sync_pb::ThemeSpecifics theme_specifics;
   theme_specifics.set_use_custom_theme(true);
   theme_specifics.set_custom_theme_id(theme_extension_->id());
   theme_specifics.set_custom_theme_name(kCustomThemeName);
   theme_specifics.set_custom_theme_name(kCustomThemeUrl);
   theme_specifics.set_use_system_theme_by_default(true);
-  syncer::SyncError error = theme_sync_service_->MergeDataAndStartSyncing(
-      syncer::THEMES, MakeThemeDataList(theme_specifics),
-      fake_change_processor_.Pass(),
-      scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock())).
-          error();
+  syncer::SyncError error =
+      theme_sync_service_->MergeDataAndStartSyncing(
+                               syncer::THEMES,
+                               MakeThemeDataList(theme_specifics),
+                               scoped_ptr<syncer::SyncChangeProcessor>(
+                                   new syncer::SyncChangeProcessorDelegator(
+                                       fake_change_processor_.get())),
+                               scoped_ptr<syncer::SyncErrorFactory>(
+                                   new syncer::SyncErrorFactoryMock())).error();
   EXPECT_EQ(fake_theme_service_->theme_extension(), theme_extension_.get());
 
   // Change to default theme and notify theme_sync_service_.
   // use_system_theme_by_default bit should be preserved.
   fake_theme_service_->UseDefaultTheme();
   theme_sync_service_->OnThemeChange();
-  EXPECT_EQ(1u, change_list.size());
+  const syncer::SyncChangeList& changes = fake_change_processor_->changes();
+  EXPECT_EQ(1u, changes.size());
   const sync_pb::ThemeSpecifics& change_specifics =
-      change_list[0].sync_data().GetSpecifics().theme();
+      changes[0].sync_data().GetSpecifics().theme();
   EXPECT_FALSE(change_specifics.use_custom_theme());
   EXPECT_TRUE(change_specifics.use_system_theme_by_default());
 }
 #endif
 
 TEST_F(PolicyInstalledThemeTest, InstallThemeByPolicy) {
   // Set up theme service to use custom theme that was installed by policy.
   fake_theme_service_->SetTheme(theme_extension_.get());
 
   syncer::SyncDataList data_list =
       theme_sync_service_->GetAllSyncData(syncer::THEMES);
 
   ASSERT_EQ(0u, data_list.size());
 }