Implement WebStorage API methods

android_webview/native/aw_quota_manager_bridge_impl.cc

+// 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.
+
+#include "android_webview/native/aw_quota_manager_bridge_impl.h"
+
+#include <set>
+
+#include "android_webview/browser/aw_browser_context.h"
+#include "android_webview/browser/aw_content_browser_client.h"
+#include "base/android/jni_array.h"
+#include "base/android/jni_string.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/storage_partition.h"
+#include "content/public/common/content_client.h"
+#include "googleurl/src/gurl.h"
+#include "jni/AwQuotaManagerBridge_jni.h"
+#include "webkit/quota/quota_manager.h"
+#include "webkit/quota/quota_types.h"
+
+using base::android::AttachCurrentThread;
+using content::BrowserThread;
+using content::StoragePartition;
+using quota::QuotaClient;
+using quota::QuotaManager;
+
+namespace android_webview {
+
+namespace {

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

The anonymous namespace is split into 3 pieces in this file to kind of group
code logically.

+
+class GetOriginsTask : public base::RefCountedThreadSafe<GetOriginsTask> {

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

This could be moved to a separate h/cc file, but should sit inside another
internal namespace.

+ public:
+  GetOriginsTask(
+      const AwQuotaManagerBridgeImpl::GetOriginsCallback& callback,
+      const scoped_refptr<QuotaManager>& quota_manager);
+
+  void Run();
+
+ private:
+  friend class base::RefCountedThreadSafe<GetOriginsTask>;
+  ~GetOriginsTask();
+
+  void OnOriginsObtained(const std::set<GURL>& origins,
+                         quota::StorageType type);
+
+  void OnUsageAndQuotaObtained(const GURL& origin,
+                               quota::QuotaStatusCode status_code,
+                               int64 usage,
+                               int64 quota);
+
+  void CheckDone();
+  void DoneOnUIThread();
+
+  AwQuotaManagerBridgeImpl::GetOriginsCallback ui_callback_;
+  scoped_refptr<QuotaManager> quota_manager_;
+
+  std::vector<std::string> origin_;
+  std::vector<int64> usage_;
+  std::vector<int64> quota_;
+
+  size_t num_callbacks_to_wait_;
+  size_t num_callbacks_received_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetOriginsTask);
+};
+
+GetOriginsTask::GetOriginsTask(
+    const AwQuotaManagerBridgeImpl::GetOriginsCallback& callback,
+    const scoped_refptr<QuotaManager>& quota_manager)
+    : ui_callback_(callback),
+      quota_manager_(quota_manager) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+}
+
+GetOriginsTask::~GetOriginsTask() {}
+
+void GetOriginsTask::Run() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&QuotaManager::GetOriginsModifiedSince,
+                 quota_manager_,
+                 quota::kStorageTypeTemporary,
+                 base::Time()  /* Since beginning of time. */,
+                 base::Bind(&GetOriginsTask::OnOriginsObtained, this)));
+}
+
+void GetOriginsTask::OnOriginsObtained(
+    const std::set<GURL>& origins, quota::StorageType type) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  num_callbacks_to_wait_ = origins.size();
+  num_callbacks_received_ = 0u;
+
+  for (std::set<GURL>::const_iterator origin = origins.begin();
+       origin != origins.end();
+       ++origin) {
+    quota_manager_->GetUsageAndQuota(
+        *origin,
+        type,
+        base::Bind(&GetOriginsTask::OnUsageAndQuotaObtained, this, *origin));
+  }
+
+  CheckDone();
+}
+
+void GetOriginsTask::OnUsageAndQuotaObtained(const GURL& origin,
+                                             quota::QuotaStatusCode status_code,
+                                             int64 usage,
+                                             int64 quota) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (status_code == quota::kQuotaStatusOk) {
+    origin_.push_back(origin.spec());
+    usage_.push_back(usage);
+    quota_.push_back(quota);
+  }
+
+  ++num_callbacks_received_;
+  CheckDone();
+}
+
+void GetOriginsTask::CheckDone() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (num_callbacks_received_ == num_callbacks_to_wait_) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&GetOriginsTask::DoneOnUIThread, this));
+  } else if (num_callbacks_received_ > num_callbacks_to_wait_) {
+    NOTREACHED();
+  }
+}
+
+void GetOriginsTask::DoneOnUIThread() {

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

This and RunGetUsageAndQuotaCallback below can be removed if
media::base::BindToLoop is moved to base.

+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ui_callback_.Run(origin_, usage_, quota_);
+}
+
+}  // namespace
+
+
+// static
+jint GetDefaultNativeAwQuotaManagerBridge(JNIEnv* env, jclass clazz) {
+  content::ContentBrowserClient* browser_client =
+      content::GetContentClient()->browser();
+  DCHECK(browser_client);
+
+  AwContentBrowserClient* aw_browser_client =
+      AwContentBrowserClient::FromContentBrowserClient(browser_client);
+  AwBrowserContext* browser_context = aw_browser_client->GetAwBrowserContext();
+  DCHECK(browser_context);
+
+  AwQuotaManagerBridgeImpl* bridge = static_cast<AwQuotaManagerBridgeImpl*>(
+      browser_context->GetQuotaManagerBridge());
+  DCHECK(bridge);
+  return reinterpret_cast<jint>(bridge);
+}
+
+AwQuotaManagerBridgeImpl::AwQuotaManagerBridgeImpl(
+    AwBrowserContext* browser_context)
+    : weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      browser_context_(browser_context) {
+}
+
+void AwQuotaManagerBridgeImpl::Init(JNIEnv* env, jobject object) {
+  java_ref_ = JavaObjectWeakGlobalRef(env, object);
+}
+
+scoped_refptr<QuotaManager>AwQuotaManagerBridgeImpl::GetQuotaManager() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // AndroidWebview does not use per-site storage partitions.
+  // TODO(boliu): Get @ajwong to review this before submit.
+  StoragePartition* storage_partition =
+      content::BrowserContext::GetStoragePartitionForSite(
+          browser_context_, GURL());
+  DCHECK(storage_partition);
+
+  QuotaManager* quota_manager = storage_partition->GetQuotaManager();

