Use base::Callback in Quota related code.

webkit/quota/usage_tracker.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/usage_tracker.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 #include <string>
+#include <vector>
 
+#include "base/bind.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "net/base/net_util.h"
 
 namespace quota {
 
 namespace {
 bool SortByHost(const GURL& lhs, const GURL& rhs) {
   return net::GetHostOrSpecFromURL(lhs) > net::GetHostOrSpecFromURL(rhs);
 }
 }
 
 // A task class for getting the total amount of data used for a collection of
 // origins.  This class is self-destructed.
 class ClientUsageTracker::GatherUsageTaskBase : public QuotaTask {
  public:
   GatherUsageTaskBase(
       UsageTracker* tracker,
       QuotaClient* client)
       : QuotaTask(tracker),
         client_(client),
         tracker_(tracker),
-        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     DCHECK(tracker_);
     DCHECK(client_);
     client_tracker_ = tracker_->GetClientTracker(client_->id());
     DCHECK(client_tracker_);
   }
   virtual ~GatherUsageTaskBase() {}
 
   // Get total usage for the given |origins|.
   void GetUsageForOrigins(const std::set<GURL>& origins, StorageType type) {
     DCHECK(original_message_loop()->BelongsToCurrentThread());
@@ skipping 23 matching lines @@
     // the completion callback immediately.
     for (std::vector<GURL>::const_iterator iter = origins_to_gather.begin();
          iter != origins_to_gather.end(); iter++)
       pending_origins_.push_back(*iter);
 
     for (std::vector<GURL>::const_iterator iter = origins_to_gather.begin();
          iter != origins_to_gather.end(); iter++)
       client_->GetOriginUsage(
           *iter,
           tracker_->type(),
-          callback_factory_.NewCallback(&GatherUsageTaskBase::DidGetUsage));
+          base::Bind(&GatherUsageTaskBase::DidGetUsage,
+                     weak_factory_.GetWeakPtr()));
   }
 
  protected:
   virtual void Aborted() OVERRIDE {
     DeleteSoon();
   }
 
   UsageTracker* tracker() const { return tracker_; }
   ClientUsageTracker* client_tracker() const { return client_tracker_; }
 
@@ skipping 25 matching lines @@
       CallCompleted();
       DeleteSoon();
     }
   }
 
   QuotaClient* client_;
   UsageTracker* tracker_;
   ClientUsageTracker* client_tracker_;
   std::deque<GURL> pending_origins_;
   std::map<GURL, int64> origin_usage_map_;
-  base::ScopedCallbackFactory<GatherUsageTaskBase> callback_factory_;
+  base::WeakPtrFactory<GatherUsageTaskBase> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GatherUsageTaskBase);
 };
 
 // A task class for getting the total amount of data used for a given storage
 // type.  This class is self-destructed.
 class ClientUsageTracker::GatherGlobalUsageTask
     : public GatherUsageTaskBase {
  public:
   GatherGlobalUsageTask(
       UsageTracker* tracker,
       QuotaClient* client)
       : GatherUsageTaskBase(tracker, client),
         client_(client),
-        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     DCHECK(tracker);
     DCHECK(client);
   }
   virtual ~GatherGlobalUsageTask() {}
 
  protected:
   virtual void Run() OVERRIDE {
     client_->GetOriginsForType(tracker()->type(),
-          callback_factory_.NewCallback(
-              &GatherUsageTaskBase::GetUsageForOrigins));
+        base::Bind(&GatherUsageTaskBase::GetUsageForOrigins,
+                   weak_factory_.GetWeakPtr()));
   }
 
   virtual void Completed() OVERRIDE {
     client_tracker()->GatherGlobalUsageComplete();
   }
 
  private:
   QuotaClient* client_;
