1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // Enumerate the various item subtypes that are supported by sync. 6 // Each sync object is expected to have an immutable object type. 7 // An object's type is inferred from the type of data it holds. 8 9 #ifndef SYNC_INTERNAL_API_PUBLIC_BASE_MODEL_TYPE_H_ 10 #define SYNC_INTERNAL_API_PUBLIC_BASE_MODEL_TYPE_H_ 11 12 #include <set> 13 #include <string> 14 15 #include "base/logging.h" 16 #include "sync/base/sync_export.h" 17 #include "sync/internal_api/public/base/enum_set.h" 18 19 namespace base { 20 class ListValue; 21 class StringValue; 22 class Value; 23 } 24 25 namespace sync_pb { 26 class EntitySpecifics; 27 class SyncEntity; 28 } 29 30 namespace syncer { 31 32 // TODO(akalin): Move the non-exported functions in this file to a 33 // private header. 34 35 enum ModelType { 36 // Object type unknown. Objects may transition through 37 // the unknown state during their initial creation, before 38 // their properties are set. After deletion, object types 39 // are generally preserved. 40 UNSPECIFIED, 41 // A permanent folder whose children may be of mixed 42 // datatypes (e.g. the "Google Chrome" folder). 43 TOP_LEVEL_FOLDER, 44 45 // ------------------------------------ Start of "real" model types. 46 // The model types declared before here are somewhat special, as they 47 // they do not correspond to any browser data model. The remaining types 48 // are bona fide model types; all have a related browser data model and 49 // can be represented in the protocol using a specific Message type in the 50 // EntitySpecifics protocol buffer. 51 // 52 // A bookmark folder or a bookmark URL object. 53 BOOKMARKS, 54 FIRST_USER_MODEL_TYPE = BOOKMARKS, // Declared 2nd, for debugger prettiness. 55 FIRST_REAL_MODEL_TYPE = FIRST_USER_MODEL_TYPE, 56 57 // A preference object. 58 PREFERENCES, 59 // A password object. 60 PASSWORDS, 61 // An AutofillProfile Object 62 AUTOFILL_PROFILE, 63 // An autofill object. 64 AUTOFILL, 65 // A themes object. 66 THEMES, 67 // A typed_url object. 68 TYPED_URLS, 69 // An extension object. 70 EXTENSIONS, 71 // An object representing a custom search engine. 72 SEARCH_ENGINES, 73 // An object representing a browser session. 74 SESSIONS, 75 // An app object. 76 APPS, 77 // An app setting from the extension settings API. 78 APP_SETTINGS, 79 // An extension setting from the extension settings API. 80 EXTENSION_SETTINGS, 81 // App notifications. 82 APP_NOTIFICATIONS, 83 // History delete directives. 84 HISTORY_DELETE_DIRECTIVES, 85 // Synced push notifications. 86 SYNCED_NOTIFICATIONS, 87 // Custom spelling dictionary. 88 DICTIONARY, 89 // Favicon images. 90 FAVICON_IMAGES, 91 // Favicon tracking information. 92 FAVICON_TRACKING, 93 // These preferences are synced before other user types and are never 94 // encrypted. 95 PRIORITY_PREFERENCES, 96 // Managed user settings. 97 MANAGED_USER_SETTINGS, 98 // Managed users. Every managed user is a profile that is configured remotely 99 // by this user and can have restrictions applied. MANAGED_USERS and 100 // MANAGED_USER_SETTINGS can not be encrypted. 101 MANAGED_USERS, 102 103 // ---- Proxy types ---- 104 // Proxy types are excluded from the sync protocol, but are still considered 105 // real user types. By convention, we prefix them with 'PROXY_' to distinguish 106 // them from normal protocol types. 107 108 // Tab sync. This is a placeholder type, so that Sessions can be implicitly 109 // enabled for history sync and tabs sync. 110 PROXY_TABS, 111 112 FIRST_PROXY_TYPE = PROXY_TABS, 113 LAST_PROXY_TYPE = PROXY_TABS, 114 115 LAST_USER_MODEL_TYPE = PROXY_TABS, 116 117 // ---- Control Types ---- 118 // An object representing a set of Nigori keys. 119 NIGORI, 120 FIRST_CONTROL_MODEL_TYPE = NIGORI, 121 // Client-specific metadata. 122 DEVICE_INFO, 123 // Flags to enable experimental features. 124 EXPERIMENTS, 125 LAST_CONTROL_MODEL_TYPE = EXPERIMENTS, 126 127 LAST_REAL_MODEL_TYPE = LAST_CONTROL_MODEL_TYPE, 128 129 // If you are adding a new sync datatype that is exposed to the user via the 130 // sync preferences UI, be sure to update the list in 131 // chrome/browser/sync/user_selectable_sync_type.h so that the UMA histograms 132 // for sync include your new type. 133 // In this case, be sure to also update the UserSelectableTypes() definition 134 // in sync/syncable/model_type.cc. 135 136 MODEL_TYPE_COUNT, 137 }; 138 139 typedef EnumSet<ModelType, FIRST_REAL_MODEL_TYPE, LAST_REAL_MODEL_TYPE> 140 ModelTypeSet; 141 typedef EnumSet<ModelType, UNSPECIFIED, LAST_REAL_MODEL_TYPE> 142 FullModelTypeSet; 143 144 inline ModelType ModelTypeFromInt(int i) { 145 DCHECK_GE(i, 0); 146 DCHECK_LT(i, MODEL_TYPE_COUNT); 147 return static_cast<ModelType>(i); 148 } 149 150 // Used by tests outside of sync/. 151 SYNC_EXPORT void AddDefaultFieldValue(ModelType datatype, 152 sync_pb::EntitySpecifics* specifics); 153 154 // Extract the model type of a SyncEntity protocol buffer. ModelType is a 155 // local concept: the enum is not in the protocol. The SyncEntity's ModelType 156 // is inferred from the presence of particular datatype field in the 157 // entity specifics. 158 SYNC_EXPORT_PRIVATE ModelType GetModelType( 159 const sync_pb::SyncEntity& sync_entity); 160 161 // Extract the model type from an EntitySpecifics field. Note that there 162 // are some ModelTypes (like TOP_LEVEL_FOLDER) that can't be inferred this way; 163 // prefer using GetModelType where possible. 164 SYNC_EXPORT ModelType GetModelTypeFromSpecifics( 165 const sync_pb::EntitySpecifics& specifics); 166 167 // Protocol types are those types that have actual protocol buffer 168 // representations. This distinguishes them from Proxy types, which have no 169 // protocol representation and are never sent to the server. 170 SYNC_EXPORT ModelTypeSet ProtocolTypes(); 171 172 // These are the normal user-controlled types. This is to distinguish from 173 // ControlTypes which are always enabled. Note that some of these share a 174 // preference flag, so not all of them are individually user-selectable. 175 SYNC_EXPORT ModelTypeSet UserTypes(); 176 177 // These are the user-selectable data types. 178 SYNC_EXPORT ModelTypeSet UserSelectableTypes(); 179 SYNC_EXPORT bool IsUserSelectableType(ModelType model_type); 180 181 // This is the subset of UserTypes() that can be encrypted. 182 SYNC_EXPORT_PRIVATE ModelTypeSet EncryptableUserTypes(); 183 184 // This is the subset of UserTypes() that have priority over other types. These 185 // types are synced before other user types and are never encrypted. 186 SYNC_EXPORT ModelTypeSet PriorityUserTypes(); 187 188 // Proxy types are placeholder types for handling implicitly enabling real 189 // types. They do not exist at the server, and are simply used for 190 // UI/Configuration logic. 191 SYNC_EXPORT ModelTypeSet ProxyTypes(); 192 193 // Returns a list of all control types. 194 // 195 // The control types are intended to contain metadata nodes that are essential 196 // for the normal operation of the syncer. As such, they have the following 197 // special properties: 198 // - They are downloaded early during SyncBackend initialization. 199 // - They are always enabled. Users may not disable these types. 200 // - Their contents are not encrypted automatically. 201 // - They support custom update application and conflict resolution logic. 202 // - All change processing occurs on the sync thread (GROUP_PASSIVE). 203 SYNC_EXPORT ModelTypeSet ControlTypes(); 204 205 // Returns true if this is a control type. 206 // 207 // See comment above for more information on what makes these types special. 208 SYNC_EXPORT bool IsControlType(ModelType model_type); 209 210 // Core types are those data types used by sync's core functionality (i.e. not 211 // user data types). These types are always enabled, and include ControlTypes(). 212 // 213 // The set of all core types. 214 SYNC_EXPORT ModelTypeSet CoreTypes(); 215 // Those core types that have high priority (includes ControlTypes()). 216 SYNC_EXPORT ModelTypeSet PriorityCoreTypes(); 217 218 // Determine a model type from the field number of its associated 219 // EntitySpecifics field. Returns UNSPECIFIED if the field number is 220 // not recognized. 221 // 222 // If you're putting the result in a ModelTypeSet, you should use the 223 // following pattern: 224 // 225 // ModelTypeSet model_types; 226 // // Say we're looping through a list of items, each of which has a 227 // // field number. 228 // for (...) { 229 // int field_number = ...; 230 // ModelType model_type = 231 // GetModelTypeFromSpecificsFieldNumber(field_number); 232 // if (!IsRealDataType(model_type)) { 233 // DLOG(WARNING) << "Unknown field number " << field_number; 234 // continue; 235 // } 236 // model_types.Put(model_type); 237 // } 238 SYNC_EXPORT_PRIVATE ModelType GetModelTypeFromSpecificsFieldNumber( 239 int field_number); 240 241 // Return the field number of the EntitySpecifics field associated with 242 // a model type. 243 // 244 // Used by tests outside of sync. 245 SYNC_EXPORT int GetSpecificsFieldNumberFromModelType( 246 ModelType model_type); 247 248 FullModelTypeSet ToFullModelTypeSet(ModelTypeSet in); 249 250 // TODO(sync): The functions below badly need some cleanup. 251 252 // Returns a pointer to a string with application lifetime that represents 253 // the name of |model_type|. 254 SYNC_EXPORT const char* ModelTypeToString(ModelType model_type); 255 256 // Some histograms take an integer parameter that represents a model type. 257 // The mapping from ModelType to integer is defined here. It should match 258 // the mapping from integer to labels defined in histograms.xml. 259 SYNC_EXPORT int ModelTypeToHistogramInt(ModelType model_type); 260 261 // Handles all model types, and not just real ones. 262 // 263 // Caller takes ownership of returned value. 264 SYNC_EXPORT_PRIVATE base::StringValue* ModelTypeToValue(ModelType model_type); 265 266 // Converts a Value into a ModelType - complement to ModelTypeToValue(). 267 SYNC_EXPORT_PRIVATE ModelType ModelTypeFromValue(const base::Value& value); 268 269 // Returns the ModelType corresponding to the name |model_type_string|. 270 SYNC_EXPORT ModelType ModelTypeFromString( 271 const std::string& model_type_string); 272 273 SYNC_EXPORT std::string ModelTypeSetToString(ModelTypeSet model_types); 274 275 // Caller takes ownership of returned list. 276 SYNC_EXPORT base::ListValue* ModelTypeSetToValue(ModelTypeSet model_types); 277 278 SYNC_EXPORT ModelTypeSet ModelTypeSetFromValue(const base::ListValue& value); 279 280 // Returns a string corresponding to the syncable tag for this datatype. 281 SYNC_EXPORT std::string ModelTypeToRootTag(ModelType type); 282 283 // Convert a real model type to a notification type (used for 284 // subscribing to server-issued notifications). Returns true iff 285 // |model_type| was a real model type and |notification_type| was 286 // filled in. 287 bool RealModelTypeToNotificationType(ModelType model_type, 288 std::string* notification_type); 289 290 // Converts a notification type to a real model type. Returns true 291 // iff |notification_type| was the notification type of a real model 292 // type and |model_type| was filled in. 293 SYNC_EXPORT bool NotificationTypeToRealModelType( 294 const std::string& notification_type, 295 ModelType* model_type); 296 297 // Returns true if |model_type| is a real datatype 298 SYNC_EXPORT bool IsRealDataType(ModelType model_type); 299 300 // Returns true if |model_type| is an act-once type. Act once types drop 301 // entities after applying them. Drops are deletes that are not synced to other 302 // clients. 303 // TODO(haitaol): Make entries of act-once data types immutable. 304 SYNC_EXPORT bool IsActOnceDataType(ModelType model_type); 305 306 } // namespace syncer 307 308 #endif // SYNC_INTERNAL_API_PUBLIC_BASE_MODEL_TYPE_H_ 309