Implement WebStorage API methods

android_webview/native/aw_quota_manager_bridge.h

Index: android_webview/native/aw_quota_manager_bridge.h
diff --git a/android_webview/native/aw_quota_manager_bridge.h b/android_webview/native/aw_quota_manager_bridge.h
new file mode 100644
index 0000000000000000000000000000000000000000..d83161e3b964fa0ef68f282a8a8fefce5fe146b3
--- /dev/null
+++ b/android_webview/native/aw_quota_manager_bridge.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2013 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.
+
+#ifndef ANDROID_WEBVIEW_NATIVE_AW_QUOTA_MANAGER_BRIDGE_H_
+#define ANDROID_WEBVIEW_NATIVE_AW_QUOTA_MANAGER_BRIDGE_H_
+
+#include <jni.h>
+#include <set>
+#include <vector>
+#include <string>
+
+#include "base/android/jni_helper.h"
+#include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "webkit/quota/quota_types.h"
+
+class GURL;
+
+namespace content {
+class StoragePartition;
+}
+
+namespace quota {
+class QuotaManager;
+}  // namespace quota
+
+namespace android_webview {
+
+class AwBrowserContext;
+class AwQuotaManagerBridge;
+
+namespace internal {
+
+class IOThreadSwitcher : public base::RefCountedThreadSafe<IOThreadSwitcher> {

[mkosiba (inactive), 2013/02/19 11:37:13]

this is a bit nasty. I get that you need to spill out the implementation because
you're using scoped_refptr but maybe, as a form of damage control, you could
only declare the public interface in the header (and have an Impl class in the
.cc file)?

Looking at this a bit more I don't quite see why do you need a scoped_refptr to
this switcher but end newing up the other switcher on the spot - please be
consistent.

[boliu, 2013/02/19 17:03:21]

Me and my micro/premature optimizations.

I thought all the calls would map directly to one function in QuotaManager, so
there'd be no state so I though, why not just new up one of these which lead to
this. Then realized can't use QuotaManager::GetUsageInfo since it doesn't return
quota info so GetOrigins will need get a list of origins and query each
individually, so need to remember state, and thus the other switcher.

Also switcher is a horrible name...

I'll think of something.

[boliu, 2013/02/20 00:53:50]

Through the magic of base::Bind, this class is gone!

+ public:
+  IOThreadSwitcher(const base::WeakPtr<AwQuotaManagerBridge>& bridge);

[mkosiba (inactive), 2013/02/19 11:37:13]

to be honest I think this class and the other switcher deserve their own .h and
.cc file and a slighlty better interface. It seems to me you're trying to create
a subset of the QuotaManager interface that works on the UI thread. Maybe merge
the two switchers and call them QuotaManagerThreadAdapter (or something) and
have the interface mimic the QuotaManager more closely? You want to aim for the
QuotaManagerBridge to not have to do any Post calls.

[boliu, 2013/02/19 17:03:21]

Just found base::PostTaskAndReplyWithResult. There is also
media::base::BindToLoop which I wish is in base right now...

+
+  void DeleteAllDataOnIOThread();

[mkosiba (inactive), 2013/02/19 11:37:13]

Looks like all of the methods are OnIOThread, maybe ditch the suffix since the
class name sort of implies this happens on the IO Thread anyway.

+  void DeleteOriginOnIOThread(const GURL& origin);
+  void GetQuotaForOriginOnIOThread(const GURL& origin, int jcallback_id);
+  void GetUsageForOriginOnIOThread(const GURL& origin, int jcallback_id);
+
+ private:
+  friend class base::RefCountedThreadSafe<IOThreadSwitcher>;
+  ~IOThreadSwitcher();
+
+  void DeleteOrigins(const std::set<GURL>& origins, quota::StorageType type);
+
+  void GetQuotaForOriginCallback(int jcallback_id,
+                                 quota::QuotaStatusCode status_code,
+                                 int64 usage,
+                                 int64 quota);
+  void GetUsageForOriginCallback(int jcallback_id,
+                                 quota::QuotaStatusCode status_code,
+                                 int64 usage,
+                                 int64 quota);
+
+  void GetQuotaForOriginCallbackOnUiThread(int jcallback_id, int64 quota);
+  void GetUsageForOriginCallbackOnUiThread(int jcallback_id, int64 usage);
+
+  base::WeakPtr<AwQuotaManagerBridge> bridge_;
+  quota::QuotaManager* quota_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(IOThreadSwitcher);
+};
+
+}  // namespace internal
+
+class AwQuotaManagerBridge
+    : public base::SupportsWeakPtr<AwQuotaManagerBridge> {
+ public:
+  static AwQuotaManagerBridge* Create(AwBrowserContext* browser_context);
+
+  void Init(JNIEnv* env, jobject object);
+  void DeleteAllData(JNIEnv* env, jobject object);
+  void DeleteOrigin(JNIEnv* env, jobject object, jstring origin);
+  void GetOrigins(JNIEnv* env, jobject object, jint callback_id);
+  void GetQuotaForOrigin(JNIEnv* env,
+                         jobject object,
+                         jstring origin,
+                         jint callback_id);
+  void GetUsageForOrigin(JNIEnv* env,
+                         jobject object,
+                         jstring origin,
+                         jint callback_id);
+
+  // Used by the IOThreadSwitchers.
+  quota::QuotaManager* GetQuotaManager() const;
+  void GetOriginsCallback(
+      int jcallback_id,
+      const std::vector<std::string>& origin,
+      const std::vector<int64>& quota,
+      const std::vector<int64>& usage);
+  void GetQuotaForOriginCallback(int jcallback_id, int64 quota);
+  void GetUsageForOriginCallback(int jcallback_id, int64 usage);
+
+ private:
+  AwQuotaManagerBridge(AwBrowserContext* browser_context);
+
+  JavaObjectWeakGlobalRef java_ref_;
+  AwBrowserContext* browser_context_;
+  scoped_refptr<internal::IOThreadSwitcher> io_thread_switcher_;
+  DISALLOW_COPY_AND_ASSIGN(AwQuotaManagerBridge);
+};
+
+bool RegisterAwQuotaManagerBridge(JNIEnv* env);
+
+}  // namespace android_webview
+
+#endif  // ANDROID_WEBVIEW_NATIVE_AW_QUOTA_MANAGER_BRIDGE_H_