Add Sync data type for managed users.

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/strings/string_split.h"
 #include "base/values.h"
 #include "sync/protocol/app_notification_specifics.pb.h"
 #include "sync/protocol/app_setting_specifics.pb.h"
@@ skipping 86 matching lines @@
       break;
     case FAVICON_IMAGES:
       specifics->mutable_favicon_image();
       break;
     case FAVICON_TRACKING:
       specifics->mutable_favicon_tracking();
       break;
     case MANAGED_USER_SETTINGS:
       specifics->mutable_managed_user_setting();
       break;
+    case MANAGED_USERS:
+      specifics->mutable_managed_user();
+      break;
     default:
       NOTREACHED() << "No known extension for model type.";
   }
 }
 
 ModelType GetModelTypeFromSpecificsFieldNumber(int field_number) {
   ModelTypeSet protocol_types = ProtocolTypes();
   for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
        iter.Inc()) {
     if (GetSpecificsFieldNumberFromModelType(iter.Get()) == field_number)
@@ skipping 68 matching lines @@
       break;
     case DICTIONARY:
       return sync_pb::EntitySpecifics::kDictionaryFieldNumber;
       break;
     case FAVICON_IMAGES:
       return sync_pb::EntitySpecifics::kFaviconImageFieldNumber;
     case FAVICON_TRACKING:
       return sync_pb::EntitySpecifics::kFaviconTrackingFieldNumber;
     case MANAGED_USER_SETTINGS:
       return sync_pb::EntitySpecifics::kManagedUserSettingFieldNumber;
+    case MANAGED_USERS:
+      return sync_pb::EntitySpecifics::kManagedUserFieldNumber;
     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 99 matching lines @@
 
   if (specifics.has_favicon_image())
     return FAVICON_IMAGES;
 
   if (specifics.has_favicon_tracking())
     return FAVICON_TRACKING;
 
   if (specifics.has_managed_user_setting())
     return MANAGED_USER_SETTINGS;
 
+  if (specifics.has_managed_user())
+    return MANAGED_USERS;
+
   return UNSPECIFIED;
 }
 
 ModelTypeSet ProtocolTypes() {
   ModelTypeSet set = ModelTypeSet::All();
   set.RemoveAll(ProxyTypes());
   return set;
 }
 
 ModelTypeSet UserTypes() {
@@ skipping 31 matching lines @@
   ModelTypeSet encryptable_user_types = UserTypes();
   // We never encrypt history delete directives.
   encryptable_user_types.Remove(HISTORY_DELETE_DIRECTIVES);
   // Synced notifications are not encrypted since the server must see changes.
   encryptable_user_types.Remove(SYNCED_NOTIFICATIONS);
   // Priority preferences are not encrypted because they might be synced before
   // encryption is ready.
   encryptable_user_types.RemoveAll(PriorityUserTypes());
   // Managed user settings are not encrypted since they are set server-side.
   encryptable_user_types.Remove(MANAGED_USER_SETTINGS);
+  // Managed users are not encrypted since they are managed server-side.
+  encryptable_user_types.Remove(MANAGED_USERS);
   // Proxy types have no sync representation and are therefore not encrypted.
   // Note however that proxy types map to one or more protocol types, which
   // may or may not be encrypted themselves.
   encryptable_user_types.RemoveAll(ProxyTypes());
   return encryptable_user_types;
 }
 
 ModelTypeSet PriorityUserTypes() {
   return ModelTypeSet(PRIORITY_PREFERENCES);
 }
@@ skipping 70 matching lines @@
     case PRIORITY_PREFERENCES:
       return "Priority Preferences";
     case DICTIONARY:
       return "Dictionary";
     case FAVICON_IMAGES:
       return "Favicon Images";
     case FAVICON_TRACKING:
       return "Favicon Tracking";
     case MANAGED_USER_SETTINGS:
       return "Managed User Settings";
+    case MANAGED_USERS:
+      return "Managed Users";
     case PROXY_TABS:
       return "Tabs";
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
   return "INVALID";
 }
 
 // The normal rules about histograms apply here.  Always append to the bottom of
