Extension Settings API: make it so that when leveldb storage areas fail to be

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"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
-#include "chrome/browser/extensions/settings/settings_leveldb_storage.h"
+#include "chrome/browser/extensions/settings/failing_settings_storage.h"
 #include "chrome/browser/extensions/settings/settings_storage_cache.h"
+#include "chrome/browser/extensions/settings/settings_storage_factory.h"
 #include "chrome/browser/extensions/settings/settings_storage_quota_enforcer.h"
 #include "chrome/browser/extensions/settings/settings_sync_util.h"
-#include "chrome/browser/extensions/settings/in_memory_settings_storage.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
-#include "third_party/leveldatabase/src/include/leveldb/iterator.h"
-#include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
+
+using content::BrowserThread;
 
 namespace extensions {
 
-using content::BrowserThread;
-
 namespace {
 
 // Total quota for all settings per extension, in bytes.  100K should be enough
 // for most uses, but this can be increased as demand increases.
 const size_t kTotalQuotaBytes = 100 * 1024;
 
 // Quota for each setting.  Sync supports 5k per setting, so be a bit more
 // restrictive than that.
 const size_t kQuotaPerSettingBytes = 2048;
 
 // Max number of settings per extension.  Keep low for sync.
 const size_t kMaxSettingKeys = 512;
 
 }  // namespace
 
 SettingsBackend::SettingsBackend(
+    SettingsStorageFactory* storage_factory,
     const FilePath& base_path,
     const scoped_refptr<SettingsObserverList>& observers)
-    : base_path_(base_path),
+    : storage_factory_(storage_factory),
+      base_path_(base_path),
       observers_(observers),
       sync_type_(syncable::UNSPECIFIED),
       sync_processor_(NULL) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 SettingsBackend::~SettingsBackend() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 SettingsStorage* SettingsBackend::GetStorage(
     const std::string& extension_id) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DictionaryValue empty;
   return GetOrCreateStorageWithSyncData(extension_id, empty);
 }
 
 SyncableSettingsStorage*
 SettingsBackend::GetOrCreateStorageWithSyncData(
     const std::string& extension_id, const DictionaryValue& sync_data) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  linked_ptr<SyncableSettingsStorage> syncable_storage =
-      storage_objs_[extension_id];
-  if (syncable_storage.get()) {
-    return syncable_storage.get();
+  StorageObjMap::iterator maybe_storage = storage_objs_.find(extension_id);
+  if (maybe_storage != storage_objs_.end()) {
+    return maybe_storage->second.get();
   }
 
-  SettingsStorage* storage =
-      SettingsLeveldbStorage::Create(base_path_, extension_id);
+  SettingsStorage* storage = storage_factory_->Create(base_path_, extension_id);
   if (storage) {
     storage = new SettingsStorageCache(storage);
+    // It's fine to create the quota enforcer underneath the sync layer, since
+    // sync will only go ahead if each underlying storage operation succeeds.
+    storage = new SettingsStorageQuotaEnforcer(
+        kTotalQuotaBytes, kQuotaPerSettingBytes, kMaxSettingKeys, storage);
   } else {
-    // Failed to create a leveldb storage area, create an in-memory one.
-    // It's ok for these to be synced, it just means that on next starting up
-    // extensions will see the "old" settings, then overwritten (and notified)
-    // when the sync changes come through.
-    storage = new InMemorySettingsStorage();
+    storage = new FailingSettingsStorage();
   }
 
-  // It's fine to create the quota enforcer underneath the sync later, since
-  // sync will only go ahead if each underlying storage operation is successful.
-  storage = new SettingsStorageQuotaEnforcer(
-      kTotalQuotaBytes, kQuotaPerSettingBytes, kMaxSettingKeys, storage);
-
-  syncable_storage =
-      linked_ptr<SyncableSettingsStorage>(
-          new SyncableSettingsStorage(
-              observers_,
-              extension_id,
-              storage));
+  linked_ptr<SyncableSettingsStorage> syncable_storage(
+      new SyncableSettingsStorage(
+          observers_,
+          extension_id,
+          storage));
   if (sync_processor_) {
     // TODO(kalman): do something if StartSyncing fails.
     ignore_result(syncable_storage->StartSyncing(
         sync_type_, sync_data, sync_processor_));
   }
 
   storage_objs_[extension_id] = syncable_storage;
   return syncable_storage.get();
 }
 
@@ skipping 39 matching lines @@
 
   return result;
 }
 
 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()));
+        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);
@@ skipping 114 matching lines @@
   sync_type_ = syncable::UNSPECIFIED;
   sync_processor_ = NULL;
 
   for (StorageObjMap::iterator it = storage_objs_.begin();
       it != storage_objs_.end(); ++it) {
     it->second->StopSyncing();
   }
 }
 
 }  // namespace extensions