Re-commit 106660 with the crashing test disabled.

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,
+    const scoped_refptr<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_,
+              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::DeleteExtensionData(
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   StorageObjMap::iterator maybe_storage = storage_objs_.find(extension_id);
   if (maybe_storage == storage_objs_.end()) {
     return;
   }
 
   // Clear settings when the extension is uninstalled.  Leveldb implementations
   // will also delete the database from disk when the object is destroyed as
   // a result of being removed from |storage_objs_|.
   maybe_storage->second->Clear();
   storage_objs_.erase(maybe_storage);
 }
 
+void ExtensionSettingsBackend::TriggerOnSettingsChanged(
+    Profile* profile,
+    const std::string& extension_id,
+    const ExtensionSettingChanges& changes) const {
+  observers_->Notify(
+      &ExtensionSettingsObserver::OnSettingsChanged,
+      profile,
+      extension_id,
+      changes);
+}
+
 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 33 matching lines @@
 
   for (std::set<std::string>::const_iterator it = known_extension_ids.begin();
       it != known_extension_ids.end(); ++it) {
     ExtensionSettingsStorage::Result maybe_settings = GetStorage(*it)->Get();
     if (maybe_settings.HasError()) {
       LOG(WARNING) << "Failed to get settings for " << *it << ": " <<
           maybe_settings.GetError();
       continue;
     }
 
-    DictionaryValue* settings = maybe_settings.GetSettings();
+    const DictionaryValue* settings = maybe_settings.GetSettings();
     for (DictionaryValue::key_iterator key_it = settings->begin_keys();
         key_it != settings->end_keys(); ++key_it) {
       Value *value = NULL;
       settings->GetWithoutPathExpansion(*key_it, &value);
       all_sync_data.push_back(
           extension_settings_sync_util::CreateData(*it, *key_it, *value));
     }
   }
 
   return all_sync_data;
@@ skipping 82 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();
   }
 }