Use base::Callback in Quota related code.

webkit/quota/quota_manager.cc

Index: webkit/quota/quota_manager.cc
diff --git a/webkit/quota/quota_manager.cc b/webkit/quota/quota_manager.cc
index 60d7c323c682683a8c2b5fb6e90c7854c5c33eb2..57cd2b9ca87be8f04fedf11f84f3339748a5aa02 100644
--- a/webkit/quota/quota_manager.cc
+++ b/webkit/quota/quota_manager.cc
@@ -15,7 +15,6 @@
 #include "base/memory/ref_counted.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
-#include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/time.h"
@@ -30,8 +29,6 @@
       (name), static_cast<int>((sample) / kMBytes), \
       1, 10 * 1024 * 1024 /* 10TB */, 100)
 
-using base::ScopedCallbackFactory;
-
 namespace quota {
 
 namespace {
@@ -114,14 +111,14 @@ const base::TimeDelta QuotaManager::kReportHistogramInterval =
 // This class is self-destructed.
 class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
  public:
-  typedef std::deque<GetUsageAndQuotaCallback*> CallbackList;
+  typedef std::deque<GetUsageAndQuotaCallback> CallbackList;
 
   static UsageAndQuotaDispatcherTask* Create(
       QuotaManager* manager, const std::string& host, StorageType type);
 
   // Returns true if it is the first call for this task; which means
   // the caller needs to call Start().
-  bool AddCallback(GetUsageAndQuotaCallback* callback, bool unlimited) {
+  bool AddCallback(const GetUsageAndQuotaCallback& callback, bool unlimited) {
     if (unlimited)
       unlimited_callbacks_.push_back(callback);
     else
@@ -181,13 +178,9 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
         host_usage_(-1),
         quota_status_(kQuotaStatusUnknown),
         waiting_callbacks_(1),
-        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
-  virtual ~UsageAndQuotaDispatcherTask() {
-    STLDeleteContainerPointers(callbacks_.begin(), callbacks_.end());
-    STLDeleteContainerPointers(unlimited_callbacks_.begin(),
-                               unlimited_callbacks_.end());
-  }
+  virtual ~UsageAndQuotaDispatcherTask() {}
 
   // Subclasses must implement them.
   virtual void RunBody() = 0;
@@ -216,8 +209,7 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
       int64 usage, int64 quota) {
     for (CallbackList::iterator iter = callbacks->begin();
          iter != callbacks->end(); ++iter) {
-      (*iter)->Run(status, usage, quota);
-      delete *iter;
+      iter->Run(status, usage, quota);
     }
     callbacks->clear();
   }
@@ -238,25 +230,25 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
 
   // Subclasses must call following methods to create a new 'waitable'
   // callback, which decrements waiting_callbacks when it is called.
-  GlobalUsageCallback* NewWaitableGlobalUsageCallback() {
+  GlobalUsageCallback NewWaitableGlobalUsageCallback() {
     ++waiting_callbacks_;
-    return callback_factory_.NewCallback(
-            &UsageAndQuotaDispatcherTask::DidGetGlobalUsage);
+    return base::Bind(&UsageAndQuotaDispatcherTask::DidGetGlobalUsage,
+                      weak_factory_.GetWeakPtr());
   }
-  HostUsageCallback* NewWaitableHostUsageCallback() {
+  HostUsageCallback NewWaitableHostUsageCallback() {
     ++waiting_callbacks_;
-    return callback_factory_.NewCallback(
-            &UsageAndQuotaDispatcherTask::DidGetHostUsage);
+    return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostUsage,
+                      weak_factory_.GetWeakPtr());
   }
-  QuotaCallback* NewWaitableGlobalQuotaCallback() {
+  QuotaCallback NewWaitableGlobalQuotaCallback() {
     ++waiting_callbacks_;
-    return callback_factory_.NewCallback(
-            &UsageAndQuotaDispatcherTask::DidGetGlobalQuota);
+    return base::Bind(&UsageAndQuotaDispatcherTask::DidGetGlobalQuota,
+                      weak_factory_.GetWeakPtr());
   }
-  HostQuotaCallback* NewWaitableHostQuotaCallback() {
+  HostQuotaCallback NewWaitableHostQuotaCallback() {
     ++waiting_callbacks_;
-    return callback_factory_.NewCallback(
-            &UsageAndQuotaDispatcherTask::DidGetHostQuota);
+    return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostQuota,
+                      weak_factory_.GetWeakPtr());
   }
 
  private:
@@ -285,7 +277,7 @@ class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
   CallbackList callbacks_;
   CallbackList unlimited_callbacks_;
   int waiting_callbacks_;
-  ScopedCallbackFactory<UsageAndQuotaDispatcherTask> callback_factory_;
+  base::WeakPtrFactory<UsageAndQuotaDispatcherTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaDispatcherTask);
 };
@@ -379,14 +371,14 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {
   OriginDataDeleter(QuotaManager* manager,
                     const GURL& origin,
                     StorageType type,
-                    StatusCallback* callback)
+                    const StatusCallback& callback)
       : QuotaTask(manager),
         origin_(origin),
         type_(type),
         error_count_(0),
         remaining_clients_(-1),
         callback_(callback),
-        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
  protected:
   virtual void Run() OVERRIDE {
@@ -394,23 +386,25 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {
     remaining_clients_ = manager()->clients_.size();
     for (QuotaClientList::iterator iter = manager()->clients_.begin();
          iter != manager()->clients_.end(); ++iter) {
-      (*iter)->DeleteOriginData(origin_, type_, callback_factory_.NewCallback(
-          &OriginDataDeleter::DidDeleteOriginData));
+      (*iter)->DeleteOriginData(
+          origin_, type_,
+          base::Bind(&OriginDataDeleter::DidDeleteOriginData,
+                     weak_factory_.GetWeakPtr()));
     }
   }
 
   virtual void Completed() OVERRIDE {
     if (error_count_ == 0) {
       manager()->DeleteOriginFromDatabase(origin_, type_);
-      callback_->Run(kQuotaStatusOk);
+      callback_.Run(kQuotaStatusOk);
     } else {
-      callback_->Run(kQuotaErrorInvalidModification);
+      callback_.Run(kQuotaErrorInvalidModification);
     }
     DeleteSoon();
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(kQuotaErrorAbort);
+    callback_.Run(kQuotaErrorAbort);
     DeleteSoon();
   }
 
@@ -432,9 +426,9 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {
   StorageType type_;
   int error_count_;
   int remaining_clients_;
-  scoped_ptr<StatusCallback> callback_;
+  StatusCallback callback_;
 
-  ScopedCallbackFactory<OriginDataDeleter> callback_factory_;
+  base::WeakPtrFactory<OriginDataDeleter> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(OriginDataDeleter);
 };
 
@@ -526,7 +520,7 @@ class QuotaManager::UpdateTemporaryGlobalQuotaTask
   UpdateTemporaryGlobalQuotaTask(
       QuotaManager* manager,
       int64 new_quota,
-      QuotaCallback* callback)
+      const QuotaCallback& callback)
       : DatabaseTaskBase(manager),
         new_quota_(new_quota),
         callback_(callback) {
@@ -542,8 +536,8 @@ class QuotaManager::UpdateTemporaryGlobalQuotaTask
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
-                   kStorageTypeTemporary, new_quota_);
+    callback_.Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
+                  kStorageTypeTemporary, new_quota_);
     if (!db_disabled()) {
       manager()->temporary_global_quota_ = new_quota_;
     }
@@ -551,7 +545,7 @@ class QuotaManager::UpdateTemporaryGlobalQuotaTask
 
  private:
   int64 new_quota_;
-  scoped_ptr<QuotaCallback> callback_;
+  QuotaCallback callback_;
 };
 
 class QuotaManager::GetPersistentHostQuotaTask
@@ -560,7 +554,7 @@ class QuotaManager::GetPersistentHostQuotaTask
   GetPersistentHostQuotaTask(
       QuotaManager* manager,
       const std::string& host,
-      HostQuotaCallback* callback)
+      const HostQuotaCallback& callback)
       : DatabaseTaskBase(manager),
         host_(host),
         quota_(-1),
