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 {
+    indexed_db_context_->EvictOrigin(origin_url_);
+  }
+  virtual void Completed() OVERRIDE {
+    callback_->Run(quota::kQuotaStatusOk);
+  }
+  GURL origin_url_;
+  scoped_ptr<DeletionCallback> callback_;
+};
+
 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) {
   }
 
  private:
   virtual void RunOnTargetThread() OVERRIDE {
-    string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url_);
-    FilePath file_path = indexed_db_context_->GetIndexedDBFilePath(origin_id);
-    usage_ = 0;
-    usage_ = file_util::ComputeDirectorySize(file_path);
+    usage_ = indexed_db_context_->InitializeDiskUsage(origin_url_);
   }
   virtual void Completed() OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     client_->DidGetOriginUsage(origin_url_, usage_);
   }
   GURL origin_url_;
   int64 usage_;
 };
 
 class IndexedDBQuotaClient::GetOriginsTaskBase : public HelperTask {
  protected:
   GetOriginsTaskBase(
       IndexedDBQuotaClient* client,
@@ skipping 133 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.
+  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);
 }