Add onChanged events to the extension settings API, both from sync and between

chrome/browser/extensions/extension_settings_backend.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_settings_backend.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 18 matching lines @@
 
 // Quota for each setting.  Sync supports 5k per setting, so be a bit more
 // restrictive than that.
 const size_t kQuotaPerSettingBytes = 2048;
 
 // Max number of settings per extension.  Keep low for sync.
 const size_t kMaxSettingKeys = 512;
 
 }  // namespace
 
-ExtensionSettingsBackend::ExtensionSettingsBackend(const FilePath& base_path)
+ExtensionSettingsBackend::ExtensionSettingsBackend(
+    const FilePath& base_path,
+    ObserverListThreadSafe<ExtensionSettingsObserver>* observers)
     : base_path_(base_path),
+      observers_(observers),
       sync_processor_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 ExtensionSettingsBackend::~ExtensionSettingsBackend() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 ExtensionSettingsStorage* ExtensionSettingsBackend::GetStorage(
     const std::string& extension_id) const {
@@ skipping 25 matching lines @@
     storage = new InMemoryExtensionSettingsStorage();
   }
 
   // It's fine to create the quota enforcer underneath the sync later, since
   // sync will only go ahead if each underlying storage operation is successful.
   storage = new ExtensionSettingsStorageQuotaEnforcer(
       kTotalQuotaBytes, kQuotaPerSettingBytes, kMaxSettingKeys, storage);
 
   syncable_storage =
       linked_ptr<SyncableExtensionSettingsStorage>(
-          new SyncableExtensionSettingsStorage(extension_id, storage));
+          new SyncableExtensionSettingsStorage(
+              observers_.get(),
+              extension_id,
+              storage));
   if (sync_processor_) {
     // TODO(kalman): do something if StartSyncing fails.
     ignore_result(syncable_storage->StartSyncing(sync_data, sync_processor_));
   }
 
   storage_objs_[extension_id] = syncable_storage;
   return syncable_storage.get();
 }
 
+void ExtensionSettingsBackend::TriggerOnSettingsChanged(
+    Profile* profile,
+    const std::string& extension_id,
+    const std::string& event_json) {
+  observers_->Notify(
+      &ExtensionSettingsObserver::OnSettingsChanged,
+      profile,
+      extension_id,
+      event_json);
+}
+
 std::set<std::string> ExtensionSettingsBackend::GetKnownExtensionIDs() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   std::set<std::string> result;
 
   // TODO(kalman): we will need to do something to disambiguate between app
   // settings and extension settings, since settings for apps should be synced
   // iff app sync is turned on, ditto for extensions.
 
   // Extension IDs live in-memory and/or on disk.  The cache will contain all
   // that are in-memory.
@@ skipping 136 matching lines @@
 void ExtensionSettingsBackend::StopSyncing(syncable::ModelType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(sync_processor_);
   sync_processor_ = NULL;
 
   for (StorageObjMap::iterator it = storage_objs_.begin();
       it != storage_objs_.end(); ++it) {
     it->second->StopSyncing();
   }
 }