Enable sync for the settings from the Extension Settings API.

chrome/browser/sync/syncable/model_type.cc

 // Copyright (c) 2011 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 "chrome/browser/sync/syncable/model_type.h"
 
 #include "base/metrics/histogram.h"
 #include "base/string_split.h"
 #include "base/values.h"
 #include "chrome/browser/sync/engine/syncproto.h"
 #include "chrome/browser/sync/protocol/app_specifics.pb.h"
 #include "chrome/browser/sync/protocol/autofill_specifics.pb.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
+#include "chrome/browser/sync/protocol/extension_setting_specifics.pb.h"
 #include "chrome/browser/sync/protocol/extension_specifics.pb.h"
 #include "chrome/browser/sync/protocol/nigori_specifics.pb.h"
 #include "chrome/browser/sync/protocol/password_specifics.pb.h"
 #include "chrome/browser/sync/protocol/preference_specifics.pb.h"
 #include "chrome/browser/sync/protocol/search_engine_specifics.pb.h"
 #include "chrome/browser/sync/protocol/session_specifics.pb.h"
 #include "chrome/browser/sync/protocol/sync.pb.h"
 #include "chrome/browser/sync/protocol/theme_specifics.pb.h"
 #include "chrome/browser/sync/protocol/typed_url_specifics.pb.h"
 
@@ skipping 31 matching lines @@
       break;
     case SEARCH_ENGINES:
       specifics->MutableExtension(sync_pb::search_engine);
       break;
     case SESSIONS:
       specifics->MutableExtension(sync_pb::session);
       break;
     case APPS:
       specifics->MutableExtension(sync_pb::app);
       break;
