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 // Synced Notification app info. 88 SYNCED_NOTIFICATION_APP_INFO, 89 // Custom spelling dictionary. 90 DICTIONARY, 91 // Favicon images. 92 FAVICON_IMAGES, 93 // Favicon tracking information. 94 FAVICON_TRACKING, 95 // These preferences are synced before other user types and are never 96 // encrypted. 97 PRIORITY_PREFERENCES, 98 // Supervised user settings. 99 SUPERVISED_USER_SETTINGS, 100 // Supervised users. Every supervised user is a profile that is configured 101 // remotely by this user and can have restrictions applied. SUPERVISED_USERS 102 // and SUPERVISED_USER_SETTINGS can not be encrypted. 103 SUPERVISED_USERS, 104 // Supervised user shared settings. Shared settings can be modified both by 105 // the manager and the supervised user. 106 SUPERVISED_USER_SHARED_SETTINGS, 107 // Distilled articles. 108 ARTICLES, 109 // App List items 110 APP_LIST, 111 112 // ---- Proxy types ---- 113 // Proxy types are excluded from the sync protocol, but are still considered 114 // real user types. By convention, we prefix them with 'PROXY_' to distinguish 115 // them from normal protocol types. 116 117 // Tab sync. This is a placeholder type, so that Sessions can be implicitly 118 // enabled for history sync and tabs sync. 119 PROXY_TABS, 120 121 FIRST_PROXY_TYPE = PROXY_TABS, 122 LAST_PROXY_TYPE = PROXY_TABS, 123 124 LAST_USER_MODEL_TYPE = PROXY_TABS, 125 126 // ---- Control Types ---- 127 // An object representing a set of Nigori keys. 128 NIGORI, 129 FIRST_CONTROL_MODEL_TYPE = NIGORI, 130 // Client-specific metadata. 131 DEVICE_INFO, 132 // Flags to enable experimental features. 133 EXPERIMENTS, 134 LAST_CONTROL_MODEL_TYPE = EXPERIMENTS, 135 136 LAST_REAL_MODEL_TYPE = LAST_CONTROL_MODEL_TYPE, 137 138 // If you are adding a new sync datatype that is exposed to the user via the 139 // sync preferences UI, be sure to update the list in 140 // components/sync_driver/user_selectable_sync_type.h so that the UMA 141 // histograms for sync include your new type. In this case, be sure to also 142 // update the UserSelectableTypes() definition in 143 // sync/syncable/model_type.cc. 144 145 MODEL_TYPE_COUNT, 146 }; 147 148 typedef EnumSet<ModelType, FIRST_REAL_MODEL_TYPE, LAST_REAL_MODEL_TYPE> 149 ModelTypeSet; 150 typedef EnumSet<ModelType, UNSPECIFIED, LAST_REAL_MODEL_TYPE> 151 FullModelTypeSet; 152 153 inline ModelType ModelTypeFromInt(int i) { 154 DCHECK_GE(i, 0); 155 DCHECK_LT(i, MODEL_TYPE_COUNT); 156 return static_cast<ModelType>(i); 157 } 158 159 // Used by tests outside of sync/. 160 SYNC_EXPORT void AddDefaultFieldValue(ModelType datatype, 161 sync_pb::EntitySpecifics* specifics); 162 163 // Extract the model type of a SyncEntity protocol buffer. ModelType is a 164 // local concept: the enum is not in the protocol. The SyncEntity's ModelType 165 // is inferred from the presence of particular datatype field in the 166 // entity specifics. 167 SYNC_EXPORT_PRIVATE ModelType GetModelType( 168 const sync_pb::SyncEntity& sync_entity); 169 170 // Extract the model type from an EntitySpecifics field. Note that there 171 // are some ModelTypes (like TOP_LEVEL_FOLDER) that can't be inferred this way; 172 // prefer using GetModelType where possible. 173 SYNC_EXPORT ModelType GetModelTypeFromSpecifics( 174 const sync_pb::EntitySpecifics& specifics); 175 176 // Protocol types are those types that have actual protocol buffer 177 // representations. This distinguishes them from Proxy types, which have no 178 // protocol representation and are never sent to the server. 179 SYNC_EXPORT ModelTypeSet ProtocolTypes(); 180 181 // These are the normal user-controlled types. This is to distinguish from 182 // ControlTypes which are always enabled. Note that some of these share a 183 // preference flag, so not all of them are individually user-selectable. 184 SYNC_EXPORT ModelTypeSet UserTypes(); 185 186 // These are the user-selectable data types. 187 SYNC_EXPORT ModelTypeSet UserSelectableTypes(); 188 SYNC_EXPORT bool IsUserSelectableType(ModelType model_type); 189 190 // This is the subset of UserTypes() that can be encrypted. 191 SYNC_EXPORT_PRIVATE ModelTypeSet EncryptableUserTypes(); 192 193 // This is the subset of UserTypes() that have priority over other types. These 194 // types are synced before other user types and are never encrypted. 195 SYNC_EXPORT ModelTypeSet PriorityUserTypes(); 196 197 // Proxy types are placeholder types for handling implicitly enabling real 198 // types. They do not exist at the server, and are simply used for 199 // UI/Configuration logic. 200 SYNC_EXPORT ModelTypeSet ProxyTypes(); 201 202 // Returns a list of all control types. 203 // 204 // The control types are intended to contain metadata nodes that are essential 205 // for the normal operation of the syncer. As such, they have the following 206 // special properties: 207 // - They are downloaded early during SyncBackend initialization. 208 // - They are always enabled. Users may not disable these types. 209 // - Their contents are not encrypted automatically. 210 // - They support custom update application and conflict resolution logic. 211 // - All change processing occurs on the sync thread (GROUP_PASSIVE). 212 SYNC_EXPORT ModelTypeSet ControlTypes(); 213 214 // Returns true if this is a control type. 215 // 216 // See comment above for more information on what makes these types special. 217 SYNC_EXPORT bool IsControlType(ModelType model_type); 218 219 // Core types are those data types used by sync's core functionality (i.e. not 220 // user data types). These types are always enabled, and include ControlTypes(). 221 // 222 // The set of all core types. 223 SYNC_EXPORT ModelTypeSet CoreTypes(); 224 // Those core types that have high priority (includes ControlTypes()). 225 SYNC_EXPORT ModelTypeSet PriorityCoreTypes(); 226 227 // Determine a model type from the field number of its associated 228 // EntitySpecifics field. Returns UNSPECIFIED if the field number is 229 // not recognized. 230 // 231 // If you're putting the result in a ModelTypeSet, you should use the 232 // following pattern: 233 // 234 // ModelTypeSet model_types; 235 // // Say we're looping through a list of items, each of which has a 236 // // field number. 237 // for (...) { 238 // int field_number = ...; 239 // ModelType model_type = 240 // GetModelTypeFromSpecificsFieldNumber(field_number); 241 // if (!IsRealDataType(model_type)) { 242 // DLOG(WARNING) << "Unknown field number " << field_number; 243 // continue; 244 // } 245 // model_types.Put(model_type); 246 // } 247 SYNC_EXPORT_PRIVATE ModelType GetModelTypeFromSpecificsFieldNumber( 248 int field_number); 249 250 // Return the field number of the EntitySpecifics field associated with 251 // a model type. 252 // 253 // Used by tests outside of sync. 254 SYNC_EXPORT int GetSpecificsFieldNumberFromModelType( 255 ModelType model_type); 256 257 FullModelTypeSet ToFullModelTypeSet(ModelTypeSet in); 258 259 // TODO(sync): The functions below badly need some cleanup. 260 261 // Returns a pointer to a string with application lifetime that represents 262 // the name of |model_type|. 263 SYNC_EXPORT const char* ModelTypeToString(ModelType model_type); 264 265 // Some histograms take an integer parameter that represents a model type. 266 // The mapping from ModelType to integer is defined here. It should match 267 // the mapping from integer to labels defined in histograms.xml. 268 SYNC_EXPORT int ModelTypeToHistogramInt(ModelType model_type); 269 270 // Handles all model types, and not just real ones. 271 // 272 // Caller takes ownership of returned value. 273 SYNC_EXPORT_PRIVATE base::StringValue* ModelTypeToValue(ModelType model_type); 274 275 // Converts a Value into a ModelType - complement to ModelTypeToValue(). 276 SYNC_EXPORT_PRIVATE ModelType ModelTypeFromValue(const base::Value& value); 277 278 // Returns the ModelType corresponding to the name |model_type_string|. 279 SYNC_EXPORT ModelType ModelTypeFromString( 280 const std::string& model_type_string); 281 282 // Returns the comma-separated string representation of |model_types|. 283 SYNC_EXPORT std::string ModelTypeSetToString(ModelTypeSet model_types); 284 285 // Returns the set of comma-separated model types from |model_type_string|. 286 SYNC_EXPORT ModelTypeSet ModelTypeSetFromString( 287 const std::string& model_type_string); 288 289 // Caller takes ownership of returned list. 290 SYNC_EXPORT base::ListValue* ModelTypeSetToValue(ModelTypeSet model_types); 291 292 SYNC_EXPORT ModelTypeSet ModelTypeSetFromValue(const base::ListValue& value); 293 294 // Returns a string corresponding to the syncable tag for this datatype. 295 SYNC_EXPORT std::string ModelTypeToRootTag(ModelType type); 296 297 // Convert a real model type to a notification type (used for 298 // subscribing to server-issued notifications). Returns true iff 299 // |model_type| was a real model type and |notification_type| was 300 // filled in. 301 bool RealModelTypeToNotificationType(ModelType model_type, 302 std::string* notification_type); 303 304 // Converts a notification type to a real model type. Returns true 305 // iff |notification_type| was the notification type of a real model 306 // type and |model_type| was filled in. 307 SYNC_EXPORT bool NotificationTypeToRealModelType( 308 const std::string& notification_type, 309 ModelType* model_type); 310 311 // Returns true if |model_type| is a real datatype 312 SYNC_EXPORT bool IsRealDataType(ModelType model_type); 313 314 // Returns true if |model_type| is a proxy type 315 SYNC_EXPORT bool IsProxyType(ModelType model_type); 316 317 // Returns true if |model_type| is an act-once type. Act once types drop 318 // entities after applying them. Drops are deletes that are not synced to other 319 // clients. 320 // TODO(haitaol): Make entries of act-once data types immutable. 321 SYNC_EXPORT bool IsActOnceDataType(ModelType model_type); 322 323 // Returns set of model types that should be backed up before first sync. 324 SYNC_EXPORT ModelTypeSet BackupTypes(); 325 326 } // namespace syncer 327 328 #endif // SYNC_INTERNAL_API_PUBLIC_BASE_MODEL_TYPE_H_ 329