Support for multiple sync ModelSafeWorkers....

chrome/browser/sync/engine/syncer_unittest.cc

 // Copyright (c) 2009 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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <list>
 #include <map>
 #include <set>
@@ skipping 78 matching lines @@
 using sessions::StatusController;
 using sessions::SyncSessionContext;
 using sessions::SyncSession;
 
 namespace {
 const char* kTestData = "Hello World!";
 const int kTestDataLen = 12;
 const int64 kTestLogRequestTimestamp = 123456;
 }  // namespace
 
-class SyncerTest : public testing::Test, public SyncSession::Delegate {
+class SyncerTest : public testing::Test,
+                   public SyncSession::Delegate,
+                   public ModelSafeWorkerRegistrar {
  protected:
   SyncerTest() : syncer_(NULL) {}
 
   // SyncSession::Delegate implementation.
   virtual void OnSilencedUntil(const base::TimeTicks& silenced_until) {
     FAIL() << "Should not get silenced.";
   }
   virtual bool IsSyncingCurrentlySilenced() {
     return false;
   }
   virtual void OnReceivedLongPollIntervalUpdate(
       const base::TimeDelta& new_interval) {
     last_long_poll_interval_received_ = new_interval;
   }
   virtual void OnReceivedShortPollIntervalUpdate(
       const base::TimeDelta& new_interval) {
     last_short_poll_interval_received_ = new_interval;
   }
 
+  // ModelSafeWorkerRegistrar implementation.
+  virtual void GetWorkers(std::vector<ModelSafeWorker*>* out) {
+    out->push_back(worker_.get());
+  }
+
+  virtual void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
+    // We're just testing the sync engine here, so we shunt everything to
+    // the SyncerThread.
+    (*out)[syncable::BOOKMARKS] = GROUP_PASSIVE;
+  }
+
   void HandleSyncerEvent(SyncerEvent event) {
     LOG(INFO) << "HandleSyncerEvent in unittest " << event.what_happened;
     // we only test for entry-specific events, not status changed ones.
     switch (event.what_happened) {
       case SyncerEvent::STATUS_CHANGED:
         // fall through
       case SyncerEvent::SYNC_CYCLE_ENDED:
         // fall through
       case SyncerEvent::COMMITS_SUCCEEDED:
         return;
@@ skipping 15 matching lines @@
       ASSERT_LT(++loop_iterations, 100) << "infinite loop detected. please fix";
       should_loop = syncer->SyncShare(this);
     } while (should_loop);
   }
 
   virtual void SetUp() {
     syncdb_.SetUp();
 
     mock_server_.reset(
         new MockConnectionManager(syncdb_.manager(), syncdb_.name()));
-
+    worker_.reset(new ModelSafeWorker());
     context_.reset(new SyncSessionContext(mock_server_.get(), syncdb_.manager(),
-        new ModelSafeWorker()));
+       this));
     context_->set_account_name(syncdb_.name());
     ASSERT_FALSE(context_->syncer_event_channel());
     ASSERT_FALSE(context_->resolver());
     syncer_ = new Syncer(context_.get());
     // The Syncer installs some components on the context.
     ASSERT_TRUE(context_->syncer_event_channel());
     ASSERT_TRUE(context_->resolver());
 
     hookup_.reset(NewEventListenerHookup(context_->syncer_event_channel(), this,
                                          &SyncerTest::HandleSyncerEvent));
@@ skipping 190 matching lines @@
   scoped_ptr<MockConnectionManager> mock_server_;
   scoped_ptr<EventListenerHookup> hookup_;
 
   Syncer* syncer_;
 
   scoped_ptr<SyncSession> session_;
   scoped_ptr<SyncSessionContext> context_;
   std::set<SyncerEvent> syncer_events_;
   base::TimeDelta last_short_poll_interval_received_;
   base::TimeDelta last_long_poll_interval_received_;
+  scoped_ptr<ModelSafeWorker> worker_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerTest);
 };
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   ScopedDirLookup dir(syncdb_.manager(), syncdb_.name());
   ASSERT_TRUE(dir.good());
   {
     Syncer::UnsyncedMetaHandles handles;
     {
@@ skipping 3608 matching lines @@
   Add(low_id_);
   Add(high_id_);
   syncer_->SyncShare(this);
   ExpectLocalOrderIsByServerId();
 }
 
 const SyncerTest::CommitOrderingTest
 SyncerTest::CommitOrderingTest::LAST_COMMIT_ITEM = {-1, TestIdFactory::root()};
 
 }  // namespace browser_sync