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),
+        IsNotificationsInitialSetupDone(extension_id),
+        IsNotificationsDisabled(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()),
+        IsNotificationsInitialSetupDone(extension.id()),
+        IsNotificationsDisabled(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 142 matching lines @@
        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())));
+                            IsIncognitoEnabled(extension.id()),
+                            IsNotificationsInitialSetupDone(extension.id()),
+                            IsNotificationsDisabled(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);
 }
 
+bool ExtensionService::IsNotificationsInitialSetupDone(
+   const std::string& extension_id) const {
+ return extension_prefs_->IsNotificationsInitialSetupDone(extension_id);
+}
+
+void ExtensionService::SetNotificationsInitialSetupDone(
+    const std::string& extension_id,
+    bool value) {
+  extension_prefs_->SetNotificationsInitialSetupDone(extension_id, value);

[asargent_no_longer_on_chrome, 2011/10/27 16:52:21]

nit: probably not worth writing this into the prefs if the extension isn't
installed - perhaps move the check for the result of GetInstalledExtension up to
the top, and just exit this method if the extension isn't installed. (Perhaps
add NOTREACHED() too? Should anyone really call this on a non-installed
extension?)

[Munjal (Google), 2011/10/27 18:35:05]

Done.

I have one question though - is it possible to have a race between an app being
installed and the webstie calling the JS API (and hte user is logged in) and we
detect that the website is actually an app? I guess it is unlikely but making
sure.

[asargent_no_longer_on_chrome, 2011/10/27 19:49:41]

A race condition is unlikely to happen - the way the code works for implementing
the browser process C++ side of the js method exposed in the renderer process,
we need to have a valid installed Extension already.

[Munjal (Google), 2011/10/27 20:01:50]

Great, good to know.

+  const Extension* extension = GetInstalledExtension(extension_id);
+  if (extension)
+    SyncExtensionChangeIfNeeded(*extension);
+}
+
+bool ExtensionService::IsNotificationsDisabled(
+    const std::string& extension_id) const {
+  return extension_prefs_->IsNotificationsDisabled(extension_id);
+}
+
+void ExtensionService::SetNotificationsDisabled(
+    const std::string& extension_id,
+    bool value) {
+  extension_prefs_->SetNotificationsDisabled(extension_id, value);
+  const Extension* extension = GetInstalledExtension(extension_id);
+  if (extension)

[asargent_no_longer_on_chrome, 2011/10/27 16:52:21]

same thing here about bailing out if the extension isn't installed

[Munjal (Google), 2011/10/27 18:35:05]

Done.

+    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();
 }