Improve IndexedDB's quota support

content/browser/in_process_webkit/indexed_db_quota_client.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 "content/browser/in_process_webkit/indexed_db_quota_client.h"
 
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
@@ skipping 13 matching lines @@
       IndexedDBQuotaClient* client,
       base::MessageLoopProxy* webkit_thread_message_loop)
       : QuotaThreadTask(client, webkit_thread_message_loop),
         client_(client), indexed_db_context_(client->indexed_db_context_) {
   }
 
   IndexedDBQuotaClient* client_;
   scoped_refptr<IndexedDBContext> indexed_db_context_;
 };
 
+class IndexedDBQuotaClient::DeleteOriginTask : public HelperTask {
+ public:
+  DeleteOriginTask(IndexedDBQuotaClient* client,
+                   base::MessageLoopProxy* webkit_thread_message_loop,
+                   const GURL& origin_url,
+                   DeletionCallback* callback)
+      : HelperTask(client, webkit_thread_message_loop),
+        origin_url_(origin_url), callback_(callback) {
+  }
+ private:
+  virtual void RunOnTargetThread() OVERRIDE {
+    string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url_);
+    indexed_db_context_->EvictOrigin(origin_id);
+  }
+  virtual void Completed() OVERRIDE {
+    callback_->Run(quota::kQuotaStatusOk);
+  }
+  GURL origin_url_;
+  scoped_ptr<DeletionCallback> callback_;

[michaeln, 2011/07/27 01:31:35]

It would be good to ensure that this callback object got deleted on the IO
thread. Calling .reset() in Completed() and in an Aborted() OVERRIDE should take
care of that.

+};
+
 class IndexedDBQuotaClient::GetOriginUsageTask : public HelperTask {
  public:
   GetOriginUsageTask(
       IndexedDBQuotaClient* client,
       base::MessageLoopProxy* webkit_thread_message_loop,
       const GURL& origin_url)
       : HelperTask(client, webkit_thread_message_loop),
         origin_url_(origin_url), usage_(0) {
   }
 
@@ skipping 151 matching lines @@
   if (origins_for_host_callbacks_.Add(host, callback.release())) {
     scoped_refptr<GetOriginsForHostTask> task(
         new GetOriginsForHostTask(this, webkit_thread_message_loop_, host));
     task->Start();
   }
 }
 
 void IndexedDBQuotaClient::DeleteOriginData(const GURL& origin,
                                            quota::StorageType type,
                                            DeletionCallback* callback) {
-  // TODO(tzik): implement me
-  callback->Run(quota::kQuotaErrorNotSupported);
-  delete callback;
+  // DeleteOriginData is only called on origins that are not in use, so we can
+  // safely delete them here.

[dgrogan, 2011/07/26 02:02:16]

Kinuko, can you confirm that this is true?

[kinuko, 2011/07/26 06:35:28]

It's half true-- it won't be called while it is in use for eviction, but after
we make a change like this BrowsingDataDeleter will also be calling this one,
which might be kicked by UI action.
http://codereview.chromium.org/7129018/

...or the manager could avoid calling this whenever the origin is in use.  Maybe
we should do that?

[dgrogan, 2011/07/26 17:46:15]

That would be great for IDB.

[michaeln, 2011/07/27 01:31:35]

I think we want to support deleting resources while they are in use. If a user
gestures to delete all in the browsing data remover ui, we don't want to put up
an alert that says "not all data could be deleted, close some tabs and try
again".

What happens in the appcache and sqldb case is that pages using the deleted
resources get errors when trying to subsquently access the deleted resources.
I'm not sure what happens in the case of the filesystem?

[kinuko, 2011/07/27 10:09:20]

Currently the filesystem impl doesn't fully support deletion-in-use cases.  It
was in my TODO list but somehow has been forgotten.  I'll file a bug if we're
going along this direction.
(We'd stop accepting new operations, cancel ongoing writes and delete data after
all the inflight operations are done.)

[dgrogan, 2011/07/27 22:56:01]

Sorry, I only meant it would be great for IDB because we don't currently support
delete-in-use and we would have to scramble if we had to support it in the next
week or two.

So I guess we need to figure out if and when we want FileAPI and IndexedDB to
handle delete-in-use?

+  if (type != quota::kStorageTypeTemporary) {
+    callback->Run(quota::kQuotaErrorNotSupported);
+    return;
+  }
+  scoped_refptr<DeleteOriginTask> task(
+      new DeleteOriginTask(this,
+                           webkit_thread_message_loop_,
+                           origin,
+                           callback));
+  task->Start();
 }
 
 void IndexedDBQuotaClient::DidGetOriginUsage(
     const GURL& origin_url, int64 usage) {
   DCHECK(usage_for_origin_callbacks_.HasCallbacks(origin_url));
   usage_for_origin_callbacks_.Run(origin_url, usage);
 }
 
 void IndexedDBQuotaClient::DidGetAllOrigins(const std::set<GURL>& origins) {
   DCHECK(origins_for_type_callbacks_.HasCallbacks());
   origins_for_type_callbacks_.Run(origins);
 }
 
 void IndexedDBQuotaClient::DidGetOriginsForHost(
     const std::string& host, const std::set<GURL>& origins) {
   DCHECK(origins_for_host_callbacks_.HasCallbacks(host));
   origins_for_host_callbacks_.Run(host, origins);
 }