Implement an initial extension settings API.

chrome/browser/extensions/extension_settings.cc

Index: chrome/browser/extensions/extension_settings.cc
diff --git a/chrome/browser/extensions/extension_settings.cc b/chrome/browser/extensions/extension_settings.cc
new file mode 100644
index 0000000000000000000000000000000000000000..88a243808fef90d6712889c083e0e35705e16a8c
--- /dev/null
+++ b/chrome/browser/extensions/extension_settings.cc
@@ -0,0 +1,249 @@
+// 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.h"
+
+#include "base/bind.h"
+#include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "content/browser/browser_thread.h"
+#include "chrome/browser/extensions/extension_settings_leveldb_storage.h"
+#include "chrome/browser/extensions/extension_settings_noop_storage.h"
+#include "chrome/browser/extensions/extension_settings_storage_cache.h"
+#include "third_party/leveldb/include/leveldb/iterator.h"
+#include "third_party/leveldb/include/leveldb/write_batch.h"
+
+// TODO(kalman): Policy for dots in the key names.  Make sure the behaviour of
+//               DictionaryValue and JSON classes is consistent with leveldb.
+// TODO(kalman): Integration tests.
+// TODO(kalman): More unit tests (see extension_settings_storage_unittest.cc).
+// TODO(kalman): Use structured cloning rather than JSON.
+
+namespace {
+
+const char kDatabaseName[] = "settings";
+
+// Creates a storage area of a requested type on the FILE thread.
+class CreateStorageClosure {
+ public:
+  // Fallback type may be 0 to not have any fallback type.
+  // Ownership of callback is taken.
+  CreateStorageClosure(const FilePath& base_path,
+      std::map<std::string, ExtensionSettingsStorage*>* storage_objs,
+      const std::string& extension_id, int type, int fallback_type,
+      ExtensionSettings::Callback* callback)
+      : base_path_(base_path), storage_objs_(storage_objs),
+        extension_id_(extension_id), type_(type), fallback_type_(fallback_type),
+        callback_(callback), storage_(NULL) {}
+
+  ~CreateStorageClosure() {}
+
+  void Run() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    BrowserThread::PostTask(
+        BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(
+          &CreateStorageClosure::RunOnFileThread, base::Unretained(this)));
+  }
+
+ private:
+  void RunOnFileThread() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    storage_ = CreateStorage(type_);
+    if (storage_ == NULL && fallback_type_ > 0) {
+      storage_ = CreateStorage(fallback_type_);
+    }
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&CreateStorageClosure::Done, base::Unretained(this)));
+  }
+
+  void Done() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK(storage_ != NULL);
+    // Cache the result now.  To avoid a race condition, check again to see
+    // whether a storage has been created already; if so, use that one.
+    std::map<std::string, ExtensionSettingsStorage*>::iterator existing =
+        storage_objs_->find(extension_id_);
+    if (existing == storage_objs_->end()) {
+      (*storage_objs_)[extension_id_] = storage_;
+    } else {
+      delete storage_;
+      storage_ = existing->second;
+      DCHECK(storage_ != NULL);
+    }
+    callback_->Run(storage_);
+    delete this;
+  }
+
+  // Creates a storage object of a given type.  If that fails, returns NULL.
+  ExtensionSettingsStorage* CreateStorage(int type) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    ExtensionSettingsStorage* storage = NULL;
+
+    switch (type & ~ExtensionSettingsStorage::CACHED) {
+      case ExtensionSettingsStorage::NOOP:
+        storage = new ExtensionSettingsNoopStorage();
+        break;
+
+      case ExtensionSettingsStorage::LEVELDB: {
+        FilePath path = base_path_.Append(extension_id_).Append(kDatabaseName);
+        // TODO(kalman): why doesn't FilePath/leveldb handle this internally?
+#if defined(OS_POSIX)
+        std::string os_path(path.value());
+#elif defined(OS_WIN)
+        std::string os_path = base::SysWideToUTF8(path.value());
+#endif
+        leveldb::Options options;
+        options.create_if_missing = true;
+        leveldb::DB* db;
+        leveldb::Status status = leveldb::DB::Open(options, os_path, &db);
+        if (!status.ok()) {
+          LOG(WARNING) << "Failed to create leveldb at " << path.value();

[dgrogan, 2011/06/18 01:54:40]

You can also print out status.ToString()

[not at google - send to devlin, 2011/06/20 05:33:11]

Done.

+          return NULL;
+        }
+        storage = new ExtensionSettingsLeveldbStorage(db);
+        break;
+      }
+
+      default:
+        NOTREACHED();
+    }
+
+    if (type & ExtensionSettingsStorage::CACHED) {
+      storage = new ExtensionSettingsStorageCache(storage);
+    }
+
+    return storage;
+  }
+
+  const FilePath& base_path_;
+  std::map<std::string, ExtensionSettingsStorage*>* storage_objs_;
+  std::string extension_id_;
+  int type_;
+  int fallback_type_;
+  scoped_ptr<ExtensionSettings::Callback> callback_;
+
+  ExtensionSettingsStorage* storage_;
+};
+
+// Returns a specified storage object on the message loop of the current thread.
+// Used to force an asynchronous API even when a storage area already exists.
+class GetExistingStorageClosure {
+ public:
+  GetExistingStorageClosure(ExtensionSettings::Callback* callback,
+      ExtensionSettingsStorage* storage)
+      : callback_(callback), storage_(storage) {}
+
+  ~GetExistingStorageClosure() {
+    delete callback_;
+  }
+
+  void Run() {
+    MessageLoop::current()->PostTask(FROM_HERE,
+        base::Bind(&GetExistingStorageClosure::Run2, base::Unretained(this)));
+  }
+
+ private:
+  void Run2() {
+    callback_->Run(storage_);
+    delete this;
+  }
+
+  ExtensionSettings::Callback* callback_;
+  ExtensionSettingsStorage* storage_;
+};
+
+// Deletes a storage area on the FILE thread.
+class DeleteStorageClosure {
+ public:
+  explicit DeleteStorageClosure(ExtensionSettingsStorage* storage)
+      : storage_(storage) {}
+
+  ~DeleteStorageClosure() {}
+
+  void Run() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    BrowserThread::PostTask(
+        BrowserThread::FILE,

[dgrogan, 2011/06/18 01:54:40]

Thread-lifetime issues are fresh in my mind, so: do you know if the FILE thread
will always be around when this is executed?

[not at google - send to devlin, 2011/06/20 05:33:11]

Hmm.  I guess not.  Excuse my naivety with respect to thread lifetime in the
following comments.

Do you make this comment in particular for this callback (which seems reasonable
given it's called from a destructor), or for all places when I've done PostTask?

If the former -- I don't really think it matters.  If the FILE thread doesn't
exist then there is a memory leak, but would this only be the case if Chrome is
already shutting down?  Besides, there isn't much that can be done about it.  It
needs to be destructed on the FILE thread.  And also, there isn't anything
waiting on a callback.

If the latter -- i.e. if normal browser operation were to result in the FILE
thread not existing -- I presume a fix would be something along the lines of
changing

BrowserThread::PostTask(...)

to

if (!BrowserThread::PostTask(...)) {
  // Can't post to the FILE thread, so post an asynchronous
  // OnFailure event to the current thread
  MessageLoop::current()->PostTask(FROM_HERE, ...);
}

?

[dgrogan, 2011/06/21 02:36:05]

The former, I saw it was called from the destructor.
I think so but don't know.  I was kind of hoping you would know and could tell
me :)

I erroneously thought that the leveldb object's destructor _needed_ to run.  I
think you're right though: no big deal if it doesn't.

Besides, there isn't much that can be done about it.  It

[not at google - send to devlin, 2011/06/22 09:40:38]

Ah.  Sadly not :)

+        FROM_HERE,
+        base::Bind(
+          &DeleteStorageClosure::RunOnFileThread, base::Unretained(this)));
+  }
+
+ private:
+  void RunOnFileThread() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    delete storage_;
+    delete this;
+  }
+
+  ExtensionSettingsStorage* storage_;
+};
+
+}  // namespace
+
+ExtensionSettings::ExtensionSettings(const FilePath& base_path)
+    : base_path_(base_path) {
+}
+
+ExtensionSettings::~ExtensionSettings() {
+  // Need to delete all the storage objects we created; and any leveldb-based
+  // ones must be deleted on the FILE thread.
+  std::map<std::string, ExtensionSettingsStorage*>::iterator it;
+  for (it = storage_objs_.begin(); it != storage_objs_.end(); ++it) {
+    ExtensionSettingsStorage* storage = it->second;
+    if (storage->type() & ExtensionSettingsStorage::LEVELDB) {
+      (new DeleteStorageClosure(storage))->Run();
+    } else {
+      delete storage;
+    }
+  }
+}
+
+void ExtensionSettings::GetStorage(const std::string& extension_id,
+    ExtensionSettings::Callback* callback) {
+  if (!GetExistingStorage(extension_id, callback)) {
+    (new CreateStorageClosure(
+        base_path_,
+        &storage_objs_,
+        extension_id,
+        ExtensionSettingsStorage::LEVELDB | ExtensionSettingsStorage::CACHED,
+        ExtensionSettingsStorage::NOOP | ExtensionSettingsStorage::CACHED,
+        callback))->Run();
+  }
+}
+
+void ExtensionSettings::GetStorageForTesting(int type, const std::string&
+    extension_id,
+    Callback* callback) {
+  if (!GetExistingStorage(extension_id, callback)) {
+    (new CreateStorageClosure(
+        base_path_,
+        &storage_objs_,
+        extension_id,
+        type,
+        0,
+        callback))->Run();
+  }
+}
+
+bool ExtensionSettings::GetExistingStorage(const std::string& extension_id,
+    ExtensionSettings::Callback* callback) {
+  std::map<std::string, ExtensionSettingsStorage*>::iterator existing =
+      storage_objs_.find(extension_id);
+  if (existing == storage_objs_.end()) {
+    // No existing storage.
+    return false;
+  }
+  // Existing storage.  Reply with that.
+  ExtensionSettingsStorage* storage = existing->second;
+  DCHECK(storage != NULL);
+  (new GetExistingStorageClosure(callback, storage))->Run();
+  return true;
+}