[Sync] Clean up ModelType code.

components/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 "components/sync/base/model_type.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/string_split.h"
@@ skipping 145 matching lines @@
 //    ModelType enum.
 const char* kUserSelectableDataTypeNames[] = {
     "bookmarks",   "preferences", "passwords",  "autofill",
     "themes",      "typedUrls",   "extensions", "apps",
 #if BUILDFLAG(ENABLE_READING_LIST)
     "readingList",
 #endif
     "tabs",
 };
 
-static_assert(
-    39 == MODEL_TYPE_COUNT,
-    "update kUserSelectableDataTypeName to match UserSelectableTypes");
-
-void AddDefaultFieldValue(ModelType datatype,
-                          sync_pb::EntitySpecifics* specifics) {
-  if (!ProtocolTypes().Has(datatype)) {
-    NOTREACHED() << "Only protocol types have field values.";
-    return;
-  }
-  switch (datatype) {
+void AddDefaultFieldValue(ModelType type, sync_pb::EntitySpecifics* specifics) {
+  switch (type) {
+    case UNSPECIFIED:
+    case TOP_LEVEL_FOLDER:
+      NOTREACHED() << "No default field value for " << ModelTypeToString(type);
+      break;
     case BOOKMARKS:
       specifics->mutable_bookmark();
       break;
+    case PREFERENCES:
+      specifics->mutable_preference();
+      break;
     case PASSWORDS:
       specifics->mutable_password();
       break;
-    case PREFERENCES:
-      specifics->mutable_preference();
+    case AUTOFILL_PROFILE:
+      specifics->mutable_autofill_profile();
       break;
     case AUTOFILL:
       specifics->mutable_autofill();
       break;
-    case AUTOFILL_PROFILE:
-      specifics->mutable_autofill_profile();
-      break;
     case AUTOFILL_WALLET_DATA:
       specifics->mutable_autofill_wallet();
       break;
     case AUTOFILL_WALLET_METADATA:
       specifics->mutable_wallet_metadata();
       break;
     case THEMES:
       specifics->mutable_theme();
       break;
     case TYPED_URLS:
       specifics->mutable_typed_url();
       break;
     case EXTENSIONS:
       specifics->mutable_extension();
       break;
-    case NIGORI:
-      specifics->mutable_nigori();
-      break;
     case SEARCH_ENGINES:
       specifics->mutable_search_engine();
       break;
     case SESSIONS:
       specifics->mutable_session();
       break;
     case APPS:
       specifics->mutable_app();
       break;
-    case APP_LIST:
-      specifics->mutable_app_list();
-      break;
     case APP_SETTINGS:
       specifics->mutable_app_setting();
       break;
-    case ARC_PACKAGE:
-      specifics->mutable_arc_package();
-      break;
     case EXTENSION_SETTINGS:
       specifics->mutable_extension_setting();
       break;
     case APP_NOTIFICATIONS:
       specifics->mutable_app_notification();
       break;
     case HISTORY_DELETE_DIRECTIVES:
       specifics->mutable_history_delete_directive();
       break;
     case SYNCED_NOTIFICATIONS:
       specifics->mutable_synced_notification();
       break;
     case SYNCED_NOTIFICATION_APP_INFO:
       specifics->mutable_synced_notification_app_info();
       break;
-    case DEVICE_INFO:
-      specifics->mutable_device_info();
-      break;
-    case EXPERIMENTS:
-      specifics->mutable_experiments();
-      break;
-    case PRINTERS:
-      specifics->mutable_printer();
-      break;
-    case PRIORITY_PREFERENCES:
-      specifics->mutable_priority_preference();
-      break;
     case DICTIONARY:
       specifics->mutable_dictionary();
       break;
     case FAVICON_IMAGES:
       specifics->mutable_favicon_image();
       break;
     case FAVICON_TRACKING:
       specifics->mutable_favicon_tracking();
       break;
+    case DEVICE_INFO:
+      specifics->mutable_device_info();
+      break;
+    case PRIORITY_PREFERENCES:
+      specifics->mutable_priority_preference();
+      break;
     case SUPERVISED_USER_SETTINGS:
       specifics->mutable_managed_user_setting();
       break;
     case SUPERVISED_USERS:
       specifics->mutable_managed_user();
       break;
     case SUPERVISED_USER_SHARED_SETTINGS:
       specifics->mutable_managed_user_shared_setting();
+    case ARTICLES:
+      specifics->mutable_article();
+      break;
+    case APP_LIST:
+      specifics->mutable_app_list();
+      break;
+    case WIFI_CREDENTIALS:
+      specifics->mutable_wifi_credential();
       break;
     case SUPERVISED_USER_WHITELISTS:
       specifics->mutable_managed_user_whitelist();
       break;
-    case ARTICLES:
-      specifics->mutable_article();
+    case ARC_PACKAGE:
+      specifics->mutable_arc_package();
       break;
-    case WIFI_CREDENTIALS:
-      specifics->mutable_wifi_credential();
+    case PRINTERS:
+      specifics->mutable_printer();
       break;
     case READING_LIST:
       specifics->mutable_reading_list();
       break;
-    default:
-      NOTREACHED() << "No known extension for model type.";
+    case PROXY_TABS:
+      NOTREACHED() << "No default field value for " << ModelTypeToString(type);
+      break;
+    case NIGORI:
+      specifics->mutable_nigori();
+      break;
+    case EXPERIMENTS:
+      specifics->mutable_experiments();
+      break;
+    case MODEL_TYPE_COUNT:
+      NOTREACHED() << "No default field value for " << ModelTypeToString(type);
+      break;
   }
 }
 
 ModelType GetModelTypeFromSpecificsFieldNumber(int field_number) {
   ModelTypeSet protocol_types = ProtocolTypes();
   for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
        iter.Inc()) {
     if (GetSpecificsFieldNumberFromModelType(iter.Get()) == field_number)
       return iter.Get();
   }
@@ skipping 37 matching lines @@
   }
 
   // This is an item of a datatype we can't understand. Maybe it's
   // from the future?  Either we mis-encoded the object, or the
   // server sent us entries it shouldn't have.
   NOTREACHED() << "Unknown datatype in sync proto.";
   return UNSPECIFIED;
 }
 
 ModelType GetModelTypeFromSpecifics(const sync_pb::EntitySpecifics& specifics) {
+  static_assert(39 == MODEL_TYPE_COUNT,
+                "When adding new protocol types, the following type lookup "
+                "logic must be updated.");
   if (specifics.has_bookmark())
     return BOOKMARKS;
-
+  if (specifics.has_preference())
+    return PREFERENCES;
   if (specifics.has_password())
     return PASSWORDS;
-
-  if (specifics.has_preference())
-    return PREFERENCES;
-
+  if (specifics.has_autofill_profile())
+    return AUTOFILL_PROFILE;
   if (specifics.has_autofill())
     return AUTOFILL;
-
-  if (specifics.has_autofill_profile())
-    return AUTOFILL_PROFILE;
-
   if (specifics.has_autofill_wallet())
     return AUTOFILL_WALLET_DATA;
-
   if (specifics.has_wallet_metadata())
     return AUTOFILL_WALLET_METADATA;
-
   if (specifics.has_theme())
     return THEMES;
-
   if (specifics.has_typed_url())
     return TYPED_URLS;
-
   if (specifics.has_extension())
     return EXTENSIONS;
-
+  if (specifics.has_search_engine())
+    return SEARCH_ENGINES;
+  if (specifics.has_session())
+    return SESSIONS;
+  if (specifics.has_app())
+    return APPS;
+  if (specifics.has_app_setting())
+    return APP_SETTINGS;
+  if (specifics.has_extension_setting())
+    return EXTENSION_SETTINGS;
+  if (specifics.has_app_notification())
+    return APP_NOTIFICATIONS;
+  if (specifics.has_history_delete_directive())
+    return HISTORY_DELETE_DIRECTIVES;
+  if (specifics.has_synced_notification())
+    return SYNCED_NOTIFICATIONS;
+  if (specifics.has_synced_notification_app_info())
+    return SYNCED_NOTIFICATION_APP_INFO;
+  if (specifics.has_dictionary())
+    return DICTIONARY;
+  if (specifics.has_favicon_image())
+    return FAVICON_IMAGES;
+  if (specifics.has_favicon_tracking())
+    return FAVICON_TRACKING;
+  if (specifics.has_device_info())
+    return DEVICE_INFO;
+  if (specifics.has_priority_preference())
+    return PRIORITY_PREFERENCES;
+  if (specifics.has_managed_user_setting())
+    return SUPERVISED_USER_SETTINGS;
+  if (specifics.has_managed_user())
+    return SUPERVISED_USERS;
+  if (specifics.has_managed_user_shared_setting())
+    return SUPERVISED_USER_SHARED_SETTINGS;
+  if (specifics.has_article())
+    return ARTICLES;
+  if (specifics.has_app_list())
+    return APP_LIST;
+  if (specifics.has_wifi_credential())
+    return WIFI_CREDENTIALS;
+  if (specifics.has_managed_user_whitelist())
+    return SUPERVISED_USER_WHITELISTS;
+  if (specifics.has_arc_package())
+    return ARC_PACKAGE;
+  if (specifics.has_printer())
+    return PRINTERS;
+  if (specifics.has_reading_list())
+    return READING_LIST;
   if (specifics.has_nigori())
     return NIGORI;
-
-  if (specifics.has_app())
-    return APPS;
-
-  if (specifics.has_app_list())
-    return APP_LIST;
-
-  if (specifics.has_arc_package())
-    return ARC_PACKAGE;
-
-  if (specifics.has_search_engine())
-    return SEARCH_ENGINES;
-
-  if (specifics.has_session())
-    return SESSIONS;
-
-  if (specifics.has_app_setting())
-    return APP_SETTINGS;
-
-  if (specifics.has_extension_setting())
-    return EXTENSION_SETTINGS;
-
-  if (specifics.has_app_notification())
-    return APP_NOTIFICATIONS;
-
-  if (specifics.has_reading_list())
-    return READING_LIST;
-
-  if (specifics.has_history_delete_directive())
-    return HISTORY_DELETE_DIRECTIVES;
-
-  if (specifics.has_synced_notification())
-    return SYNCED_NOTIFICATIONS;
-
-  if (specifics.has_synced_notification_app_info())
-    return SYNCED_NOTIFICATION_APP_INFO;
-
-  if (specifics.has_device_info())
-    return DEVICE_INFO;
-
   if (specifics.has_experiments())
     return EXPERIMENTS;
 
-  if (specifics.has_priority_preference())
-    return PRIORITY_PREFERENCES;
-
-  if (specifics.has_printer())
-    return PRINTERS;
-
-  if (specifics.has_dictionary())
-    return DICTIONARY;
-
-  if (specifics.has_favicon_image())
-    return FAVICON_IMAGES;
-
-  if (specifics.has_favicon_tracking())
-    return FAVICON_TRACKING;
-
-  if (specifics.has_managed_user_setting())
-    return SUPERVISED_USER_SETTINGS;
-
-  if (specifics.has_managed_user())
-    return SUPERVISED_USERS;
-
-  if (specifics.has_managed_user_shared_setting())
-    return SUPERVISED_USER_SHARED_SETTINGS;
-
-  if (specifics.has_managed_user_whitelist())
-    return SUPERVISED_USER_WHITELISTS;
-
-  if (specifics.has_article())
-    return ARTICLES;
-
-  if (specifics.has_wifi_credential())
-    return WIFI_CREDENTIALS;
-
   return UNSPECIFIED;
 }
 
 ModelTypeSet ProtocolTypes() {
-  ModelTypeSet set = ModelTypeSet::All();
-  set.RemoveAll(ProxyTypes());
-  return set;
+  return Difference(ModelTypeSet::All(), ProxyTypes());
 }
 
 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;
