Separate the syncing of extension settings and app settings into separate data

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 "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/public/browser/browser_thread.h"
 
 SyncableExtensionSettingsStorage::SyncableExtensionSettingsStorage(
     const scoped_refptr<ObserverListThreadSafe<ExtensionSettingsObserver> >&
         observers,
     const std::string& extension_id,
     ExtensionSettingsStorage* delegate)
     : observers_(observers),
       extension_id_(extension_id),
       delegate_(delegate),
+      sync_type_(syncable::UNSPECIFIED),
       sync_processor_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 SyncableExtensionSettingsStorage::~SyncableExtensionSettingsStorage() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 ExtensionSettingsStorage::Result SyncableExtensionSettingsStorage::Get(
     const std::string& key) {
@@ skipping 72 matching lines @@
   }
   if (sync_processor_ && !result.GetChangedKeys()->empty()) {
     SendDeletesToSync(*result.GetChangedKeys());
   }
   return result;
 }
 
 // Sync-related methods.
 
 SyncError SyncableExtensionSettingsStorage::StartSyncing(
-    const DictionaryValue& sync_state, SyncChangeProcessor* sync_processor) {
+    syncable::ModelType type,
+    const DictionaryValue& sync_state,
+    SyncChangeProcessor* sync_processor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(type == syncable::EXTENSION_SETTINGS ||
+         type == syncable::APP_SETTINGS);
+  DCHECK_EQ(sync_type_, syncable::UNSPECIFIED);
   DCHECK(!sync_processor_);
   DCHECK(synced_keys_.empty());
+
+  sync_type_ = type;
   sync_processor_ = sync_processor;
 
   Result maybe_settings = delegate_->Get();
   if (maybe_settings.HasError()) {
     return SyncError(
         FROM_HERE,
         std::string("Failed to get settings: ") + maybe_settings.GetError(),
-        syncable::EXTENSION_SETTINGS);
+        type);
   }
 
   const DictionaryValue* settings = maybe_settings.GetSettings();
   if (sync_state.empty()) {
     return SendLocalSettingsToSync(*settings);
   }
   return OverwriteLocalSettingsWithSync(sync_state, *settings);
 }
 
 SyncError SyncableExtensionSettingsStorage::SendLocalSettingsToSync(
@@ skipping 79 matching lines @@
   std::vector<SyncError> sync_errors(ProcessSyncChanges(changes));
   if (sync_errors.empty()) {
     return SyncError();
   }
   // TODO(kalman): something sensible with multiple errors.
   return sync_errors[0];
 }
 
 void SyncableExtensionSettingsStorage::StopSyncing() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(sync_type_ == syncable::EXTENSION_SETTINGS ||
+         sync_type_ == syncable::APP_SETTINGS);
   DCHECK(sync_processor_);
+
+  sync_type_ = syncable::UNSPECIFIED;
   sync_processor_ = NULL;
   synced_keys_.clear();
 }
 
 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;
   ExtensionSettingChanges::Builder changes;
 
   for (ExtensionSettingSyncDataList::const_iterator it = sync_changes.begin();
       it != sync_changes.end(); ++it) {
     DCHECK_EQ(extension_id_, it->extension_id());
 
     const std::string& key = it->key();
     const Value& value = it->value();
 
     scoped_ptr<Value> current_value;
     {
       Result maybe_settings = Get(it->key());
       if (maybe_settings.HasError()) {
         errors.push_back(SyncError(
             FROM_HERE,
             std::string("Error getting current sync state for ") +
                 extension_id_ + "/" + key + ": " + maybe_settings.GetError(),
-            syncable::EXTENSION_SETTINGS));
+            sync_type_));
         continue;
       }
       const DictionaryValue* settings = maybe_settings.GetSettings();
       if (settings) {
         Value* value = NULL;
         if (settings->GetWithoutPathExpansion(key, &value)) {
           current_value.reset(value->DeepCopy());
         }
       }
     }
@@ skipping 126 matching lines @@
     Value* new_value,
     ExtensionSettingChanges::Builder* changes) {
   DCHECK(new_value);
   synced_keys_.insert(key);
   Result result = delegate_->Set(key, *new_value);
   if (result.HasError()) {
     return SyncError(
         FROM_HERE,
         std::string("Error pushing sync add to local settings: ") +
             result.GetError(),
-        syncable::EXTENSION_SETTINGS);
+        sync_type_);
   }
   changes->AppendChange(key, NULL, new_value);
   return SyncError();
 }
 
 SyncError SyncableExtensionSettingsStorage::OnSyncUpdate(
     const std::string& key,
     Value* old_value,
     Value* new_value,
     ExtensionSettingChanges::Builder* changes) {
   DCHECK(old_value);
   DCHECK(new_value);
   Result result = delegate_->Set(key, *new_value);
   if (result.HasError()) {
     return SyncError(
         FROM_HERE,
         std::string("Error pushing sync update to local settings: ") +
             result.GetError(),
-        syncable::EXTENSION_SETTINGS);
+        sync_type_);
   }
   changes->AppendChange(key, old_value, new_value);
   return SyncError();
 }
 
 SyncError SyncableExtensionSettingsStorage::OnSyncDelete(
     const std::string& key,
     Value* old_value,
     ExtensionSettingChanges::Builder* changes) {
   DCHECK(old_value);
   synced_keys_.erase(key);
   Result result = delegate_->Remove(key);
   if (result.HasError()) {
     return SyncError(
         FROM_HERE,
         std::string("Error pushing sync remove to local settings: ") +
             result.GetError(),
-        syncable::EXTENSION_SETTINGS);
+        sync_type_);
   }
   changes->AppendChange(key, old_value, NULL);
   return SyncError();
 }