Use base::Callback in Quota related code.

webkit/quota/quota_manager.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/quota/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #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"
 #include "net/base/net_util.h"
 #include "webkit/quota/quota_database.h"
 #include "webkit/quota/quota_temporary_storage_evictor.h"
 #include "webkit/quota/quota_types.h"
 #include "webkit/quota/usage_tracker.h"
 
 #define UMA_HISTOGRAM_MBYTES(name, sample)          \
   UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
       (name), static_cast<int>((sample) / kMBytes), \
       1, 10 * 1024 * 1024 /* 10TB */, 100)
 
-using base::ScopedCallbackFactory;
-
 namespace quota {
 
 namespace {
 
 const int64 kMBytes = 1024 * 1024;
 const int kMinutesInMilliSeconds = 60 * 1000;
 
 const int64 kIncognitoDefaultTemporaryQuota = 50 * kMBytes;
 const int64 kReportHistogramInterval = 60 * 60 * 1000;  // 1 hour
 const double kTemporaryQuotaRatioToAvail = 0.5;  // 50%
@@ skipping 24 matching lines @@
 
 const char QuotaManager::kDatabaseName[] = "QuotaManager";
 
 const int QuotaManager::kThresholdOfErrorsToBeBlacklisted = 3;
 
 const int QuotaManager::kEvictionIntervalInMilliSeconds =
     30 * kMinutesInMilliSeconds;
 
 // Callback translators.
 void CallGetUsageAndQuotaCallback(
-    QuotaManager::GetUsageAndQuotaCallback* callback,
+    const QuotaManager::GetUsageAndQuotaCallback& callback,
     bool unlimited,
     QuotaStatusCode status,
     const QuotaAndUsage& quota_and_usage) {
   int64 usage =
       unlimited ? quota_and_usage.unlimited_usage : quota_and_usage.usage;
   int64 quota = unlimited ? kint64max : quota_and_usage.quota;
-  callback->Run(status, usage, quota);
-  delete callback;
+  callback.Run(status, usage, quota);
 }
 
 void CallQuotaCallback(
-    QuotaCallback* callback,
+    const QuotaCallback& callback,
     StorageType type,
     QuotaStatusCode status,
     const QuotaAndUsage& quota_and_usage) {
-  callback->Run(status, type, quota_and_usage.quota);
-  delete callback;
+  callback.Run(status, type, quota_and_usage.quota);
 }
 
 // This class is for posting GetUsage/GetQuota tasks, gathering
 // results and dispatching GetAndQuota callbacks.
 // This class is self-destructed.
 class QuotaManager::UsageAndQuotaDispatcherTask : public QuotaTask {
  public:
   typedef UsageAndQuotaDispatcherCallback Callback;
   typedef std::deque<Callback> CallbackList;
 
@@ skipping 57 matching lines @@
       : QuotaTask(manager),
         host_and_type_(host_and_type),
         started_(false),
         host_quota_(-1),
         global_usage_(-1),
         global_unlimited_usage_(-1),
         host_usage_(-1),
         available_space_(-1),
         quota_status_(kQuotaStatusUnknown),
         waiting_callbacks_(1),
-        ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {}
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
   virtual ~UsageAndQuotaDispatcherTask() {}
 
   // Subclasses must implement them.
   virtual void RunBody() = 0;
   virtual void DispatchCallbacks() = 0;
 
   virtual void Run() OVERRIDE {
     DCHECK(!started_);
     started_ = true;
@@ skipping 54 matching lines @@
       // We basically calculate the temporary quota by
       // [available_space + space_used_for_temp] * kTempQuotaRatio,
       // but make sure we'll have no overflow.
       avail_space += limited_usage;
     }
     return avail_space * kTemporaryQuotaRatioToAvail;
   }
 
   // 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());
   }
-  HostQuotaCallback* NewWaitableHostQuotaCallback() {
+  HostQuotaCallback NewWaitableHostQuotaCallback() {
     ++waiting_callbacks_;
-    return callback_factory_.NewCallback(
-            &UsageAndQuotaDispatcherTask::DidGetHostQuota);
+    return base::Bind(&UsageAndQuotaDispatcherTask::DidGetHostQuota,
+                      weak_factory_.GetWeakPtr());
   }
-  AvailableSpaceCallback* NewWaitableAvailableSpaceCallback() {
+  AvailableSpaceCallback NewWaitableAvailableSpaceCallback() {
     ++waiting_callbacks_;
-    return callback_factory_.NewCallback(
-            &UsageAndQuotaDispatcherTask::DidGetAvailableSpace);
+    return base::Bind(&UsageAndQuotaDispatcherTask::DidGetAvailableSpace,
+                      weak_factory_.GetWeakPtr());
   }
 
+
  private:
   void CheckCompleted() {
     if (--waiting_callbacks_ <= 0) {
       DispatchCallbacks();
       DCHECK(callbacks_.empty());
 
       UsageAndQuotaDispatcherTaskMap& dispatcher_map =
           manager()->usage_and_quota_dispatchers_;
       DCHECK(dispatcher_map.find(host_and_type_) != dispatcher_map.end());
       dispatcher_map.erase(host_and_type_);
       CallCompleted();
     }
   }
 
   const std::string host_;
   const HostAndType host_and_type_;
   bool started_;
   int64 host_quota_;
   int64 global_usage_;
   int64 global_unlimited_usage_;
   int64 host_usage_;
   int64 available_space_;
   QuotaStatusCode quota_status_;
   CallbackList callbacks_;
   int waiting_callbacks_;
-  ScopedCallbackFactory<UsageAndQuotaDispatcherTask> callback_factory_;
+  base::WeakPtrFactory<UsageAndQuotaDispatcherTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaDispatcherTask);
 };
 
 class QuotaManager::GetUsageInfoTask : public QuotaTask {
  private:
   typedef QuotaManager::GetUsageInfoTask self_type;
 
  public:
   GetUsageInfoTask(
       QuotaManager* manager,
-      GetUsageInfoCallback* callback)
+      const GetUsageInfoCallback& callback)
       : QuotaTask(manager),
         callback_(callback),
-        ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   }
  protected:
   virtual void Run() OVERRIDE {
     remaining_trackers_ = 2;
     // This will populate cached hosts and usage info.
     manager()->GetUsageTracker(kStorageTypeTemporary)->GetGlobalUsage(
-        callback_factory_.NewCallback(&GetUsageInfoTask::DidGetGlobalUsage));
+        base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
+                   weak_factory_.GetWeakPtr()));
     manager()->GetUsageTracker(kStorageTypePersistent)->GetGlobalUsage(
-        callback_factory_.NewCallback(&GetUsageInfoTask::DidGetGlobalUsage));
+        base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
+                   weak_factory_.GetWeakPtr()));
   }
 
   virtual void Completed() OVERRIDE {
-    callback_->Run(entries_);
+    callback_.Run(entries_);
     DeleteSoon();
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(UsageInfoEntries());
+    callback_.Run(UsageInfoEntries());
     DeleteSoon();
   }
 
  private:
   void AddEntries(StorageType type, UsageTracker* tracker) {
     std::map<std::string, int64> host_usage;
     tracker->GetCachedHostsUsage(&host_usage);
     for (std::map<std::string, int64>::const_iterator iter = host_usage.begin();
          iter != host_usage.end();
          ++iter) {
       entries_.push_back(UsageInfo(iter->first, type, iter->second));
     }
     if (--remaining_trackers_ == 0)
       CallCompleted();
   }
 
   void DidGetGlobalUsage(StorageType type, int64, int64) {
     AddEntries(type, manager()->GetUsageTracker(type));
   }
 
   QuotaManager* manager() const {
     return static_cast<QuotaManager*>(observer());
   }
 
