Sync user's custom spellcheck dictionary

sync/syncable/model_type.cc

 // Copyright (c) 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.
 
 #include "sync/internal_api/public/base/model_type.h"
 
 #include "base/string_split.h"
 #include "base/values.h"
 #include "sync/protocol/app_notification_specifics.pb.h"
 #include "sync/protocol/app_setting_specifics.pb.h"
@@ skipping 70 matching lines @@
       break;
     case DEVICE_INFO:
       specifics->mutable_device_info();
       break;
     case EXPERIMENTS:
       specifics->mutable_experiments();
       break;
     case PRIORITY_PREFERENCES:
       specifics->mutable_priority_preference();
       break;
+    case DICTIONARY:
+      specifics->mutable_dictionary();
+      break;
     default:
       NOTREACHED() << "No known extension for model type.";
   }
 }
 
 ModelType GetModelTypeFromSpecificsFieldNumber(int field_number) {
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     ModelType model_type = ModelTypeFromInt(i);
     if (GetSpecificsFieldNumberFromModelType(model_type) == field_number)
       return model_type;
@@ skipping 54 matching lines @@
       return sync_pb::EntitySpecifics::kSyncedNotificationFieldNumber;
     case DEVICE_INFO:
       return sync_pb::EntitySpecifics::kDeviceInfoFieldNumber;
       break;
     case EXPERIMENTS:
       return sync_pb::EntitySpecifics::kExperimentsFieldNumber;
       break;
     case PRIORITY_PREFERENCES:
       return sync_pb::EntitySpecifics::kPriorityPreferenceFieldNumber;
       break;
+    case DICTIONARY:
+      return sync_pb::EntitySpecifics::kDictionaryFieldNumber;
+      break;
     default:
       NOTREACHED() << "No known extension for model type.";
       return 0;
   }
   NOTREACHED() << "Needed for linux_keep_shadow_stacks because of "
                << "http://gcc.gnu.org/bugzilla/show_bug.cgi?id=20681";
   return 0;
 }
 
 FullModelTypeSet ToFullModelTypeSet(ModelTypeSet in) {
@@ skipping 87 matching lines @@
 
   if (specifics.has_device_info())
     return DEVICE_INFO;
 
   if (specifics.has_experiments())
     return EXPERIMENTS;
 
   if (specifics.has_priority_preference())
     return PRIORITY_PREFERENCES;
 
+  if (specifics.has_dictionary())
+    return DICTIONARY;
+
   return UNSPECIFIED;
 }
 
 bool ShouldMaintainPosition(ModelType model_type) {
   return model_type == BOOKMARKS;
 }
 
 ModelTypeSet UserTypes() {
   ModelTypeSet set;
   for (int i = FIRST_USER_MODEL_TYPE; i <= LAST_USER_MODEL_TYPE; ++i) {
@@ skipping 69 matching lines @@
     case HISTORY_DELETE_DIRECTIVES:
       return "History Delete Directives";
     case SYNCED_NOTIFICATIONS:
       return "Synced Notifications";
     case DEVICE_INFO:
       return "Device Info";
     case EXPERIMENTS:
       return "Experiments";
     case PRIORITY_PREFERENCES:
       return "Priority Preferences";
+    case DICTIONARY:
+      return "Dictionary";
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
   return "INVALID";
 }
 
 StringValue* ModelTypeToValue(ModelType model_type) {
   if (model_type >= FIRST_REAL_MODEL_TYPE) {
     return Value::CreateStringValue(ModelTypeToString(model_type));
@@ skipping 55 matching lines @@
   else if (model_type_string == "History Delete Directives")
     return HISTORY_DELETE_DIRECTIVES;
   else if (model_type_string == "Synced Notifications")
     return SYNCED_NOTIFICATIONS;
   else if (model_type_string == "Device Info")
     return DEVICE_INFO;
   else if (model_type_string == "Experiments")
     return EXPERIMENTS;
   else if (model_type_string == "Priority Preferences")
     return PRIORITY_PREFERENCES;
+  else if (model_type_string == "Dictionary")
+    return DICTIONARY;
   else
     NOTREACHED() << "No known model type corresponding to "
                  << model_type_string << ".";
   return UNSPECIFIED;
 }
 
 std::string ModelTypeSetToString(ModelTypeSet model_types) {
   std::string result;
   for (ModelTypeSet::Iterator it = model_types.First(); it.Good(); it.Inc()) {
     if (!result.empty()) {
@@ skipping 58 matching lines @@
     case HISTORY_DELETE_DIRECTIVES:
       return "google_chrome_history_delete_directives";
     case SYNCED_NOTIFICATIONS:
       return "google_chrome_synced_notifications";
     case DEVICE_INFO:
       return "google_chrome_device_info";
     case EXPERIMENTS:
       return "google_chrome_experiments";
     case PRIORITY_PREFERENCES:
       return "google_chrome_priority_preferences";
+    case DICTIONARY:
+      return "google_chrome_dictionary";
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
   return "INVALID";
 }
 
 // TODO(akalin): Figure out a better way to do these mappings.
 
 namespace {
@@ skipping 11 matching lines @@
 const char kSearchEngineNotificationType[] = "SEARCH_ENGINE";
 const char kSessionNotificationType[] = "SESSION";
 const char kAutofillProfileNotificationType[] = "AUTOFILL_PROFILE";
 const char kAppNotificationNotificationType[] = "APP_NOTIFICATION";
 const char kHistoryDeleteDirectiveNotificationType[] =
     "HISTORY_DELETE_DIRECTIVE";
 const char kSyncedNotificationType[] = "SYNCED_NOTIFICATION";
 const char kDeviceInfoNotificationType[] = "DEVICE_INFO";
 const char kExperimentsNotificationType[] = "EXPERIMENTS";
 const char kPriorityPreferenceNotificationType[] = "PRIORITY_PREFERENCE";
+const char kDictionaryNotificationType[] = "DICTIONARY";
 }  // namespace
 
 bool RealModelTypeToNotificationType(ModelType model_type,
                                      std::string* notification_type) {
   switch (model_type) {
     case BOOKMARKS:
       *notification_type = kBookmarkNotificationType;
       return true;
     case PREFERENCES:
       *notification_type = kPreferenceNotificationType;
@@ skipping 42 matching lines @@
     case SYNCED_NOTIFICATIONS:
       *notification_type = kSyncedNotificationType;
     case DEVICE_INFO:
       *notification_type = kDeviceInfoNotificationType;
       return true;
     case EXPERIMENTS:
       *notification_type = kExperimentsNotificationType;
       return true;
     case PRIORITY_PREFERENCES:
       *notification_type = kPriorityPreferenceNotificationType;
+      return true;
+    case DICTIONARY:
+      *notification_type = kDictionaryNotificationType;
+      return true;
     default:
       break;
   }
   notification_type->clear();
   return false;
 }
 
 bool NotificationTypeToRealModelType(const std::string& notification_type,
                                      ModelType* model_type) {
   if (notification_type == kBookmarkNotificationType) {
@@ skipping 44 matching lines @@
   } else if (notification_type == kHistoryDeleteDirectiveNotificationType) {
     *model_type = HISTORY_DELETE_DIRECTIVES;
   } else if (notification_type == kSyncedNotificationType) {
     *model_type = SYNCED_NOTIFICATIONS;
   } else if (notification_type == kDeviceInfoNotificationType) {
     *model_type = DEVICE_INFO;;
     return true;
   } else if (notification_type == kPriorityPreferenceNotificationType) {
     *model_type = PRIORITY_PREFERENCES;
     return true;
+  } else if (notification_type == kDictionaryNotificationType) {
+    *model_type = DICTIONARY;
+    return true;
   }
   *model_type = UNSPECIFIED;
   return false;
 }
 
 bool IsRealDataType(ModelType model_type) {
   return model_type >= FIRST_REAL_MODEL_TYPE && model_type < MODEL_TYPE_COUNT;
 }
 
 }  // namespace syncer