Refactor ModelTypePayloadMap and ObjectIdPayloadMap to StateMaps.

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"
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/syncer_types.h"
 #include "sync/engine/throttled_data_type_tracker.h"
 #include "sync/internal_api/public/base/model_type.h"
+#include "sync/internal_api/public/base/model_type_state_map_test_util.h"
 #include "sync/sessions/session_state.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/syncable_id.h"
 #include "sync/syncable/write_transaction.h"
 #include "sync/test/engine/fake_model_worker.h"
 #include "sync/test/engine/test_directory_setter_upper.h"
 #include "sync/test/fake_extensions_activity_monitor.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
@@ skipping 240 matching lines @@
   session_->PrepareForAnotherSyncCycle();
   EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION,
             session_->source().updates_source);
   EXPECT_FALSE(status()->conflicts_resolved());
   EXPECT_FALSE(session_->HasMoreToSync());
 }
 
 TEST_F(SyncSessionTest, Coalesce) {
   std::vector<ModelSafeWorker*> workers_one, workers_two;
   ModelSafeRoutingInfo routes_one, routes_two;
-  ModelTypePayloadMap one_type =
-      ModelTypePayloadMapFromEnumSet(
+  ModelTypeStateMap one_type =
+      ModelTypeSetToStateMap(
           ParamsMeaningJustOneEnabledType(),
           std::string());
-  ModelTypePayloadMap all_types =
-      ModelTypePayloadMapFromEnumSet(
+  ModelTypeStateMap all_types =
+      ModelTypeSetToStateMap(
           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> db_worker(new FakeModelWorker(GROUP_DB));
   scoped_refptr<ModelSafeWorker> ui_worker(new FakeModelWorker(GROUP_UI));
   workers_one.push_back(passive_worker);
@@ skipping 18 matching lines @@
 
   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());
 
   EXPECT_EQ(two.source().updates_source, one.source().updates_source);
-  EXPECT_EQ(all_types, one.source().types);
+  EXPECT_THAT(all_types, Eq(one.source().types));
   std::vector<ModelSafeWorker*>::const_iterator it_db =
       std::find(one.workers().begin(), one.workers().end(), db_worker);
   std::vector<ModelSafeWorker*>::const_iterator it_ui =
       std::find(one.workers().begin(), one.workers().end(), ui_worker);
   EXPECT_NE(it_db, one.workers().end());
   EXPECT_NE(it_ui, one.workers().end());
   EXPECT_EQ(routes_two, one.routing_info());
 }
 
 TEST_F(SyncSessionTest, RebaseRoutingInfoWithLatestRemoveOneType) {
   std::vector<ModelSafeWorker*> workers_one, workers_two;
   ModelSafeRoutingInfo routes_one, routes_two;
-  ModelTypePayloadMap one_type =
-      ModelTypePayloadMapFromEnumSet(
+  ModelTypeStateMap one_type =
+      ModelTypeSetToStateMap(
           ParamsMeaningJustOneEnabledType(),
           std::string());
-  ModelTypePayloadMap all_types =
-      ModelTypePayloadMapFromEnumSet(
+  ModelTypeStateMap all_types =
+      ModelTypeSetToStateMap(
           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> db_worker(new FakeModelWorker(GROUP_DB));
   scoped_refptr<ModelSafeWorker> ui_worker(new FakeModelWorker(GROUP_UI));
   workers_one.push_back(passive_worker);
@@ skipping 22 matching lines @@
   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);
+  EXPECT_THAT(one_type, Eq(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);
 
   // Make sure the model safe routing info is reduced to one type.
   ModelSafeRoutingInfo::const_iterator it =
       two.routing_info().find(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;
-  ModelTypePayloadMap all_types =
-      ModelTypePayloadMapFromEnumSet(
+  ModelTypeStateMap all_types =
+      ModelTypeSetToStateMap(
           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<FakeModelWorker> db_worker(new FakeModelWorker(GROUP_DB));
@@ skipping 24 matching lines @@
   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);
+  EXPECT_THAT(all_types, Eq(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());
@@ skipping 13 matching lines @@
   EXPECT_EQ(it1->second, GROUP_DB);
 
   // Note that attempting to use EXPECT_NE would fail for an Android build due
   // to seeming incompatibility with gtest and stlport.
   EXPECT_TRUE(it2 != second.routing_info().end());
   EXPECT_EQ(it2->second, GROUP_UI);
   EXPECT_EQ(second.routing_info().size(), 2U);
 }
 
 
-TEST_F(SyncSessionTest, MakeTypePayloadMapFromBitSet) {
+TEST_F(SyncSessionTest, MakeTypeStateMapFromBitSet) {
   ModelTypeSet types;
   std::string payload = "test";
-  ModelTypePayloadMap types_with_payloads =
-      ModelTypePayloadMapFromEnumSet(types, payload);
-  EXPECT_TRUE(types_with_payloads.empty());
+  ModelTypeStateMap type_state_map =
+      ModelTypeSetToStateMap(types, payload);
+  EXPECT_TRUE(type_state_map.empty());
 
   types.Put(BOOKMARKS);
   types.Put(PASSWORDS);
   types.Put(AUTOFILL);
   payload = "test2";
-  types_with_payloads = ModelTypePayloadMapFromEnumSet(types, payload);
+  type_state_map = ModelTypeSetToStateMap(types, payload);
 
-  ASSERT_EQ(3U, types_with_payloads.size());
-  EXPECT_EQ(types_with_payloads[BOOKMARKS], payload);
-  EXPECT_EQ(types_with_payloads[PASSWORDS], payload);
-  EXPECT_EQ(types_with_payloads[AUTOFILL], payload);
+  ASSERT_EQ(3U, type_state_map.size());
+  EXPECT_EQ(type_state_map[BOOKMARKS].payload, payload);
+  EXPECT_EQ(type_state_map[PASSWORDS].payload, payload);
+  EXPECT_EQ(type_state_map[AUTOFILL].payload, payload);
 }
 
 }  // namespace
 }  // namespace sessions
 }  // namespace syncer