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

chrome/browser/extensions/extension_settings_storage_cache.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_storage_cache.h"
 
 ExtensionSettingsStorageCache::ExtensionSettingsStorageCache(
     ExtensionSettingsStorage* delegate) : delegate_(delegate) {}
 
 ExtensionSettingsStorageCache::~ExtensionSettingsStorageCache() {}
 
 ExtensionSettingsStorage::Result ExtensionSettingsStorageCache::Get(
     const std::string& key) {
   Value *value;
   if (GetFromCache(key, &value)) {
     DictionaryValue* settings = new DictionaryValue();
     settings->SetWithoutPathExpansion(key, value);
-    return Result(settings, NULL);
+    return Result(settings, NULL, NULL);
   }
 
   Result result = delegate_->Get(key);
   if (result.HasError()) {
     return result;
   }
 
   cache_.MergeDictionary(result.GetSettings());
   return result;
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsStorageCache::Get(
     const std::vector<std::string>& keys) {
   scoped_ptr<DictionaryValue> from_cache(new DictionaryValue());
   std::vector<std::string> missing_keys;
 
   for (std::vector<std::string>::const_iterator it = keys.begin();
       it != keys.end(); ++it) {
     Value *value;
     if (GetFromCache(*it, &value)) {
       from_cache->SetWithoutPathExpansion(*it, value);
     } else {
       missing_keys.push_back(*it);
     }
   }
 
   if (missing_keys.empty()) {
-    return Result(from_cache.release(), NULL);
+    return Result(from_cache.release(), NULL, NULL);
   }
 
   Result result = delegate_->Get(keys);
   if (result.HasError()) {
     return result;
   }
 
   cache_.MergeDictionary(result.GetSettings());
-  result.GetSettings()->MergeDictionary(from_cache.get());
-  return result;
+
+  DictionaryValue* settings_with_cache = result.GetSettings()->DeepCopy();
+  settings_with_cache->MergeDictionary(from_cache.get());
+  return Result(settings_with_cache, NULL, NULL);
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsStorageCache::Get() {
   Result result = delegate_->Get();
   if (!result.HasError()) {
     cache_.MergeDictionary(result.GetSettings());
   }
   return result;
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsStorageCache::Set(
     const std::string& key, const Value& value) {
   Result result = delegate_->Set(key, value);
   if (!result.HasError()) {
     cache_.MergeDictionary(result.GetSettings());
   }
   return result;
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsStorageCache::Set(
     const DictionaryValue& settings) {
   Result result = delegate_->Set(settings);
   if (result.HasError()) {
     return result;
   }
 
-  std::set<std::string>* changed_keys = result.GetChangedKeys();
+  const std::set<std::string>* changed_keys = result.GetChangedKeys();
   DCHECK(changed_keys);
   for (std::set<std::string>::iterator it = changed_keys->begin();
       it != changed_keys->end(); ++it) {
     Value* new_value = NULL;
     result.GetSettings()->GetWithoutPathExpansion(*it, &new_value);
     DCHECK(new_value);
     cache_.SetWithoutPathExpansion(*it, new_value->DeepCopy());
   }
   return result;
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsStorageCache::Remove(
     const std::string& key) {
   Result result = delegate_->Remove(key);
   if (!result.HasError()) {
     cache_.RemoveWithoutPathExpansion(key, NULL);
   }
   return result;
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsStorageCache::Remove(
     const std::vector<std::string>& keys) {
   Result result = delegate_->Remove(keys);
   if (result.HasError()) {
     return result;
   }
 
-  std::set<std::string>* changed_keys = result.GetChangedKeys();
+  const std::set<std::string>* changed_keys = result.GetChangedKeys();
   DCHECK(changed_keys);
   for (std::set<std::string>::iterator it = changed_keys->begin();
       it != changed_keys->end(); ++it) {
     cache_.RemoveWithoutPathExpansion(*it, NULL);
   }
   return result;
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsStorageCache::Clear() {
   Result result = delegate_->Clear();
   if (!result.HasError()) {
     cache_.Clear();
   }
   return result;
 }
 
 bool ExtensionSettingsStorageCache::GetFromCache(
     const std::string& key, Value** value) {
   Value* cached_value;
   if (!cache_.GetWithoutPathExpansion(key, &cached_value)) {
     return false;
   }
 
   *value = cached_value->DeepCopy();
   return true;
 }