FYI: Control Data + Per-Device Metadata

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 55 matching lines @@
       break;
     case APP_SETTINGS:
       specifics->mutable_app_setting();
       break;
     case EXTENSION_SETTINGS:
       specifics->mutable_extension_setting();
       break;
     case APP_NOTIFICATIONS:
       specifics->mutable_app_notification();
       break;
+    case PER_DEVICE_METADATA:
+      specifics->mutable_per_device_metadata();
+      break;
+    case PER_USER_METADATA:
+      specifics->mutable_per_user_metadata();
+      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 42 matching lines @@
       break;
     case APP_SETTINGS:
       return sync_pb::EntitySpecifics::kAppSettingFieldNumber;
       break;
     case EXTENSION_SETTINGS:
       return sync_pb::EntitySpecifics::kExtensionSettingFieldNumber;
       break;
     case APP_NOTIFICATIONS:
       return sync_pb::EntitySpecifics::kAppNotificationFieldNumber;
       break;
+    case PER_DEVICE_METADATA:
+      return sync_pb::EntitySpecifics::kPerDeviceMetadataFieldNumber;
+      break;
+    case PER_USER_METADATA:
+      return sync_pb::EntitySpecifics::kPerUserMetadataFieldNumber;
+      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;
 }
 
 // Note: keep this consistent with GetModelType in syncable.cc!
@@ skipping 64 matching lines @@
 
   if (specifics.has_app_setting())
     return APP_SETTINGS;
 
   if (specifics.has_extension_setting())
     return EXTENSION_SETTINGS;
 
   if (specifics.has_app_notification())
     return APP_NOTIFICATIONS;
 
+  if (specifics.has_per_device_metadata())
+    return PER_DEVICE_METADATA;
+
+  if (specifics.has_per_user_metadata())
+    return PER_USER_METADATA;
+
   return UNSPECIFIED;
 }
 
 bool ShouldMaintainPosition(ModelType model_type) {
   return model_type == BOOKMARKS;
 }
 
