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

chrome/browser/extensions/extension_settings_leveldb_storage.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_leveldb_storage.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 82 matching lines @@
     const std::string& key) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   scoped_ptr<Value> setting;
   if (!ReadFromDb(leveldb::ReadOptions(), key, &setting)) {
     return Result(kGenericOnFailureMessage);
   }
   DictionaryValue* settings = new DictionaryValue();
   if (setting.get()) {
     settings->SetWithoutPathExpansion(key, setting.release());
   }
-  return Result(settings, NULL);
+  return Result(settings, NULL, NULL);
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsLeveldbStorage::Get(
     const std::vector<std::string>& keys) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   leveldb::ReadOptions options;
   scoped_ptr<DictionaryValue> settings(new DictionaryValue());
 
   // All interaction with the db is done on the same thread, so snapshotting
   // isn't strictly necessary.  This is just defensive.
   ScopedSnapshot snapshot(db_.get());
   options.snapshot = snapshot.get();
   for (std::vector<std::string>::const_iterator it = keys.begin();
       it != keys.end(); ++it) {
     scoped_ptr<Value> setting;
     if (!ReadFromDb(options, *it, &setting)) {
       return Result(kGenericOnFailureMessage);
     }
     if (setting.get()) {
       settings->SetWithoutPathExpansion(*it, setting.release());
     }
   }
 
-  return Result(settings.release(), NULL);
+  return Result(settings.release(), NULL, NULL);
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsLeveldbStorage::Get() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   base::JSONReader json_reader;
   leveldb::ReadOptions options = leveldb::ReadOptions();
   // All interaction with the db is done on the same thread, so snapshotting
   // isn't strictly necessary.  This is just defensive.
   scoped_ptr<DictionaryValue> settings(new DictionaryValue());
 
   ScopedSnapshot snapshot(db_.get());
   options.snapshot = snapshot.get();
   scoped_ptr<leveldb::Iterator> it(db_->NewIterator(options));
   for (it->SeekToFirst(); it->Valid(); it->Next()) {
     Value* value =
         json_reader.JsonToValue(it->value().ToString(), false, false);
     if (value != NULL) {
       settings->SetWithoutPathExpansion(it->key().ToString(), value);
     } else {
       // TODO(kalman): clear the offending non-JSON value from the database.
       LOG(ERROR) << "Invalid JSON: " << it->value().ToString();
     }
   }
 
   if (!it->status().ok()) {
     LOG(ERROR) << "DB iteration failed: " << it->status().ToString();
     return Result(kGenericOnFailureMessage);
   }
 
