Remove duplicated code from sync related unit tests.

chrome/browser/extensions/api/storage/settings_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/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/extensions/api/storage/leveldb_settings_storage_factory.h"
 #include "chrome/browser/extensions/api/storage/settings_frontend.h"
 #include "chrome/browser/extensions/api/storage/settings_storage_factory.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "chrome/browser/extensions/api/storage/settings_test_util.h"
 #include "chrome/browser/extensions/api/storage/syncable_settings_storage.h"
 #include "chrome/browser/extensions/test_extension_service.h"
 #include "chrome/browser/value_store/testing_value_store.h"
 #include "content/public/test/test_browser_thread.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/manifest.h"
 #include "sync/api/sync_change_processor.h"
+#include "sync/api/sync_change_processor_delegator.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using base::Value;
 using content::BrowserThread;
 
 namespace extensions {
@@ skipping 117 matching lines @@
            extension_id << "/" << key << " (out of " << changes_.size() << ")";
     }
     return matching_changes[0];
   }
 
  private:
   SettingSyncDataList changes_;
   bool fail_all_requests_;
 };
 
-class SyncChangeProcessorDelegate : public syncer::SyncChangeProcessor {
- public:
-  explicit SyncChangeProcessorDelegate(syncer::SyncChangeProcessor* recipient)
-      : recipient_(recipient) {
-    DCHECK(recipient_);
-  }
-  virtual ~SyncChangeProcessorDelegate() {}
-
-  // syncer::SyncChangeProcessor implementation.
-  virtual syncer::SyncError ProcessSyncChanges(
-      const tracked_objects::Location& from_here,
-      const syncer::SyncChangeList& change_list) OVERRIDE {
-    return recipient_->ProcessSyncChanges(from_here, change_list);
-  }
-
-  virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
-      OVERRIDE {
-    return recipient_->GetAllSyncData(type);
-  }
-
- private:
-  // The recipient of all sync changes.
-  syncer::SyncChangeProcessor* recipient_;
-
-  DISALLOW_COPY_AND_ASSIGN(SyncChangeProcessorDelegate);
-};
-
 // SettingsStorageFactory which always returns TestingValueStore objects,
 // and allows individually created objects to be returned.
 class TestingValueStoreFactory : public SettingsStorageFactory {
  public:
   TestingValueStore* GetExisting(const std::string& extension_id) {
     DCHECK(created_.count(extension_id));
     return created_[extension_id];
   }
 
   // SettingsStorageFactory implementation.
@@ skipping 16 matching lines @@
 
 }  // namespace
 
 class ExtensionSettingsSyncTest : public testing::Test {
  public:
   ExtensionSettingsSyncTest()
       : ui_thread_(BrowserThread::UI, base::MessageLoop::current()),
         file_thread_(BrowserThread::FILE, base::MessageLoop::current()),
         storage_factory_(new util::ScopedSettingsStorageFactory()),
         sync_processor_(new MockSyncChangeProcessor),
-        sync_processor_delegate_(new SyncChangeProcessorDelegate(
-            sync_processor_.get())) {}
+        sync_processor_delegate_(
+            new syncer::SyncChangeProcessorDelegator(sync_processor_.get())) {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     profile_.reset(new util::MockProfile(temp_dir_.path()));
     storage_factory_->Reset(new LeveldbSettingsStorageFactory());
     frontend_.reset(
         SettingsFrontend::Create(storage_factory_.get(), profile_.get()));
   }
 
   virtual void TearDown() OVERRIDE {
@@ skipping 39 matching lines @@
   // Need these so that the DCHECKs for running on FILE or UI threads pass.
   base::MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   base::ScopedTempDir temp_dir_;
   scoped_ptr<util::MockProfile> profile_;
   scoped_ptr<SettingsFrontend> frontend_;
   scoped_refptr<util::ScopedSettingsStorageFactory> storage_factory_;
   scoped_ptr<MockSyncChangeProcessor> sync_processor_;
-  scoped_ptr<SyncChangeProcessorDelegate> sync_processor_delegate_;
+  scoped_ptr<syncer::SyncChangeProcessorDelegator> sync_processor_delegate_;
 };
 
 // Get a semblance of coverage for both EXTENSION_SETTINGS and APP_SETTINGS
 // sync by roughly alternative which one to test.
 
 TEST_F(ExtensionSettingsSyncTest, NoDataDoesNotInvokeSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
@@ skipping 391 matching lines @@
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
   GetSyncableService(syncer::EXTENSION_SETTINGS)->
       StopSyncing(syncer::EXTENSION_SETTINGS);
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   sync_data.clear();
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2, syncer::APP_SETTINGS));
 
