Implement DatabaseQuotaClient's DeteleteOriginData method.

webkit/database/database_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/database/database_quota_client.h"
 
 #include <vector>
 
 #include "base/message_loop_proxy.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "webkit/database/database_tracker.h"
 #include "webkit/database/database_util.h"
 
 using quota::QuotaClient;
 
 namespace webkit_database {
 
 // Helper tasks ---------------------------------------------------------------
 
 class DatabaseQuotaClient::HelperTask : public quota::QuotaThreadTask {
  protected:
   HelperTask(
       DatabaseQuotaClient* client,
-      scoped_refptr<base::MessageLoopProxy> db_tracker_thread)
+      base::MessageLoopProxy* db_tracker_thread)
       : QuotaThreadTask(client, db_tracker_thread),
         client_(client), db_tracker_(client->db_tracker_) {
   }
 
   DatabaseQuotaClient* client_;
   scoped_refptr<DatabaseTracker> db_tracker_;
 };
 
 class DatabaseQuotaClient::GetOriginUsageTask : public HelperTask {
  public:
   GetOriginUsageTask(
       DatabaseQuotaClient* client,
-      scoped_refptr<base::MessageLoopProxy> db_tracker_thread,
+      base::MessageLoopProxy* db_tracker_thread,
       const GURL& origin_url)
       : HelperTask(client, db_tracker_thread),
         origin_url_(origin_url), usage_(0) {
   }
 
  private:
   virtual void RunOnTargetThread() OVERRIDE {
     OriginInfo info;
     if (db_tracker_->GetOriginInfo(
             DatabaseUtil::GetOriginIdentifier(origin_url_),
             &info)) {
       usage_ = info.TotalSize();
     }
   }
   virtual void Completed() OVERRIDE {
     client_->DidGetOriginUsage(origin_url_, usage_);
   }
   GURL origin_url_;
   int64 usage_;
 };
 
 class DatabaseQuotaClient::GetOriginsTaskBase : public HelperTask {
  protected:
   GetOriginsTaskBase(
       DatabaseQuotaClient* client,
-      scoped_refptr<base::MessageLoopProxy> db_tracker_thread)
+      base::MessageLoopProxy* db_tracker_thread)
       : HelperTask(client, db_tracker_thread) {
   }
 
   virtual bool ShouldAddOrigin(const GURL& origin) = 0;
 
   virtual void RunOnTargetThread() OVERRIDE {
     std::vector<string16> origin_identifiers;
     if (db_tracker_->GetAllOriginIdentifiers(&origin_identifiers)) {
       for (std::vector<string16>::const_iterator iter =
                origin_identifiers.begin();
            iter != origin_identifiers.end(); ++iter) {
         GURL origin = DatabaseUtil::GetOriginFromIdentifier(*iter);
         if (ShouldAddOrigin(origin))
           origins_.insert(origin);
       }
     }
   }
 
   std::set<GURL> origins_;
 };
 
 class DatabaseQuotaClient::GetAllOriginsTask : public GetOriginsTaskBase {
  public:
   GetAllOriginsTask(
       DatabaseQuotaClient* client,
-      scoped_refptr<base::MessageLoopProxy> db_tracker_thread)
+      base::MessageLoopProxy* db_tracker_thread)
       : GetOriginsTaskBase(client, db_tracker_thread) {
   }
 
  protected:
   virtual bool ShouldAddOrigin(const GURL& origin) OVERRIDE {
     return true;
   }
   virtual void Completed() OVERRIDE {
     client_->DidGetAllOrigins(origins_);
   }
 };
 
 class DatabaseQuotaClient::GetOriginsForHostTask : public GetOriginsTaskBase {
  public:
   GetOriginsForHostTask(
       DatabaseQuotaClient* client,
-      scoped_refptr<base::MessageLoopProxy> db_tracker_thread,
+      base::MessageLoopProxy* db_tracker_thread,
       const std::string& host)
       : GetOriginsTaskBase(client, db_tracker_thread),
         host_(host) {
   }
 
  private:
   virtual bool ShouldAddOrigin(const GURL& origin) OVERRIDE {
     return host_ == net::GetHostOrSpecFromURL(origin);
   }
   virtual void Completed() OVERRIDE {
     client_->DidGetOriginsForHost(host_, origins_);
   }
   std::string host_;
 };
 
