Support for multiple sync ModelSafeWorkers....

chrome/browser/sync/engine/syncer_thread_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.
 
 #include <list>
 #include <map>
 #include <set>
 
 #include "base/command_line.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "base/waitable_event.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/syncer_thread.h"
 #include "chrome/browser/sync/sessions/sync_session_context.h"
 #include "chrome/test/sync/engine/mock_server_connection.h"
 #include "chrome/test/sync/engine/test_directory_setter_upper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeTicks;
 using base::TimeDelta;
 
 namespace browser_sync {
 using sessions::SyncSessionContext;
 
 typedef testing::Test SyncerThreadTest;
 typedef SyncerThread::WaitInterval WaitInterval;
 
-class SyncerThreadWithSyncerTest : public testing::Test {
+class SyncerThreadWithSyncerTest : public testing::Test,
+                                   public ModelSafeWorkerRegistrar {
  public:
   SyncerThreadWithSyncerTest() : sync_cycle_ended_event_(false, false) {}
   virtual void SetUp() {
     metadb_.SetUp();
     connection_.reset(new MockConnectionManager(metadb_.manager(),
                                                 metadb_.name()));
     allstatus_.reset(new AllStatus());
+    worker_.reset(new ModelSafeWorker());
     SyncSessionContext* context = new SyncSessionContext(connection_.get(),
-        metadb_.manager(), new ModelSafeWorker());
+        metadb_.manager(), this);
     syncer_thread_ = new SyncerThread(context, allstatus_.get());
     syncer_event_hookup_.reset(
         NewEventListenerHookup(syncer_thread_->relay_channel(), this,
             &SyncerThreadWithSyncerTest::HandleSyncerEvent));
     allstatus_->WatchSyncerThread(syncer_thread_);
     syncer_thread_->SetConnected(true);
   }
   virtual void TearDown() {
     syncer_thread_ = NULL;
     allstatus_.reset();
     connection_.reset();
     metadb_.TearDown();
   }
 
+  // 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;
+  }
+
   ManuallyOpenedTestDirectorySetterUpper* metadb() { return &metadb_; }
   MockConnectionManager* connection() { return connection_.get(); }
   SyncerThread* syncer_thread() { return syncer_thread_; }
 
   // Waits an indefinite amount of sync cycles for the syncer thread to become
   // throttled.  Only call this if a throttle is supposed to occur!
   void WaitForThrottle() {
     while (!syncer_thread()->IsSyncingCurrentlySilenced())
       sync_cycle_ended_event_.Wait();
   }
 
  private:
 
   void HandleSyncerEvent(const SyncerEvent& event) {
     if (event.what_happened == SyncerEvent::SYNC_CYCLE_ENDED)
       sync_cycle_ended_event_.Signal();
   }
 
   ManuallyOpenedTestDirectorySetterUpper metadb_;
   scoped_ptr<MockConnectionManager> connection_;
   scoped_ptr<AllStatus> allstatus_;
   scoped_refptr<SyncerThread> syncer_thread_;
+  scoped_ptr<ModelSafeWorker> worker_;
   scoped_ptr<EventListenerHookup> syncer_event_hookup_;
   base::WaitableEvent sync_cycle_ended_event_;
   DISALLOW_COPY_AND_ASSIGN(SyncerThreadWithSyncerTest);
 };
 
 class SyncShareIntercept : public MockConnectionManager::ThrottleRequestVisitor,
                            public MockConnectionManager::MidCommitObserver {
  public:
   SyncShareIntercept() : sync_occured_(false, false),
                          allow_multiple_interceptions_(true) {}
@@ skipping 534 matching lines @@
   // Wait until the syncer thread reports that it is throttled.  Any further
   // sync share interceptions will result in failure.  If things are broken,
   // we may never halt.
   WaitForThrottle();
   EXPECT_TRUE(syncer_thread()->IsSyncingCurrentlySilenced());
 
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 }  // namespace browser_sync