+bool IsControlType(ModelType model_type) {
+  return ControlTypes().Has(model_type);
+}
+
+ModelTypeSet ControlTypes() {
+  ModelTypeSet set;
+  set.Put(NIGORI);
+  set.Put(PER_DEVICE_METADATA);
+  set.Put(PER_USER_METADATA);
+  return set;
+}
+
+ModelTypeSet EncryptableTypes() {
+  ModelTypeSet unencryptable_types(PER_DEVICE_METADATA, PER_USER_METADATA);

[rlarocque, 2012/08/11 01:31:52]

Why do these types skip encryption?

I believe these types are likely to contain information which we can't do
without.  They might contain flags which affect how we encrypt things, so it
would be bad if a 'passphrase required' state prevented us from reading them.

The justification for downloading them early is similar.

+  return Difference(ModelTypeSet::All(), unencryptable_types);
+}
+
 const char* ModelTypeToString(ModelType model_type) {
   // This is used in serialization routines as well as for displaying debug
   // information.  Do not attempt to change these string values unless you know
   // what you're doing.
   switch (model_type) {
     case TOP_LEVEL_FOLDER:
       return "Top Level Folder";
     case UNSPECIFIED:
       return "Unspecified";
     case BOOKMARKS:
@@ skipping 19 matching lines @@
     case APPS:
       return "Apps";
     case AUTOFILL_PROFILE:
       return "Autofill Profiles";
     case APP_SETTINGS:
       return "App settings";
     case EXTENSION_SETTINGS:
       return "Extension settings";
     case APP_NOTIFICATIONS:
       return "App Notifications";
+    case PER_DEVICE_METADATA:
+      return "Device Metadata";
+    case PER_USER_METADATA:
+      return "User Metadata";
     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 45 matching lines @@
   else if (model_type_string == "Sessions")
     return SESSIONS;
   else if (model_type_string == "Apps")
     return APPS;
   else if (model_type_string == "App settings")
     return APP_SETTINGS;
   else if (model_type_string == "Extension settings")
     return EXTENSION_SETTINGS;
   else if (model_type_string == "App Notifications")
     return APP_NOTIFICATIONS;
+  else if (model_type_string == "Device Metadata")
+    return PER_DEVICE_METADATA;
+  else if (model_type_string == "User Metadata")
+    return PER_USER_METADATA;
   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 48 matching lines @@
     case APPS:
       return "google_chrome_apps";
     case AUTOFILL_PROFILE:
       return "google_chrome_autofill_profiles";
     case APP_SETTINGS:
       return "google_chrome_app_settings";
     case EXTENSION_SETTINGS:
       return "google_chrome_extension_settings";
     case APP_NOTIFICATIONS:
       return "google_chrome_app_notifications";
+    case PER_DEVICE_METADATA:
+      return "google_chrome_per_device_metadata";
+    case PER_USER_METADATA:
+      return "google_chrome_per_user_metadata";
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
   return "INVALID";
 }
 
 // TODO(akalin): Figure out a better way to do these mappings.
 
 namespace {
 const char kBookmarkNotificationType[] = "BOOKMARK";
 const char kPreferenceNotificationType[] = "PREFERENCE";
 const char kPasswordNotificationType[] = "PASSWORD";
 const char kAutofillNotificationType[] = "AUTOFILL";
 const char kThemeNotificationType[] = "THEME";
 const char kTypedUrlNotificationType[] = "TYPED_URL";
 const char kExtensionNotificationType[] = "EXTENSION";
 const char kExtensionSettingNotificationType[] = "EXTENSION_SETTING";
 const char kNigoriNotificationType[] = "NIGORI";
 const char kAppSettingNotificationType[] = "APP_SETTING";
 const char kAppNotificationType[] = "APP";
 const char kSearchEngineNotificationType[] = "SEARCH_ENGINE";
 const char kSessionNotificationType[] = "SESSION";
 const char kAutofillProfileNotificationType[] = "AUTOFILL_PROFILE";
 const char kAppNotificationNotificationType[] = "APP_NOTIFICATION";
+const char kPerDeviceNotificationType[] = "PER_DEVICE_METADATA";
+const char kPerUserNotificationType[] = "PER_USER_METADATA";
 }  // 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 30 matching lines @@
       return true;
     case AUTOFILL_PROFILE:
       *notification_type = kAutofillProfileNotificationType;
       return true;
     case EXTENSION_SETTINGS:
       *notification_type = kExtensionSettingNotificationType;
       return true;
     case APP_NOTIFICATIONS:
       *notification_type = kAppNotificationNotificationType;
       return true;
+    case PER_DEVICE_METADATA:
+      *notification_type = kPerDeviceNotificationType;
+      return true;
+    case PER_USER_METADATA:
+      *notification_type = kPerUserNotificationType;
+      return true;
     default:
       break;
   }
   notification_type->clear();
   return false;
 }
 
 bool NotificationTypeToRealModelType(const std::string& notification_type,
                                      ModelType* model_type) {
   if (notification_type == kBookmarkNotificationType) {
@@ skipping 34 matching lines @@
     return true;
   } else if (notification_type == kAppSettingNotificationType) {
     *model_type = APP_SETTINGS;
     return true;
   } else if (notification_type == kExtensionSettingNotificationType) {
     *model_type = EXTENSION_SETTINGS;
     return true;
   } else if (notification_type == kAppNotificationNotificationType) {
     *model_type = APP_NOTIFICATIONS;
     return true;
+  } else if (notification_type == kPerDeviceNotificationType) {
+    *model_type = PER_DEVICE_METADATA;;
+    return true;
+  } else if (notification_type == kPerUserNotificationType) {
+    *model_type = PER_USER_METADATA;;
+    return true;
   } else {
     *model_type = UNSPECIFIED;
     return false;
   }
 }
 
 bool IsRealDataType(ModelType model_type) {
   return model_type >= FIRST_REAL_MODEL_TYPE && model_type < MODEL_TYPE_COUNT;
 }
 
 }  // namespace syncer