Refactor ModelTypePayloadMap and ObjectIdPayloadMap to StateMaps.

sync/internal_api/public/base/model_type_state_map.h

Index: sync/internal_api/public/base/model_type_state_map.h
diff --git a/sync/internal_api/public/base/model_type_state_map.h b/sync/internal_api/public/base/model_type_state_map.h
new file mode 100644
index 0000000000000000000000000000000000000000..71b0e65fd8c6d8795e0ee9c5f3da521be6c703fe
--- /dev/null
+++ b/sync/internal_api/public/base/model_type_state_map.h
@@ -0,0 +1,54 @@
+// 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.
+//
+// Definition of ModelTypeStateMap and various utility functions.
+
+#ifndef SYNC_INTERNAL_PUBLIC_API_BASE_MODEL_TYPE_STATE_MAP_H_
+#define SYNC_INTERNAL_PUBLIC_API_BASE_MODEL_TYPE_STATE_MAP_H_
+
+#include <map>
+#include <string>
+
+#include "sync/base/sync_export.h"
+#include "sync/internal_api/public/base/invalidation_state.h"

[akalin, 2012/08/22 23:24:27]

i wonder if it's possible to forward-declare here, too

[dcheng, 2012/08/22 23:47:11]

IIRC, in the past, we chose to #include types that were part of a std::map<>
typedef rather than forward declaring. While we can forward declare, this means
that every file that uses instantiates either StateMap will need to #include
"invalidation_state.h", including a lot of "not obviously related" files.

+#include "sync/internal_api/public/base/model_type.h"
+
+// TODO(akalin): Move the non-exported functions in this file to a
+// private header.
+
+namespace base {
+class DictionaryValue;
+}
+
+namespace syncer {
+
+// A container that contains a set of datatypes with possible string
+// payloads.
+typedef std::map<ModelType, InvalidationState> ModelTypeStateMap;
+
+// Helper functions for building ModelTypeStateMaps.
+
+// Make a TypeStateMap from all the types in a ModelTypeSet using a
+// default payload.
+SYNC_EXPORT ModelTypeStateMap ModelTypeSetToStateMap(
+    ModelTypeSet model_types, const std::string& payload);
+
+ModelTypeSet ModelTypeStateMapToSet(
+    const ModelTypeStateMap& payload_map);
+
+std::string ModelTypeStateMapToString(
+    const ModelTypeStateMap& model_type_payloads);
+
+// Caller takes ownership of the returned dictionary.
+base::DictionaryValue* ModelTypeStateMapToValue(
+    const ModelTypeStateMap& model_type_payloads);
+
+// Coalesce |update| into |original|, overwriting only when |update| has
+// a non-empty payload.
+void CoalesceStates(ModelTypeStateMap* original,
+                    const ModelTypeStateMap& update);
+
+}  // namespace syncer
+
+#endif  // SYNC_INTERNAL_PUBLIC_API_BASE_MODEL_TYPE_STATE_MAP_H_