Use base::Callback in Quota related code.

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/location.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 119 matching lines @@
   std::string host_;
   quota::StorageType type_;
 };
 
 class DatabaseQuotaClient::DeleteOriginTask : public HelperTask {
  public:
   DeleteOriginTask(
       DatabaseQuotaClient* client,
       base::MessageLoopProxy* db_tracker_thread,
       const GURL& origin_url,
-      DeletionCallback* caller_callback)
+      const DeletionCallback& caller_callback)
       : HelperTask(client, db_tracker_thread),
         origin_url_(origin_url),
         result_(quota::kQuotaStatusUnknown),
         caller_callback_(caller_callback),
         ALLOW_THIS_IN_INITIALIZER_LIST(completion_callback_(
             this, &DeleteOriginTask::OnOldCompletionCallback)) {
   }
 
  private:
   virtual void Completed() OVERRIDE {
-    if (!caller_callback_.get())
+    if (caller_callback_.is_null())
       return;
-    caller_callback_->Run(result_);
-    caller_callback_.reset();
+    caller_callback_.Run(result_);
+    caller_callback_.Reset();
   }
 
   virtual void Aborted() OVERRIDE {
-    caller_callback_.reset();
+    caller_callback_.Reset();
   }
 
   virtual bool RunOnTargetThreadAsync() OVERRIDE {
     AddRef();  // balanced in OnOldCompletionCallback
     string16 origin_id = DatabaseUtil::GetOriginIdentifier(origin_url_);
     int rv = db_tracker_->DeleteDataForOrigin(origin_id, &completion_callback_);
     if (rv == net::ERR_IO_PENDING)
       return false;  // we wait for the callback
     OnOldCompletionCallback(rv);
     return false;
   }
 
   void OnOldCompletionCallback(int rv) {
     if (rv == net::OK)
       result_ = quota::kQuotaStatusOk;
     original_message_loop()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &DeleteOriginTask::CallCompleted));
     Release();  // balanced in RunOnTargetThreadAsync
   }
 
   const GURL origin_url_;
   quota::QuotaStatusCode result_;
-  scoped_ptr<DeletionCallback> caller_callback_;
+  DeletionCallback caller_callback_;
   net::OldCompletionCallbackImpl<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() {
 }
 
 QuotaClient::ID DatabaseQuotaClient::id() const {
   return kDatabase;
 }
 
 void DatabaseQuotaClient::OnQuotaManagerDestroyed() {
   delete this;
 }
 
 void DatabaseQuotaClient::GetOriginUsage(
     const GURL& origin_url,
     quota::StorageType type,
-    GetUsageCallback* callback_ptr) {
-  DCHECK(callback_ptr);
+    const GetUsageCallback& callback) {
+  DCHECK(!callback.is_null());
   DCHECK(db_tracker_.get());
-  scoped_ptr<GetUsageCallback> callback(callback_ptr);
 
   // All databases are 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, db_tracker_thread_, origin_url));
     task->Start();
   }
 }
 
 void DatabaseQuotaClient::GetOriginsForType(
     quota::StorageType type,
-    GetOriginsCallback* callback_ptr) {
-  DCHECK(callback_ptr);
+    const GetOriginsCallback& callback) {
+  DCHECK(!callback.is_null());
   DCHECK(db_tracker_.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, db_tracker_thread_, type));
     task->Start();
   }
 }
 
 void DatabaseQuotaClient::GetOriginsForHost(
     quota::StorageType type,
     const std::string& host,
-    GetOriginsCallback* callback_ptr) {
-  DCHECK(callback_ptr);
+    const GetOriginsCallback& callback) {
+  DCHECK(!callback.is_null());
   DCHECK(db_tracker_.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, db_tracker_thread_, host, type));
     task->Start();
   }
 }
 
 void DatabaseQuotaClient::DeleteOriginData(const GURL& origin,
                                            quota::StorageType type,
-                                           DeletionCallback* callback_ptr) {
-  DCHECK(callback_ptr);
+                                           const DeletionCallback& callback) {
+  DCHECK(!callback.is_null());
   DCHECK(db_tracker_.get());
-  scoped_ptr<DeletionCallback> callback(callback_ptr);
 
   // All databases are in the temp namespace for now, so nothing to delete.
   if (type != quota::kStorageTypeTemporary) {
-    callback->Run(quota::kQuotaStatusOk);
+    callback.Run(quota::kQuotaStatusOk);
     return;
   }
 
   scoped_refptr<DeleteOriginTask> task(
       new DeleteOriginTask(this, db_tracker_thread_,
-                           origin, callback.release()));
+                           origin, callback));
   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,
     quota::StorageType type) {
   DCHECK(origins_for_type_callbacks_.HasCallbacks());
   origins_for_type_callbacks_.Run(origins, type);
 }
 
 void DatabaseQuotaClient::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);
 }
 
 }  // namespace webkit_database