[mkosiba (inactive), 2013/02/20 12:21:38]

This bit me a couple of times so just double-checking with you.
Normally, if the object needs to be interacted with on the IO thread, you need
to get the instance on the IO thread too. I'm assuming that storage_partition is
UI-thread safe and the only thing it does with the QuotaManager is hold a
pointer to it (and create it? But then QuotaManager would be constructed on the
UI thread...)

[boliu, 2013/02/20 20:14:16]

Good point.

First, BrowsingDataRemover::RemoveImpl calls this on the UI thread. Also
StoragePartitionImpl and its corresponding QuotaManager is created in
StoragePartitionImpl::Create, which is run on the UI thread (apparently it's
even allowed to be called before message loops are started).

So, I'm safe by accident :)

+  DCHECK(quota_manager);
+  return make_scoped_refptr(quota_manager);
+}
+
+namespace {
+
+// TODO(boliu): Does this create a static initializer?
+int ALL_CLIENT_MASK = QuotaClient::kFileSystem |

[joth, 2013/02/20 19:49:33]

you should make it const.

also, I think the kFoo style is preferred (modulo where we're sharing constant
across c++ & java) so I'd be tempted to use that here, given the individual
consts are kStyle.

although, I see kAllClientsMask already declared in
https://code.google.com/p/chromium/codesearch#chromium/src/webkit/quota/quota...

why not using that? as you have it, you'd need to remember to update this too.
(is that this intent? if so, should probably comment it)

[boliu, 2013/02/20 20:14:16]

In the documentation for QuotaManager::DeleteOriginData: "Setting the mask to
QuotaClient::kAllClientsMask will remove all clients from the origin, regardless
of type." We only want to remove temporary type, not all types.

Added a comment.

[mnaganov (inactive), 2013/02/20 21:54:34]

I think we are misinterpreting the comment, as looking at the actual code, there
is nothing special being done to the type specified for the kAllClientsMask
case. The type is always being passed down to quota manager clients.

[boliu, 2013/02/20 22:26:26]

You are right. It's a confusing comment. And I learned that enums are basically
unsigned so two's compliment makes -1 equivalent to 0xffff... the all inclusive
mask, no cast required!

+                      QuotaClient::kDatabase |
+                      QuotaClient::kAppcache |

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

Mikhail: You've implemented some app cache methods. Is it cleared in a different
path? Should the quota here include app cache as well (If not, then need to
rewrite the QuotaManager api to add this flag, if possible...)

Joth: Know if this will create a static initializer? I've never disassembled
anything so wouldn't know where to check.

[mnaganov (inactive), 2013/02/20 09:29:03]

I wasn't doing anything for clearing Appcache. It should be handled together
with other OWP storage types, so your code is correct. In the legacy
implementation, Appcache should be cleared by WebStorage.deleteOrigin.
 
Sorry for intervening. The values of these constants are known at compile time,
so this shouldn't create static a initializer. See
https://docs.google.com/a/google.com/document/d/1Zk9JZR3z1L7LMXbd05tj04rClYcu...

[As a sanity check, you can try creating an enum with this value, and the code
just wouldn't compile if the operands values can't be determined at compile
time]

[joth, 2013/02/20 19:49:33]

That's a neat trick! Nice.

[boliu, 2013/02/20 20:14:16]

The enum test failed with:
error: 'android_webview::(anonymous namespace)::ALL_CLIENT_MASK' cannot appear
in a constant-expression

I'll take that as there *is* a static initializer. So made this into an
anonymous function instead.

[mnaganov (inactive), 2013/02/20 21:54:34]

Sorry, are you trying to write "enum { X = ALL_CLIENT_MASK }"? This will not
work unless you declare ALL_CLIENT_MASK as a "const int" (and maybe even in that
case, I'm not sure).

What I meant was trying to write "enum { ALL_CLIENT_MASK =
QuotaClient::kFileSystem | ... }"

[boliu, 2013/02/20 22:26:26]

And you are right again. I did it the first way. The second way does indeed
compile. But now I don't need it anymore :)

+                      QuotaClient::kIndexedDatabase;
+
+void IgnoreStatus(quota::QuotaStatusCode status_code) {}
+
+void DeleteOrigins(

[mkosiba (inactive), 2013/02/20 12:21:38]

nit2: it would also be nice if the name indicated it's "dedicated" for being
invoked from the AwQuotaManagerBridgeImpl::DeleteAllData method. 

DeleteOriginDataWorker or DeleteAllOriginDataWorker?

[boliu, 2013/02/20 20:14:16]

Don't like "Worker" moniker for a function. Changed to DeleteAllOriginData.

+    const scoped_refptr<QuotaManager>& quota_manager,
+    const std::set<GURL>& origins,
+    quota::StorageType type) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // TODO(boliu): Maybe not spam the db thread?
+  for (std::set<GURL>::const_iterator origin = origins.begin();
+       origin != origins.end();
+       ++origin) {
+    quota_manager->DeleteOriginData(*origin,
+                                    type,
+                                    ALL_CLIENT_MASK,
+                                    base::Bind(&IgnoreStatus));
+  }
+}
+
+}  // namespace
+
+void AwQuotaManagerBridgeImpl::DeleteAllData(JNIEnv* env, jobject object) {

[mkosiba (inactive), 2013/02/20 12:21:38]

nit: still think this should match the quota manager API more closely
(DeleteOriginData or DeleteAllOriginData).

[boliu, 2013/02/20 20:14:16]

So these names match the public java WebStorage api. Not all of those methods
map directly to QuotaManager, and this is an example, so I'm inclined to stick
with the java name all these methods.

[mkosiba (inactive), 2013/02/21 11:38:30]

ah, OK.

+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  scoped_refptr<quota::QuotaManager> quota_manager = GetQuotaManager();
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&QuotaManager::GetOriginsModifiedSince,
+                 quota_manager,
+                 quota::kStorageTypeTemporary,
+                 base::Time()  /* Since beginning of time. */,
+                 base::Bind(&DeleteOrigins, quota_manager)));
+}
+
+void AwQuotaManagerBridgeImpl::DeleteOrigin(

[mkosiba (inactive), 2013/02/20 12:21:38]

same nit: DeleteOriginData

+    JNIEnv* env, jobject object, jstring origin) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&QuotaManager::DeleteOriginData,
+                 GetQuotaManager(),
+                 GURL(base::android::ConvertJavaStringToUTF16(env, origin)),
+                 quota::kStorageTypeTemporary,
+                 ALL_CLIENT_MASK,
+                 base::Bind(&IgnoreStatus)));
+}
+
+void AwQuotaManagerBridgeImpl::GetOrigins(
+    JNIEnv* env, jobject object, jint callback_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  const GetOriginsCallback ui_callback = base::Bind(
+      &AwQuotaManagerBridgeImpl::GetOriginsCallbackImpl,
+      weak_factory_.GetWeakPtr(),
+      callback_id);
+
+  (new GetOriginsTask(ui_callback, GetQuotaManager()))->Run();
+}
+
+void AwQuotaManagerBridgeImpl::GetOriginsCallbackImpl(
+    int jcallback_id,
+    const std::vector<std::string>& origin,
+    const std::vector<int64>& usage,
+    const std::vector<int64>& quota) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
+  if (obj.is_null())
+    return;
+
+  Java_AwQuotaManagerBridge_onGetOriginsCallback(
+      env,
+      obj.obj(),
+      jcallback_id,
+      base::android::ToJavaArrayOfStrings(env, origin).obj(),
+      base::android::ToJavaLongArray(env, usage.begin(), usage.size()).obj(),
+      base::android::ToJavaLongArray(env, quota.begin(), quota.size()).obj());
+}
+
+namespace {
+
+void RunGetUsageAndQuotaCallback(
+    const AwQuotaManagerBridgeImpl::QuotaUsageCallback& ui_callback,
+    int64 usage,
+    int64 quota) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ui_callback.Run(usage, quota);
+}
+
+void OnUsageAndQuotaObtained(
+    const AwQuotaManagerBridgeImpl::QuotaUsageCallback& ui_callback,
+    quota::QuotaStatusCode status_code,
+    int64 usage,
+    int64 quota) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (status_code != quota::kQuotaStatusOk) {
+    // Indicate error. TODO(boliu): Check this does not mean infinite.
+    usage = -1;
+    quota = -1;
+  }
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&RunGetUsageAndQuotaCallback,
+                 ui_callback,
+                 usage,
+                 quota));
+}
+
+} // namespace
+
+void AwQuotaManagerBridgeImpl::GetUsageAndQuotaForOrigin(
+    JNIEnv* env, jobject object,
+    jstring origin,
+    jint callback_id,
+    bool is_quota) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const QuotaUsageCallback ui_callback = base::Bind(
+      &AwQuotaManagerBridgeImpl::QuotaUsageCallbackImpl,
+      weak_factory_.GetWeakPtr(),
+      callback_id,
+      is_quota);
+
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&QuotaManager::GetUsageAndQuota,
+                 GetQuotaManager(),
+                 GURL(base::android::ConvertJavaStringToUTF16(env, origin)),
+                 quota::kStorageTypeTemporary,
+                 base::Bind(&OnUsageAndQuotaObtained, ui_callback)));
+}
+
+void AwQuotaManagerBridgeImpl::QuotaUsageCallbackImpl(
+    int jcallback_id, bool is_quota, int64 usage, int64 quota) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
+  if (obj.is_null())
+    return;
+
+  Java_AwQuotaManagerBridge_onGetUsageAndQuotaForOriginCallback(
+      env, obj.obj(), jcallback_id, is_quota, usage, quota);
+}
+
+bool RegisterAwQuotaManagerBridge(JNIEnv* env) {
+  return RegisterNativesImpl(env) >= 0;
+}
+
+}  // namespace android_webview