-  return Result(settings.release(), NULL);
+  return Result(settings.release(), NULL, NULL);
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsLeveldbStorage::Set(
     const std::string& key, const Value& value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DictionaryValue settings;
   settings.SetWithoutPathExpansion(key, value.DeepCopy());
   return Set(settings);
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsLeveldbStorage::Set(
     const DictionaryValue& settings) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  scoped_ptr<DictionaryValue> old_settings(new DictionaryValue());
   scoped_ptr<std::set<std::string> > changed_keys(new std::set<std::string>());
   std::string value_as_json;
   leveldb::WriteBatch batch;
 
   for (DictionaryValue::key_iterator it = settings.begin_keys();
       it != settings.end_keys(); ++it) {
-    scoped_ptr<Value> original_value;
-    if (!ReadFromDb(leveldb::ReadOptions(), *it, &original_value)) {
+    scoped_ptr<Value> old_value;
+    if (!ReadFromDb(leveldb::ReadOptions(), *it, &old_value)) {
       return Result(kGenericOnFailureMessage);
     }
 
     Value* new_value = NULL;
     settings.GetWithoutPathExpansion(*it, &new_value);
-    if (!original_value.get() || !original_value->Equals(new_value)) {
+    if (!old_value.get() || !old_value->Equals(new_value)) {
       changed_keys->insert(*it);
       base::JSONWriter::Write(new_value, false, &value_as_json);
       batch.Put(*it, value_as_json);
     }
+
+    if (old_value.get()) {
+      old_settings->SetWithoutPathExpansion(*it, old_value.release());
+    }
   }
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
   if (!status.ok()) {
     LOG(WARNING) << "DB batch write failed: " << status.ToString();
     return Result(kGenericOnFailureMessage);
   }
 
-  return Result(settings.DeepCopy(), changed_keys.release());
+  return Result(
+      settings.DeepCopy(), old_settings.release(), changed_keys.release());
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsLeveldbStorage::Remove(
     const std::string& key) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   std::vector<std::string> keys;
   keys.push_back(key);
   return Remove(keys);
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsLeveldbStorage::Remove(
     const std::vector<std::string>& keys) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  scoped_ptr<DictionaryValue> old_settings(new DictionaryValue());
   scoped_ptr<std::set<std::string> > changed_keys(new std::set<std::string>());
 
   leveldb::WriteBatch batch;
   for (std::vector<std::string>::const_iterator it = keys.begin();
       it != keys.end(); ++it) {
-    scoped_ptr<Value> original_value;
-    if (!ReadFromDb(leveldb::ReadOptions(), *it, &original_value)) {
+    scoped_ptr<Value> old_value;
+    if (!ReadFromDb(leveldb::ReadOptions(), *it, &old_value)) {
       return Result(kGenericOnFailureMessage);
     }
 
-    if (original_value.get()) {
+    if (old_value.get()) {
       changed_keys->insert(*it);
+      old_settings->SetWithoutPathExpansion(*it, old_value.release());
       batch.Delete(*it);
     }
   }
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
   if (!status.ok() && !status.IsNotFound()) {
     LOG(WARNING) << "DB batch delete failed: " << status.ToString();
     return Result(kGenericOnFailureMessage);
   }
 
-  return Result(NULL, changed_keys.release());
+  return Result(NULL, old_settings.release(), changed_keys.release());
 }
 
 ExtensionSettingsStorage::Result ExtensionSettingsLeveldbStorage::Clear() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  scoped_ptr<DictionaryValue> old_settings(new DictionaryValue());
   scoped_ptr<std::set<std::string> > changed_keys(new std::set<std::string>());
   leveldb::ReadOptions options;
   // All interaction with the db is done on the same thread, so snapshotting
   // isn't strictly necessary.  This is just defensive.
   leveldb::WriteBatch batch;
 
   ScopedSnapshot snapshot(db_.get());
   options.snapshot = snapshot.get();
   scoped_ptr<leveldb::Iterator> it(db_->NewIterator(options));
   for (it->SeekToFirst(); it->Valid(); it->Next()) {
-    changed_keys->insert(it->key().ToString());
-    batch.Delete(it->key());
+    const std::string key = it->key().ToString();
+    const std::string old_value_as_json = it->value().ToString();
+    changed_keys->insert(key);
+    Value* old_value =
+        base::JSONReader().JsonToValue(old_value_as_json, false, false);
+    if (old_value) {
+      old_settings->SetWithoutPathExpansion(key, old_value);
+    } else {
+      LOG(ERROR) << "Invalid JSON in database: " << old_value_as_json;
+    }
+    batch.Delete(key);
   }
 
   if (!it->status().ok()) {
     LOG(WARNING) << "Clear iteration failed: " << it->status().ToString();
     return Result(kGenericOnFailureMessage);
   }
 
   leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch);
   if (!status.ok() && !status.IsNotFound()) {
     LOG(WARNING) << "Clear failed: " << status.ToString();
     return Result(kGenericOnFailureMessage);
   }
 
-  return Result(NULL, changed_keys.release());
+  return Result(NULL, old_settings.release(), changed_keys.release());
 }
 
 bool ExtensionSettingsLeveldbStorage::ReadFromDb(
     leveldb::ReadOptions options,
     const std::string& key,
     scoped_ptr<Value>* setting) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(setting != NULL);
   std::string value_as_json;
   leveldb::Status s = db_->Get(options, key, &value_as_json);
@@ skipping 24 matching lines @@
   scoped_ptr<leveldb::Iterator> it(db_->NewIterator(leveldb::ReadOptions()));
 
   it->SeekToFirst();
   bool is_empty = !it->Valid();
   if (!it->status().ok()) {
     LOG(ERROR) << "Checking DB emptiness failed: " << it->status().ToString();
     return false;
   }
   return is_empty;
 }