Add a datatype for supervised user whitelists.

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 26 matching lines @@
   "autofill",
   "themes",
   "typedUrls",
   "extensions",
   "apps",
   "wifiCredentials",
   "tabs",
 };
 
 COMPILE_ASSERT(
-    33 == MODEL_TYPE_COUNT,
+    34 == MODEL_TYPE_COUNT,
     update_kUserSelectableDataTypeNames_to_match_UserSelectableTypes);
 
 void AddDefaultFieldValue(ModelType datatype,
                           sync_pb::EntitySpecifics* specifics) {
   if (!ProtocolTypes().Has(datatype)) {
     NOTREACHED() << "Only protocol types have field values.";
     return;
   }
   switch (datatype) {
     case BOOKMARKS:
@@ skipping 73 matching lines @@
       break;
     case SUPERVISED_USER_SETTINGS:
       specifics->mutable_managed_user_setting();
       break;
     case SUPERVISED_USERS:
       specifics->mutable_managed_user();
       break;
     case SUPERVISED_USER_SHARED_SETTINGS:
       specifics->mutable_managed_user_shared_setting();
       break;
+    case SUPERVISED_USER_WHITELISTS:
+      specifics->mutable_managed_user_whitelist();
+      break;
     case ARTICLES:
       specifics->mutable_article();
       break;
     case WIFI_CREDENTIALS:
       specifics->mutable_wifi_credential();
       break;
     default:
       NOTREACHED() << "No known extension for model type.";
   }
 }
@@ skipping 61 matching lines @@
     case FAVICON_IMAGES:
       return sync_pb::EntitySpecifics::kFaviconImageFieldNumber;
     case FAVICON_TRACKING:
       return sync_pb::EntitySpecifics::kFaviconTrackingFieldNumber;
     case SUPERVISED_USER_SETTINGS:
       return sync_pb::EntitySpecifics::kManagedUserSettingFieldNumber;
     case SUPERVISED_USERS:
       return sync_pb::EntitySpecifics::kManagedUserFieldNumber;
     case SUPERVISED_USER_SHARED_SETTINGS:
       return sync_pb::EntitySpecifics::kManagedUserSharedSettingFieldNumber;
+    case SUPERVISED_USER_WHITELISTS:
+      return sync_pb::EntitySpecifics::kManagedUserWhitelistFieldNumber;
     case ARTICLES:
       return sync_pb::EntitySpecifics::kArticleFieldNumber;
     case WIFI_CREDENTIALS:
       return sync_pb::EntitySpecifics::kWifiCredentialFieldNumber;
     default:
       NOTREACHED() << "No known extension for model type.";
       return 0;
   }
 }
 
@@ skipping 109 matching lines @@
 
   if (specifics.has_managed_user_setting())
     return SUPERVISED_USER_SETTINGS;
 
   if (specifics.has_managed_user())
     return SUPERVISED_USERS;
 
   if (specifics.has_managed_user_shared_setting())
     return SUPERVISED_USER_SHARED_SETTINGS;
 
+  if (specifics.has_managed_user_whitelist())
+    return SUPERVISED_USER_WHITELISTS;
+
   if (specifics.has_article())
     return ARTICLES;
 
   if (specifics.has_wifi_credential())
     return WIFI_CREDENTIALS;
 
   return UNSPECIFIED;
 }
 
 ModelTypeSet ProtocolTypes() {
@@ skipping 61 matching lines @@
   // Priority preferences are not encrypted because they might be synced before
   // encryption is ready.
   encryptable_user_types.Remove(PRIORITY_PREFERENCES);
   // Supervised user settings are not encrypted since they are set server-side.
   encryptable_user_types.Remove(SUPERVISED_USER_SETTINGS);
   // Supervised users are not encrypted since they are managed server-side.
   encryptable_user_types.Remove(SUPERVISED_USERS);
   // Supervised user shared settings are not encrypted since they are managed
   // server-side and shared between manager and supervised user.
   encryptable_user_types.Remove(SUPERVISED_USER_SHARED_SETTINGS);
+  // Supervised user whitelists are not encrypted since they are managed
+  // server-side.
+  encryptable_user_types.Remove(SUPERVISED_USER_WHITELISTS);
   // 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(DEVICE_INFO, PRIORITY_PREFERENCES);
 }
@@ skipping 21 matching lines @@
 }
 
 ModelTypeSet CoreTypes() {
   syncer::ModelTypeSet result;
   result.PutAll(PriorityCoreTypes());
 
   // The following are low priority core types.
   result.Put(SYNCED_NOTIFICATIONS);
   result.Put(SYNCED_NOTIFICATION_APP_INFO);
   result.Put(SUPERVISED_USER_SHARED_SETTINGS);
+  result.Put(SUPERVISED_USER_WHITELISTS);
 
   return result;
 }
 
 ModelTypeSet PriorityCoreTypes() {
   syncer::ModelTypeSet result;
   result.PutAll(ControlTypes());
 
   // The following are non-control core types.
   result.Put(SUPERVISED_USERS);
@@ skipping 75 matching lines @@
     case FAVICON_IMAGES:
       return "Favicon Images";
     case FAVICON_TRACKING:
       return "Favicon Tracking";
     case SUPERVISED_USER_SETTINGS:
       return "Managed User Settings";
     case SUPERVISED_USERS:
       return "Managed Users";
     case SUPERVISED_USER_SHARED_SETTINGS:
       return "Managed User Shared Settings";
+    case SUPERVISED_USER_WHITELISTS:
+      return "Managed User Whitelists";
     case ARTICLES:
       return "Articles";
     case WIFI_CREDENTIALS:
       return "WiFi Credentials";
     case PROXY_TABS:
       return "Tabs";
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
@@ skipping 65 matching lines @@
     case ARTICLES:
       return 28;
     case APP_LIST:
       return 29;
     case SUPERVISED_USER_SHARED_SETTINGS:
       return 30;
     case SYNCED_NOTIFICATION_APP_INFO:
       return 31;
     case WIFI_CREDENTIALS:
       return 32;
+    case SUPERVISED_USER_WHITELISTS:
+      return 33;
     // 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 71 matching lines @@
   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 SUPERVISED_USER_SETTINGS;
   else if (model_type_string == "Managed Users")
     return SUPERVISED_USERS;
   else if (model_type_string == "Managed User Shared Settings")
     return SUPERVISED_USER_SHARED_SETTINGS;
+  else if (model_type_string == "Managed User Whitelists")
+    return SUPERVISED_USER_WHITELISTS;
   else if (model_type_string == "Articles")
     return ARTICLES;
   else if (model_type_string == "WiFi Credentials")
     return WIFI_CREDENTIALS;
   else if (model_type_string == "Tabs")
     return PROXY_TABS;
   else
     NOTREACHED() << "No known model type corresponding to "
                  << model_type_string << ".";
   return UNSPECIFIED;
@@ skipping 106 matching lines @@
     case FAVICON_IMAGES:
       return "google_chrome_favicon_images";
     case FAVICON_TRACKING:
       return "google_chrome_favicon_tracking";
     case SUPERVISED_USER_SETTINGS:
       return "google_chrome_managed_user_settings";
     case SUPERVISED_USERS:
       return "google_chrome_managed_users";
     case SUPERVISED_USER_SHARED_SETTINGS:
       return "google_chrome_managed_user_shared_settings";
+    case SUPERVISED_USER_WHITELISTS:
+      return "google_chrome_managed_user_whitelists";
     case ARTICLES:
       return "google_chrome_articles";
     case WIFI_CREDENTIALS:
       return "google_chrome_wifi_credentials";
     case PROXY_TABS:
       return std::string();
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
@@ skipping 27 matching lines @@
 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 kSupervisedUserSettingNotificationType[] = "MANAGED_USER_SETTING";
 const char kSupervisedUserNotificationType[] = "MANAGED_USER";
 const char kSupervisedUserSharedSettingNotificationType[] =
     "MANAGED_USER_SHARED_SETTING";
+const char kSupervisedUserWhitelistNotificationType[] =
+    "MANAGED_USER_WHITELIST";
 const char kArticleNotificationType[] = "ARTICLE";
 }  // namespace
 
 bool RealModelTypeToNotificationType(ModelType model_type,
                                      std::string* notification_type) {
   switch (model_type) {
     case BOOKMARKS:
       *notification_type = kBookmarkNotificationType;
       return true;
     case PREFERENCES:
@@ skipping 70 matching lines @@
       return true;
     case SUPERVISED_USER_SETTINGS:
       *notification_type = kSupervisedUserSettingNotificationType;
       return true;
     case SUPERVISED_USERS:
       *notification_type = kSupervisedUserNotificationType;
       return true;
     case SUPERVISED_USER_SHARED_SETTINGS:
       *notification_type = kSupervisedUserSharedSettingNotificationType;
       return true;
+    case SUPERVISED_USER_WHITELISTS:
+      *notification_type = kSupervisedUserWhitelistNotificationType;
+      return true;
     case ARTICLES:
       *notification_type = kArticleNotificationType;
       return true;
     default:
       break;
   }
   notification_type->clear();
   return false;
 }
 
@@ skipping 77 matching lines @@
   } else if (notification_type == kSupervisedUserSettingNotificationType) {
     *model_type = SUPERVISED_USER_SETTINGS;
     return true;
   } else if (notification_type == kSupervisedUserNotificationType) {
     *model_type = SUPERVISED_USERS;
     return true;
   } else if (notification_type ==
       kSupervisedUserSharedSettingNotificationType) {
     *model_type = SUPERVISED_USER_SHARED_SETTINGS;
     return true;
+  } else if (notification_type == kSupervisedUserWhitelistNotificationType) {
+    *model_type = SUPERVISED_USER_WHITELISTS;
+    return true;
   } else if (notification_type == kArticleNotificationType) {
     *model_type = ARTICLES;
     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 IsProxyType(ModelType model_type) {
   return model_type >= FIRST_PROXY_TYPE && model_type <= LAST_PROXY_TYPE;
 }
 
 bool IsActOnceDataType(ModelType model_type) {
   return model_type == HISTORY_DELETE_DIRECTIVES;
 }
 
 }  // namespace syncer