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 19namespace base { 20class ListValue; 21class StringValue; 22class Value; 23} 24 25namespace sync_pb { 26class EntitySpecifics; 27class SyncEntity; 28} 29 30namespace syncer { 31 32// TODO(akalin): Move the non-exported functions in this file to a 33// private header. 34 35enum 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 148typedef EnumSet<ModelType, FIRST_REAL_MODEL_TYPE, LAST_REAL_MODEL_TYPE> 149 ModelTypeSet; 150typedef EnumSet<ModelType, UNSPECIFIED, LAST_REAL_MODEL_TYPE> 151 FullModelTypeSet; 152 153inline 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/. 160SYNC_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. 167SYNC_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. 173SYNC_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. 179SYNC_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. 184SYNC_EXPORT ModelTypeSet UserTypes(); 185 186// These are the user-selectable data types. 187SYNC_EXPORT ModelTypeSet UserSelectableTypes(); 188SYNC_EXPORT bool IsUserSelectableType(ModelType model_type); 189 190// This is the subset of UserTypes() that can be encrypted. 191SYNC_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. 195SYNC_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. 200SYNC_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). 212SYNC_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. 217SYNC_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. 223SYNC_EXPORT ModelTypeSet CoreTypes(); 224// Those core types that have high priority (includes ControlTypes()). 225SYNC_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// } 247SYNC_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. 254SYNC_EXPORT int GetSpecificsFieldNumberFromModelType( 255 ModelType model_type); 256 257FullModelTypeSet 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|. 263SYNC_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. 268SYNC_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. 273SYNC_EXPORT_PRIVATE base::StringValue* ModelTypeToValue(ModelType model_type); 274 275// Converts a Value into a ModelType - complement to ModelTypeToValue(). 276SYNC_EXPORT_PRIVATE ModelType ModelTypeFromValue(const base::Value& value); 277 278// Returns the ModelType corresponding to the name |model_type_string|. 279SYNC_EXPORT ModelType ModelTypeFromString( 280 const std::string& model_type_string); 281 282// Returns the comma-separated string representation of |model_types|. 283SYNC_EXPORT std::string ModelTypeSetToString(ModelTypeSet model_types); 284 285// Returns the set of comma-separated model types from |model_type_string|. 286SYNC_EXPORT ModelTypeSet ModelTypeSetFromString( 287 const std::string& model_type_string); 288 289// Caller takes ownership of returned list. 290SYNC_EXPORT base::ListValue* ModelTypeSetToValue(ModelTypeSet model_types); 291 292SYNC_EXPORT ModelTypeSet ModelTypeSetFromValue(const base::ListValue& value); 293 294// Returns a string corresponding to the syncable tag for this datatype. 295SYNC_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. 301bool 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. 307SYNC_EXPORT bool NotificationTypeToRealModelType( 308 const std::string& notification_type, 309 ModelType* model_type); 310 311// Returns true if |model_type| is a real datatype 312SYNC_EXPORT bool IsRealDataType(ModelType model_type); 313 314// Returns true if |model_type| is a proxy type 315SYNC_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. 321SYNC_EXPORT bool IsActOnceDataType(ModelType model_type); 322 323// Returns set of model types that should be backed up before first sync. 324SYNC_EXPORT ModelTypeSet BackupTypes(); 325 326} // namespace syncer 327 328#endif // SYNC_INTERNAL_API_PUBLIC_BASE_MODEL_TYPE_H_ 329