sync: Process 'control' data separately

sync/engine/syncer_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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
@@ skipping 129 matching lines @@
       const base::TimeDelta& new_delay) OVERRIDE {
     last_sessions_commit_delay_seconds_ = new_delay;
   }
   virtual void OnShouldStopSyncingPermanently() OVERRIDE {
   }
   virtual void OnSyncProtocolError(
       const sessions::SyncSessionSnapshot& snapshot) OVERRIDE {
   }
 
   void GetWorkers(std::vector<ModelSafeWorker*>* out) {
-    out->push_back(worker_.get());
+    out->push_back(control_worker_.get());
+    out->push_back(passive_worker_.get());
   }
 
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
     // We're just testing the sync engine here, so we shunt everything to
     // the SyncerThread.  Datatypes which aren't enabled aren't in the map.
     for (syncable::ModelTypeSet::Iterator it = enabled_datatypes_.First();
          it.Good(); it.Inc()) {
-      (*out)[it.Get()] = GROUP_PASSIVE;
+      if (!IsInternalType(it.Get())) {
+        (*out)[it.Get()] = GROUP_PASSIVE;
+      } else {
+        (*out)[it.Get()] = GROUP_CONTROL;
+      }
     }
   }
 
   virtual void OnSyncEngineEvent(const SyncEngineEvent& event) OVERRIDE {
     DVLOG(1) << "HandleSyncEngineEvent in unittest " << event.what_happened;
     // we only test for entry-specific events, not status changed ones.
     switch (event.what_happened) {
       case SyncEngineEvent::SYNC_CYCLE_BEGIN: // Fall through.
       case SyncEngineEvent::STATUS_CHANGED:
       case SyncEngineEvent::SYNC_CYCLE_ENDED:
@@ skipping 46 matching lines @@
     } while (should_loop);
   }
 
   virtual void SetUp() {
     dir_maker_.SetUp();
     mock_server_.reset(new MockConnectionManager(directory()));
     EnableDatatype(syncable::BOOKMARKS);
     EnableDatatype(syncable::NIGORI);
     EnableDatatype(syncable::PREFERENCES);
     EnableDatatype(syncable::NIGORI);
-    worker_ = new FakeModelWorker(GROUP_PASSIVE);
+    passive_worker_ = new FakeModelWorker(GROUP_PASSIVE);
+    control_worker_ = new FakeModelWorker(GROUP_CONTROL);
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(this);
 
     ModelSafeRoutingInfo routing_info;
     std::vector<ModelSafeWorker*> workers;
 
     GetModelSafeRoutingInfo(&routing_info);
     GetWorkers(&workers);
 
     throttled_data_type_tracker_.reset(new ThrottledDataTypeTracker(NULL));
@@ skipping 314 matching lines @@
   scoped_ptr<MockConnectionManager> mock_server_;
 
   Syncer* syncer_;
 
   scoped_ptr<SyncSession> session_;
   scoped_ptr<SyncSessionContext> context_;
   bool saw_syncer_event_;
   base::TimeDelta last_short_poll_interval_received_;
   base::TimeDelta last_long_poll_interval_received_;
   base::TimeDelta last_sessions_commit_delay_seconds_;
-  scoped_refptr<ModelSafeWorker> worker_;
+  scoped_refptr<ModelSafeWorker> passive_worker_;
+  scoped_refptr<ModelSafeWorker> control_worker_;
 
   syncable::ModelTypeSet enabled_datatypes_;
   csync::TrafficRecorder traffic_recorder_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerTest);
 };
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   {
     Syncer::UnsyncedMetaHandles handles;
@@ skipping 4254 matching lines @@
 
 TEST_F(SyncerPositionTiebreakingTest, MidLowHigh) {
   Add(mid_id_);
   Add(low_id_);
   Add(high_id_);
   SyncShareNudge();
   ExpectLocalOrderIsByServerId();
 }
 
 }  // namespace csync