-  base::ScopedCallbackFactory<GatherUsageTaskBase> callback_factory_;
+  base::WeakPtrFactory<GatherUsageTaskBase> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GatherGlobalUsageTask);
 };
 
 // A task class for getting the total amount of data used for a given host.
 // This class is self-destructed.
 class ClientUsageTracker::GatherHostUsageTask
     : public GatherUsageTaskBase {
  public:
   GatherHostUsageTask(
       UsageTracker* tracker,
       QuotaClient* client,
       const std::string& host)
       : GatherUsageTaskBase(tracker, client),
         client_(client),
         host_(host),
-        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     DCHECK(client_);
   }
   virtual ~GatherHostUsageTask() {}
 
  protected:
   virtual void Run() OVERRIDE {
     client_->GetOriginsForHost(tracker()->type(), host_,
-          callback_factory_.NewCallback(
-              &GatherUsageTaskBase::GetUsageForOrigins));
+        base::Bind(&GatherUsageTaskBase::GetUsageForOrigins,
+                   weak_factory_.GetWeakPtr()));
   }
 
   virtual void Completed() OVERRIDE {
     client_tracker()->GatherHostUsageComplete(host_);
   }
 
  private:
   QuotaClient* client_;
   std::string host_;
-  base::ScopedCallbackFactory<GatherUsageTaskBase> callback_factory_;
+  base::WeakPtrFactory<GatherUsageTaskBase> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GatherHostUsageTask);
 };
 
 // UsageTracker ----------------------------------------------------------
 
 UsageTracker::UsageTracker(const QuotaClientList& clients, StorageType type,
                            SpecialStoragePolicy* special_storage_policy)
     : type_(type),
-      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   for (QuotaClientList::const_iterator iter = clients.begin();
       iter != clients.end();
       ++iter) {
     client_tracker_map_.insert(std::make_pair(
         (*iter)->id(),
         new ClientUsageTracker(this, *iter, type, special_storage_policy)));
   }
 }
 
 UsageTracker::~UsageTracker() {
   STLDeleteValues(&client_tracker_map_);
 }
 
 ClientUsageTracker* UsageTracker::GetClientTracker(QuotaClient::ID client_id) {
   ClientTrackerMap::iterator found = client_tracker_map_.find(client_id);
   if (found != client_tracker_map_.end())
     return found->second;
   return NULL;
 }
 
-void UsageTracker::GetGlobalUsage(GlobalUsageCallback* callback) {
+void UsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) {
   if (client_tracker_map_.size() == 0) {
     // No clients registered.
-    callback->Run(type_, 0, 0);
-    delete callback;
+    callback.Run(type_, 0, 0);
     return;
   }
   if (global_usage_callbacks_.Add(callback)) {
     // This is the first call.  Asks each ClientUsageTracker to collect
     // usage information.
     global_usage_.pending_clients = client_tracker_map_.size();
     global_usage_.usage = 0;
     global_usage_.unlimited_usage = 0;
     for (ClientTrackerMap::iterator iter = client_tracker_map_.begin();
          iter != client_tracker_map_.end();
          ++iter) {
-      iter->second->GetGlobalUsage(callback_factory_.NewCallback(
-          &UsageTracker::DidGetClientGlobalUsage));
+      iter->second->GetGlobalUsage(
+          base::Bind(&UsageTracker::DidGetClientGlobalUsage,
+                     weak_factory_.GetWeakPtr()));
     }
   }
 }
 
 void UsageTracker::GetHostUsage(
-    const std::string& host, HostUsageCallback* callback) {
+    const std::string& host, const HostUsageCallback& callback) {
   if (client_tracker_map_.size() == 0) {
     // No clients registered.
-    callback->Run(host, type_, 0);
-    delete callback;
+    callback.Run(host, type_, 0);
     return;
   }
   if (host_usage_callbacks_.Add(host, callback)) {
     // This is the first call for the given host.
     DCHECK(outstanding_host_usage_.find(host) == outstanding_host_usage_.end());
     outstanding_host_usage_[host].pending_clients = client_tracker_map_.size();
     for (ClientTrackerMap::iterator iter = client_tracker_map_.begin();
          iter != client_tracker_map_.end();
          ++iter) {
-      iter->second->GetHostUsage(host, callback_factory_.NewCallback(
-          &UsageTracker::DidGetClientHostUsage));
+      iter->second->GetHostUsage(host,
+          base::Bind(&UsageTracker::DidGetClientHostUsage,
+                     weak_factory_.GetWeakPtr()));
     }
   }
 }
 
 void UsageTracker::UpdateUsageCache(
     QuotaClient::ID client_id, const GURL& origin, int64 delta) {
   ClientUsageTracker* client_tracker = GetClientTracker(client_id);
   DCHECK(client_tracker);
   client_tracker->UpdateUsageCache(origin, delta);
 }