+  // bitset value here at compile time, instead of makes a new one each time.
+  return ModelTypeSet::FromRange(FIRST_USER_MODEL_TYPE, LAST_USER_MODEL_TYPE);
 }
 
 ModelTypeSet UserSelectableTypes() {
-  ModelTypeSet set;
-  // Although the order doesn't technically matter here, it's clearer to keep
-  // these in the same order as their definition in the ModelType enum.
-  set.Put(BOOKMARKS);
-  set.Put(PREFERENCES);
-  set.Put(PASSWORDS);
-  set.Put(AUTOFILL);
-  set.Put(THEMES);
-  set.Put(TYPED_URLS);
-  set.Put(EXTENSIONS);
-  set.Put(APPS);
+  return ModelTypeSet(BOOKMARKS, PREFERENCES, PASSWORDS, AUTOFILL, THEMES,

[pavely, 2017/02/23 23:23:03]

What if you put one type per line? Will it be more readable? Will git cl format
try to straighten it on every change in the file?

[skym, 2017/02/24 18:59:07]

Yeah, format wants them to look like this.

I really wish we could do something like just return the keys from the map
created in RegisterPrefGroups() here, but things are not setup to facilitate
that right now.

+                      TYPED_URLS, EXTENSIONS, APPS,
 #if BUILDFLAG(ENABLE_READING_LIST)
-  set.Put(READING_LIST);
+                      READING_LIST,
 #endif
-  set.Put(PROXY_TABS);
-  return set;
+                      PROXY_TABS);
 }
 
 bool IsUserSelectableType(ModelType model_type) {
   return UserSelectableTypes().Has(model_type);
 }
 
 ModelTypeNameMap GetUserSelectableTypeNameMap() {
   ModelTypeNameMap type_names;
   ModelTypeSet type_set = UserSelectableTypes();
   ModelTypeSet::Iterator it = type_set.First();
   DCHECK_EQ(arraysize(kUserSelectableDataTypeNames), type_set.Size());
   for (size_t i = 0; i < arraysize(kUserSelectableDataTypeNames) && it.Good();
        ++i, it.Inc()) {
     type_names[it.Get()] = kUserSelectableDataTypeNames[i];
   }
   return type_names;
 }
 
 ModelTypeSet EncryptableUserTypes() {
+  static_assert(39 == MODEL_TYPE_COUNT,
+                "If adding an unencryptable type, remove from "
+                "encryptable_user_types below.");
   ModelTypeSet encryptable_user_types = UserTypes();
+  // Wallet data is not encrypted since it actually originates on the server.
+  encryptable_user_types.Remove(AUTOFILL_WALLET_DATA);
   // 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);
   // Synced Notification App Info does not have private data, so it is not
   // encrypted.
   encryptable_user_types.Remove(SYNCED_NOTIFICATION_APP_INFO);
   // Device info data is not encrypted because it might be synced before
   // encryption is ready.
   encryptable_user_types.Remove(DEVICE_INFO);
   // Priority preferences are not encrypted because they might be synced before
   // encryption is ready.
   encryptable_user_types.Remove(PRIORITY_PREFERENCES);
   // Supervised user settings are not encrypted since they are set server-side.
   encryptable_user_types.Remove(SUPERVISED_USER_SETTINGS);
   // Supervised users are not encrypted since they are managed server-side.
   encryptable_user_types.Remove(SUPERVISED_USERS);
   // Supervised user shared settings are not encrypted since they are managed
   // server-side and shared between manager and supervised user.
   encryptable_user_types.Remove(SUPERVISED_USER_SHARED_SETTINGS);
   // Supervised user whitelists are not encrypted since they are managed
   // server-side.
   encryptable_user_types.Remove(SUPERVISED_USER_WHITELISTS);
   // 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());
-  // Wallet data is not encrypted since it actually originates on the server.
-  encryptable_user_types.Remove(AUTOFILL_WALLET_DATA);
   return encryptable_user_types;
 }
 
 ModelTypeSet PriorityUserTypes() {
   return ModelTypeSet(DEVICE_INFO, PRIORITY_PREFERENCES);
 }
 
 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));
