Remove duplicated code from sync related unit tests.

chrome/browser/history/history_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.
 
 // History unit tests come in two flavors:
 //
 // 1. The more complicated style is that the unit test creates a full history
 //    service. This spawns a background thread for the history backend, and
 //    all communication is asynchronous. This is useful for testing more
 //    complicated things or end-to-end behavior.
@@ skipping 42 matching lines @@
 #include "chrome/browser/history/page_usage_data.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/tools/profiles/thumbnail-inl.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
+#include "sync/api/fake_sync_change_processor.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_change_processor.h"
+#include "sync/api/sync_change_processor_wrapper_for_test.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/protocol/history_delete_directive_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 
 using base::Time;
@@ skipping 1455 matching lines @@
   CancelableRequestConsumerT<int, 0> request_consumer;
   scoped_refptr<HistoryDBTaskImpl> task(new HistoryDBTaskImpl());
   history_service_->ScheduleDBTask(task.get(), &request_consumer);
   request_consumer.CancelAllRequests();
   CleanupHistoryService();
   // WARNING: history has now been deleted.
   history_service_.reset();
   ASSERT_FALSE(task->done_invoked);
 }
 
-// Dummy SyncChangeProcessor used to help review what SyncChanges are pushed
-// back up to Sync.
-//
-// TODO(akalin): Unify all the various test implementations of
-// syncer::SyncChangeProcessor.
-class TestChangeProcessor : public syncer::SyncChangeProcessor {
- public:
-  TestChangeProcessor() {}
-  virtual ~TestChangeProcessor() {}
-
-  virtual syncer::SyncError ProcessSyncChanges(
-      const tracked_objects::Location& from_here,
-      const syncer::SyncChangeList& change_list) OVERRIDE {
-    changes_.insert(changes_.end(), change_list.begin(), change_list.end());
-    return syncer::SyncError();
-  }
-
-  virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
-      OVERRIDE {
-    return syncer::SyncDataList();
-  }
-
-  const syncer::SyncChangeList& GetChanges() const {
-    return changes_;
-  }
-
- private:
-  syncer::SyncChangeList changes_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestChangeProcessor);
-};
-
-// SyncChangeProcessor implementation that delegates to another one.
-// This is necessary since most things expect a
-// scoped_ptr<SyncChangeProcessor>.
-//
-// TODO(akalin): Unify this too.
-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* const recipient_;
-
-  DISALLOW_COPY_AND_ASSIGN(SyncChangeProcessorDelegate);
-};
-
 // Create a local delete directive and process it while sync is
 // online, and then when offline. The delete directive should be sent to sync,
 // no error should be returned for the first time, and an error should be
 // returned for the second time.
 TEST_F(HistoryTest, ProcessLocalDeleteDirectiveSyncOnline) {
   ASSERT_TRUE(history_service_.get());
 
   const GURL test_url("http://www.google.com/");
   for (int64 i = 1; i <= 10; ++i) {
     base::Time t =
         base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(i);
     history_service_->AddPage(test_url, t, NULL, 0, GURL(),
                               history::RedirectList(),
                               content::PAGE_TRANSITION_LINK,
                               history::SOURCE_BROWSED, false);
   }
 
   sync_pb::HistoryDeleteDirectiveSpecifics delete_directive;
   sync_pb::GlobalIdDirective* global_id_directive =
       delete_directive.mutable_global_id_directive();
   global_id_directive->add_global_id(
       (base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(1))
       .ToInternalValue());
 
-  TestChangeProcessor change_processor;
+  syncer::FakeSyncChangeProcessor change_processor;
 
   EXPECT_FALSE(
       history_service_->MergeDataAndStartSyncing(
-          syncer::HISTORY_DELETE_DIRECTIVES,
-          syncer::SyncDataList(),
-          scoped_ptr<syncer::SyncChangeProcessor>(
-              new SyncChangeProcessorDelegate(&change_processor)),
-          scoped_ptr<syncer::SyncErrorFactory>()).error().IsSet());
+                            syncer::HISTORY_DELETE_DIRECTIVES,
+                            syncer::SyncDataList(),
+                            scoped_ptr<syncer::SyncChangeProcessor>(
+                                new syncer::SyncChangeProcessorWrapperForTest(
+                                    &change_processor)),
+                            scoped_ptr<syncer::SyncErrorFactory>())
+          .error()
+          .IsSet());
 
   syncer::SyncError err =
       history_service_->ProcessLocalDeleteDirective(delete_directive);
   EXPECT_FALSE(err.IsSet());
-  EXPECT_EQ(1u, change_processor.GetChanges().size());
+  EXPECT_EQ(1u, change_processor.changes().size());
 
   history_service_->StopSyncing(syncer::HISTORY_DELETE_DIRECTIVES);
   err = history_service_->ProcessLocalDeleteDirective(delete_directive);
   EXPECT_TRUE(err.IsSet());
-  EXPECT_EQ(1u, change_processor.GetChanges().size());
+  EXPECT_EQ(1u, change_processor.changes().size());
 }
 
 // Closure function that runs periodically to check result of delete directive
 // processing. Stop when timeout or processing ends indicated by the creation
 // of sync changes.
 void CheckDirectiveProcessingResult(
-    Time timeout, const TestChangeProcessor* change_processor,
+    Time timeout,
+    const syncer::FakeSyncChangeProcessor* change_processor,
     uint32 num_changes) {
   if (base::Time::Now() > timeout ||
-      change_processor->GetChanges().size() >= num_changes) {
+      change_processor->changes().size() >= num_changes) {
     return;
   }
 
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&CheckDirectiveProcessingResult, timeout,
                  change_processor, num_changes));
 }
 
