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

chrome/browser/extensions/syncable_extension_settings_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/syncable_extension_settings_storage.h"
 
 #include "base/memory/scoped_ptr.h"
+#include "base/stringprintf.h"
 #include "chrome/browser/extensions/extension_settings_sync_util.h"
 #include "chrome/browser/sync/api/sync_data.h"
 #include "chrome/browser/sync/protocol/extension_setting_specifics.pb.h"
 #include "content/browser/browser_thread.h"
 
 SyncableExtensionSettingsStorage::SyncableExtensionSettingsStorage(
-    std::string extension_id, ExtensionSettingsStorage* delegate)
-    : extension_id_(extension_id), delegate_(delegate), sync_processor_(NULL) {
+    const scoped_refptr<ObserverListThreadSafe<ExtensionSettingsObserver> >&
+        observers,
+    const std::string& extension_id,
+    ExtensionSettingsStorage* delegate)
+    : observers_(observers),
+      extension_id_(extension_id),
+      delegate_(delegate),
+      sync_processor_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 SyncableExtensionSettingsStorage::~SyncableExtensionSettingsStorage() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 ExtensionSettingsStorage::Result SyncableExtensionSettingsStorage::Get(
     const std::string& key) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 192 matching lines @@
 }
 
 std::vector<SyncError> SyncableExtensionSettingsStorage::ProcessSyncChanges(
     const ExtensionSettingSyncDataList& sync_changes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(sync_processor_);
   DCHECK(!sync_changes.empty()) << "No sync changes for " << extension_id_;
 
   std::vector<SyncError> errors;
 
+  // Change event to build then send to onChanged listeners of the settings API.
+  ExtensionSettingsObserver::ChangeList change_event;
+
   for (ExtensionSettingSyncDataList::const_iterator it = sync_changes.begin();
       it != sync_changes.end(); ++it) {
     DCHECK_EQ(extension_id_, it->extension_id());
+
+    scoped_ptr<Value> current_value;
+    {
+      Result maybe_settings = Get(it->key());
+      if (maybe_settings.HasError()) {
+        errors.push_back(SyncError(
+            FROM_HERE,
+            base::StringPrintf(
+                "Error getting current sync state for %s/%s: %s",
+                extension_id_.c_str(),
+                it->key().c_str(),
+                maybe_settings.GetError().c_str()),
+            syncable::EXTENSION_SETTINGS));
+        continue;
+      }
+      if (maybe_settings.GetSettings() != NULL) {
+        Value* value_ownership = NULL;
+        maybe_settings.GetSettings()->RemoveWithoutPathExpansion(
+            it->key(), &value_ownership);
+        current_value.reset(value_ownership);
+      }
+    }
+
     switch (it->change_type()) {
-      case SyncChange::ACTION_ADD:
-      case SyncChange::ACTION_UPDATE: {
+      case SyncChange::ACTION_ADD: {
+        if (current_value.get()) {
+          errors.push_back(SyncError(
+              FROM_HERE,
+              base::StringPrintf(
+                  "Got add from sync for existing setting %s/%s",

[akalin, 2011/10/12 22:26:30]

unnecessary use of StringPrintf; just use strings and + (also everywhere else)

[not at google - send to devlin, 2011/10/13 06:40:43]

...

So, reverting this back to the way it was.  Eh...

+                  extension_id_.c_str(),
+                  it->key().c_str()),
+              syncable::EXTENSION_SETTINGS));
+          break;
+        }
+
         synced_keys_.insert(it->key());
         Result result = delegate_->Set(it->key(), it->value());
         if (result.HasError()) {
           errors.push_back(SyncError(
               FROM_HERE,
-              std::string("Error pushing sync change to local settings: ") +
-                  result.GetError(),
+              base::StringPrintf(
+                  "Error pushing sync add to local settings: %s",
+                  result.GetError().c_str()),
               syncable::EXTENSION_SETTINGS));
+          break;
         }
+
+        change_event.AppendChange(it->key(), NULL, it->value().DeepCopy());
+        break;
+      }
+
+      case SyncChange::ACTION_UPDATE: {
+        if (!current_value.get()) {
+          errors.push_back(SyncError(
+              FROM_HERE,
+              base::StringPrintf(
+                  "Got update from sync for nonexistent setting %s/%s",
+                  extension_id_.c_str(),
+                  it->key().c_str()),
+              syncable::EXTENSION_SETTINGS));
+          break;
+        }
+
+        synced_keys_.insert(it->key());
+        Result result = delegate_->Set(it->key(), it->value());
+        if (result.HasError()) {
+          errors.push_back(SyncError(
+              FROM_HERE,
+              base::StringPrintf(
+                  "Error pushing sync update to local settings: %s",
+                  result.GetError().c_str()),
+              syncable::EXTENSION_SETTINGS));
+          break;
+        }
+
+        change_event.AppendChange(
+            it->key(), current_value.release(), it->value().DeepCopy());
         break;
       }
 
       case SyncChange::ACTION_DELETE: {
+        if (!current_value.get()) {
+          errors.push_back(SyncError(
+              FROM_HERE,
+              base::StringPrintf(
+                  "Got delete from sync for nonexistent setting %s/%s",
+                  extension_id_.c_str(),
+                  it->key().c_str()),
+              syncable::EXTENSION_SETTINGS));
+          break;
+        }
+
         synced_keys_.erase(it->key());
         Result result = delegate_->Remove(it->key());
         if (result.HasError()) {
           errors.push_back(SyncError(
               FROM_HERE,
-              std::string("Error removing sync change from local settings: ") +
-                  result.GetError(),
+              base::StringPrintf(
+                  "Error pushing sync remove to local settings: %s",
+                  result.GetError().c_str()),
               syncable::EXTENSION_SETTINGS));
+          break;
         }
+
+        change_event.AppendChange(it->key(), current_value.release(), NULL);
         break;
       }
 
       default:
         NOTREACHED();
     }
   }
 
+  observers_->Notify(
+      &ExtensionSettingsObserver::OnSettingsChanged,
+      static_cast<Profile*>(NULL),
+      extension_id_,
+      change_event.GetEventJson());
+
   return errors;
 }
 
 void SyncableExtensionSettingsStorage::SendAddsOrUpdatesToSync(
     const std::set<std::string>& changed_keys,
     const DictionaryValue& settings) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(sync_processor_);
   DCHECK(!changed_keys.empty());
 
@@ skipping 42 matching lines @@
   if (error.IsSet()) {
     LOG(WARNING) << "Failed to send changes to sync: " << error.message();
     return;
   }
 
   for (std::set<std::string>::const_iterator it = keys.begin();
       it != keys.end(); ++it) {
     synced_keys_.erase(*it);
   }
 }