Home | History | Annotate | Download | only in syncable 
      1 // Copyright (c) 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 #include "sync/internal_api/public/base/model_type.h"
      6 
      7 #include "base/strings/string_split.h"
      8 #include "base/values.h"
      9 #include "sync/protocol/app_notification_specifics.pb.h"
     10 #include "sync/protocol/app_setting_specifics.pb.h"
     11 #include "sync/protocol/app_specifics.pb.h"
     12 #include "sync/protocol/autofill_specifics.pb.h"
     13 #include "sync/protocol/bookmark_specifics.pb.h"
     14 #include "sync/protocol/extension_setting_specifics.pb.h"
     15 #include "sync/protocol/extension_specifics.pb.h"
     16 #include "sync/protocol/nigori_specifics.pb.h"
     17 #include "sync/protocol/password_specifics.pb.h"
     18 #include "sync/protocol/preference_specifics.pb.h"
     19 #include "sync/protocol/search_engine_specifics.pb.h"
     20 #include "sync/protocol/session_specifics.pb.h"
     21 #include "sync/protocol/sync.pb.h"
     22 #include "sync/protocol/theme_specifics.pb.h"
     23 #include "sync/protocol/typed_url_specifics.pb.h"
     24 #include "sync/syncable/syncable_proto_util.h"
     25 
     26 namespace syncer {
     27 
     28 void AddDefaultFieldValue(ModelType datatype,
     29                           sync_pb::EntitySpecifics* specifics) {
     30   if (!ProtocolTypes().Has(datatype)) {
     31     NOTREACHED() << "Only protocol types have field values.";
     32     return;
     33   }
     34   switch (datatype) {
     35     case BOOKMARKS:
     36       specifics->mutable_bookmark();
     37       break;
     38     case PASSWORDS:
     39       specifics->mutable_password();
     40       break;
     41     case PREFERENCES:
     42       specifics->mutable_preference();
     43       break;
     44     case AUTOFILL:
     45       specifics->mutable_autofill();
     46       break;
     47     case AUTOFILL_PROFILE:
     48       specifics->mutable_autofill_profile();
     49       break;
     50     case THEMES:
     51       specifics->mutable_theme();
     52       break;
     53     case TYPED_URLS:
     54       specifics->mutable_typed_url();
     55       break;
     56     case EXTENSIONS:
     57       specifics->mutable_extension();
     58       break;
     59     case NIGORI:
     60       specifics->mutable_nigori();
     61       break;
     62     case SEARCH_ENGINES:
     63       specifics->mutable_search_engine();
     64       break;
     65     case SESSIONS:
     66       specifics->mutable_session();
     67       break;
     68     case APPS:
     69       specifics->mutable_app();
     70       break;
     71     case APP_LIST:
     72       specifics->mutable_app_list();
     73       break;
     74     case APP_SETTINGS:
     75       specifics->mutable_app_setting();
     76       break;
     77     case EXTENSION_SETTINGS:
     78       specifics->mutable_extension_setting();
     79       break;
     80     case APP_NOTIFICATIONS:
     81       specifics->mutable_app_notification();
     82       break;
     83     case HISTORY_DELETE_DIRECTIVES:
     84       specifics->mutable_history_delete_directive();
     85       break;
     86     case SYNCED_NOTIFICATIONS:
     87       specifics->mutable_synced_notification();
     88       break;
     89     case SYNCED_NOTIFICATION_APP_INFO:
     90       specifics->mutable_synced_notification_app_info();
     91       break;
     92     case DEVICE_INFO:
     93       specifics->mutable_device_info();
     94       break;
     95     case EXPERIMENTS:
     96       specifics->mutable_experiments();
     97       break;
     98     case PRIORITY_PREFERENCES:
     99       specifics->mutable_priority_preference();
    100       break;
    101     case DICTIONARY:
    102       specifics->mutable_dictionary();
    103       break;
    104     case FAVICON_IMAGES:
    105       specifics->mutable_favicon_image();
    106       break;
    107     case FAVICON_TRACKING:
    108       specifics->mutable_favicon_tracking();
    109       break;
    110     case SUPERVISED_USER_SETTINGS:
    111       specifics->mutable_managed_user_setting();
    112       break;
    113     case SUPERVISED_USERS:
    114       specifics->mutable_managed_user();
    115       break;
    116     case SUPERVISED_USER_SHARED_SETTINGS:
    117       specifics->mutable_managed_user_shared_setting();
    118       break;
    119     case ARTICLES:
    120       specifics->mutable_article();
    121       break;
    122     default:
    123       NOTREACHED() << "No known extension for model type.";
    124   }
    125 }
    126 
    127 ModelType GetModelTypeFromSpecificsFieldNumber(int field_number) {
    128   ModelTypeSet protocol_types = ProtocolTypes();
    129   for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
    130        iter.Inc()) {
    131     if (GetSpecificsFieldNumberFromModelType(iter.Get()) == field_number)
    132       return iter.Get();
    133   }
    134   return UNSPECIFIED;
    135 }
    136 
    137 int GetSpecificsFieldNumberFromModelType(ModelType model_type) {
    138   DCHECK(ProtocolTypes().Has(model_type))
    139       << "Only protocol types have field values.";
    140   switch (model_type) {
    141     case BOOKMARKS:
    142       return sync_pb::EntitySpecifics::kBookmarkFieldNumber;
    143     case PASSWORDS:
    144       return sync_pb::EntitySpecifics::kPasswordFieldNumber;
    145     case PREFERENCES:
    146       return sync_pb::EntitySpecifics::kPreferenceFieldNumber;
    147     case AUTOFILL:
    148       return sync_pb::EntitySpecifics::kAutofillFieldNumber;
    149     case AUTOFILL_PROFILE:
    150       return sync_pb::EntitySpecifics::kAutofillProfileFieldNumber;
    151     case THEMES:
    152       return sync_pb::EntitySpecifics::kThemeFieldNumber;
    153     case TYPED_URLS:
    154       return sync_pb::EntitySpecifics::kTypedUrlFieldNumber;
    155     case EXTENSIONS:
    156       return sync_pb::EntitySpecifics::kExtensionFieldNumber;
    157     case NIGORI:
    158       return sync_pb::EntitySpecifics::kNigoriFieldNumber;
    159     case SEARCH_ENGINES:
    160       return sync_pb::EntitySpecifics::kSearchEngineFieldNumber;
    161     case SESSIONS:
    162       return sync_pb::EntitySpecifics::kSessionFieldNumber;
    163     case APPS:
    164       return sync_pb::EntitySpecifics::kAppFieldNumber;
    165     case APP_LIST:
    166       return sync_pb::EntitySpecifics::kAppListFieldNumber;
    167     case APP_SETTINGS:
    168       return sync_pb::EntitySpecifics::kAppSettingFieldNumber;
    169     case EXTENSION_SETTINGS:
    170       return sync_pb::EntitySpecifics::kExtensionSettingFieldNumber;
    171     case APP_NOTIFICATIONS:
    172       return sync_pb::EntitySpecifics::kAppNotificationFieldNumber;
    173     case HISTORY_DELETE_DIRECTIVES:
    174       return sync_pb::EntitySpecifics::kHistoryDeleteDirectiveFieldNumber;
    175     case SYNCED_NOTIFICATIONS:
    176       return sync_pb::EntitySpecifics::kSyncedNotificationFieldNumber;
    177     case SYNCED_NOTIFICATION_APP_INFO:
    178       return sync_pb::EntitySpecifics::kSyncedNotificationAppInfoFieldNumber;
    179     case DEVICE_INFO:
    180       return sync_pb::EntitySpecifics::kDeviceInfoFieldNumber;
    181     case EXPERIMENTS:
    182       return sync_pb::EntitySpecifics::kExperimentsFieldNumber;
    183     case PRIORITY_PREFERENCES:
    184       return sync_pb::EntitySpecifics::kPriorityPreferenceFieldNumber;
    185     case DICTIONARY:
    186       return sync_pb::EntitySpecifics::kDictionaryFieldNumber;
    187     case FAVICON_IMAGES:
    188       return sync_pb::EntitySpecifics::kFaviconImageFieldNumber;
    189     case FAVICON_TRACKING:
    190       return sync_pb::EntitySpecifics::kFaviconTrackingFieldNumber;
    191     case SUPERVISED_USER_SETTINGS:
    192       return sync_pb::EntitySpecifics::kManagedUserSettingFieldNumber;
    193     case SUPERVISED_USERS:
    194       return sync_pb::EntitySpecifics::kManagedUserFieldNumber;
    195     case SUPERVISED_USER_SHARED_SETTINGS:
    196       return sync_pb::EntitySpecifics::kManagedUserSharedSettingFieldNumber;
    197     case ARTICLES:
    198       return sync_pb::EntitySpecifics::kArticleFieldNumber;
    199     default:
    200       NOTREACHED() << "No known extension for model type.";
    201       return 0;
    202   }
    203 }
    204 
    205 FullModelTypeSet ToFullModelTypeSet(ModelTypeSet in) {
    206   FullModelTypeSet out;
    207   for (ModelTypeSet::Iterator i = in.First(); i.Good(); i.Inc()) {
    208     out.Put(i.Get());
    209   }
    210   return out;
    211 }
    212 
    213 // Note: keep this consistent with GetModelType in entry.cc!
    214 ModelType GetModelType(const sync_pb::SyncEntity& sync_entity) {
    215   DCHECK(!IsRoot(sync_entity));  // Root shouldn't ever go over the wire.
    216 
    217   // Backwards compatibility with old (pre-specifics) protocol.
    218   if (sync_entity.has_bookmarkdata())
    219     return BOOKMARKS;
    220 
    221   ModelType specifics_type = GetModelTypeFromSpecifics(sync_entity.specifics());
    222   if (specifics_type != UNSPECIFIED)
    223     return specifics_type;
    224 
    225   // Loose check for server-created top-level folders that aren't
    226   // bound to a particular model type.
    227   if (!sync_entity.server_defined_unique_tag().empty() &&
    228       IsFolder(sync_entity)) {
    229     return TOP_LEVEL_FOLDER;
    230   }
    231 
    232   // This is an item of a datatype we can't understand. Maybe it's
    233   // from the future?  Either we mis-encoded the object, or the
    234   // server sent us entries it shouldn't have.
    235   NOTREACHED() << "Unknown datatype in sync proto.";
    236   return UNSPECIFIED;
    237 }
    238 
    239 ModelType GetModelTypeFromSpecifics(const sync_pb::EntitySpecifics& specifics) {
    240   if (specifics.has_bookmark())
    241     return BOOKMARKS;
    242 
    243   if (specifics.has_password())
    244     return PASSWORDS;
    245 
    246   if (specifics.has_preference())
    247     return PREFERENCES;
    248 
    249   if (specifics.has_autofill())
    250     return AUTOFILL;
    251 
    252   if (specifics.has_autofill_profile())
    253     return AUTOFILL_PROFILE;
    254 
    255   if (specifics.has_theme())
    256     return THEMES;
    257 
    258   if (specifics.has_typed_url())
    259     return TYPED_URLS;
    260 
    261   if (specifics.has_extension())
    262     return EXTENSIONS;
    263 
    264   if (specifics.has_nigori())
    265     return NIGORI;
    266 
    267   if (specifics.has_app())
    268     return APPS;
    269 
    270   if (specifics.has_app_list())
    271     return APP_LIST;
    272 
    273   if (specifics.has_search_engine())
    274     return SEARCH_ENGINES;
    275 
    276   if (specifics.has_session())
    277     return SESSIONS;
    278 
    279   if (specifics.has_app_setting())
    280     return APP_SETTINGS;
    281 
    282   if (specifics.has_extension_setting())
    283     return EXTENSION_SETTINGS;
    284 
    285   if (specifics.has_app_notification())
    286     return APP_NOTIFICATIONS;
    287 
    288   if (specifics.has_history_delete_directive())
    289     return HISTORY_DELETE_DIRECTIVES;
    290 
    291   if (specifics.has_synced_notification())
    292     return SYNCED_NOTIFICATIONS;
    293 
    294   if (specifics.has_synced_notification_app_info())
    295     return SYNCED_NOTIFICATION_APP_INFO;
    296 
    297   if (specifics.has_device_info())
    298     return DEVICE_INFO;
    299 
    300   if (specifics.has_experiments())
    301     return EXPERIMENTS;
    302 
    303   if (specifics.has_priority_preference())
    304     return PRIORITY_PREFERENCES;
    305 
    306   if (specifics.has_dictionary())
    307     return DICTIONARY;
    308 
    309   if (specifics.has_favicon_image())
    310     return FAVICON_IMAGES;
    311 
    312   if (specifics.has_favicon_tracking())
    313     return FAVICON_TRACKING;
    314 
    315   if (specifics.has_managed_user_setting())
    316     return SUPERVISED_USER_SETTINGS;
    317 
    318   if (specifics.has_managed_user())
    319     return SUPERVISED_USERS;
    320 
    321   if (specifics.has_managed_user_shared_setting())
    322     return SUPERVISED_USER_SHARED_SETTINGS;
    323 
    324   if (specifics.has_article())
    325     return ARTICLES;
    326 
    327   return UNSPECIFIED;
    328 }
    329 
    330 ModelTypeSet ProtocolTypes() {
    331   ModelTypeSet set = ModelTypeSet::All();
    332   set.RemoveAll(ProxyTypes());
    333   return set;
    334 }
    335 
    336 ModelTypeSet UserTypes() {
    337   ModelTypeSet set;
    338   // TODO(sync): We should be able to build the actual enumset's internal
    339   // bitset value here at compile time, rather than performing an iteration
    340   // every time.
    341   for (int i = FIRST_USER_MODEL_TYPE; i <= LAST_USER_MODEL_TYPE; ++i) {
    342     set.Put(ModelTypeFromInt(i));
    343   }
    344   return set;
    345 }
    346 
    347 ModelTypeSet UserSelectableTypes() {
    348   ModelTypeSet set;
    349   // Although the order doesn't technically matter here, it's clearer to keep
    350   // these in the same order as their definition in the ModelType enum.
    351   set.Put(BOOKMARKS);
    352   set.Put(PREFERENCES);
    353   set.Put(PASSWORDS);
    354   set.Put(AUTOFILL);
    355   set.Put(THEMES);
    356   set.Put(TYPED_URLS);
    357   set.Put(EXTENSIONS);
    358   set.Put(APPS);
    359   set.Put(PROXY_TABS);
    360   return set;
    361 }
    362 
    363 bool IsUserSelectableType(ModelType model_type) {
    364   return UserSelectableTypes().Has(model_type);
    365 }
    366 
    367 ModelTypeSet EncryptableUserTypes() {
    368   ModelTypeSet encryptable_user_types = UserTypes();
    369   // We never encrypt history delete directives.
    370   encryptable_user_types.Remove(HISTORY_DELETE_DIRECTIVES);
    371   // Synced notifications are not encrypted since the server must see changes.
    372   encryptable_user_types.Remove(SYNCED_NOTIFICATIONS);
    373   // Synced Notification App Info does not have private data, so it is not
    374   // encrypted.
    375   encryptable_user_types.Remove(SYNCED_NOTIFICATION_APP_INFO);
    376   // Device info data is not encrypted because it might be synced before
    377   // encryption is ready.
    378   encryptable_user_types.Remove(DEVICE_INFO);
    379   // Priority preferences are not encrypted because they might be synced before
    380   // encryption is ready.
    381   encryptable_user_types.Remove(PRIORITY_PREFERENCES);
    382   // Supervised user settings are not encrypted since they are set server-side.
    383   encryptable_user_types.Remove(SUPERVISED_USER_SETTINGS);
    384   // Supervised users are not encrypted since they are managed server-side.
    385   encryptable_user_types.Remove(SUPERVISED_USERS);
    386   // Supervised user shared settings are not encrypted since they are managed
    387   // server-side and shared between manager and supervised user.
    388   encryptable_user_types.Remove(SUPERVISED_USER_SHARED_SETTINGS);
    389   // Proxy types have no sync representation and are therefore not encrypted.
    390   // Note however that proxy types map to one or more protocol types, which
    391   // may or may not be encrypted themselves.
    392   encryptable_user_types.RemoveAll(ProxyTypes());
    393   return encryptable_user_types;
    394 }
    395 
    396 ModelTypeSet PriorityUserTypes() {
    397   return ModelTypeSet(DEVICE_INFO, PRIORITY_PREFERENCES);
    398 }
    399 
    400 ModelTypeSet ControlTypes() {
    401   ModelTypeSet set;
    402   // TODO(sync): We should be able to build the actual enumset's internal
    403   // bitset value here at compile time, rather than performing an iteration
    404   // every time.
    405   for (int i = FIRST_CONTROL_MODEL_TYPE; i <= LAST_CONTROL_MODEL_TYPE; ++i) {
    406     set.Put(ModelTypeFromInt(i));
    407   }
    408 
    409   return set;
    410 }
    411 
    412 ModelTypeSet ProxyTypes() {
    413   ModelTypeSet set;
    414   set.Put(PROXY_TABS);
    415   return set;
    416 }
    417 
    418 bool IsControlType(ModelType model_type) {
    419   return ControlTypes().Has(model_type);
    420 }
    421 
    422 ModelTypeSet CoreTypes() {
    423   syncer::ModelTypeSet result;
    424   result.PutAll(PriorityCoreTypes());
    425 
    426   // The following are low priority core types.
    427   result.Put(SYNCED_NOTIFICATIONS);
    428   result.Put(SYNCED_NOTIFICATION_APP_INFO);
    429   result.Put(SUPERVISED_USER_SHARED_SETTINGS);
    430 
    431   return result;
    432 }
    433 
    434 ModelTypeSet PriorityCoreTypes() {
    435   syncer::ModelTypeSet result;
    436   result.PutAll(ControlTypes());
    437 
    438   // The following are non-control core types.
    439   result.Put(SUPERVISED_USERS);
    440   result.Put(SUPERVISED_USER_SETTINGS);
    441 
    442   return result;
    443 }
    444 
    445 ModelTypeSet BackupTypes() {
    446   ModelTypeSet result;
    447   result.Put(BOOKMARKS);
    448   result.Put(PREFERENCES);
    449   result.Put(THEMES);
    450   result.Put(EXTENSIONS);
    451   result.Put(SEARCH_ENGINES);
    452   result.Put(APPS);
    453   result.Put(APP_LIST);
    454   result.Put(APP_SETTINGS);
    455   result.Put(EXTENSION_SETTINGS);
    456   result.Put(PRIORITY_PREFERENCES);
    457   return result;
    458 }
    459 
    460 const char* ModelTypeToString(ModelType model_type) {
    461   // This is used in serialization routines as well as for displaying debug
    462   // information.  Do not attempt to change these string values unless you know
    463   // what you're doing.
    464   switch (model_type) {
    465     case TOP_LEVEL_FOLDER:
    466       return "Top Level Folder";
    467     case UNSPECIFIED:
    468       return "Unspecified";
    469     case BOOKMARKS:
    470       return "Bookmarks";
    471     case PREFERENCES:
    472       return "Preferences";
    473     case PASSWORDS:
    474       return "Passwords";
    475     case AUTOFILL:
    476       return "Autofill";
    477     case THEMES:
    478       return "Themes";
    479     case TYPED_URLS:
    480       return "Typed URLs";
    481     case EXTENSIONS:
    482       return "Extensions";
    483     case NIGORI:
    484       return "Encryption keys";
    485     case SEARCH_ENGINES:
    486       return "Search Engines";
    487     case SESSIONS:
    488       return "Sessions";
    489     case APPS:
    490       return "Apps";
    491     case APP_LIST:
    492       return "App List";
    493     case AUTOFILL_PROFILE:
    494       return "Autofill Profiles";
    495     case APP_SETTINGS:
    496       return "App settings";
    497     case EXTENSION_SETTINGS:
    498       return "Extension settings";
    499     case APP_NOTIFICATIONS:
    500       return "App Notifications";
    501     case HISTORY_DELETE_DIRECTIVES:
    502       return "History Delete Directives";
    503     case SYNCED_NOTIFICATIONS:
    504       return "Synced Notifications";
    505     case SYNCED_NOTIFICATION_APP_INFO:
    506       return "Synced Notification App Info";
    507     case DEVICE_INFO:
    508       return "Device Info";
    509     case EXPERIMENTS:
    510       return "Experiments";
    511     case PRIORITY_PREFERENCES:
    512       return "Priority Preferences";
    513     case DICTIONARY:
    514       return "Dictionary";
    515     case FAVICON_IMAGES:
    516       return "Favicon Images";
    517     case FAVICON_TRACKING:
    518       return "Favicon Tracking";
    519     case SUPERVISED_USER_SETTINGS:
    520       return "Managed User Settings";
    521     case SUPERVISED_USERS:
    522       return "Managed Users";
    523     case SUPERVISED_USER_SHARED_SETTINGS:
    524       return "Managed User Shared Settings";
    525     case ARTICLES:
    526       return "Articles";
    527     case PROXY_TABS:
    528       return "Tabs";
    529     default:
    530       break;
    531   }
    532   NOTREACHED() << "No known extension for model type.";
    533   return "INVALID";
    534 }
    535 
    536 // The normal rules about histograms apply here.  Always append to the bottom of
    537 // the list, and be careful to not reuse integer values that have already been
    538 // assigned.  Don't forget to update histograms.xml when you make changes to
    539 // this list.
    540 int ModelTypeToHistogramInt(ModelType model_type) {
    541   switch (model_type) {
    542     case UNSPECIFIED:
    543       return 0;
    544     case TOP_LEVEL_FOLDER:
    545       return 1;
    546     case BOOKMARKS:
    547       return 2;
    548     case PREFERENCES:
    549       return 3;
    550     case PASSWORDS:
    551       return 4;
    552     case AUTOFILL_PROFILE:
    553       return 5;
    554     case AUTOFILL:
    555       return 6;
    556     case THEMES:
    557       return 7;
    558     case TYPED_URLS:
    559       return 8;
    560     case EXTENSIONS:
    561       return 9;
    562     case SEARCH_ENGINES:
    563       return 10;
    564     case SESSIONS:
    565       return 11;
    566     case APPS:
    567       return 12;
    568     case APP_SETTINGS:
    569       return 13;
    570     case EXTENSION_SETTINGS:
    571       return 14;
    572     case APP_NOTIFICATIONS:
    573       return 15;
    574     case HISTORY_DELETE_DIRECTIVES:
    575       return 16;
    576     case NIGORI:
    577       return 17;
    578     case DEVICE_INFO:
    579       return 18;
    580     case EXPERIMENTS:
    581       return 19;
    582     case SYNCED_NOTIFICATIONS:
    583       return 20;
    584     case PRIORITY_PREFERENCES:
    585       return 21;
    586     case DICTIONARY:
    587       return 22;
    588     case FAVICON_IMAGES:
    589       return 23;
    590     case FAVICON_TRACKING:
    591       return 24;
    592     case PROXY_TABS:
    593       return 25;
    594     case SUPERVISED_USER_SETTINGS:
    595       return 26;
    596     case SUPERVISED_USERS:
    597       return 27;
    598     case ARTICLES:
    599       return 28;
    600     case APP_LIST:
    601       return 29;
    602     case SUPERVISED_USER_SHARED_SETTINGS:
    603       return 30;
    604     case SYNCED_NOTIFICATION_APP_INFO:
    605       return 31;
    606     // Silence a compiler warning.
    607     case MODEL_TYPE_COUNT:
    608       return 0;
    609   }
    610   return 0;
    611 }
    612 
    613 base::StringValue* ModelTypeToValue(ModelType model_type) {
    614   if (model_type >= FIRST_REAL_MODEL_TYPE) {
    615     return new base::StringValue(ModelTypeToString(model_type));
    616   } else if (model_type == TOP_LEVEL_FOLDER) {
    617     return new base::StringValue("Top-level folder");
    618   } else if (model_type == UNSPECIFIED) {
    619     return new base::StringValue("Unspecified");
    620   }
    621   NOTREACHED();
    622   return new base::StringValue(std::string());
    623 }
    624 
    625 ModelType ModelTypeFromValue(const base::Value& value) {
    626   if (value.IsType(base::Value::TYPE_STRING)) {
    627     std::string result;
    628     CHECK(value.GetAsString(&result));
    629     return ModelTypeFromString(result);
    630   } else if (value.IsType(base::Value::TYPE_INTEGER)) {
    631     int result;
    632     CHECK(value.GetAsInteger(&result));
    633     return ModelTypeFromInt(result);
    634   } else {
    635     NOTREACHED() << "Unsupported value type: " << value.GetType();
    636     return UNSPECIFIED;
    637   }
    638 }
    639 
    640 ModelType ModelTypeFromString(const std::string& model_type_string) {
    641   if (model_type_string == "Bookmarks")
    642     return BOOKMARKS;
    643   else if (model_type_string == "Preferences")
    644     return PREFERENCES;
    645   else if (model_type_string == "Passwords")
    646     return PASSWORDS;
    647   else if (model_type_string == "Autofill")
    648     return AUTOFILL;
    649   else if (model_type_string == "Autofill Profiles")
    650     return AUTOFILL_PROFILE;
    651   else if (model_type_string == "Themes")
    652     return THEMES;
    653   else if (model_type_string == "Typed URLs")
    654     return TYPED_URLS;
    655   else if (model_type_string == "Extensions")
    656     return EXTENSIONS;
    657   else if (model_type_string == "Encryption keys")
    658     return NIGORI;
    659   else if (model_type_string == "Search Engines")
    660     return SEARCH_ENGINES;
    661   else if (model_type_string == "Sessions")
    662     return SESSIONS;
    663   else if (model_type_string == "Apps")
    664     return APPS;
    665   else if (model_type_string == "App List")
    666     return APP_LIST;
    667   else if (model_type_string == "App settings")
    668     return APP_SETTINGS;
    669   else if (model_type_string == "Extension settings")
    670     return EXTENSION_SETTINGS;
    671   else if (model_type_string == "App Notifications")
    672     return APP_NOTIFICATIONS;
    673   else if (model_type_string == "History Delete Directives")
    674     return HISTORY_DELETE_DIRECTIVES;
    675   else if (model_type_string == "Synced Notifications")
    676     return SYNCED_NOTIFICATIONS;
    677   else if (model_type_string == "Synced Notification App Info")
    678     return SYNCED_NOTIFICATION_APP_INFO;
    679   else if (model_type_string == "Device Info")
    680     return DEVICE_INFO;
    681   else if (model_type_string == "Experiments")
    682     return EXPERIMENTS;
    683   else if (model_type_string == "Priority Preferences")
    684     return PRIORITY_PREFERENCES;
    685   else if (model_type_string == "Dictionary")
    686     return DICTIONARY;
    687   else if (model_type_string == "Favicon Images")
    688     return FAVICON_IMAGES;
    689   else if (model_type_string == "Favicon Tracking")
    690     return FAVICON_TRACKING;
    691   else if (model_type_string == "Managed User Settings")
    692     return SUPERVISED_USER_SETTINGS;
    693   else if (model_type_string == "Managed Users")
    694     return SUPERVISED_USERS;
    695   else if (model_type_string == "Managed User Shared Settings")
    696     return SUPERVISED_USER_SHARED_SETTINGS;
    697   else if (model_type_string == "Articles")
    698     return ARTICLES;
    699   else if (model_type_string == "Tabs")
    700     return PROXY_TABS;
    701   else
    702     NOTREACHED() << "No known model type corresponding to "
    703                  << model_type_string << ".";
    704   return UNSPECIFIED;
    705 }
    706 
    707 std::string ModelTypeSetToString(ModelTypeSet model_types) {
    708   std::string result;
    709   for (ModelTypeSet::Iterator it = model_types.First(); it.Good(); it.Inc()) {
    710     if (!result.empty()) {
    711       result += ", ";
    712     }
    713     result += ModelTypeToString(it.Get());
    714   }
    715   return result;
    716 }
    717 
    718 ModelTypeSet ModelTypeSetFromString(const std::string& model_types_string) {
    719   std::string working_copy = model_types_string;
    720   ModelTypeSet model_types;
    721   while (!working_copy.empty()) {
    722     // Remove any leading spaces.
    723     working_copy = working_copy.substr(working_copy.find_first_not_of(' '));
    724     if (working_copy.empty())
    725       break;
    726     std::string type_str;
    727     size_t end = working_copy.find(',');
    728     if (end == std::string::npos) {
    729       end = working_copy.length() - 1;
    730       type_str = working_copy;
    731     } else {
    732       type_str = working_copy.substr(0, end);
    733     }
    734     syncer::ModelType type = ModelTypeFromString(type_str);
    735     if (IsRealDataType(type))
    736       model_types.Put(type);
    737     working_copy = working_copy.substr(end + 1);
    738   }
    739   return model_types;
    740 }
    741 
    742 base::ListValue* ModelTypeSetToValue(ModelTypeSet model_types) {
    743   base::ListValue* value = new base::ListValue();
    744   for (ModelTypeSet::Iterator it = model_types.First(); it.Good(); it.Inc()) {
    745     value->Append(new base::StringValue(ModelTypeToString(it.Get())));
    746   }
    747   return value;
    748 }
    749 
    750 ModelTypeSet ModelTypeSetFromValue(const base::ListValue& value) {
    751   ModelTypeSet result;
    752   for (base::ListValue::const_iterator i = value.begin();
    753        i != value.end(); ++i) {
    754     result.Put(ModelTypeFromValue(**i));
    755   }
    756   return result;
    757 }
    758 
    759 // TODO(zea): remove all hardcoded tags in model associators and have them use
    760 // this instead.
    761 // NOTE: Proxy types should return empty strings (so that we don't NOTREACHED
    762 // in tests when we verify they have no root node).
    763 std::string ModelTypeToRootTag(ModelType type) {
    764   switch (type) {
    765     case BOOKMARKS:
    766       return "google_chrome_bookmarks";
    767     case PREFERENCES:
    768       return "google_chrome_preferences";
    769     case PASSWORDS:
    770       return "google_chrome_passwords";
    771     case AUTOFILL:
    772       return "google_chrome_autofill";
    773     case THEMES:
    774       return "google_chrome_themes";
    775     case TYPED_URLS:
    776       return "google_chrome_typed_urls";
    777     case EXTENSIONS:
    778       return "google_chrome_extensions";
    779     case NIGORI:
    780       return "google_chrome_nigori";
    781     case SEARCH_ENGINES:
    782       return "google_chrome_search_engines";
    783     case SESSIONS:
    784       return "google_chrome_sessions";
    785     case APPS:
    786       return "google_chrome_apps";
    787     case APP_LIST:
    788       return "google_chrome_app_list";
    789     case AUTOFILL_PROFILE:
    790       return "google_chrome_autofill_profiles";
    791     case APP_SETTINGS:
    792       return "google_chrome_app_settings";
    793     case EXTENSION_SETTINGS:
    794       return "google_chrome_extension_settings";
    795     case APP_NOTIFICATIONS:
    796       return "google_chrome_app_notifications";
    797     case HISTORY_DELETE_DIRECTIVES:
    798       return "google_chrome_history_delete_directives";
    799     case SYNCED_NOTIFICATIONS:
    800       return "google_chrome_synced_notifications";
    801     case SYNCED_NOTIFICATION_APP_INFO:
    802       return "google_chrome_synced_notification_app_info";
    803     case DEVICE_INFO:
    804       return "google_chrome_device_info";
    805     case EXPERIMENTS:
    806       return "google_chrome_experiments";
    807     case PRIORITY_PREFERENCES:
    808       return "google_chrome_priority_preferences";
    809     case DICTIONARY:
    810       return "google_chrome_dictionary";
    811     case FAVICON_IMAGES:
    812       return "google_chrome_favicon_images";
    813     case FAVICON_TRACKING:
    814       return "google_chrome_favicon_tracking";
    815     case SUPERVISED_USER_SETTINGS:
    816       return "google_chrome_managed_user_settings";
    817     case SUPERVISED_USERS:
    818       return "google_chrome_managed_users";
    819     case SUPERVISED_USER_SHARED_SETTINGS:
    820       return "google_chrome_managed_user_shared_settings";
    821     case ARTICLES:
    822       return "google_chrome_articles";
    823     case PROXY_TABS:
    824       return std::string();
    825     default:
    826       break;
    827   }
    828   NOTREACHED() << "No known extension for model type.";
    829   return "INVALID";
    830 }
    831 
    832 // TODO(akalin): Figure out a better way to do these mappings.
    833 // Note: Do not include proxy types in this list. They should never receive
    834 // or trigger notifications.
    835 namespace {
    836 const char kBookmarkNotificationType[] = "BOOKMARK";
    837 const char kPreferenceNotificationType[] = "PREFERENCE";
    838 const char kPasswordNotificationType[] = "PASSWORD";
    839 const char kAutofillNotificationType[] = "AUTOFILL";
    840 const char kThemeNotificationType[] = "THEME";
    841 const char kTypedUrlNotificationType[] = "TYPED_URL";
    842 const char kExtensionNotificationType[] = "EXTENSION";
    843 const char kExtensionSettingNotificationType[] = "EXTENSION_SETTING";
    844 const char kNigoriNotificationType[] = "NIGORI";
    845 const char kAppSettingNotificationType[] = "APP_SETTING";
    846 const char kAppNotificationType[] = "APP";
    847 const char kAppListNotificationType[] = "APP_LIST";
    848 const char kSearchEngineNotificationType[] = "SEARCH_ENGINE";
    849 const char kSessionNotificationType[] = "SESSION";
    850 const char kAutofillProfileNotificationType[] = "AUTOFILL_PROFILE";
    851 const char kAppNotificationNotificationType[] = "APP_NOTIFICATION";
    852 const char kHistoryDeleteDirectiveNotificationType[] =
    853     "HISTORY_DELETE_DIRECTIVE";
    854 const char kSyncedNotificationType[] = "SYNCED_NOTIFICATION";
    855 const char kSyncedNotificationAppInfoType[] = "SYNCED_NOTIFICATION_APP_INFO";
    856 const char kDeviceInfoNotificationType[] = "DEVICE_INFO";
    857 const char kExperimentsNotificationType[] = "EXPERIMENTS";
    858 const char kPriorityPreferenceNotificationType[] = "PRIORITY_PREFERENCE";
    859 const char kDictionaryNotificationType[] = "DICTIONARY";
    860 const char kFaviconImageNotificationType[] = "FAVICON_IMAGE";
    861 const char kFaviconTrackingNotificationType[] = "FAVICON_TRACKING";
    862 const char kSupervisedUserSettingNotificationType[] = "MANAGED_USER_SETTING";
    863 const char kSupervisedUserNotificationType[] = "MANAGED_USER";
    864 const char kSupervisedUserSharedSettingNotificationType[] =
    865     "MANAGED_USER_SHARED_SETTING";
    866 const char kArticleNotificationType[] = "ARTICLE";
    867 }  // namespace
    868 
    869 bool RealModelTypeToNotificationType(ModelType model_type,
    870                                      std::string* notification_type) {
    871   switch (model_type) {
    872     case BOOKMARKS:
    873       *notification_type = kBookmarkNotificationType;
    874       return true;
    875     case PREFERENCES:
    876       *notification_type = kPreferenceNotificationType;
    877       return true;
    878     case PASSWORDS:
    879       *notification_type = kPasswordNotificationType;
    880       return true;
    881     case AUTOFILL:
    882       *notification_type = kAutofillNotificationType;
    883       return true;
    884     case THEMES:
    885       *notification_type = kThemeNotificationType;
    886       return true;
    887     case TYPED_URLS:
    888       *notification_type = kTypedUrlNotificationType;
    889       return true;
    890     case EXTENSIONS:
    891       *notification_type = kExtensionNotificationType;
    892       return true;
    893     case NIGORI:
    894       *notification_type = kNigoriNotificationType;
    895       return true;
    896     case APP_SETTINGS:
    897       *notification_type = kAppSettingNotificationType;
    898       return true;
    899     case APPS:
    900       *notification_type = kAppNotificationType;
    901       return true;
    902     case APP_LIST:
    903       *notification_type = kAppListNotificationType;
    904       return true;
    905     case SEARCH_ENGINES:
    906       *notification_type = kSearchEngineNotificationType;
    907       return true;
    908     case SESSIONS:
    909       *notification_type = kSessionNotificationType;
    910       return true;
    911     case AUTOFILL_PROFILE:
    912       *notification_type = kAutofillProfileNotificationType;
    913       return true;
    914     case EXTENSION_SETTINGS:
    915       *notification_type = kExtensionSettingNotificationType;
    916       return true;
    917     case APP_NOTIFICATIONS:
    918       *notification_type = kAppNotificationNotificationType;
    919       return true;
    920     case HISTORY_DELETE_DIRECTIVES:
    921       *notification_type = kHistoryDeleteDirectiveNotificationType;
    922       return true;
    923     case SYNCED_NOTIFICATIONS:
    924       *notification_type = kSyncedNotificationType;
    925       return true;
    926     case SYNCED_NOTIFICATION_APP_INFO:
    927       *notification_type = kSyncedNotificationAppInfoType;
    928       return true;
    929     case DEVICE_INFO:
    930       *notification_type = kDeviceInfoNotificationType;
    931       return true;
    932     case EXPERIMENTS:
    933       *notification_type = kExperimentsNotificationType;
    934       return true;
    935     case PRIORITY_PREFERENCES:
    936       *notification_type = kPriorityPreferenceNotificationType;
    937       return true;
    938     case DICTIONARY:
    939       *notification_type = kDictionaryNotificationType;
    940       return true;
    941     case FAVICON_IMAGES:
    942       *notification_type = kFaviconImageNotificationType;
    943       return true;
    944     case FAVICON_TRACKING:
    945       *notification_type = kFaviconTrackingNotificationType;
    946       return true;
    947     case SUPERVISED_USER_SETTINGS:
    948       *notification_type = kSupervisedUserSettingNotificationType;
    949       return true;
    950     case SUPERVISED_USERS:
    951       *notification_type = kSupervisedUserNotificationType;
    952       return true;
    953     case SUPERVISED_USER_SHARED_SETTINGS:
    954       *notification_type = kSupervisedUserSharedSettingNotificationType;
    955       return true;
    956     case ARTICLES:
    957       *notification_type = kArticleNotificationType;
    958       return true;
    959     default:
    960       break;
    961   }
    962   notification_type->clear();
    963   return false;
    964 }
    965 
    966 bool NotificationTypeToRealModelType(const std::string& notification_type,
    967                                      ModelType* model_type) {
    968   if (notification_type == kBookmarkNotificationType) {
    969     *model_type = BOOKMARKS;
    970     return true;
    971   } else if (notification_type == kPreferenceNotificationType) {
    972     *model_type = PREFERENCES;
    973     return true;
    974   } else if (notification_type == kPasswordNotificationType) {
    975     *model_type = PASSWORDS;
    976     return true;
    977   } else if (notification_type == kAutofillNotificationType) {
    978     *model_type = AUTOFILL;
    979     return true;
    980   } else if (notification_type == kThemeNotificationType) {
    981     *model_type = THEMES;
    982     return true;
    983   } else if (notification_type == kTypedUrlNotificationType) {
    984     *model_type = TYPED_URLS;
    985     return true;
    986   } else if (notification_type == kExtensionNotificationType) {
    987     *model_type = EXTENSIONS;
    988     return true;
    989   } else if (notification_type == kNigoriNotificationType) {
    990     *model_type = NIGORI;
    991     return true;
    992   } else if (notification_type == kAppNotificationType) {
    993     *model_type = APPS;
    994     return true;
    995   } else if (notification_type == kAppListNotificationType) {
    996     *model_type = APP_LIST;
    997     return true;
    998   } else if (notification_type == kSearchEngineNotificationType) {
    999     *model_type = SEARCH_ENGINES;
   1000     return true;
   1001   } else if (notification_type == kSessionNotificationType) {
   1002     *model_type = SESSIONS;
   1003     return true;
   1004   } else if (notification_type == kAutofillProfileNotificationType) {
   1005     *model_type = AUTOFILL_PROFILE;
   1006     return true;
   1007   } else if (notification_type == kAppSettingNotificationType) {
   1008     *model_type = APP_SETTINGS;
   1009     return true;
   1010   } else if (notification_type == kExtensionSettingNotificationType) {
   1011     *model_type = EXTENSION_SETTINGS;
   1012     return true;
   1013   } else if (notification_type == kAppNotificationNotificationType) {
   1014     *model_type = APP_NOTIFICATIONS;
   1015     return true;
   1016   } else if (notification_type == kHistoryDeleteDirectiveNotificationType) {
   1017     *model_type = HISTORY_DELETE_DIRECTIVES;
   1018     return true;
   1019   } else if (notification_type == kSyncedNotificationType) {
   1020     *model_type = SYNCED_NOTIFICATIONS;
   1021     return true;
   1022   } else if (notification_type == kSyncedNotificationAppInfoType) {
   1023     *model_type = SYNCED_NOTIFICATION_APP_INFO;
   1024     return true;
   1025   } else if (notification_type == kDeviceInfoNotificationType) {
   1026     *model_type = DEVICE_INFO;
   1027     return true;
   1028   } else if (notification_type == kExperimentsNotificationType) {
   1029     *model_type = EXPERIMENTS;
   1030     return true;
   1031   } else if (notification_type == kPriorityPreferenceNotificationType) {
   1032     *model_type = PRIORITY_PREFERENCES;
   1033     return true;
   1034   } else if (notification_type == kDictionaryNotificationType) {
   1035     *model_type = DICTIONARY;
   1036     return true;
   1037   } else if (notification_type == kFaviconImageNotificationType) {
   1038     *model_type = FAVICON_IMAGES;
   1039     return true;
   1040   } else if (notification_type == kFaviconTrackingNotificationType) {
   1041     *model_type = FAVICON_TRACKING;
   1042     return true;
   1043   } else if (notification_type == kSupervisedUserSettingNotificationType) {
   1044     *model_type = SUPERVISED_USER_SETTINGS;
   1045     return true;
   1046   } else if (notification_type == kSupervisedUserNotificationType) {
   1047     *model_type = SUPERVISED_USERS;
   1048     return true;
   1049   } else if (notification_type ==
   1050       kSupervisedUserSharedSettingNotificationType) {
   1051     *model_type = SUPERVISED_USER_SHARED_SETTINGS;
   1052     return true;
   1053   } else if (notification_type == kArticleNotificationType) {
   1054     *model_type = ARTICLES;
   1055     return true;
   1056   }
   1057   *model_type = UNSPECIFIED;
   1058   return false;
   1059 }
   1060 
   1061 bool IsRealDataType(ModelType model_type) {
   1062   return model_type >= FIRST_REAL_MODEL_TYPE && model_type < MODEL_TYPE_COUNT;
   1063 }
   1064 
   1065 bool IsProxyType(ModelType model_type) {
   1066   return model_type >= FIRST_PROXY_TYPE && model_type <= LAST_PROXY_TYPE;
   1067 }
   1068 
   1069 bool IsActOnceDataType(ModelType model_type) {
   1070   return model_type == HISTORY_DELETE_DIRECTIVES;
   1071 }
   1072 
   1073 }  // namespace syncer
   1074