Use base::Callback in Quota related code.

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 {

[awong, 2011/09/29 18:05:15]

Could this be simplified with PostTaskAndReply?

[tzik, 2011/10/11 04:53:57]

Later.

  public:
   DeleteOriginTask(IndexedDBQuotaClient* client,
                    base::MessageLoopProxy* webkit_thread_message_loop,
                    const GURL& origin_url,
-                   DeletionCallback* callback)
+                   DeletionCallback callback)
       : HelperTask(client, webkit_thread_message_loop),
         origin_url_(origin_url), callback_(callback) {
   }
  private:
   virtual void RunOnTargetThread() OVERRIDE {
     indexed_db_context_->DeleteIndexedDBForOrigin(origin_url_);
   }
   virtual void Aborted() OVERRIDE {
-    callback_.reset();
+    callback_.Reset();
   }
   virtual void Completed() OVERRIDE {
-    callback_->Run(quota::kQuotaStatusOk);
-    callback_.reset();
+    callback_.Run(quota::kQuotaStatusOk);
+    callback_.Reset();
   }
   GURL origin_url_;
-  scoped_ptr<DeletionCallback> callback_;
+  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) {
@@ skipping 95 matching lines @@
   return kIndexedDatabase;
 }
 
 void IndexedDBQuotaClient::OnQuotaManagerDestroyed() {
   delete this;
 }
 
 void IndexedDBQuotaClient::GetOriginUsage(
     const GURL& origin_url,
     quota::StorageType type,
-    GetUsageCallback* callback_ptr) {
-  DCHECK(callback_ptr);
+    GetUsageCallback callback) {
+  DCHECK(!callback.is_null());
   DCHECK(indexed_db_context_.get());
-  scoped_ptr<GetUsageCallback> callback(callback_ptr);
 
   // IndexedDB is in the temp namespace for now.
   if (type != quota::kStorageTypeTemporary) {
-    callback->Run(0);
+    callback.Run(0);
     return;
   }
 
-  if (usage_for_origin_callbacks_.Add(origin_url, callback.release())) {
+  if (usage_for_origin_callbacks_.Add(origin_url, callback)) {
     scoped_refptr<GetOriginUsageTask> task(
         new GetOriginUsageTask(this, webkit_thread_message_loop_, origin_url));
     task->Start();
   }
 }
 
 void IndexedDBQuotaClient::GetOriginsForType(
     quota::StorageType type,
-    GetOriginsCallback* callback_ptr) {
-  DCHECK(callback_ptr);
+    GetOriginsCallback callback) {
+  DCHECK(!callback.is_null());
   DCHECK(indexed_db_context_.get());
-  scoped_ptr<GetOriginsCallback> callback(callback_ptr);
 
   // All databases are in the temp namespace for now.
   if (type != quota::kStorageTypeTemporary) {
-    callback->Run(std::set<GURL>(), type);
+    callback.Run(std::set<GURL>(), type);
     return;
   }
 
-  if (origins_for_type_callbacks_.Add(callback.release())) {
+  if (origins_for_type_callbacks_.Add(callback)) {
     scoped_refptr<GetAllOriginsTask> task(
         new GetAllOriginsTask(this, webkit_thread_message_loop_, type));
     task->Start();
   }
 }
 
 void IndexedDBQuotaClient::GetOriginsForHost(
     quota::StorageType type,
     const std::string& host,
-    GetOriginsCallback* callback_ptr) {
-  DCHECK(callback_ptr);
+    GetOriginsCallback callback) {
+  DCHECK(!callback.is_null());
   DCHECK(indexed_db_context_.get());
-  scoped_ptr<GetOriginsCallback> callback(callback_ptr);
 
   // All databases are in the temp namespace for now.
   if (type != quota::kStorageTypeTemporary) {
-    callback->Run(std::set<GURL>(), type);
+    callback.Run(std::set<GURL>(), type);
     return;
   }
 
-  if (origins_for_host_callbacks_.Add(host, callback.release())) {
+  if (origins_for_host_callbacks_.Add(host, callback)) {
     scoped_refptr<GetOriginsForHostTask> task(
         new GetOriginsForHostTask(
             this, webkit_thread_message_loop_, host, type));
     task->Start();
   }
 }
 
 void IndexedDBQuotaClient::DeleteOriginData(const GURL& origin,
                                            quota::StorageType type,
-                                           DeletionCallback* callback) {
+                                           DeletionCallback callback) {
   if (type != quota::kStorageTypeTemporary) {
-    callback->Run(quota::kQuotaErrorNotSupported);
+    callback.Run(quota::kQuotaErrorNotSupported);
     return;
   }
   scoped_refptr<DeleteOriginTask> task(

[awong, 2011/09/29 18:05:15]

I'm thinking something like

webkit_thread_message_loop_proxy_->PostTaskAndReply(
  FROM_HERE,
  base::Bind(&IndexDBContext::DeleteIndexedDBForOrigin, indexed_db_context_,
origin_url),
  base::Bind(callback_, quota::kQuotaStatusOk));

For that last bind, you'd need this CL to be checked in first: 
http://codereview.chromium.org/8073012/  but I think that'll go in today, and if
PostTaskAndReply is good enough, it'd get rid of the whole HelperTask thing.

[tzik, 2011/10/11 04:53:57]

Sounds good. But this CL is already too big, let me do it in other CL.

       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,
     quota::StorageType type) {
   DCHECK(origins_for_type_callbacks_.HasCallbacks());
   origins_for_type_callbacks_.Run(origins, type);
 }
 
 void IndexedDBQuotaClient::DidGetOriginsForHost(
     const std::string& host, const std::set<GURL>& origins,
     quota::StorageType type) {
   DCHECK(origins_for_host_callbacks_.HasCallbacks(host));
   origins_for_host_callbacks_.Run(host, origins, type);
 }