sync: Process 'control' data separately

sync/sessions/sync_session_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 "sync/sessions/sync_session.h"
 
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
@@ skipping 38 matching lines @@
     context_.reset(
         new SyncSessionContext(
             NULL, NULL, routing_info, workers, &extensions_activity_monitor_,
             throttled_data_type_tracker_.get(),
             std::vector<SyncEngineEventListener*>(), NULL, NULL));
     routes_.clear();
     routes_[syncable::BOOKMARKS] = GROUP_UI;
     routes_[syncable::AUTOFILL] = GROUP_DB;
     scoped_refptr<ModelSafeWorker> passive_worker(
         new FakeModelWorker(GROUP_PASSIVE));
+    scoped_refptr<ModelSafeWorker> control_worker(
+        new FakeModelWorker(GROUP_CONTROL));
     scoped_refptr<ModelSafeWorker> ui_worker(
         new FakeModelWorker(GROUP_UI));
     scoped_refptr<ModelSafeWorker> db_worker(
         new FakeModelWorker(GROUP_DB));
     workers_.clear();
+    workers_.push_back(control_worker);
     workers_.push_back(passive_worker);
     workers_.push_back(ui_worker);
     workers_.push_back(db_worker);
     session_.reset(MakeSession());
     throttled_data_type_tracker_.reset(new ThrottledDataTypeTracker(NULL));
   }
   virtual void TearDown() {
     session_.reset();
     context_.reset();
   }
@@ skipping 62 matching lines @@
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
   scoped_ptr<ThrottledDataTypeTracker> throttled_data_type_tracker_;
 };
 
 TEST_F(SyncSessionTest, EnabledGroupsEmpty) {
   routes_.clear();
   workers_.clear();
   scoped_ptr<SyncSession> session(MakeSession());
   std::set<ModelSafeGroup> expected_enabled_groups;
   expected_enabled_groups.insert(GROUP_PASSIVE);
+  expected_enabled_groups.insert(GROUP_CONTROL);
   EXPECT_EQ(expected_enabled_groups, session->GetEnabledGroups());
 }
 
 TEST_F(SyncSessionTest, EnabledGroups) {
   scoped_ptr<SyncSession> session(MakeSession());
   std::set<ModelSafeGroup> expected_enabled_groups;
   expected_enabled_groups.insert(GROUP_PASSIVE);
+  expected_enabled_groups.insert(GROUP_CONTROL);
   expected_enabled_groups.insert(GROUP_UI);
   expected_enabled_groups.insert(GROUP_DB);
   EXPECT_EQ(expected_enabled_groups, session->GetEnabledGroups());
 }
 
 TEST_F(SyncSessionTest, EnabledGroupsWithConflictsEmpty) {
   scoped_ptr<SyncSession> session(MakeSession());
   // Auto-create conflict progress.  This shouldn't put that group in
   // conflict.
   session->mutable_status_controller()->
@@ skipping 110 matching lines @@
           std::string());
   syncable::ModelTypePayloadMap all_types =
       syncable::ModelTypePayloadMapFromEnumSet(
           ParamsMeaningAllEnabledTypes(),
           std::string());
   SyncSourceInfo source_one(sync_pb::GetUpdatesCallerInfo::PERIODIC, one_type);
   SyncSourceInfo source_two(sync_pb::GetUpdatesCallerInfo::LOCAL, all_types);
 
   scoped_refptr<ModelSafeWorker> passive_worker(
       new FakeModelWorker(GROUP_PASSIVE));
+  scoped_refptr<ModelSafeWorker> control_worker(
+      new FakeModelWorker(GROUP_CONTROL));
   scoped_refptr<ModelSafeWorker> db_worker(new FakeModelWorker(GROUP_DB));
   scoped_refptr<ModelSafeWorker> ui_worker(new FakeModelWorker(GROUP_UI));
   workers_one.push_back(passive_worker);
+  workers_one.push_back(control_worker);
   workers_one.push_back(db_worker);
   workers_two.push_back(passive_worker);
+  workers_two.push_back(control_worker);
   workers_two.push_back(db_worker);
   workers_two.push_back(ui_worker);
   routes_one[syncable::AUTOFILL] = GROUP_DB;
   routes_two[syncable::AUTOFILL] = GROUP_DB;
   routes_two[syncable::BOOKMARKS] = GROUP_UI;
   SyncSession one(context_.get(), this, source_one, routes_one, workers_one);
   SyncSession two(context_.get(), this, source_two, routes_two, workers_two);
 
   std::set<ModelSafeGroup> expected_enabled_groups_one;
   expected_enabled_groups_one.insert(GROUP_PASSIVE);