-  scoped_ptr<GetUsageInfoCallback> callback_;
+  GetUsageInfoCallback callback_;
   UsageInfoEntries entries_;
-  base::ScopedCallbackFactory<GetUsageInfoTask> callback_factory_;
+  base::WeakPtrFactory<GetUsageInfoTask> weak_factory_;
   int remaining_trackers_;
 
   DISALLOW_COPY_AND_ASSIGN(GetUsageInfoTask);
 };
 
 class QuotaManager::UsageAndQuotaDispatcherTaskForTemporary
     : public QuotaManager::UsageAndQuotaDispatcherTask {
  public:
   UsageAndQuotaDispatcherTaskForTemporary(
       QuotaManager* manager, const HostAndType& host_and_type)
@@ skipping 91 matching lines @@
       NOTREACHED();
   }
   return NULL;
 }
 
 class QuotaManager::OriginDataDeleter : public QuotaTask {
  public:
   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),
-        ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {}
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
 
  protected:
   virtual void Run() OVERRIDE {
     error_count_ = 0;
     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();
   }
 
   void DidDeleteOriginData(QuotaStatusCode status) {
     DCHECK_GT(remaining_clients_, 0);
 
     if (status != kQuotaStatusOk)
       ++error_count_;
 
     if (--remaining_clients_ == 0)
       CallCompleted();
   }
 
   QuotaManager* manager() const {
     return static_cast<QuotaManager*>(observer());
   }
 
   GURL origin_;
   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);
 };
 
 class QuotaManager::DatabaseTaskBase : public QuotaThreadTask {
  public:
   explicit DatabaseTaskBase(QuotaManager* manager)
       : QuotaThreadTask(manager, manager->db_thread_),
         manager_(manager),
         database_(manager->database_.get()),
         db_disabled_(false) {
@@ skipping 52 matching lines @@
   int64 temporary_quota_override_;
   int64 desired_available_space_;
 };
 
 class QuotaManager::UpdateTemporaryQuotaOverrideTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   UpdateTemporaryQuotaOverrideTask(
       QuotaManager* manager,
       int64 new_quota,
-      QuotaCallback* callback)
+      const QuotaCallback& callback)
       : DatabaseTaskBase(manager),
         new_quota_(new_quota),
         callback_(callback) {}
 
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->SetQuotaConfigValue(
             QuotaDatabase::kTemporaryQuotaOverrideKey, new_quota_)) {
       set_db_disabled(true);
       new_quota_ = -1;
       return;
     }
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
     if (!db_disabled()) {
       manager()->temporary_quota_override_ = new_quota_;
       CallCallback(kQuotaStatusOk, kStorageTypeTemporary, new_quota_);
     } else {
       CallCallback(kQuotaErrorInvalidAccess, kStorageTypeTemporary, new_quota_);
     }
   }
 
  private:
   void CallCallback(QuotaStatusCode status, StorageType type, int64 quota) {
-    if (callback_.get()) {
-      callback_->Run(status, type, quota);
-      callback_.reset();
+    if (!callback_.is_null()) {
+      callback_.Run(status, type, quota);
+      callback_.Reset();
     }
   }
 
   int64 new_quota_;
-  scoped_ptr<QuotaCallback> callback_;
+  QuotaCallback callback_;
 };
 
 class QuotaManager::GetPersistentHostQuotaTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   GetPersistentHostQuotaTask(
       QuotaManager* manager,
       const std::string& host,
-      HostQuotaCallback* callback)
+      const HostQuotaCallback& callback)
       : DatabaseTaskBase(manager),
         host_(host),
         quota_(-1),
         callback_(callback) {
   }
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->GetHostQuota(host_, kStorageTypePersistent, &quota_))
       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
     : public QuotaManager::DatabaseTaskBase {
  public:
   UpdatePersistentHostQuotaTask(
       QuotaManager* manager,
       const std::string& host,
       int new_quota,
-      HostQuotaCallback* callback)
+      const HostQuotaCallback& callback)
       : DatabaseTaskBase(manager),
         host_(host),
         new_quota_(new_quota),
         callback_(callback) {
     DCHECK_GE(new_quota_, 0);
   }
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->SetHostQuota(host_, kStorageTypePersistent, new_quota_)) {
       set_db_disabled(true);
       new_quota_ = 0;
     }
   }
 
   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
     : public QuotaManager::DatabaseTaskBase {
  public:
   GetLRUOriginTask(
       QuotaManager* manager,
       StorageType type,
       const std::map<GURL, int>& origins_in_use,
       const std::map<GURL, int>& origins_in_error,
@@ skipping 94 matching lines @@
 
  private:
   std::set<GURL> origins_;
   bool has_registered_origins_;
 };
 
 class QuotaManager::AvailableSpaceQueryTask : public QuotaThreadTask {
  public:
   AvailableSpaceQueryTask(
       QuotaManager* manager,
-      AvailableSpaceCallback* callback)
+      const AvailableSpaceCallback& callback)
       : QuotaThreadTask(manager, manager->db_thread_),
         profile_path_(manager->profile_path_),
         space_(-1),
         callback_(callback) {
   }
   virtual ~AvailableSpaceQueryTask() {}
 
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     space_ = base::SysInfo::AmountOfFreeDiskSpace(profile_path_);
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_.reset();
+    callback_.Reset();
   }
 
   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
     : public QuotaManager::DatabaseTaskBase {
  public:
   UpdateAccessTimeTask(
       QuotaManager* manager,
       const GURL& origin,
       StorageType type,
       base::Time accessed_time)
@@ skipping 44 matching lines @@
   base::Time modified_time_;
 };
 
 class QuotaManager::GetModifiedSinceTask
     : public QuotaManager::DatabaseTaskBase {
  public:
   GetModifiedSinceTask(
       QuotaManager* manager,
       StorageType type,
       base::Time modified_since,
-      GetOriginsCallback* callback)
+      GetOriginsCallback callback)
       : DatabaseTaskBase(manager),
         type_(type),
         modified_since_(modified_since),
         callback_(callback) {}
 
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->GetOriginsModifiedSince(
             type_, &origins_, modified_since_)) {
       set_db_disabled(true);
     }
   }
 
   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
     : public QuotaManager::DatabaseTaskBase {
  private:
   typedef QuotaManager::DumpQuotaTableTask self_type;
   typedef QuotaManager::DumpQuotaTableCallback Callback;
   typedef QuotaManager::QuotaTableEntry TableEntry;
   typedef QuotaManager::QuotaTableEntries TableEntries;
   typedef QuotaDatabase::QuotaTableCallback TableCallback;
 
  public:
   DumpQuotaTableTask(
       QuotaManager* manager,
-      Callback* callback)
+      const Callback& callback)
       : DatabaseTaskBase(manager),
         callback_(callback) {
   }
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->DumpQuotaTable(
             new TableCallback(
                 base::Bind(&self_type::AppendEntry, this))))
       set_db_disabled(true);
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(TableEntries());
+    callback_.Run(TableEntries());
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(entries_);
+    callback_.Run(entries_);
   }
 
  private:
   bool AppendEntry(const TableEntry& entry) {
     entries_.push_back(entry);
     return true;
   }
 