@@ -572,13 +566,13 @@ class QuotaManager::GetPersistentHostQuotaTask
       quota_ = 0;
   }
   virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(kQuotaStatusOk,
-                   host_, kStorageTypePersistent, quota_);
+    callback_.Run(kQuotaStatusOk,
+                  host_, kStorageTypePersistent, quota_);
   }
  private:
   std::string host_;
   int64 quota_;
-  scoped_ptr<HostQuotaCallback> callback_;
+  HostQuotaCallback callback_;
 };
 
 class QuotaManager::UpdatePersistentHostQuotaTask
@@ -588,7 +582,7 @@ class QuotaManager::UpdatePersistentHostQuotaTask
       QuotaManager* manager,
       const std::string& host,
       int new_quota,
-      HostQuotaCallback* callback)
+      const HostQuotaCallback& callback)
       : DatabaseTaskBase(manager),
         host_(host),
         new_quota_(new_quota),
@@ -604,18 +598,18 @@ class QuotaManager::UpdatePersistentHostQuotaTask
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
-                   host_, kStorageTypePersistent, new_quota_);
+    callback_.Run(db_disabled() ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
+                  host_, kStorageTypePersistent, new_quota_);
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_.reset();
+    callback_.Reset();
   }
 
  private:
   std::string host_;
   int64 new_quota_;