+  expected_enabled_groups_one.insert(GROUP_CONTROL);
   expected_enabled_groups_one.insert(GROUP_DB);
 
   std::set<ModelSafeGroup> expected_enabled_groups_two;
   expected_enabled_groups_two.insert(GROUP_PASSIVE);
+  expected_enabled_groups_two.insert(GROUP_CONTROL);
   expected_enabled_groups_two.insert(GROUP_DB);
   expected_enabled_groups_two.insert(GROUP_UI);
 
   EXPECT_EQ(expected_enabled_groups_one, one.GetEnabledGroups());
   EXPECT_EQ(expected_enabled_groups_two, two.GetEnabledGroups());
 
   one.Coalesce(two);
 
   EXPECT_EQ(expected_enabled_groups_two, one.GetEnabledGroups());
   EXPECT_EQ(expected_enabled_groups_two, two.GetEnabledGroups());
@@ skipping 18 matching lines @@
           std::string());
   syncable::ModelTypePayloadMap all_types =
       syncable::ModelTypePayloadMapFromEnumSet(
           ParamsMeaningAllEnabledTypes(),
           std::string());
   SyncSourceInfo source_one(sync_pb::GetUpdatesCallerInfo::PERIODIC, one_type);
   SyncSourceInfo source_two(sync_pb::GetUpdatesCallerInfo::LOCAL, all_types);
 
   scoped_refptr<ModelSafeWorker> passive_worker(
       new FakeModelWorker(GROUP_PASSIVE));
+  scoped_refptr<ModelSafeWorker> control_worker(
+      new FakeModelWorker(GROUP_CONTROL));
   scoped_refptr<ModelSafeWorker> db_worker(new FakeModelWorker(GROUP_DB));
   scoped_refptr<ModelSafeWorker> ui_worker(new FakeModelWorker(GROUP_UI));
   workers_one.push_back(passive_worker);
+  workers_one.push_back(control_worker);
   workers_one.push_back(db_worker);
   workers_two.push_back(passive_worker);
+  workers_two.push_back(control_worker);
   workers_two.push_back(db_worker);
   workers_two.push_back(ui_worker);
   routes_one[syncable::AUTOFILL] = GROUP_DB;
   routes_two[syncable::AUTOFILL] = GROUP_DB;
   routes_two[syncable::BOOKMARKS] = GROUP_UI;
   SyncSession one(context_.get(), this, source_one, routes_one, workers_one);
   SyncSession two(context_.get(), this, source_two, routes_two, workers_two);
 
   std::set<ModelSafeGroup> expected_enabled_groups_one;
   expected_enabled_groups_one.insert(GROUP_PASSIVE);
+  expected_enabled_groups_one.insert(GROUP_CONTROL);
   expected_enabled_groups_one.insert(GROUP_DB);
 
   std::set<ModelSafeGroup> expected_enabled_groups_two;
   expected_enabled_groups_two.insert(GROUP_PASSIVE);
+  expected_enabled_groups_two.insert(GROUP_CONTROL);
   expected_enabled_groups_two.insert(GROUP_DB);
   expected_enabled_groups_two.insert(GROUP_UI);
 
   EXPECT_EQ(expected_enabled_groups_one, one.GetEnabledGroups());
   EXPECT_EQ(expected_enabled_groups_two, two.GetEnabledGroups());
 
   two.RebaseRoutingInfoWithLatest(one);
 
   EXPECT_EQ(expected_enabled_groups_one, one.GetEnabledGroups());
   EXPECT_EQ(expected_enabled_groups_one, two.GetEnabledGroups());
 
   // Make sure the source has not been touched.
   EXPECT_EQ(two.source().updates_source,
       sync_pb::GetUpdatesCallerInfo::LOCAL);
 
   // Make sure the payload is reduced to one.
   EXPECT_EQ(one_type, two.source().types);
 
   // Make sure the workers are udpated.
   std::vector<ModelSafeWorker*>::const_iterator it_db =
       std::find(two.workers().begin(), two.workers().end(), db_worker);
   std::vector<ModelSafeWorker*>::const_iterator it_ui =
       std::find(two.workers().begin(), two.workers().end(), ui_worker);
   EXPECT_NE(it_db, two.workers().end());
   EXPECT_EQ(it_ui, two.workers().end());