-  scoped_ptr<Callback> callback_;
+  Callback callback_;
   TableEntries entries_;
 };
 
 class QuotaManager::DumpOriginInfoTableTask
     : public QuotaManager::DatabaseTaskBase {
  private:
   typedef QuotaManager::DumpOriginInfoTableTask self_type;
   typedef QuotaManager::DumpOriginInfoTableCallback Callback;
   typedef QuotaManager::OriginInfoTableEntry TableEntry;
   typedef QuotaManager::OriginInfoTableEntries TableEntries;
   typedef QuotaDatabase::OriginInfoTableCallback TableCallback;
 
  public:
   DumpOriginInfoTableTask(
       QuotaManager* manager,
-      Callback* callback)
+      const Callback& callback)
       : DatabaseTaskBase(manager),
         callback_(callback) {
   }
  protected:
   virtual void RunOnTargetThread() OVERRIDE {
     if (!database()->DumpOriginInfoTable(
             new TableCallback(
                 base::Bind(&self_type::AppendEntry, this))))
       set_db_disabled(true);
   }
 
   virtual void Aborted() OVERRIDE {
-    callback_->Run(TableEntries());
+    callback_.Run(TableEntries());
   }
 
   virtual void DatabaseTaskCompleted() OVERRIDE {
-    callback_->Run(entries_);
+    callback_.Run(entries_);
   }
 
  private:
   bool AppendEntry(const TableEntry& entry) {
     entries_.push_back(entry);
     return true;
   }
 
