sync: add WIFI_CREDENTIALS protobuf, ModelType, and preference

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"
 #include "sync/protocol/app_specifics.pb.h"
 #include "sync/protocol/autofill_specifics.pb.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/extension_setting_specifics.pb.h"
 #include "sync/protocol/extension_specifics.pb.h"
 #include "sync/protocol/nigori_specifics.pb.h"
 #include "sync/protocol/password_specifics.pb.h"
 #include "sync/protocol/preference_specifics.pb.h"
 #include "sync/protocol/search_engine_specifics.pb.h"
 #include "sync/protocol/session_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/protocol/theme_specifics.pb.h"
 #include "sync/protocol/typed_url_specifics.pb.h"
 #include "sync/syncable/syncable_proto_util.h"
 
 namespace syncer {
 
+// Notes:
+// 1) This list must contain exactly the same elements as the set returned by
+//    UserSelectableTypes().
+// 2) This list must be in the same order as the respective values in the
+//    ModelType enum.
+const char* kUserSelectableDataTypeNames[] = {
+  "bookmarks",
+  "preferences",
+  "passwords",
+  "autofill",
+  "themes",
+  "typedUrls",
+  "extensions",
+  "apps",
+  "wifiCredentials",
+  "tabs",
+};
+
+COMPILE_ASSERT(
+    33 == 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:
       specifics->mutable_bookmark();
       break;
@@ skipping 74 matching lines @@
       break;
     case SUPERVISED_USERS:
       specifics->mutable_managed_user();
       break;
     case SUPERVISED_USER_SHARED_SETTINGS:
       specifics->mutable_managed_user_shared_setting();
       break;
     case ARTICLES:
       specifics->mutable_article();
       break;
+    case WIFI_CREDENTIALS:
+      specifics->mutable_wifi_credential();
+      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 57 matching lines @@
     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 ARTICLES:
       return sync_pb::EntitySpecifics::kArticleFieldNumber;
+    case WIFI_CREDENTIALS:
+      return sync_pb::EntitySpecifics::kWifiCredentialFieldNumber;
     default:
       NOTREACHED() << "No known extension for model type.";
       return 0;
   }
 }
 
 FullModelTypeSet ToFullModelTypeSet(ModelTypeSet in) {
   FullModelTypeSet out;
   for (ModelTypeSet::Iterator i = in.First(); i.Good(); i.Inc()) {
     out.Put(i.Get());
@@ skipping 108 matching lines @@
 
   if (specifics.has_managed_user())
     return SUPERVISED_USERS;
 
   if (specifics.has_managed_user_shared_setting())
     return SUPERVISED_USER_SHARED_SETTINGS;
 
   if (specifics.has_article())
     return ARTICLES;
 
+  if (specifics.has_wifi_credential())
+    return WIFI_CREDENTIALS;
+
   return UNSPECIFIED;
 }
 
 ModelTypeSet ProtocolTypes() {
   ModelTypeSet set = ModelTypeSet::All();
   set.RemoveAll(ProxyTypes());
   return set;
 }
 
 ModelTypeSet UserTypes() {
@@ skipping 12 matching lines @@
   // Although the order doesn't technically matter here, it's clearer to keep
   // these in the same order as their definition in the ModelType enum.
   set.Put(BOOKMARKS);
   set.Put(PREFERENCES);
   set.Put(PASSWORDS);
   set.Put(AUTOFILL);
   set.Put(THEMES);
   set.Put(TYPED_URLS);
   set.Put(EXTENSIONS);
   set.Put(APPS);
+  set.Put(WIFI_CREDENTIALS);
   set.Put(PROXY_TABS);
   return set;
 }
 
 bool IsUserSelectableType(ModelType model_type) {
   return UserSelectableTypes().Has(model_type);
 }
 
+ModelTypeNameMap GetUserSelectableTypeNameMap() {
+  ModelTypeNameMap type_names;
+  ModelTypeSet type_set = UserSelectableTypes();
+  ModelTypeSet::Iterator it = type_set.First();
+  DCHECK_EQ(arraysize(kUserSelectableDataTypeNames), type_set.Size());
+  for (size_t i = 0; i < arraysize(kUserSelectableDataTypeNames) && it.Good();
+       ++i, it.Inc()) {
+    type_names[it.Get()] = kUserSelectableDataTypeNames[i];
+  }
+  return type_names;
+}
+
 ModelTypeSet EncryptableUserTypes() {
   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);
   // Synced Notification App Info does not have private data, so it is not
   // encrypted.
   encryptable_user_types.Remove(SYNCED_NOTIFICATION_APP_INFO);
   // Device info data is not encrypted because it might be synced before
@@ skipping 140 matching lines @@
     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 ARTICLES:
       return "Articles";
+    case WIFI_CREDENTIALS:
+      return "WiFi Credentials";
     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 59 matching lines @@
     case SUPERVISED_USERS:
       return 27;
     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;
     // 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 73 matching lines @@
   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 == "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;
 }
 
 std::string ModelTypeSetToString(ModelTypeSet model_types) {
   std::string result;
@@ skipping 104 matching lines @@
     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 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.";
   return "INVALID";
 }
 
 // TODO(akalin): Figure out a better way to do these mappings.
@@ skipping 231 matching lines @@
 
 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