-  EXPECT_EQ(two.workers().size(), 2U);
+  EXPECT_EQ(two.workers().size(), 3U);
 
   // Make sure the model safe routing info is reduced to one type.
   ModelSafeRoutingInfo::const_iterator it =
       two.routing_info().find(syncable::AUTOFILL);
   // Note that attempting to use EXPECT_NE would fail for an Android build due
   // to seeming incompatibility with gtest and stlport.
   EXPECT_TRUE(it != two.routing_info().end());
   EXPECT_EQ(it->second, GROUP_DB);
   EXPECT_EQ(two.routing_info().size(), 1U);
 }
 
 TEST_F(SyncSessionTest, RebaseRoutingInfoWithLatestWithSameType) {
   std::vector<ModelSafeWorker*> workers_first, workers_second;
   ModelSafeRoutingInfo routes_first, routes_second;
   syncable::ModelTypePayloadMap all_types =
       syncable::ModelTypePayloadMapFromEnumSet(
           ParamsMeaningAllEnabledTypes(),
           std::string());
   SyncSourceInfo source_first(sync_pb::GetUpdatesCallerInfo::PERIODIC,
       all_types);
   SyncSourceInfo source_second(sync_pb::GetUpdatesCallerInfo::LOCAL,
       all_types);
 
   scoped_refptr<ModelSafeWorker> passive_worker(
       new FakeModelWorker(GROUP_PASSIVE));
+  scoped_refptr<ModelSafeWorker> control_worker(
+      new FakeModelWorker(GROUP_CONTROL));
   scoped_refptr<FakeModelWorker> db_worker(new FakeModelWorker(GROUP_DB));
   scoped_refptr<FakeModelWorker> ui_worker(new FakeModelWorker(GROUP_UI));
   workers_first.push_back(passive_worker);
+  workers_first.push_back(control_worker);
   workers_first.push_back(db_worker);
   workers_first.push_back(ui_worker);
   workers_second.push_back(passive_worker);
+  workers_second.push_back(control_worker);
   workers_second.push_back(db_worker);
   workers_second.push_back(ui_worker);
   routes_first[syncable::AUTOFILL] = GROUP_DB;
   routes_first[syncable::BOOKMARKS] = GROUP_UI;
   routes_second[syncable::AUTOFILL] = GROUP_DB;
   routes_second[syncable::BOOKMARKS] = GROUP_UI;
   SyncSession first(context_.get(), this, source_first, routes_first,
       workers_first);
   SyncSession second(context_.get(), this, source_second, routes_second,
       workers_second);
 
   std::set<ModelSafeGroup> expected_enabled_groups;
   expected_enabled_groups.insert(GROUP_PASSIVE);
+  expected_enabled_groups.insert(GROUP_CONTROL);
   expected_enabled_groups.insert(GROUP_DB);
   expected_enabled_groups.insert(GROUP_UI);
 
   EXPECT_EQ(expected_enabled_groups, first.GetEnabledGroups());
   EXPECT_EQ(expected_enabled_groups, second.GetEnabledGroups());
 
   second.RebaseRoutingInfoWithLatest(first);
 
   EXPECT_EQ(expected_enabled_groups, first.GetEnabledGroups());
   EXPECT_EQ(expected_enabled_groups, second.GetEnabledGroups());
 
   // Make sure the source has not been touched.
   EXPECT_EQ(second.source().updates_source,
       sync_pb::GetUpdatesCallerInfo::LOCAL);
 
   // Make sure our payload is still the same.
   EXPECT_EQ(all_types, second.source().types);
 
   // Make sure the workers are still the same.
   std::vector<ModelSafeWorker*>::const_iterator it_passive =
       std::find(second.workers().begin(), second.workers().end(),
                 passive_worker);
   std::vector<ModelSafeWorker*>::const_iterator it_db =
       std::find(second.workers().begin(), second.workers().end(), db_worker);
   std::vector<ModelSafeWorker*>::const_iterator it_ui =
       std::find(second.workers().begin(), second.workers().end(), ui_worker);
   EXPECT_NE(it_passive, second.workers().end());
   EXPECT_NE(it_db, second.workers().end());
   EXPECT_NE(it_ui, second.workers().end());
-  EXPECT_EQ(second.workers().size(), 3U);
+  EXPECT_EQ(second.workers().size(), 4U);
 
   // Make sure the model safe routing info is reduced to first type.
   ModelSafeRoutingInfo::const_iterator it1 =
       second.routing_info().find(syncable::AUTOFILL);
   ModelSafeRoutingInfo::const_iterator it2 =
       second.routing_info().find(syncable::BOOKMARKS);
 
   // Note that attempting to use EXPECT_NE would fail for an Android build due
   // to seeming incompatibility with gtest and stlport.
   EXPECT_TRUE(it1 != second.routing_info().end());
@@ skipping 62 matching lines @@
   EXPECT_EQ(empty_payload, original[syncable::BOOKMARKS]);
   EXPECT_EQ(payload1, original[syncable::PASSWORDS]);
   EXPECT_EQ(payload1, original[syncable::AUTOFILL]);
   EXPECT_EQ(payload2, original[syncable::SESSIONS]);
   EXPECT_EQ(payload3, original[syncable::THEMES]);
 }
 
 }  // namespace
 }  // namespace sessions
 }  // namespace csync