+    case EXTENSION_SETTINGS:
+      specifics->MutableExtension(sync_pb::extension_setting);
+      break;
     default:
       NOTREACHED() << "No known extension for model type.";
   }
 }
 
 ModelType GetModelTypeFromExtensionFieldNumber(int field_number) {
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     ModelType model_type = ModelTypeFromInt(i);
     if (GetExtensionFieldNumberFromModelType(model_type) == field_number)
       return model_type;
@@ skipping 33 matching lines @@
       break;
     case SEARCH_ENGINES:
       return sync_pb::kSearchEngineFieldNumber;
       break;
     case SESSIONS:
       return sync_pb::kSessionFieldNumber;
       break;
     case APPS:
       return sync_pb::kAppFieldNumber;
       break;
+    case EXTENSION_SETTINGS:
+      return sync_pb::kExtensionSettingFieldNumber;
+      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 57 matching lines @@
 
   if (specifics.HasExtension(sync_pb::app))
     return APPS;
 
   if (specifics.HasExtension(sync_pb::search_engine))
     return SEARCH_ENGINES;
 
   if (specifics.HasExtension(sync_pb::session))
     return SESSIONS;
 
+  if (specifics.HasExtension(sync_pb::extension_setting))
+    return EXTENSION_SETTINGS;
+
   return UNSPECIFIED;
 }
 
 bool ShouldMaintainPosition(ModelType model_type) {
   return model_type == BOOKMARKS;
 }
 
 std::string ModelTypeToString(ModelType model_type) {
   switch (model_type) {
     case BOOKMARKS:
@@ skipping 13 matching lines @@
     case NIGORI:
       return "Encryption keys";
     case SEARCH_ENGINES:
       return "Search Engines";
     case SESSIONS:
       return "Sessions";
     case APPS:
       return "Apps";
     case AUTOFILL_PROFILE:
       return "Autofill Profiles";
+    case EXTENSION_SETTINGS:
+      return "Extension settings";
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
   return "INVALID";
 }
 
 StringValue* ModelTypeToValue(ModelType model_type) {
   if (model_type >= syncable::FIRST_REAL_MODEL_TYPE) {
     return Value::CreateStringValue(ModelTypeToString(model_type));
@@ skipping 50 matching lines @@
   else if (model_type_string == "Extensions")
     return EXTENSIONS;
   else if (model_type_string == "Encryption keys")
     return NIGORI;
   else if (model_type_string == "Search Engines")
     return SEARCH_ENGINES;
   else if (model_type_string == "Sessions")
     return SESSIONS;
   else if (model_type_string == "Apps")
     return APPS;
+  else if (model_type_string == "Extension settings")
+    return EXTENSION_SETTINGS;
   else
     NOTREACHED() << "No known model type corresponding to "
                  << model_type_string << ".";
   return UNSPECIFIED;
 }
 
 std::string ModelTypeBitSetToString(const ModelTypeBitSet& model_types) {
   std::string result;
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     if (model_types[i]) {
@@ skipping 72 matching lines @@
     case NIGORI:
       return "google_chrome_nigori";
     case SEARCH_ENGINES:
       return "google_chrome_search_engines";
     case SESSIONS:
       return "google_chrome_sessions";
     case APPS:
       return "google_chrome_apps";
     case AUTOFILL_PROFILE:
       return "google_chrome_autofill_profiles";
+    case EXTENSION_SETTINGS:
+      return "google_chrome_extension_settings";
     default:
       break;
   }
   NOTREACHED() << "No known extension for model type.";
   return "INVALID";
 }
 
 // For now, this just implements UMA_HISTOGRAM_LONG_TIMES. This can be adjusted
 // if we feel the min, max, or bucket count amount are not appropriate.
 #define SYNC_FREQ_HISTOGRAM(name, time) UMA_HISTOGRAM_CUSTOM_TIMES( \
@@ skipping 43 matching lines @@
         return;
     }
     case SESSIONS: {
         SYNC_FREQ_HISTOGRAM("Sync.FreqSessions", time);
         return;
     }
     case APPS: {
         SYNC_FREQ_HISTOGRAM("Sync.FreqApps", time);
         return;
     }
+    case EXTENSION_SETTINGS: {
+        SYNC_FREQ_HISTOGRAM("Sync.FreqExtensionSettings", time);
+        return;
+    }
     default:
       LOG(ERROR) << "No known extension for model type.";
   }
 }
 
 #undef SYNC_FREQ_HISTOGRAM
 
 // 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 kAppNotificationType[] = "APP";
 const char kSearchEngineNotificationType[] = "SEARCH_ENGINE";
 const char kSessionNotificationType[] = "SESSION";
 const char kAutofillProfileNotificationType[] = "AUTOFILL_PROFILE";
 }  // namespace
 
 bool RealModelTypeToNotificationType(ModelType model_type,
                                      std::string* notification_type) {
   switch (model_type) {
@@ skipping 26 matching lines @@
       return true;
     case SEARCH_ENGINES:
       *notification_type = kSearchEngineNotificationType;
       return true;
     case SESSIONS:
       *notification_type = kSessionNotificationType;
       return true;
     case AUTOFILL_PROFILE:
       *notification_type = kAutofillProfileNotificationType;
       return true;
+    case EXTENSION_SETTINGS:
+      *notification_type = kExtensionSettingNotificationType;
+      return true;
     default:
       break;
   }
   notification_type->clear();
   return false;
 }
 
 bool NotificationTypeToRealModelType(const std::string& notification_type,
                                      ModelType* model_type) {
   if (notification_type == kBookmarkNotificationType) {
@@ skipping 25 matching lines @@
     return true;
   } else if (notification_type == kSearchEngineNotificationType) {
     *model_type = SEARCH_ENGINES;
     return true;
   } else if (notification_type == kSessionNotificationType) {
     *model_type = SESSIONS;
     return true;
   } else if (notification_type == kAutofillProfileNotificationType) {
     *model_type = AUTOFILL_PROFILE;
     return true;
+  } else if (notification_type == kExtensionSettingNotificationType) {
+    *model_type = EXTENSION_SETTINGS;
+    return true;
   }
   *model_type = UNSPECIFIED;
   return false;
 }
 
 ModelTypeSet GetAllRealModelTypes() {
   ModelTypeSet all_types;
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     all_types.insert(ModelTypeFromInt(i));
   }
   return all_types;
 }
 
 bool IsRealDataType(ModelType model_type) {
   return model_type >= FIRST_REAL_MODEL_TYPE && model_type < MODEL_TYPE_COUNT;
 }
 
 }  // namespace syncable