Add a declarative way in c/b/s/sync_prefs.cc to say which data types have prefs

chrome/browser/sync/sync_prefs.h

Index: chrome/browser/sync/sync_prefs.h
diff --git a/chrome/browser/sync/sync_prefs.h b/chrome/browser/sync/sync_prefs.h
index bb67b1c3812c26210a06d427d25519a84bcbf862..2b4f28a5d1501e0534609c89e52785ffe8c9ab30 100644
--- a/chrome/browser/sync/sync_prefs.h
+++ b/chrome/browser/sync/sync_prefs.h
@@ -118,6 +118,7 @@ class SyncPrefs : public base::SupportsWeakPtr<SyncPrefs>,
   syncable::ModelTypeSet GetAcknowledgeSyncedTypesForTest() const;
 
  private:
+  void RegisterDeterminedTypes();
   void RegisterPreferences();
 
   void RegisterDataTypePreferredPref(
@@ -136,6 +137,13 @@ class SyncPrefs : public base::SupportsWeakPtr<SyncPrefs>,
   // configuration management.
   BooleanPrefMember pref_sync_managed_;
 
+  // Data types where the enable/disabled preference is determined by another
+  // type, such APP_NOTIFICATIONS being determined by APPS. This is map from
+  // determined type (APP_NOTIFICATIONS) -> determining type (APPS).
+  typedef std::map<syncable::ModelType, syncable::ModelType>
+      TypesDeterminedByMap;

[akalin, 2012/02/29 05:33:03]

These names are kinda awkward.  How about:

typedef ... TypeDependencyMap;
TypeDependencyMap type_dependencies_;

[not at google - send to devlin, 2012/03/01 03:14:40]

I avoided using the term "dependency" because it gives the wrong connotation in
the context of software; I think of "A is a dependency of B" as meaning that "A
must be in a valid state before we can think about B", but that's not what this
is. Maybe "DependentTypesMap"/"dependent_types_" would be more accurate?

Or maybe this is thinking about the wrong way. Chatting to a colleague, perhaps
a more sensible model would be to think of it as "pref groups" such that the
value of one pref determines the values of a group of prefs. So this would be

// Groups of prefs that always have the same value as a master pref.
// For example, the APPS group has {APP_NOTIFICATIONS, APP_SETTINGS}
// (as well as APPS, but that is implied), so
//   pref_groups_[syncable::APPS] = { syncable::APP_NOTIFICATIONS,
syncable::APP_SETTINGS}
//   pref_groups_[syncable::EXTENSIONS = { syncable::EXTENSION_SETTINGS }
// etc.
typedef std::map<syncable::ModelType, ModelTypeSet> PrefGroupsMap;
PrefGroupsMap pref_groups_;

It'd also be slightly more efficient that way.

In the meantime though, pending your opinion about this, I'll go with the
original plan and use DependentTypesMap/dependent_types_.

+  TypesDeterminedByMap types_determined_by_;
+
   DISALLOW_COPY_AND_ASSIGN(SyncPrefs);
 };