Add a couple of notifications related settings to app/extensions sync:

chrome/browser/extensions/extension_service.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/extensions/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 888 matching lines @@
     }
     return false;
   }
 
   // Extract the data we need for sync now, but don't actually sync until we've
   // completed the uninstallation.
   SyncBundle* sync_bundle = GetSyncBundleForExtension(*extension);
 
   SyncChange sync_change;
   if (sync_bundle) {
-    ExtensionSyncData extension_sync_data(*extension,
-                                          IsExtensionEnabled(extension_id),
-                                          IsIncognitoEnabled(extension_id));
+    ExtensionSyncData extension_sync_data(
+        *extension,
+        IsExtensionEnabled(extension_id),
+        IsIncognitoEnabled(extension_id),
+        extension_prefs_->IsAppNotificationSetupDone(extension_id),
+        extension_prefs_->IsAppNotificationDisabled(extension_id));
     sync_change = extension_sync_data.GetSyncChange(SyncChange::ACTION_DELETE);
   }
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.UninstallType",
                             extension->GetType(), 100);
   RecordPermissionMessagesHistogram(
       extension, "Extensions.Permissions_Uninstall");
 
   TemplateURLService* url_service =
       TemplateURLServiceFactory::GetForProfile(profile_);
@@ skipping 818 matching lines @@
 }
 
 bool ExtensionService::SyncBundle::HasPendingExtensionId(const std::string& id)
     const {
   return pending_sync_data.find(id) != pending_sync_data.end();
 }
 
 void ExtensionService::SyncExtensionChangeIfNeeded(const Extension& extension) {
   SyncBundle* sync_bundle = GetSyncBundleForExtension(extension);
   if (sync_bundle) {
-    ExtensionSyncData extension_sync_data(extension,
-                                          IsExtensionEnabled(extension.id()),
-                                          IsIncognitoEnabled(extension.id()));
+    ExtensionSyncData extension_sync_data(
+        extension,
+        IsExtensionEnabled(extension.id()),
+        IsIncognitoEnabled(extension.id()),
+        extension_prefs_->IsAppNotificationSetupDone(extension.id()),
+        extension_prefs_->IsAppNotificationDisabled(extension.id()));
 
     SyncChangeList sync_change_list(1, extension_sync_data.GetSyncChange(
         sync_bundle->HasExtensionId(extension.id()) ?
             SyncChange::ACTION_UPDATE : SyncChange::ACTION_ADD));
     sync_bundle->sync_processor->ProcessSyncChanges(
         FROM_HERE, sync_change_list);
     sync_bundle->synced_extensions.insert(extension.id());
     sync_bundle->pending_sync_data.erase(extension.id());
   }
 }
@@ skipping 139 matching lines @@
     const SyncBundle& bundle,
     std::vector<ExtensionSyncData>* sync_data_list) const {
   for (ExtensionList::const_iterator it = extensions.begin();
        it != extensions.end(); ++it) {
     const Extension& extension = **it;
     if (bundle.filter(extension) &&
         // If we have pending extension data for this extension, then this
         // version is out of date.  We'll sync back the version we got from
         // sync.
         !bundle.HasPendingExtensionId(extension.id())) {
-      sync_data_list->push_back(
-          ExtensionSyncData(extension,
-                            IsExtensionEnabled(extension.id()),
-                            IsIncognitoEnabled(extension.id())));
+      sync_data_list->push_back(ExtensionSyncData(
+          extension,
+          IsExtensionEnabled(extension.id()),
+          IsIncognitoEnabled(extension.id()),
+          extension_prefs_->IsAppNotificationSetupDone(extension.id()),
+          extension_prefs_->IsAppNotificationDisabled(extension.id())));
     }
   }
 }
 
 std::vector<ExtensionSyncData> ExtensionService::GetSyncDataList(
     const SyncBundle& bundle) const {
   std::vector<ExtensionSyncData> extension_sync_list;
   GetSyncDataListHelper(extensions_, bundle, &extension_sync_list);
   GetSyncDataListHelper(disabled_extensions_, bundle, &extension_sync_list);
   GetSyncDataListHelper(terminated_extensions_, bundle, &extension_sync_list);
@@ skipping 103 matching lines @@
   if (enabled_extension) {
     NotifyExtensionUnloaded(
         enabled_extension, extension_misc::UNLOAD_REASON_DISABLE);
     NotifyExtensionLoaded(enabled_extension);
   }
 
   if (extension)
     SyncExtensionChangeIfNeeded(*extension);
 }
 
+void ExtensionService::SetAppNotificationSetupDone(
+    const std::string& extension_id,
+    bool value) {
+  const Extension* extension = GetInstalledExtension(extension_id);
+  // This method is called when the user sets up app notifications.
+  // So it is not expected to be called until the extension is installed.
+  if (!extension) {
+    NOTREACHED();
+    return;
+  }
+  extension_prefs_->SetAppNotificationSetupDone(extension_id, value);
+  SyncExtensionChangeIfNeeded(*extension);
+}
+
+void ExtensionService::SetAppNotificationDisabled(
+    const std::string& extension_id,
+    bool value) {
+  const Extension* extension = GetInstalledExtension(extension_id);
+  // This method is called when the user enables/disables app notifications.
+  // So it is not expected to be called until the extension is installed.
+  if (!extension) {
+    NOTREACHED();
+    return;
+  }
+
+  extension_prefs_->SetAppNotificationDisabled(extension_id, value);
+  SyncExtensionChangeIfNeeded(*extension);
+}
+
 bool ExtensionService::CanCrossIncognito(const Extension* extension) {
   // We allow the extension to see events and data from another profile iff it
   // uses "spanning" behavior and it has incognito access. "split" mode
   // extensions only see events for a matching profile.
   CHECK(extension);
   return IsIncognitoEnabled(extension->id()) &&
       !extension->incognito_split_mode();
 }
 
 bool ExtensionService::CanLoadInIncognito(const Extension* extension) const {
@@ skipping 977 matching lines @@
 
 ExtensionService::NaClModuleInfoList::iterator
     ExtensionService::FindNaClModule(const GURL& url) {
   for (NaClModuleInfoList::iterator iter = nacl_module_list_.begin();
        iter != nacl_module_list_.end(); ++iter) {
     if (iter->url == url)
       return iter;
   }
   return nacl_module_list_.end();
 }