Added DeleteOriginData to QuotaClient

webkit/fileapi/sandbox_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 "webkit/fileapi/sandbox_quota_client.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/file_path.h"
@@ skipping 166 matching lines @@
 
   virtual void Completed() OVERRIDE {
     quota_client()->DidGetOriginsForHost(std::make_pair(type(), host_),
                                          origins());
   }
 
  private:
   std::string host_;
 };
 
+class SandboxQuotaClient::DeleteOriginTask
+    : public QuotaThreadTask {
+ public:
+  DeleteOriginTask(
+      SandboxQuotaClient* quota_client,
+      scoped_refptr<MessageLoopProxy> file_message_loop,
+      const GURL& origin,
+      FileSystemType type,
+      DeletionCallback* callback)
+      : QuotaThreadTask(quota_client, file_message_loop),
+        file_system_context_(quota_client->file_system_context_),
+        origin_(origin),
+        type_(type),
+        status_(quota::kQuotaStatusUnknown),
+        callback_(callback) {
+  }
+
+  virtual ~DeleteOriginTask() {}
+
+  virtual void RunOnTargetThread() OVERRIDE {
+    if (file_system_context_->
+            DeleteDataForOriginAndTypeOnFileThread(origin_, type_))
+      status_ = quota::kQuotaStatusOk;
+    else
+      status_ = quota::kQuotaErrorInvalidModification;
+  }
+
+  virtual void Completed() OVERRIDE {
+    callback_->Run(status_);
+  }
+ private:
+  FileSystemContext* file_system_context_;
+  GURL origin_;
+  FileSystemType type_;
+  quota::QuotaStatusCode status_;
+  scoped_ptr<DeletionCallback> callback_;
+};
+
 SandboxQuotaClient::SandboxQuotaClient(
     scoped_refptr<base::MessageLoopProxy> file_message_loop,
     FileSystemContext* file_system_context,
     bool is_incognito)
     : file_message_loop_(file_message_loop),
       file_system_context_(file_system_context),
       is_incognito_(is_incognito) {
   DCHECK(file_message_loop);
 }
 
@@ skipping 62 matching lines @@
 
   if (pending_origins_for_host_callbacks_.Add(
           std::make_pair(type, host), callback.release())) {
     scoped_refptr<GetOriginsForHostTask> task(
         new GetOriginsForHostTask(this, file_message_loop_,
                                   type, host));
     task->Start();
   }
 }
 
+void SandboxQuotaClient::DeleteOriginData(const GURL& origin,
+                                          StorageType type,
+                                          DeletionCallback* callback) {
+  FileSystemType fs_type = QuotaStorageTypeToFileSystemType(type);
+  DCHECK(fs_type != kFileSystemTypeUnknown);
+  scoped_refptr<DeleteOriginTask> task(
+      new DeleteOriginTask(this, file_message_loop_,
+                           origin, fs_type, callback));
+  task->Start();
+}
+
 void SandboxQuotaClient::DidGetOriginUsage(
     FileSystemType type, const GURL& origin_url, int64 usage) {
   visited_origins_.insert(origin_url);
   TypeAndHostOrOrigin type_and_origin(std::make_pair(
       type, origin_url.spec()));
   DCHECK(pending_usage_callbacks_.HasCallbacks(type_and_origin));
   pending_usage_callbacks_.Run(type_and_origin, usage);
 }
 
 void SandboxQuotaClient::DidGetOriginsForType(
     FileSystemType type, const std::set<GURL>& origins) {
   DCHECK(pending_origins_for_type_callbacks_.HasCallbacks(type));
   pending_origins_for_type_callbacks_.Run(type, origins);
 }
 
 void SandboxQuotaClient::DidGetOriginsForHost(
     const TypeAndHostOrOrigin& type_and_host, const std::set<GURL>& origins) {
   DCHECK(pending_origins_for_host_callbacks_.HasCallbacks(type_and_host));
   pending_origins_for_host_callbacks_.Run(type_and_host, origins);
 }
 
 }  // namespace fileapi