-  scoped_ptr<SyncChangeProcessorDelegate> app_settings_delegate_(
-      new SyncChangeProcessorDelegate(sync_processor_.get()));
+  scoped_ptr<syncer::SyncChangeProcessorDelegator> app_settings_delegate_(
+      new syncer::SyncChangeProcessorDelegator(sync_processor_.get()));
   GetSyncableService(syncer::APP_SETTINGS)->MergeDataAndStartSyncing(
       syncer::APP_SETTINGS,
       sync_data,
       app_settings_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
   GetSyncableService(syncer::APP_SETTINGS)->
       StopSyncing(syncer::APP_SETTINGS);
   EXPECT_EQ(0u, sync_processor_->changes().size());
 }
 
@@ skipping 131 matching lines @@
   }
   {
     base::DictionaryValue dict;
     dict.Set("bar", fooValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Restarting sync should make bad start syncing again.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
-  sync_processor_delegate_.reset(new SyncChangeProcessorDelegate(
-      sync_processor_.get()));
+  sync_processor_delegate_.reset(
+      new syncer::SyncChangeProcessorDelegator(sync_processor_.get()));
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type,
       syncer::SyncDataList(),
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   // Local settings will have been pushed to sync, since it's empty (in this
   // test; presumably it wouldn't be live, since we've been getting changes).
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
@@ skipping 259 matching lines @@
     base::DictionaryValue dict;
     dict.Set("foo", fooValue.DeepCopy());
     dict.Set("bar", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Re-enabling sync without failing should cause the local changes from bad
   // to be pushed to sync successfully, as should future changes to bad.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
-  sync_processor_delegate_.reset(new SyncChangeProcessorDelegate(
-      sync_processor_.get()));
+  sync_processor_delegate_.reset(
+      new syncer::SyncChangeProcessorDelegator(sync_processor_.get()));
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type,
       syncer::SyncDataList(),
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
@@ skipping 72 matching lines @@
   }
   {
     base::DictionaryValue dict;
     dict.Set("foo", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Restarting sync makes everything work again.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
-  sync_processor_delegate_.reset(new SyncChangeProcessorDelegate(
-      sync_processor_.get()));
+  sync_processor_delegate_.reset(
+      new syncer::SyncChangeProcessorDelegator(sync_processor_.get()));
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type,
       syncer::SyncDataList(),
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
@@ skipping 75 matching lines @@
   }
   {
     base::DictionaryValue dict;
     dict.Set("foo", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Restarting sync makes everything work again.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
-  sync_processor_delegate_.reset(new SyncChangeProcessorDelegate(
-      sync_processor_.get()));
+  sync_processor_delegate_.reset(
+      new syncer::SyncChangeProcessorDelegator(sync_processor_.get()));
   GetSyncableService(model_type)->MergeDataAndStartSyncing(
       model_type,
       syncer::SyncDataList(),
       sync_processor_delegate_.PassAs<syncer::SyncChangeProcessor>(),
       scoped_ptr<syncer::SyncErrorFactory>(new syncer::SyncErrorFactoryMock()));
 
   EXPECT_EQ(
       syncer::SyncChange::ACTION_ADD,
       sync_processor_->GetOnlyChange("good", "foo").change_type());
   EXPECT_EQ(
@@ skipping 100 matching lines @@
     ASSERT_EQ(1u, sync_processor_->changes().size());
     SettingSyncData sync_data = sync_processor_->changes()[0];
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, sync_data.change_type());
     EXPECT_EQ("ext", sync_data.extension_id());
     EXPECT_EQ("key.with.spot", sync_data.key());
     EXPECT_TRUE(sync_data.value().Equals(string_value.get()));
   }
 }
 
 }  // namespace extensions