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

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 20 matching lines @@
 // 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,
-    const scoped_refptr<ObserverListThreadSafe<ExtensionSettingsObserver> >&
-        observers)
+    const scoped_refptr<ExtensionSettingsObserverList>& observers)
     : base_path_(base_path),
       observers_(observers),
+      sync_type_(syncable::UNSPECIFIED),
       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 31 matching lines @@
       kTotalQuotaBytes, kQuotaPerSettingBytes, kMaxSettingKeys, storage);
 
   syncable_storage =
       linked_ptr<SyncableExtensionSettingsStorage>(
           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_));
+    ignore_result(syncable_storage->StartSyncing(
+        sync_type_, sync_data, sync_processor_));
   }
 
   storage_objs_[extension_id] = syncable_storage;
   return syncable_storage.get();
 }
 
-void ExtensionSettingsBackend::DeleteExtensionData(
-    const std::string& extension_id) {
+void ExtensionSettingsBackend::DeleteStorage(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.
   for (StorageObjMap::iterator it = storage_objs_.begin();
       it != storage_objs_.end(); ++it) {
     result.insert(it->first);
   }
 
   // Leveldb databases are directories inside base_path_.
   file_util::FileEnumerator::FindInfo find_info;
   file_util::FileEnumerator extension_dirs(
       base_path_, false, file_util::FileEnumerator::DIRECTORIES);
   while (!extension_dirs.Next().empty()) {
     extension_dirs.GetFindInfo(&find_info);
     FilePath extension_dir(file_util::FileEnumerator::GetFilename(find_info));
     DCHECK(!extension_dir.IsAbsolute());
     // Extension IDs are created as std::strings so they *should* be ASCII.
     std::string maybe_as_ascii(extension_dir.MaybeAsASCII());
     if (!maybe_as_ascii.empty()) {
       result.insert(maybe_as_ascii);
     }
   }
 
   return result;
 }
 
 SyncDataList ExtensionSettingsBackend::GetAllSyncData(
     syncable::ModelType type) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK_EQ(type, syncable::EXTENSION_SETTINGS);
+  // Ignore the type, it's just for sanity checking; assume that whatever base
+  // path we're constructed with is correct for the sync type.
+  DCHECK(type == syncable::EXTENSION_SETTINGS ||
+         type == syncable::APP_SETTINGS);
 
-  // For all extensions, get all their settings.
-  // This has the effect of bringing in the entire state of extension settings
-  // in memory; sad.
+  // For all extensions, get all their settings.  This has the effect
+  // of bringing in the entire state of extension settings in memory; sad.
   SyncDataList all_sync_data;
   std::set<std::string> known_extension_ids(GetKnownExtensionIDs());
 
   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;
@@ skipping 10 matching lines @@
   }
 
   return all_sync_data;
 }
 
 SyncError ExtensionSettingsBackend::MergeDataAndStartSyncing(
     syncable::ModelType type,
     const SyncDataList& initial_sync_data,
     SyncChangeProcessor* sync_processor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  DCHECK_EQ(type, syncable::EXTENSION_SETTINGS);
+  DCHECK(type == syncable::EXTENSION_SETTINGS ||
+         type == syncable::APP_SETTINGS);
+  DCHECK_EQ(sync_type_, syncable::UNSPECIFIED);
   DCHECK(!sync_processor_);
+
+  sync_type_ = type;
   sync_processor_ = sync_processor;
 
   // Group the initial sync data by extension id.
   std::map<std::string, linked_ptr<DictionaryValue> > grouped_sync_data;
   for (SyncDataList::const_iterator it = initial_sync_data.begin();
       it != initial_sync_data.end(); ++it) {
     ExtensionSettingSyncData data(*it);
     linked_ptr<DictionaryValue> sync_data =
         grouped_sync_data[data.extension_id()];
     if (!sync_data.get()) {
       sync_data = linked_ptr<DictionaryValue>(new DictionaryValue());
       grouped_sync_data[data.extension_id()] = sync_data;
     }
     DCHECK(!sync_data->HasKey(data.key())) <<
         "Duplicate settings for " << data.extension_id() << "/" << data.key();
     sync_data->Set(data.key(), data.value().DeepCopy());
   }
 
   // Start syncing all existing storage areas.  Any storage areas created in
   // the future will start being synced as part of the creation process.
   for (StorageObjMap::iterator it = storage_objs_.begin();
       it != storage_objs_.end(); ++it) {
     std::map<std::string, linked_ptr<DictionaryValue> >::iterator
         maybe_sync_data = grouped_sync_data.find(it->first);
     if (maybe_sync_data != grouped_sync_data.end()) {
       // TODO(kalman): do something if StartSyncing fails.
       ignore_result(
-          it->second->StartSyncing(*maybe_sync_data->second, sync_processor));
+          it->second->StartSyncing(
+              type, *maybe_sync_data->second, sync_processor));
       grouped_sync_data.erase(it->first);
     } else {
       DictionaryValue empty;
       // TODO(kalman): do something if StartSyncing fails.
-      ignore_result(it->second->StartSyncing(empty, sync_processor));
+      ignore_result(it->second->StartSyncing(type, empty, sync_processor));
     }
   }
 
   // Eagerly create and init the rest of the storage areas that have sync data.
   // Under normal circumstances (i.e. not first-time sync) this will be all of
   // them.
   for (std::map<std::string, linked_ptr<DictionaryValue> >::iterator it =
       grouped_sync_data.begin(); it != grouped_sync_data.end(); ++it) {
     GetOrCreateStorageWithSyncData(it->first, *it->second);
   }
 
   return SyncError();
 }
 
 SyncError ExtensionSettingsBackend::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& sync_changes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(sync_processor_);
 
   // Group changes by extension, to pass all changes in a single method call.
   std::map<std::string, ExtensionSettingSyncDataList> grouped_sync_data;
   for (SyncChangeList::const_iterator it = sync_changes.begin();
       it != sync_changes.end(); ++it) {
     ExtensionSettingSyncData data(*it);
     grouped_sync_data[data.extension_id()].push_back(data);
   }
 
+  // Create any storage areas that don't exist yet but have sync data.
   DictionaryValue empty;
   for (std::map<std::string, ExtensionSettingSyncDataList>::iterator
       it = grouped_sync_data.begin(); it != grouped_sync_data.end(); ++it) {
     // TODO(kalman): do something if ProcessSyncChanges fails.
     ignore_result(
         GetOrCreateStorageWithSyncData(it->first, empty)->
             ProcessSyncChanges(it->second));
   }
 
   return SyncError();
 }
 
 void ExtensionSettingsBackend::StopSyncing(syncable::ModelType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(type == syncable::EXTENSION_SETTINGS ||
+         type == syncable::APP_SETTINGS);
+  DCHECK_EQ(type, sync_type_);
   DCHECK(sync_processor_);
+
+  sync_type_ = syncable::UNSPECIFIED;
   sync_processor_ = NULL;
 
   for (StorageObjMap::iterator it = storage_objs_.begin();
       it != storage_objs_.end(); ++it) {
     it->second->StopSyncing();
   }
 }