-  scoped_ptr<Callback> callback_;
+  Callback callback_;
   TableEntries entries_;
 };
 
 // QuotaManager ---------------------------------------------------------------
 
 QuotaManager::QuotaManager(bool is_incognito,
                            const FilePath& profile_path,
                            base::MessageLoopProxy* io_thread,
                            base::MessageLoopProxy* db_thread,
                            SpecialStoragePolicy* special_storage_policy)
   : is_incognito_(is_incognito),
     profile_path_(profile_path),
     proxy_(new QuotaManagerProxy(
         ALLOW_THIS_IN_INITIALIZER_LIST(this), io_thread)),
     db_disabled_(false),
     eviction_disabled_(false),
     io_thread_(io_thread),
     db_thread_(db_thread),
     temporary_quota_initialized_(false),
     temporary_quota_override_(-1),
     desired_available_space_(-1),
     special_storage_policy_(special_storage_policy),
-    ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)),
-    ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+    weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 QuotaManager::~QuotaManager() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   proxy_->manager_ = NULL;
   std::for_each(clients_.begin(), clients_.end(),
                 std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
   if (database_.get())
     db_thread_->DeleteSoon(FROM_HERE, database_.release());
 }
 
-void QuotaManager::GetUsageInfo(GetUsageInfoCallback* callback) {
+void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
   LazyInitialize();
   GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
   get_usage_info->Start();
 }
 
 void QuotaManager::GetUsageAndQuota(
     const GURL& origin, StorageType type,
-    GetUsageAndQuotaCallback* callback) {
+    const GetUsageAndQuotaCallback& callback) {
   GetUsageAndQuotaInternal(origin, type, false /* global */,
                            base::Bind(&CallGetUsageAndQuotaCallback,
                                       callback, IsStorageUnlimited(origin)));
 }
 