-  }
-
-  return set;
+  // bitset value here at compile time, instead of makes a new one each time.
+  return ModelTypeSet::FromRange(FIRST_CONTROL_MODEL_TYPE,
+                                 LAST_CONTROL_MODEL_TYPE);
 }
 
 ModelTypeSet ProxyTypes() {
-  ModelTypeSet set;
-  set.Put(PROXY_TABS);
-  return set;
+  return ModelTypeSet::FromRange(FIRST_PROXY_TYPE, LAST_PROXY_TYPE);
 }
 
 bool IsControlType(ModelType model_type) {
   return ControlTypes().Has(model_type);
 }
 
 ModelTypeSet CoreTypes() {
-  ModelTypeSet result;
-  result.PutAll(PriorityCoreTypes());
+  ModelTypeSet result = PriorityCoreTypes();
 
   // The following are low priority core types.
   result.Put(SYNCED_NOTIFICATIONS);
   result.Put(SYNCED_NOTIFICATION_APP_INFO);
   result.Put(SUPERVISED_USER_SHARED_SETTINGS);
   result.Put(SUPERVISED_USER_WHITELISTS);
 
   return result;
 }
 
 ModelTypeSet PriorityCoreTypes() {
-  ModelTypeSet result;
-  result.PutAll(ControlTypes());
+  ModelTypeSet result = ControlTypes();
 
   // The following are non-control core types.
   result.Put(SUPERVISED_USERS);
   result.Put(SUPERVISED_USER_SETTINGS);
 
   return result;
 }
 
 const char* ModelTypeToString(ModelType model_type) {
   // This is used in serialization routines as well as for displaying debug
@@ skipping 180 matching lines @@
 bool TypeSupportsHierarchy(ModelType model_type) {
   // TODO(stanisc): crbug/438313: Should this also include TOP_LEVEL_FOLDER?
   return model_type == BOOKMARKS;
 }
 
 bool TypeSupportsOrdering(ModelType model_type) {
   return model_type == BOOKMARKS;
 }
 
 }  // namespace syncer