-  scoped_ptr<HostQuotaCallback> callback_;
+  HostQuotaCallback callback_;
 };
 
 class QuotaManager::GetLRUOriginTask
@@ -626,7 +620,7 @@ class QuotaManager::GetLRUOriginTask
       StorageType type,
       const std::map<GURL, int>& origins_in_use,
       const std::map<GURL, int>& origins_in_error,
-      GetLRUOriginCallback *callback)
+      const GetLRUOriginCallback& callback)
       : DatabaseTaskBase(manager),
         type_(type),
         callback_(callback),
@@ -653,17 +647,17 @@ class QuotaManager::GetLRUOriginTask
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(url_);
+    callback_.Run(url_);
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_.reset();
+    callback_.Reset();
   }
 
  private:
   StorageType type_;
   std::set<GURL> exceptions_;
-  scoped_ptr<GetLRUOriginCallback> callback_;
+  GetLRUOriginCallback callback_;
   scoped_refptr<SpecialStoragePolicy> special_storage_policy_;
   GURL url_;
 };
@@ -733,7 +727,7 @@ class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {
       QuotaManager* manager,
       scoped_refptr<base::MessageLoopProxy> db_message_loop,
       const FilePath& profile_path,
-      AvailableSpaceCallback* callback)
+      const AvailableSpaceCallback& callback)
       : QuotaThreadTask(manager, db_message_loop),
         profile_path_(profile_path),
         space_(-1),
@@ -746,17 +740,17 @@ class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(kQuotaErrorAbort, -1);
+    callback_.Run(kQuotaErrorAbort, -1);
   }
 
   virtual void Completed() OVERRIDE {
-    callback_->Run(kQuotaStatusOk, space_);
+    callback_.Run(kQuotaStatusOk, space_);
   }
 
  private:
   FilePath profile_path_;
   int64 space_;
-  scoped_ptr<AvailableSpaceCallback> callback_;
+  AvailableSpaceCallback callback_;
 };
 
 class QuotaManager::UpdateAccessTimeTask
@@ -821,7 +815,7 @@ class QuotaManager::GetModifiedSinceTask
       QuotaManager* manager,
       StorageType type,
       base::Time modified_since,
-      GetOriginsCallback* callback)
+      GetOriginsCallback callback)
       : DatabaseTaskBase(manager),
         type_(type),
         modified_since_(modified_since),
@@ -836,18 +830,18 @@ class QuotaManager::GetModifiedSinceTask
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(origins_, type_);
+    callback_.Run(origins_, type_);
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(std::set<GURL>(), type_);
+    callback_.Run(std::set<GURL>(), type_);
   }
 
  private:
   StorageType type_;
   base::Time modified_since_;
   std::set<GURL> origins_;
-  scoped_ptr<GetOriginsCallback> callback_;
+  GetOriginsCallback callback_;
 };
 
 class QuotaManager::DumpQuotaTableTask
@@ -862,7 +856,7 @@ class QuotaManager::DumpQuotaTableTask
  public:
   DumpQuotaTableTask(
       QuotaManager* manager,
-      Callback* callback)
+      const Callback& callback)
       : DatabaseTaskBase(manager),
         callback_(callback) {
   }
@@ -875,11 +869,11 @@ class QuotaManager::DumpQuotaTableTask
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(TableEntries());
+    callback_.Run(TableEntries());
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(entries_);
+    callback_.Run(entries_);
   }
 
  private:
@@ -888,7 +882,7 @@ class QuotaManager::DumpQuotaTableTask
     return true;
   }
 
-  scoped_ptr<Callback> callback_;
+  Callback callback_;
   TableEntries entries_;
 };
 
@@ -904,7 +898,7 @@ class QuotaManager::DumpOriginInfoTableTask
  public:
   DumpOriginInfoTableTask(
       QuotaManager* manager,
-      Callback* callback)
+      const Callback& callback)
       : DatabaseTaskBase(manager),
         callback_(callback) {
   }
@@ -917,11 +911,11 @@ class QuotaManager::DumpOriginInfoTableTask
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(TableEntries());
+    callback_.Run(TableEntries());
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(entries_);
+    callback_.Run(entries_);
   }
 
  private:
@@ -930,7 +924,7 @@ class QuotaManager::DumpOriginInfoTableTask
     return true;
   }
 
-  scoped_ptr<Callback> callback_;
+  Callback callback_;
   TableEntries entries_;
 };
 
@@ -952,7 +946,7 @@ QuotaManager::QuotaManager(bool is_incognito,
     need_initialize_origins_(false),
     temporary_global_quota_(-1),
     special_storage_policy_(special_storage_policy),
-    callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+    weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 QuotaManager::~QuotaManager() {
@@ -966,13 +960,12 @@ QuotaManager::~QuotaManager() {
 
 void QuotaManager::GetUsageAndQuota(
     const GURL& origin, StorageType type,
-    GetUsageAndQuotaCallback* callback_ptr) {
-  scoped_ptr<GetUsageAndQuotaCallback> callback(callback_ptr);
+    const GetUsageAndQuotaCallback& callback) {
   LazyInitialize();
 
   if (type == kStorageTypeUnknown) {
     // Quota only supports temporary/persistent types.
-    callback->Run(kQuotaErrorNotSupported, 0, 0);
+    callback.Run(kQuotaErrorNotSupported, 0, 0);
     return;
   }
 
@@ -986,26 +979,24 @@ void QuotaManager::GetUsageAndQuota(
     found = usage_and_quota_dispatchers_.insert(
         std::make_pair(std::make_pair(host, type), dispatcher)).first;
   }
-  if (found->second->AddCallback(
-          callback.release(), IsStorageUnlimited(origin))) {
+  if (found->second->AddCallback(callback, IsStorageUnlimited(origin))) {
     found->second->Start();
   }
 }
 
-void QuotaManager::GetAvailableSpace(AvailableSpaceCallback* callback) {
+void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
   scoped_refptr<AvailableSpaceQueryTask> task(
       new AvailableSpaceQueryTask(this, db_thread_, profile_path_, callback));
   task->Start();
 }
 
-void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {
+void QuotaManager::GetTemporaryGlobalQuota(const QuotaCallback& callback) {
   LazyInitialize();
   if (temporary_global_quota_ >= 0) {
     // TODO(kinuko): We may want to adjust the quota when the current
     // available space in the hard drive is getting tight.
-    callback->Run(kQuotaStatusOk,
-                  kStorageTypeTemporary, temporary_global_quota_);
-    delete callback;
+    callback.Run(kQuotaStatusOk,
+                 kStorageTypeTemporary, temporary_global_quota_);
     return;
   }
   // They are called upon completion of InitializeTask.
@@ -1013,12 +1004,11 @@ void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {
 }
 
 void QuotaManager::SetTemporaryGlobalQuota(int64 new_quota,
-                                           QuotaCallback* callback) {
+                                           const QuotaCallback& callback) {
   LazyInitialize();
   if (new_quota < 0) {
-    callback->Run(kQuotaErrorInvalidModification,
+    callback.Run(kQuotaErrorInvalidModification,
                   kStorageTypeTemporary, -1);
-    delete callback;
     return;
   }
 
@@ -1027,64 +1017,61 @@ void QuotaManager::SetTemporaryGlobalQuota(int64 new_quota,
         new UpdateTemporaryGlobalQuotaTask(this, new_quota, callback));
     task->Start();
   } else {
-    callback->Run(kQuotaErrorInvalidAccess,
+    callback.Run(kQuotaErrorInvalidAccess,
                   kStorageTypeTemporary, -1);
-    delete callback;
   }
 }
 
 void QuotaManager::GetPersistentHostQuota(const std::string& host,
-                                          HostQuotaCallback* callback_ptr) {
-  scoped_ptr<HostQuotaCallback> callback(callback_ptr);
+                                          const HostQuotaCallback& callback) {
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
     // TODO(kinuko) We may want to respect --allow-file-access-from-files
     // command line switch.
-    callback->Run(kQuotaStatusOk, host, kStorageTypePersistent, 0);
+    callback.Run(kQuotaStatusOk, host, kStorageTypePersistent, 0);
     return;
   }
   scoped_refptr<GetPersistentHostQuotaTask> task(
-      new GetPersistentHostQuotaTask(this, host, callback.release()));
+      new GetPersistentHostQuotaTask(this, host, callback));
   task->Start();
 }
 
 void QuotaManager::SetPersistentHostQuota(const std::string& host,
                                           int64 new_quota,
-                                          HostQuotaCallback* callback_ptr) {
-  scoped_ptr<HostQuotaCallback> callback(callback_ptr);
+                                          const HostQuotaCallback& callback) {
   LazyInitialize();
   if (host.empty()) {
     // This could happen if we are called on file:///.
-    callback->Run(kQuotaErrorNotSupported, host, kStorageTypePersistent, 0);
+    callback.Run(kQuotaErrorNotSupported, host, kStorageTypePersistent, 0);
     return;
   }
   if (new_quota < 0) {
-    callback->Run(kQuotaErrorInvalidModification,
-                  host, kStorageTypePersistent, -1);
+    callback.Run(kQuotaErrorInvalidModification,
+                 host, kStorageTypePersistent, -1);
     return;
   }
 
   if (!db_disabled_) {
     scoped_refptr<UpdatePersistentHostQuotaTask> task(
         new UpdatePersistentHostQuotaTask(
-            this, host, new_quota, callback.release()));
+            this, host, new_quota, callback));
     task->Start();
   } else {
-    callback->Run(kQuotaErrorInvalidAccess,
+    callback.Run(kQuotaErrorInvalidAccess,
                   host, kStorageTypePersistent, -1);
   }
 }
 
-void QuotaManager::GetGlobalUsage(
-    StorageType type,
-    GlobalUsageCallback* callback) {
+void QuotaManager::GetGlobalUsage(StorageType type,
+                                  const GlobalUsageCallback& callback) {
   LazyInitialize();
   GetUsageTracker(type)->GetGlobalUsage(callback);
 }
 
-void QuotaManager::GetHostUsage(const std::string& host, StorageType type,
-                                HostUsageCallback* callback) {
+void QuotaManager::GetHostUsage(const std::string& host,
+                                StorageType type,
+                                const HostUsageCallback& callback) {
   LazyInitialize();
   GetUsageTracker(type)->GetHostUsage(host, callback);
 }
@@ -1102,10 +1089,9 @@ void QuotaManager::GetStatistics(
   }
 }
 
-void QuotaManager::GetOriginsModifiedSince(
-    StorageType type,
-    base::Time modified_since,
-    GetOriginsCallback* callback) {
+void QuotaManager::GetOriginsModifiedSince(StorageType type,
+                                           base::Time modified_since,
+                                           const GetOriginsCallback& callback) {
   LazyInitialize();
   make_scoped_refptr(new GetModifiedSinceTask(
       this, type, modified_since, callback))->Start();
@@ -1167,12 +1153,11 @@ void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {
 }
 
 void QuotaManager::DeleteOriginData(
-    const GURL& origin, StorageType type, StatusCallback* callback) {
+    const GURL& origin, StorageType type, const StatusCallback& callback) {
   LazyInitialize();
 
   if (origin.is_empty() || clients_.empty()) {
-    callback->Run(kQuotaStatusOk);
-    delete callback;
+    callback.Run(kQuotaStatusOk);
     return;
   }
 
@@ -1238,7 +1223,7 @@ void QuotaManager::NotifyStorageAccessedInternal(
     const GURL& origin, StorageType type,
     base::Time accessed_time) {
   LazyInitialize();
-  if (type == kStorageTypeTemporary && lru_origin_callback_.get()) {
+  if (type == kStorageTypeTemporary && !lru_origin_callback_.is_null()) {
     // Record the accessed origins while GetLRUOrigin task is runing
     // to filter out them from eviction.
     access_notified_origins_.insert(origin);
@@ -1262,12 +1247,12 @@ void QuotaManager::NotifyStorageModifiedInternal(
       this, origin, type, modified_time))->Start();
 }
 
-void QuotaManager::DumpQuotaTable(DumpQuotaTableCallback* callback) {
+void QuotaManager::DumpQuotaTable(const DumpQuotaTableCallback& callback) {
   make_scoped_refptr(new DumpQuotaTableTask(this, callback))->Start();
 }
 
 void QuotaManager::DumpOriginInfoTable(
-    DumpOriginInfoTableCallback* callback) {
+    const DumpOriginInfoTableCallback& callback) {
   make_scoped_refptr(new DumpOriginInfoTableTask(this, callback))->Start();
 }
 
@@ -1282,27 +1267,26 @@ void QuotaManager::DeleteOriginFromDatabase(
   task->Start();
 }
 
-void QuotaManager::GetLRUOrigin(
-    StorageType type,
-    GetLRUOriginCallback* callback) {
+void QuotaManager::GetLRUOrigin(StorageType type,
+                                const GetLRUOriginCallback& callback) {
   LazyInitialize();
   // This must not be called while there's an in-flight task.
-  DCHECK(!lru_origin_callback_.get());
-  lru_origin_callback_.reset(callback);
+  DCHECK(lru_origin_callback_.is_null());
+  lru_origin_callback_ = callback;
   if (db_disabled_) {
-    lru_origin_callback_->Run(GURL());
-    lru_origin_callback_.reset();
+    lru_origin_callback_.Run(GURL());
+    lru_origin_callback_.Reset();
     return;
   }
   scoped_refptr<GetLRUOriginTask> task(new GetLRUOriginTask(
       this, type, origins_in_use_,
-      origins_in_error_, callback_factory_.NewCallback(
-          &QuotaManager::DidGetDatabaseLRUOrigin)));
+      origins_in_error_,
+      base::Bind(&QuotaManager::DidGetDatabaseLRUOrigin,
+                 weak_factory_.GetWeakPtr())));
   task->Start();
 }
 
-void QuotaManager::DidOriginDataEvicted(
-    QuotaStatusCode status) {
+void QuotaManager::DidOriginDataEvicted(QuotaStatusCode status) {
   DCHECK(io_thread_->BelongsToCurrentThread());
 
   // We only try evict origins that are not in use, so basically
@@ -1312,33 +1296,34 @@ void QuotaManager::DidOriginDataEvicted(
   if (status != kQuotaStatusOk)
     origins_in_error_[eviction_context_.evicted_origin]++;
 
-  eviction_context_.evict_origin_data_callback->Run(status);
-  eviction_context_.evict_origin_data_callback.reset();
+  eviction_context_.evict_origin_data_callback.Run(status);
+  eviction_context_.evict_origin_data_callback.Reset();
 }
 
 void QuotaManager::EvictOriginData(
     const GURL& origin,
     StorageType type,
-    EvictOriginDataCallback* callback) {
+    const EvictOriginDataCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK_EQ(type, kStorageTypeTemporary);
 
   eviction_context_.evicted_origin = origin;
   eviction_context_.evicted_type = type;
-  eviction_context_.evict_origin_data_callback.reset(callback);
+  eviction_context_.evict_origin_data_callback = callback;
 
-  DeleteOriginData(origin, type, callback_factory_.NewCallback(
-      &QuotaManager::DidOriginDataEvicted));
+  DeleteOriginData(origin, type,
+      base::Bind(&QuotaManager::DidOriginDataEvicted,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidGetAvailableSpaceForEviction(
     QuotaStatusCode status,
     int64 available_space) {
-  eviction_context_.get_usage_and_quota_callback->Run(status,
+  eviction_context_.get_usage_and_quota_callback.Run(status,
       eviction_context_.usage,
       eviction_context_.unlimited_usage,
       eviction_context_.quota, available_space);
-  eviction_context_.get_usage_and_quota_callback.reset();
+  eviction_context_.get_usage_and_quota_callback.Reset();
 }
 
 void QuotaManager::DidGetGlobalQuotaForEviction(
@@ -1347,15 +1332,16 @@ void QuotaManager::DidGetGlobalQuotaForEviction(
     int64 quota) {
   DCHECK_EQ(type, kStorageTypeTemporary);
   if (status != kQuotaStatusOk) {
-    eviction_context_.get_usage_and_quota_callback->Run(
+    eviction_context_.get_usage_and_quota_callback.Run(
         status, 0, 0, 0, 0);
-    eviction_context_.get_usage_and_quota_callback.reset();
+    eviction_context_.get_usage_and_quota_callback.Reset();
     return;
   }
 
   eviction_context_.quota = quota;
-  GetAvailableSpace(callback_factory_.
-      NewCallback(&QuotaManager::DidGetAvailableSpaceForEviction));
+  GetAvailableSpace(
+      base::Bind(&QuotaManager::DidGetAvailableSpaceForEviction,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidGetGlobalUsageForEviction(
@@ -1364,19 +1350,21 @@ void QuotaManager::DidGetGlobalUsageForEviction(
   DCHECK_GE(usage, unlimited_usage);
   eviction_context_.usage = usage;
   eviction_context_.unlimited_usage = unlimited_usage;
-  GetTemporaryGlobalQuota(callback_factory_.
-      NewCallback(&QuotaManager::DidGetGlobalQuotaForEviction));
+  GetTemporaryGlobalQuota(
+      base::Bind(&QuotaManager::DidGetGlobalQuotaForEviction,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::GetUsageAndQuotaForEviction(
-    GetUsageAndQuotaForEvictionCallback* callback) {
+    const GetUsageAndQuotaForEvictionCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
-  DCHECK(!eviction_context_.get_usage_and_quota_callback.get());
+  DCHECK(eviction_context_.get_usage_and_quota_callback.is_null());
 
-  eviction_context_.get_usage_and_quota_callback.reset(callback);
+  eviction_context_.get_usage_and_quota_callback = callback;
   // TODO(dmikurube): Make kStorageTypeTemporary an argument.
-  GetGlobalUsage(kStorageTypeTemporary, callback_factory_.
-      NewCallback(&QuotaManager::DidGetGlobalUsageForEviction));
+  GetGlobalUsage(kStorageTypeTemporary,
+                 base::Bind(&QuotaManager::DidGetGlobalUsageForEviction,
+                            weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::StartEviction() {
@@ -1388,11 +1376,13 @@ void QuotaManager::StartEviction() {
 
 void QuotaManager::ReportHistogram() {
   GetGlobalUsage(kStorageTypeTemporary,
-                 callback_factory_.NewCallback(
-                     &QuotaManager::DidGetTemporaryGlobalUsageForHistogram));
+                 base::Bind(
+                     &QuotaManager::DidGetTemporaryGlobalUsageForHistogram,
+                     weak_factory_.GetWeakPtr()));
   GetGlobalUsage(kStorageTypePersistent,
-                 callback_factory_.NewCallback(
-                     &QuotaManager::DidGetPersistentGlobalUsageForHistogram));
+                 base::Bind(
+                     &QuotaManager::DidGetPersistentGlobalUsageForHistogram,
+                     weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidGetTemporaryGlobalUsageForHistogram(
@@ -1460,8 +1450,9 @@ void QuotaManager::DidInitializeTemporaryGlobalQuota(int64 quota) {
   // of origins that have data in temporary storage to register them
   // in the database.  (We'll need the global temporary usage anyway
   // for eviction later.)
-  temporary_usage_tracker_->GetGlobalUsage(callback_factory_.NewCallback(
-      &QuotaManager::DidRunInitialGetTemporaryGlobalUsage));
+  temporary_usage_tracker_->GetGlobalUsage(
+      base::Bind(&QuotaManager::DidRunInitialGetTemporaryGlobalUsage,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidRunInitialGetTemporaryGlobalUsage(
@@ -1480,11 +1471,11 @@ void QuotaManager::DidGetDatabaseLRUOrigin(const GURL& origin) {
   // and has not been accessed since we posted the task.
   if (origins_in_use_.find(origin) != origins_in_use_.end() ||
       access_notified_origins_.find(origin) != access_notified_origins_.end())
-    lru_origin_callback_->Run(GURL());
+    lru_origin_callback_.Run(GURL());
   else
-    lru_origin_callback_->Run(origin);
+    lru_origin_callback_.Run(origin);
   access_notified_origins_.clear();
-  lru_origin_callback_.reset();
+  lru_origin_callback_.Reset();
 }
 
 void QuotaManager::DeleteOnCorrectThread() const {