-void QuotaManager::GetAvailableSpace(AvailableSpaceCallback* callback) {
+void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
   if (is_incognito_) {
-    callback->Run(kQuotaStatusOk, kIncognitoDefaultTemporaryQuota);
-    delete callback;
+    callback.Run(kQuotaStatusOk, kIncognitoDefaultTemporaryQuota);
     return;
   }
   make_scoped_refptr(new AvailableSpaceQueryTask(this, callback))->Start();
 }
 
-void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {
+void QuotaManager::GetTemporaryGlobalQuota(const QuotaCallback& callback) {
   if (temporary_quota_override_ > 0) {
-    callback->Run(kQuotaStatusOk, kStorageTypeTemporary,
-                  temporary_quota_override_);
-    delete callback;
+    callback.Run(kQuotaStatusOk, kStorageTypeTemporary,
+                 temporary_quota_override_);
     return;
   }
   GetUsageAndQuotaInternal(
       GURL(), kStorageTypeTemporary, true /* global */,
       base::Bind(&CallQuotaCallback, callback, kStorageTypeTemporary));
 }
 
 void QuotaManager::SetTemporaryGlobalOverrideQuota(
-    int64 new_quota, QuotaCallback* callback_ptr) {
-  scoped_ptr<QuotaCallback> callback(callback_ptr);
+    int64 new_quota, const QuotaCallback& callback) {
   LazyInitialize();
 
   if (new_quota < 0) {
-    if (callback.get())
-      callback->Run(kQuotaErrorInvalidModification,
-                    kStorageTypeTemporary, -1);
+    if (!callback.is_null())
+      callback.Run(kQuotaErrorInvalidModification,
+                   kStorageTypeTemporary, -1);
     return;
   }
 
   if (db_disabled_) {
-    if (callback.get())
-      callback->Run(kQuotaErrorInvalidAccess,
-                    kStorageTypeTemporary, -1);
+    if (callback.is_null())
+      callback.Run(kQuotaErrorInvalidAccess,
+                   kStorageTypeTemporary, -1);
     return;
   }
 
   make_scoped_refptr(new UpdateTemporaryQuotaOverrideTask(
-      this, new_quota, callback.release()))->Start();
+      this, new_quota, callback))->Start();
 }
 
 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);
 }
 
 void QuotaManager::GetStatistics(
     std::map<std::string, std::string>* statistics) {
   DCHECK(statistics);
   if (temporary_storage_evictor_.get()) {
     std::map<std::string, int64> stats;
     temporary_storage_evictor_->GetStatistics(&stats);
     for (std::map<std::string, int64>::iterator p = stats.begin();
          p != stats.end();
          ++p)
       (*statistics)[p->first] = base::Int64ToString(p->second);
   }
 }
 