@@ skipping 32 matching lines @@
   // 2nd directive.
   global_id_directive->Clear();
   global_id_directive->add_global_id(
       (base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(17))
       .ToInternalValue());
   global_id_directive->set_start_time_usec(13);
   global_id_directive->set_end_time_usec(19);
   directives.push_back(
       syncer::SyncData::CreateRemoteData(2, entity_specs, base::Time()));
 
-  TestChangeProcessor change_processor;
+  syncer::FakeSyncChangeProcessor change_processor;
   EXPECT_FALSE(
       history_service_->MergeDataAndStartSyncing(
-          syncer::HISTORY_DELETE_DIRECTIVES,
-          directives,
-          scoped_ptr<syncer::SyncChangeProcessor>(
-              new SyncChangeProcessorDelegate(&change_processor)),
-          scoped_ptr<syncer::SyncErrorFactory>()).error().IsSet());
+                            syncer::HISTORY_DELETE_DIRECTIVES,
+                            directives,
+                            scoped_ptr<syncer::SyncChangeProcessor>(
+                                new syncer::SyncChangeProcessorWrapperForTest(
+                                    &change_processor)),
+                            scoped_ptr<syncer::SyncErrorFactory>())
+          .error()
+          .IsSet());
 
   // Inject a task to check status and keep message loop filled before directive
   // processing finishes.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&CheckDirectiveProcessingResult,
                  base::Time::Now() + base::TimeDelta::FromSeconds(10),
                  &change_processor, 2));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   ASSERT_EQ(5, query_url_row_.visit_count());
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(1),
             query_url_visits_[0].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(2),
             query_url_visits_[1].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(11),
             query_url_visits_[2].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(12),
             query_url_visits_[3].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(20),
             query_url_visits_[4].visit_time);
 
   // Expect two sync changes for deleting processed directives.
-  const syncer::SyncChangeList& sync_changes = change_processor.GetChanges();
+  const syncer::SyncChangeList& sync_changes = change_processor.changes();
   ASSERT_EQ(2u, sync_changes.size());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[0].change_type());
   EXPECT_EQ(1, sync_changes[0].sync_data().GetRemoteId());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[1].change_type());
   EXPECT_EQ(2, sync_changes[1].sync_data().GetRemoteId());
 }
 
 // Create delete directives for time ranges.  The expected entries should be
 // deleted.
 TEST_F(HistoryTest, ProcessTimeRangeDeleteDirective) {
@@ skipping 24 matching lines @@
                                                           base::Time()));
 
   // 2nd directive.
   time_range_directive->Clear();
   time_range_directive->set_start_time_usec(8);
   time_range_directive->set_end_time_usec(10);
   directives.push_back(syncer::SyncData::CreateRemoteData(2,
                                                           entity_specs,
                                                           base::Time()));
 
-  TestChangeProcessor change_processor;
+  syncer::FakeSyncChangeProcessor change_processor;
   EXPECT_FALSE(
       history_service_->MergeDataAndStartSyncing(
-          syncer::HISTORY_DELETE_DIRECTIVES,
-          directives,
-          scoped_ptr<syncer::SyncChangeProcessor>(
-              new SyncChangeProcessorDelegate(&change_processor)),
-          scoped_ptr<syncer::SyncErrorFactory>()).error().IsSet());
+                            syncer::HISTORY_DELETE_DIRECTIVES,
+                            directives,
+                            scoped_ptr<syncer::SyncChangeProcessor>(
+                                new syncer::SyncChangeProcessorWrapperForTest(
+                                    &change_processor)),
+                            scoped_ptr<syncer::SyncErrorFactory>())
+          .error()
+          .IsSet());
 
   // Inject a task to check status and keep message loop filled before
   // directive processing finishes.
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&CheckDirectiveProcessingResult,
                  base::Time::Now() + base::TimeDelta::FromSeconds(10),
                  &change_processor, 2));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   ASSERT_EQ(3, query_url_row_.visit_count());
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(1),
             query_url_visits_[0].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(6),
             query_url_visits_[1].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(7),
             query_url_visits_[2].visit_time);
 
   // Expect two sync changes for deleting processed directives.
-  const syncer::SyncChangeList& sync_changes = change_processor.GetChanges();
+  const syncer::SyncChangeList& sync_changes = change_processor.changes();
   ASSERT_EQ(2u, sync_changes.size());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[0].change_type());
   EXPECT_EQ(1, sync_changes[0].sync_data().GetRemoteId());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[1].change_type());
   EXPECT_EQ(2, sync_changes[1].sync_data().GetRemoteId());
 }
 
 TEST_F(HistoryBackendDBTest, MigratePresentations) {
   // Create the db we want. Use 22 since segments didn't change in that time
   // frame.
@@ skipping 57 matching lines @@
   std::vector<PageUsageData*> results;
   db_->QuerySegmentUsage(segment_time, 10, &results);
   ASSERT_EQ(1u, results.size());
   EXPECT_EQ(url, results[0]->GetURL());
   EXPECT_EQ(segment_id, results[0]->GetID());
   EXPECT_EQ(title, results[0]->GetTitle());
   STLDeleteElements(&results);
 }
 
 }  // namespace history