@@ skipping 76 matching lines @@
   DCHECK(client_);
   if (special_storage_policy_)
     special_storage_policy_->AddObserver(this);
 }
 
 ClientUsageTracker::~ClientUsageTracker() {
   if (special_storage_policy_)
     special_storage_policy_->RemoveObserver(this);
 }
 
-void ClientUsageTracker::GetGlobalUsage(GlobalUsageCallback* callback) {
+void ClientUsageTracker::GetGlobalUsage(const GlobalUsageCallback& callback) {
   if (global_usage_retrieved_) {
-    callback->Run(type_, global_usage_, GetCachedGlobalUnlimitedUsage());
-    delete callback;
+    callback.Run(type_, global_usage_, GetCachedGlobalUnlimitedUsage());
     return;
   }
   DCHECK(!global_usage_callback_.HasCallbacks());
   global_usage_callback_.Add(callback);
   global_usage_task_ = new GatherGlobalUsageTask(tracker_, client_);
   global_usage_task_->Start();
 }
 
 void ClientUsageTracker::GetHostUsage(
-    const std::string& host, HostUsageCallback* callback) {
+    const std::string& host, const HostUsageCallback& callback) {
   HostSet::const_iterator found = cached_hosts_.find(host);
   if (found != cached_hosts_.end()) {
     // TODO(kinuko): Drop host_usage_map_ cache periodically.
-    callback->Run(host, type_, GetCachedHostUsage(host));
-    delete callback;
+    callback.Run(host, type_, GetCachedHostUsage(host));
     return;
   }
   if (!host_usage_callbacks_.Add(host, callback) || global_usage_task_)
     return;
   GatherHostUsageTask* task = new GatherHostUsageTask(tracker_, client_, host);
   host_usage_tasks_[host] = task;
   task->Start();
 }
 
 void ClientUsageTracker::UpdateUsageCache(
     const GURL& origin, int64 delta) {
   std::string host = net::GetHostOrSpecFromURL(origin);
   if (cached_hosts_.find(host) != cached_hosts_.end()) {
     cached_usage_[host][origin] += delta;
     global_usage_ += delta;
     if (global_unlimited_usage_is_valid_ && IsStorageUnlimited(origin))
       global_unlimited_usage_ += delta;
     DCHECK_GE(cached_usage_[host][origin], 0);
     DCHECK_GE(global_usage_, 0);
     return;
   }
 
   // We don't know about this host yet, so populate our cache for it.
   GetHostUsage(host,
-               NewCallback(this, &ClientUsageTracker::NoopHostUsageCallback));
+               base::Bind(&ClientUsageTracker::NoopHostUsageCallback,
+                          base::Unretained(this)));
 }
 
 void ClientUsageTracker::GetCachedHostsUsage(
     std::map<std::string, int64>* host_usage) const {
   DCHECK(host_usage);
   for (HostUsageMap::const_iterator host_iter = cached_usage_.begin();
        host_iter != cached_usage_.end(); host_iter++) {
     host_usage->operator[](host_iter->first) +=
         GetCachedHostUsage(host_iter->first);
   }
@@ skipping 94 matching lines @@
 void ClientUsageTracker::NoopHostUsageCallback(
     const std::string& host,  StorageType type, int64 usage) {
 }
 
 bool ClientUsageTracker::IsStorageUnlimited(const GURL& origin) const {
   return special_storage_policy_.get() &&
          special_storage_policy_->IsStorageUnlimited(origin);
 }
 
 }  // namespace quota