-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();
 }
 
 void QuotaManager::LazyInitialize() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_.get()) {
     // Initialization seems to be done already.
     return;
@@ skipping 39 matching lines @@
 
 void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK(IsOriginInUse(origin));
   int& count = origins_in_use_[origin];
   if (--count == 0)
     origins_in_use_.erase(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;
   }
 
   OriginDataDeleter* deleter =
       new OriginDataDeleter(this, origin, type, callback);
   deleter->Start();
 }
 
 bool QuotaManager::ResetUsageTracker(StorageType type) {
   switch (type) {
@@ skipping 109 matching lines @@
   // is already initialized iff the requested type is temporary.
   // (The first dispatcher task for temporary will be kicked in
   // DidRunInitializeTask if temporary_quota_initialized_ is false here.)
   if (found->second->AddCallback(callback) &&
       (requested_type != kStorageTypeTemporary ||
        temporary_quota_initialized_)) {
     found->second->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();
 }
 
 
 void QuotaManager::DeleteOriginFromDatabase(
     const GURL& origin, StorageType type) {
   LazyInitialize();
   if (db_disabled_)
     return;
   scoped_refptr<DeleteOriginInfo> task =
@@ skipping 13 matching lines @@
     lru_origin_callback_.Reset();
     return;
   }
   scoped_refptr<GetLRUOriginTask> task(new GetLRUOriginTask(
       this, type, origins_in_use_, 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
   // deletion attempt for eviction should not fail.  Let's record
   // the origin if we get error and exclude it from future eviction
   // if the error happens consistently (> kThresholdOfErrorsToBeBlacklisted).
   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::GetUsageAndQuotaForEviction(
     const GetUsageAndQuotaForEvictionCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   GetUsageAndQuotaInternal(
       GURL(), kStorageTypeTemporary, true /* global */, callback);
 }
 
 void QuotaManager::StartEviction() {
   DCHECK(!temporary_storage_evictor_.get());
   temporary_storage_evictor_.reset(new QuotaTemporaryStorageEvictor(
       this, kEvictionIntervalInMilliSeconds));
   if (desired_available_space_ >= 0)
     temporary_storage_evictor_->set_min_available_disk_space_to_start_eviction(
         desired_available_space_);
   temporary_storage_evictor_->Start();
 }
 
 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(
     StorageType type,
     int64 usage,
     int64 unlimited_usage) {
   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfTemporaryStorage", usage);
 
   std::set<GURL> origins;
   GetCachedOrigins(type, &origins);
@@ skipping 47 matching lines @@
   // temporary_quota_initialized_ to be initialized (if there're any).
   for (UsageAndQuotaDispatcherTaskMap::iterator iter =
            usage_and_quota_dispatchers_.begin();
        iter != usage_and_quota_dispatchers_.end(); ++iter) {
     if (iter->second->IsStartable())
       iter->second->Start();
   }
 
   // Kick the first GetTemporaryGlobalQuota. This internally fetches (and
   // caches) the usage of all origins and checks the available disk space.
-  GetTemporaryGlobalQuota(callback_factory_.NewCallback(
-      &QuotaManager::DidGetInitialTemporaryGlobalQuota));
+  GetTemporaryGlobalQuota(
+      base::Bind(&QuotaManager::DidGetInitialTemporaryGlobalQuota,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void QuotaManager::DidGetInitialTemporaryGlobalQuota(
     QuotaStatusCode status, StorageType type, int64 quota_unused) {
   DCHECK_EQ(type, kStorageTypeTemporary);
 
   if (eviction_disabled_)
     return;
 
   // This will call the StartEviction() when initial origin registration
@@ skipping 94 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota