[sync] Add constexpr to EnumSet

components/sync/base/model_type.h

 // Copyright 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.
 
 #ifndef COMPONENTS_SYNC_BASE_MODEL_TYPE_H_
 #define COMPONENTS_SYNC_BASE_MODEL_TYPE_H_
 
 #include <map>
 #include <memory>
 #include <ostream>
 #include <set>
 #include <string>
 
 #include "base/logging.h"
+#include "components/reading_list/core/reading_list_enable_flags.h"
 #include "components/sync/base/enum_set.h"
 
 namespace base {
 class ListValue;
 class Value;
 }
 
 namespace sync_pb {
 class EntitySpecifics;
 class SyncEntity;
@@ skipping 164 matching lines @@
 ModelType GetModelType(const sync_pb::SyncEntity& sync_entity);
 
 // Extract the model type from an EntitySpecifics field.  Note that there
 // are some ModelTypes (like TOP_LEVEL_FOLDER) that can't be inferred this way;
 // prefer using GetModelType where possible.
 ModelType GetModelTypeFromSpecifics(const sync_pb::EntitySpecifics& specifics);
 
 // Protocol types are those types that have actual protocol buffer
 // representations. This distinguishes them from Proxy types, which have no
 // protocol representation and are never sent to the server.
 ModelTypeSet ProtocolTypes();

[skym, 2017/05/05 23:15:42]

Why isn't this one constexpr?

 
 // These are the normal user-controlled types. This is to distinguish from
 // ControlTypes which are always enabled.  Note that some of these share a
 // preference flag, so not all of them are individually user-selectable.
-ModelTypeSet UserTypes();
+constexpr ModelTypeSet UserTypes() {
+  return ModelTypeSet::FromRange(FIRST_USER_MODEL_TYPE, LAST_USER_MODEL_TYPE);
+}
 
 // These are the user-selectable data types.
-ModelTypeSet UserSelectableTypes();
-bool IsUserSelectableType(ModelType model_type);
+constexpr ModelTypeSet UserSelectableTypes() {
+  return ModelTypeSet(BOOKMARKS, PREFERENCES, PASSWORDS, AUTOFILL, THEMES,
+                      TYPED_URLS, EXTENSIONS, APPS,
+#if BUILDFLAG(ENABLE_READING_LIST)
+                      READING_LIST,
+#endif
+                      PROXY_TABS);
+}
+
+constexpr bool IsUserSelectableType(ModelType model_type) {

[skym, 2017/05/05 23:15:42]

Can you re-order these functions so all the constexpr are next to eachother?

[Patrick Noland, 2017/05/08 20:29:19]

Done.

+  return UserSelectableTypes().Has(model_type);
+}
+
 ModelTypeNameMap GetUserSelectableTypeNameMap();
 
 // This is the subset of UserTypes() that can be encrypted.
 ModelTypeSet EncryptableUserTypes();
 
 // This is the subset of UserTypes() that have priority over other types.  These
 // types are synced before other user types and are never encrypted.
-ModelTypeSet PriorityUserTypes();
+constexpr ModelTypeSet PriorityUserTypes() {
+  return ModelTypeSet(DEVICE_INFO, PRIORITY_PREFERENCES);
+}
 
 // Proxy types are placeholder types for handling implicitly enabling real
 // types. They do not exist at the server, and are simply used for
 // UI/Configuration logic.
-ModelTypeSet ProxyTypes();
+constexpr ModelTypeSet ProxyTypes() {
+  return ModelTypeSet::FromRange(FIRST_PROXY_TYPE, LAST_PROXY_TYPE);
+}
 
 // Returns a list of all control types.
 //
 // The control types are intended to contain metadata nodes that are essential
 // for the normal operation of the syncer.  As such, they have the following
 // special properties:
 // - They are downloaded early during SyncBackend initialization.
 // - They are always enabled.  Users may not disable these types.
 // - Their contents are not encrypted automatically.
 // - They support custom update application and conflict resolution logic.
 // - All change processing occurs on the sync thread (GROUP_PASSIVE).
-ModelTypeSet ControlTypes();
+constexpr ModelTypeSet ControlTypes() {
+  return ModelTypeSet::FromRange(FIRST_CONTROL_MODEL_TYPE,
+                                 LAST_CONTROL_MODEL_TYPE);
+}
 
 // Returns true if this is a control type.
 //
 // See comment above for more information on what makes these types special.
-bool IsControlType(ModelType model_type);
+constexpr bool IsControlType(ModelType model_type) {
+  return ControlTypes().Has(model_type);
+}
 
 // Core types are those data types used by sync's core functionality (i.e. not
 // user data types). These types are always enabled, and include ControlTypes().
 //
 // The set of all core types.
 ModelTypeSet CoreTypes();

[skym, 2017/05/05 23:15:41]

Why isn't this one constexpr?

[Patrick Noland, 2017/05/08 20:29:19]

Done.

 // Those core types that have high priority (includes ControlTypes()).
 ModelTypeSet PriorityCoreTypes();

[skym, 2017/05/05 23:15:42]

Why isn't this one constexpr?

[Patrick Noland, 2017/05/08 20:29:19]

Done.

 
 // Determine a model type from the field number of its associated
 // EntitySpecifics field.  Returns UNSPECIFIED if the field number is
 // not recognized.
 //
 // If you're putting the result in a ModelTypeSet, you should use the
 // following pattern:
 //
 //   ModelTypeSet model_types;
 //   // Say we're looping through a list of items, each of which has a
 //   // field number.
 //   for (...) {
 //     int field_number = ...;
 //     ModelType model_type =
 //         GetModelTypeFromSpecificsFieldNumber(field_number);
 //     if (!IsRealDataType(model_type)) {
 //       DLOG(WARNING) << "Unknown field number " << field_number;
 //       continue;
 //     }
 //     model_types.Put(model_type);
 //   }
 ModelType GetModelTypeFromSpecificsFieldNumber(int field_number);
 
 // Return the field number of the EntitySpecifics field associated with
 // a model type.
 int GetSpecificsFieldNumberFromModelType(ModelType model_type);
 
 FullModelTypeSet ToFullModelTypeSet(ModelTypeSet in);

[skym, 2017/05/05 23:15:41]

Why isn't this one constexpr?

[Patrick Noland, 2017/05/08 20:29:19]

There's not a clean way to constexpr copy an EnumSet of one type to another
type. You don't have constexpr access to the underlying uint64, and you can't
copy the bitset.

 
 // TODO(sync): The functions below badly need some cleanup.
 
 // Returns a pointer to a string with application lifetime that represents
 // the name of |model_type|.
 const char* ModelTypeToString(ModelType model_type);
 
 // Some histograms take an integer parameter that represents a model type.
 // The mapping from ModelType to integer is defined here.  It should match
 // the mapping from integer to labels defined in histograms.xml.
@@ skipping 66 matching lines @@
 
 // Returns true if |model_type| supports parent-child hierarchy or entries.
 bool TypeSupportsHierarchy(ModelType model_type);
 
 // Returns true if |model_type| supports ordering of sibling entries.
 bool TypeSupportsOrdering(ModelType model_type);
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_BASE_MODEL_TYPE_H_