[Sync] Add support for proxy types

sync/syncable/model_type.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/internal_api/public/base/model_type.h"
 
 #include "base/string_split.h"
 #include "base/values.h"
 #include "sync/protocol/app_notification_specifics.pb.h"
 #include "sync/protocol/app_setting_specifics.pb.h"
 #include "sync/protocol/app_specifics.pb.h"
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/extension_setting_specifics.pb.h"
 #include "sync/protocol/extension_specifics.pb.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/protocol/preference_specifics.pb.h"
 #include "sync/protocol/search_engine_specifics.pb.h"
 #include "sync/protocol/session_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/protocol/theme_specifics.pb.h"
 #include "sync/protocol/typed_url_specifics.pb.h"
 #include "sync/syncable/syncable_proto_util.h"
 
 namespace syncer {
 
 void AddDefaultFieldValue(ModelType datatype,
                           sync_pb::EntitySpecifics* specifics) {
+  if (!ProtocolTypes().Has(datatype)) {
+    NOTREACHED() << "Only protocol types have field values.";
+    return;
+  }
   switch (datatype) {
     case BOOKMARKS:
       specifics->mutable_bookmark();
       break;
     case PASSWORDS:
       specifics->mutable_password();
       break;
     case PREFERENCES:
       specifics->mutable_preference();
       break;
@@ skipping 50 matching lines @@
       break;
     case DICTIONARY:
       specifics->mutable_dictionary();
       break;
     default:
       NOTREACHED() << "No known extension for model type.";
   }
 }
 
 ModelType GetModelTypeFromSpecificsFieldNumber(int field_number) {
-  for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
-    ModelType model_type = ModelTypeFromInt(i);
-    if (GetSpecificsFieldNumberFromModelType(model_type) == field_number)
-      return model_type;
+  ModelTypeSet protocol_types = ProtocolTypes();
+  for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
+       iter.Inc()) {
+    if (GetSpecificsFieldNumberFromModelType(iter.Get()) == field_number)
+      return iter.Get();
   }
   return UNSPECIFIED;
 }
 
 int GetSpecificsFieldNumberFromModelType(ModelType model_type) {
+  if (!ProtocolTypes().Has(model_type)) {
+    NOTREACHED() << "Only protocol types have field values.";
+    return 0;
+  }
   switch (model_type) {
     case BOOKMARKS:
       return sync_pb::EntitySpecifics::kBookmarkFieldNumber;
       break;
     case PASSWORDS:
       return sync_pb::EntitySpecifics::kPasswordFieldNumber;
       break;
     case PREFERENCES:
       return sync_pb::EntitySpecifics::kPreferenceFieldNumber;
       break;
@@ skipping 159 matching lines @@
   if (specifics.has_dictionary())
     return DICTIONARY;
 
   return UNSPECIFIED;
 }
 
 bool ShouldMaintainPosition(ModelType model_type) {
   return model_type == BOOKMARKS;
 }
 
+ModelTypeSet ProtocolTypes() {
+  ModelTypeSet set = ModelTypeSet::All();
+  set.RemoveAll(ProxyTypes());
+  return set;
+}
+
 ModelTypeSet UserTypes() {
   ModelTypeSet set;
+  // TODO(sync): We should be able to build the actual enumset's internal
+  // bitset value here at compile time, rather than performing an iteration
+  // every time.
   for (int i = FIRST_USER_MODEL_TYPE; i <= LAST_USER_MODEL_TYPE; ++i) {
     set.Put(ModelTypeFromInt(i));
   }
   return set;
 }
 
 ModelTypeSet EncryptableUserTypes() {
   ModelTypeSet encryptable_user_types = UserTypes();
   // We never encrypt history delete directives.
   encryptable_user_types.Remove(HISTORY_DELETE_DIRECTIVES);
   // Synced notifications are not encrypted since the server must see changes.
   encryptable_user_types.Remove(SYNCED_NOTIFICATIONS);
+  // Proxy types have no sync representation and are therefore not encrypted.
+  // Note however that proxy types map to one or more protocol types, which
+  // may or may not be encrypted themselves.
+  encryptable_user_types.RemoveAll(ProxyTypes());
   return encryptable_user_types;
 }
 
 ModelTypeSet ControlTypes() {
   ModelTypeSet set;
+  // TODO(sync): We should be able to build the actual enumset's internal
+  // bitset value here at compile time, rather than performing an iteration
+  // every time.
   for (int i = FIRST_CONTROL_MODEL_TYPE; i <= LAST_CONTROL_MODEL_TYPE; ++i) {
     set.Put(ModelTypeFromInt(i));
   }
 
   // TODO(albertb): Re-enable this when the server supports it.
   set.Remove(PRIORITY_PREFERENCES);
 
   return set;
 }
 
+ModelTypeSet ProxyTypes() {
+  ModelTypeSet set;
+  // TODO(zea): add a TABS type here.
+  return set;
+}
+
 bool IsControlType(ModelType model_type) {
   return ControlTypes().Has(model_type);
 }
 
 const char* ModelTypeToString(ModelType model_type) {
   // This is used in serialization routines as well as for displaying debug
   // information.  Do not attempt to change these string values unless you know
   // what you're doing.
   switch (model_type) {
     case TOP_LEVEL_FOLDER:
@@ skipping 148 matching lines @@
 ModelTypeSet ModelTypeSetFromValue(const base::ListValue& value) {
   ModelTypeSet result;
   for (ListValue::const_iterator i = value.begin(); i != value.end(); ++i) {
     result.Put(ModelTypeFromValue(**i));
   }
   return result;
 }
 
 // TODO(zea): remove all hardcoded tags in model associators and have them use
 // this instead.
+// NOTE: Proxy types should return empty strings (so that we don't NOTREACHED
+// in tests when we verify they have no root node).
 std::string ModelTypeToRootTag(ModelType type) {
   switch (type) {
     case BOOKMARKS:
       return "google_chrome_bookmarks";
     case PREFERENCES:
       return "google_chrome_preferences";
     case PASSWORDS:
       return "google_chrome_passwords";
     case AUTOFILL:
       return "google_chrome_autofill";
@@ skipping 32 matching lines @@
     case DICTIONARY:
       return "google_chrome_dictionary";
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
   return "INVALID";
 }
 
 // TODO(akalin): Figure out a better way to do these mappings.
-
+// Note: Do not include proxy types in this list. They should never receive
+// or trigger notifications.
 namespace {
 const char kBookmarkNotificationType[] = "BOOKMARK";
 const char kPreferenceNotificationType[] = "PREFERENCE";
 const char kPasswordNotificationType[] = "PASSWORD";
 const char kAutofillNotificationType[] = "AUTOFILL";
 const char kThemeNotificationType[] = "THEME";
 const char kTypedUrlNotificationType[] = "TYPED_URL";
 const char kExtensionNotificationType[] = "EXTENSION";
 const char kExtensionSettingNotificationType[] = "EXTENSION_SETTING";
 const char kNigoriNotificationType[] = "NIGORI";
@@ skipping 153 matching lines @@
   }
   *model_type = UNSPECIFIED;
   return false;
 }
 
 bool IsRealDataType(ModelType model_type) {
   return model_type >= FIRST_REAL_MODEL_TYPE && model_type < MODEL_TYPE_COUNT;
 }
 
 }  // namespace syncer