+class DatabaseQuotaClient::DeleteOriginTask : public HelperTask {
+ public:
+  DeleteOriginTask(
+      DatabaseQuotaClient* client,
+      base::MessageLoopProxy* db_tracker_thread,
+      const GURL& origin_url,
+      DeletionCallback* caller_callback)
+      : HelperTask(client, db_tracker_thread),
+        origin_url_(origin_url),
+        result_(quota::kQuotaStatusUnknown),
+        is_complete_(false),
+        caller_callback_(caller_callback),
+        ALLOW_THIS_IN_INITIALIZER_LIST(completion_callback_(
+            this, &DeleteOriginTask::OnCompletionCallback)) {
+  }
+
+ private:
+  virtual void Completed() OVERRIDE {
+    if (!is_complete_ || !caller_callback_.get())
+      return;  // not done yet or we were aborted
+    caller_callback_->Run(result_);
+    caller_callback_.reset();
+  }
+
+  virtual void Aborted() OVERRIDE {
+    caller_callback_.reset();  // should i call it with the ABORT status code?

[kinuko, 2011/05/20 02:13:24]

If we could assume this task wouldn't be aborted except for when client gets
deleted just resetting it should be fine (as we don't do that in fs quota client
either).

[michaeln, 2011/05/20 05:14:23]

keeping parity with the fsclient is good, so long as this is ok with the caller,
which i think is since clients stay around until the end.

+  }
+
+  virtual void RunOnTargetThread() OVERRIDE {
+    AddRef();  // balanced in CompletionCallback
+
+    string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url_);
+    OriginInfo info;
+    if (!db_tracker_->GetOriginInfo(origin_id, &info)) {
+      OnCompletionCallback(net::OK);
+      return;
+    }
+
+    int rv = db_tracker_->DeleteDataForOrigin(origin_id, &completion_callback_);
+    if (rv == net::ERR_IO_PENDING)
+      return;  // we wait for the callback
+
+    OnCompletionCallback(rv);
+  }
+
+  void OnCompletionCallback(int rv) {
+    is_complete_ = true;
+    if (rv == net::OK)
+      result_ = quota::kQuotaStatusOk;
+    original_message_loop()->PostTask(
+        FROM_HERE, NewRunnableMethod(this, &DeleteOriginTask::Completed));
+    Release();
+  }
+
+  const GURL origin_url_;
+  quota::QuotaStatusCode result_;
+  bool is_complete_;
+  scoped_ptr<DeletionCallback> caller_callback_;
+  net::CompletionCallbackImpl<DeleteOriginTask> completion_callback_;
+};
+
 // DatabaseQuotaClient --------------------------------------------------------
 
 DatabaseQuotaClient::DatabaseQuotaClient(
     base::MessageLoopProxy* db_tracker_thread,
     DatabaseTracker* db_tracker)
     : db_tracker_thread_(db_tracker_thread), db_tracker_(db_tracker) {
 }
 
 DatabaseQuotaClient::~DatabaseQuotaClient() {
 }
@@ skipping 63 matching lines @@
 
   if (origins_for_host_callbacks_.Add(host, callback.release())) {
     scoped_refptr<GetOriginsForHostTask> task(
         new GetOriginsForHostTask(this, db_tracker_thread_, host));
     task->Start();
   }
 }
 
 void DatabaseQuotaClient::DeleteOriginData(const GURL& origin,
                                            quota::StorageType type,
-                                           DeletionCallback* callback) {
-  // TODO(tzik): implement me
-  callback->Run(quota::kQuotaErrorNotSupported);
-  delete callback;
+                                           DeletionCallback* callback_ptr) {
+  DCHECK(callback_ptr);
+  DCHECK(db_tracker_.get());
+  scoped_ptr<DeletionCallback> callback(callback_ptr);
+
+  // All databases are in the temp namespace for now.
+  if (type != quota::kStorageTypeTemporary) {
+    callback->Run(quota::kQuotaStatusOk);

[tzik, 2011/05/20 03:19:54]

maybe callback->Run(quota::kQuotaErrorNotSupported); ?

[michaeln, 2011/05/20 05:14:23]

There's no way for the caller to know not to call this method or the others for
the 'perm' type. My thinking was that OK is less likely to be interpreted as
"something went wrong" by the caller. There is no error, there's just nothing to
delete for the <origin,type>.

So a little less programming error prone to return OK was my thinking.

[tzik, 2011/05/20 13:26:50]

I see. I totally agree with you.

+    return;
+  }
+
+  scoped_refptr<DeleteOriginTask> task(
+      new DeleteOriginTask(this, db_tracker_thread_,
+                           origin, callback.release()));
+  task->Start();
 }
 
 void DatabaseQuotaClient::DidGetOriginUsage(
     const GURL& origin_url, int64 usage) {
   DCHECK(usage_for_origin_callbacks_.HasCallbacks(origin_url));
   usage_for_origin_callbacks_.Run(origin_url, usage);
 }
 
 void DatabaseQuotaClient::DidGetAllOrigins(const std::set<GURL>& origins) {
   DCHECK(origins_for_type_callbacks_.HasCallbacks());
   origins_for_type_callbacks_.Run(origins);
 }
 
 void DatabaseQuotaClient::DidGetOriginsForHost(
     const std::string& host, const std::set<GURL>& origins) {
   DCHECK(origins_for_host_callbacks_.HasCallbacks(host));
   origins_for_host_callbacks_.Run(host, origins);
 }
 
 }  // namespace webkit_database