Extension Settings API: make it so that when changes received from Sync fail to

chrome/browser/extensions/settings/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/settings/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 69 matching lines @@
         kTotalQuotaBytes, kQuotaPerSettingBytes, kMaxSettingKeys, storage);
   } else {
     storage = new FailingSettingsStorage();
   }
 
   linked_ptr<SyncableSettingsStorage> syncable_storage(
       new SyncableSettingsStorage(
           observers_,
           extension_id,
           storage));
+  storage_objs_[extension_id] = syncable_storage;
+
   if (sync_processor_) {
-    // TODO(kalman): do something if StartSyncing fails.
-    ignore_result(syncable_storage->StartSyncing(
-        sync_type_, sync_data, sync_processor_));
+    SyncError error =
+        syncable_storage->StartSyncing(sync_type_, sync_data, sync_processor_);
+    if (error.IsSet()) {
+      DisableSyncForExtension(extension_id);
+    }
   }
 
-  storage_objs_[extension_id] = syncable_storage;
   return syncable_storage.get();
 }
 
 void SettingsBackend::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;
   }
 
@@ skipping 26 matching lines @@
     // 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;
 }
 
+void SettingsBackend::DisableSyncForExtension(
+    const std::string& extension_id) const {
+  linked_ptr<SyncableSettingsStorage> storage = storage_objs_[extension_id];
+  DCHECK(storage.get());
+  storage->StopSyncing();
+}
+
 static void AddAllSyncData(
     const std::string& extension_id,
     const DictionaryValue& src,
     SyncDataList* dst) {
   for (DictionaryValue::Iterator it(src); it.HasNext(); it.Advance()) {
     dst->push_back(
         settings_sync_util::CreateData(extension_id, it.key(), it.value()));
   }
 }
 
 SyncDataList SettingsBackend::GetAllSyncData(
     syncable::ModelType type) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   // 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.
   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) {
-    SettingsStorage::ReadResult maybe_settings =
-        GetStorage(*it)->Get();
+    SettingsStorage::ReadResult maybe_settings = GetStorage(*it)->Get();
     if (maybe_settings.HasError()) {
       LOG(WARNING) << "Failed to get settings for " << *it << ": " <<
           maybe_settings.error();
       continue;
     }
     AddAllSyncData(*it, maybe_settings.settings(), &all_sync_data);
   }
 
   return all_sync_data;
 }
@@ skipping 26 matching lines @@
         "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);
+    SyncError error;
     if (maybe_sync_data != grouped_sync_data.end()) {
-      // TODO(kalman): do something if StartSyncing fails.
-      ignore_result(
-          it->second->StartSyncing(
-              type, *maybe_sync_data->second, sync_processor));
+      error = 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(type, empty, sync_processor));
+      error = it->second->StartSyncing(type, empty, sync_processor);
+    }
+    if (error.IsSet()) {
+      DisableSyncForExtension(it->first);
     }
   }
 
   // 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);
   }
@@ skipping 12 matching lines @@
   for (SyncChangeList::const_iterator it = sync_changes.begin();
       it != sync_changes.end(); ++it) {
     SettingSyncData 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, SettingSyncDataList>::iterator
       it = grouped_sync_data.begin(); it != grouped_sync_data.end(); ++it) {
-    // TODO(kalman): do something if ProcessSyncChanges fails.
-    ignore_result(
+    SyncError error =
         GetOrCreateStorageWithSyncData(it->first, empty)->
-            ProcessSyncChanges(it->second));
+            ProcessSyncChanges(it->second);
+    if (error.IsSet()) {
+      DisableSyncForExtension(it->first);
+    }
   }
 
   return SyncError();
 }
 
 void SettingsBackend::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) {
+    // Some storage areas may have already stopped syncing if they had areas
+    // and syncing was disabled, but StopSyncing is safe to call multiple times.
     it->second->StopSyncing();
   }
 }
 
 }  // namespace extensions