@@ skipping 49 matching lines @@
     case DICTIONARY:
       return 22;
     case FAVICON_IMAGES:
       return 23;
     case FAVICON_TRACKING:
       return 24;
     case PROXY_TABS:
       return 25;
     case MANAGED_USER_SETTINGS:
       return 26;
+    case MANAGED_USERS:
+      return 27;
     // Silence a compiler warning.
     case MODEL_TYPE_COUNT:
       return 0;
   }
   return 0;
 }
 
 base::StringValue* ModelTypeToValue(ModelType model_type) {
   if (model_type >= FIRST_REAL_MODEL_TYPE) {
     return new base::StringValue(ModelTypeToString(model_type));
@@ skipping 63 matching lines @@
   else if (model_type_string == "Priority Preferences")
     return PRIORITY_PREFERENCES;
   else if (model_type_string == "Dictionary")
     return DICTIONARY;
   else if (model_type_string == "Favicon Images")
     return FAVICON_IMAGES;
   else if (model_type_string == "Favicon Tracking")
     return FAVICON_TRACKING;
   else if (model_type_string == "Managed User Settings")
     return MANAGED_USER_SETTINGS;
+  else if (model_type_string == "Managed Users")
+    return MANAGED_USERS;
   else if (model_type_string == "Tabs")
     return PROXY_TABS;
   else
     NOTREACHED() << "No known model type corresponding to "
                  << model_type_string << ".";
   return UNSPECIFIED;
 }
 
 std::string ModelTypeSetToString(ModelTypeSet model_types) {
   std::string result;
@@ skipping 70 matching lines @@
     case PRIORITY_PREFERENCES:
       return "google_chrome_priority_preferences";
     case DICTIONARY:
       return "google_chrome_dictionary";
     case FAVICON_IMAGES:
       return "google_chrome_favicon_images";
     case FAVICON_TRACKING:
       return "google_chrome_favicon_tracking";
     case MANAGED_USER_SETTINGS:
       return "google_chrome_managed_user_settings";
+    case MANAGED_USERS:
+      return "google_chrome_managed_users";
     case PROXY_TABS:
       return std::string();
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
   return "INVALID";
 }
 
 // TODO(akalin): Figure out a better way to do these mappings.
@@ skipping 18 matching lines @@
 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";
 const char kFaviconImageNotificationType[] = "FAVICON_IMAGE";
 const char kFaviconTrackingNotificationType[] = "FAVICON_TRACKING";
 const char kManagedUserSettingNotificationType[] = "MANAGED_USER_SETTING";
+const char kManagedUserNotificationType[] = "MANAGED_USER";
 }  // 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 57 matching lines @@
       return true;
     case FAVICON_IMAGES:
       *notification_type = kFaviconImageNotificationType;
       return true;
     case FAVICON_TRACKING:
       *notification_type = kFaviconTrackingNotificationType;
       return true;
     case MANAGED_USER_SETTINGS:
       *notification_type = kManagedUserSettingNotificationType;
       return true;
+    case MANAGED_USERS:
+      *notification_type = kManagedUserNotificationType;
+      return true;
     default:
       break;
   }
   notification_type->clear();
   return false;
 }
 
 bool NotificationTypeToRealModelType(const std::string& notification_type,
                                      ModelType* model_type) {
   if (notification_type == kBookmarkNotificationType) {
@@ skipping 61 matching lines @@
     return true;
   } else if (notification_type == kFaviconImageNotificationType) {
     *model_type = FAVICON_IMAGES;
     return true;
   } else if (notification_type == kFaviconTrackingNotificationType) {
     *model_type = FAVICON_TRACKING;
     return true;
   } else if (notification_type == kManagedUserSettingNotificationType) {
     *model_type = MANAGED_USER_SETTINGS;
     return true;
+  } else if (notification_type == kManagedUserNotificationType) {
+    *model_type = MANAGED_USERS;
+    return true;
   }
   *model_type = UNSPECIFIED;
   return false;
 }
 
 bool IsRealDataType(ModelType model_type) {
   return model_type >= FIRST_REAL_MODEL_TYPE && model_type < MODEL_TYPE_COUNT;
 }
 
 bool IsActOnceDataType(ModelType model_type) {
   return model_type == HISTORY_DELETE_DIRECTIVES;
 }
 
 }  // namespace syncer