Use base::Callback in Quota related code.

content/browser/renderer_host/quota_dispatcher_host.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/renderer_host/quota_dispatcher_host.h"
 
+#include "base/bind.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "content/browser/quota_permission_context.h"
 #include "content/common/quota_messages.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "webkit/quota/quota_manager.h"
 
 using quota::QuotaClient;
 using quota::QuotaManager;
 using quota::QuotaStatusCode;
@@ skipping 33 matching lines @@
   int request_id_;
 };
 
 class QuotaDispatcherHost::QueryUsageAndQuotaDispatcher
     : public RequestDispatcher {
  public:
   QueryUsageAndQuotaDispatcher(
       QuotaDispatcherHost* dispatcher_host,
       int request_id)
       : RequestDispatcher(dispatcher_host, request_id),
-        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
   virtual ~QueryUsageAndQuotaDispatcher() {}
 
   void QueryStorageUsageAndQuota(const GURL& origin, StorageType type) {
-    quota_manager()->GetUsageAndQuota(origin, type,
-        callback_factory_.NewCallback(
-            &QueryUsageAndQuotaDispatcher::DidQueryStorageUsageAndQuota));
+    quota_manager()->GetUsageAndQuota(
+        origin, type,
+        base::Bind(&QueryUsageAndQuotaDispatcher::DidQueryStorageUsageAndQuota,
+                   weak_factory_.GetWeakPtr()));
   }
 
  private:
   void DidQueryStorageUsageAndQuota(
       QuotaStatusCode status, int64 usage, int64 quota) {
     DCHECK(dispatcher_host());
     if (status != quota::kQuotaStatusOk) {
       dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidQueryStorageUsageAndQuota(
           request_id(), usage, quota));
     }
     Completed();
   }
 
-  base::ScopedCallbackFactory<QueryUsageAndQuotaDispatcher> callback_factory_;
+  base::WeakPtrFactory<QueryUsageAndQuotaDispatcher> weak_factory_;
 };
 
 class QuotaDispatcherHost::RequestQuotaDispatcher
     : public RequestDispatcher {
  public:
   typedef RequestQuotaDispatcher self_type;
 
   RequestQuotaDispatcher(QuotaDispatcherHost* dispatcher_host,
                          int request_id,
                          const GURL& origin,
                          StorageType type,
                          int64 requested_quota,
                          int render_view_id)
       : RequestDispatcher(dispatcher_host, request_id),
         origin_(origin),
         host_(net::GetHostOrSpecFromURL(origin)),
         type_(type),
         current_quota_(0),
         requested_quota_(requested_quota),
         render_view_id_(render_view_id),
+        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
   virtual ~RequestQuotaDispatcher() {}
 
   void Start() {
     DCHECK(type_ == quota::kStorageTypeTemporary ||
            type_ == quota::kStorageTypePersistent);
     if (type_ == quota::kStorageTypePersistent) {
       quota_manager()->GetPersistentHostQuota(
           host_,
-          callback_factory_.NewCallback(&self_type::DidGetHostQuota));
+          base::Bind(&self_type::DidGetHostQuota,
+                     weak_factory_.GetWeakPtr()));
     } else {
       quota_manager()->GetUsageAndQuota(
           origin_, type_,
-          callback_factory_.NewCallback(
-              &self_type::DidGetTemporaryUsageAndQuota));
+          base::Bind(&self_type::DidGetTemporaryUsageAndQuota,
+                     weak_factory_.GetWeakPtr()));
     }
   }
 
  private:
   void DidGetHostQuota(QuotaStatusCode status,
                        const std::string& host,
                        StorageType type,
                        int64 quota) {
     DCHECK_EQ(type_, type);
     DCHECK_EQ(host_, host);
@@ skipping 23 matching lines @@
 
   void DidGetPermissionResponse(QuotaPermissionContext::Response response) {
     if (response != QuotaPermissionContext::kResponseAllow) {
       // User didn't allow the new quota.  Just returning the current quota.
       DidFinish(quota::kQuotaStatusOk, current_quota_);
       return;
     }
     // Now we're allowed to set the new quota.
     quota_manager()->SetPersistentHostQuota(
         host_, requested_quota_,
-        callback_factory_.NewCallback(&self_type::DidSetHostQuota));
+        base::Bind(&self_type::DidSetHostQuota,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void DidSetHostQuota(QuotaStatusCode status,
                        const std::string& host,
                        StorageType type,
                        int64 new_quota) {
     DCHECK_EQ(host_, host);
     DCHECK_EQ(type_, type);
     DidFinish(status, new_quota);
   }
 
   void DidFinish(QuotaStatusCode status, int64 granted_quota) {
     DCHECK(dispatcher_host());
     if (status != quota::kQuotaStatusOk) {
       dispatcher_host()->Send(new QuotaMsg_DidFail(request_id(), status));
     } else {
       dispatcher_host()->Send(new QuotaMsg_DidGrantStorageQuota(
           request_id(), granted_quota));
     }
     Completed();
   }
 
   const GURL origin_;
   const std::string host_;
   const StorageType type_;
   int64 current_quota_;
   const int64 requested_quota_;
   const int render_view_id_;
+  base::WeakPtrFactory<self_type> weak_factory_;
   base::ScopedCallbackFactory<self_type> callback_factory_;
 };
 
 QuotaDispatcherHost::QuotaDispatcherHost(
     int process_id,
     QuotaManager* quota_manager,
     QuotaPermissionContext* permission_context)
     : process_id_(process_id),
       quota_manager_(quota_manager),
       permission_context_(permission_context) {
@@ skipping 41 matching lines @@
       type != quota::kStorageTypePersistent) {
     // Unsupported storage types.
     Send(new QuotaMsg_DidFail(request_id, quota::kQuotaErrorNotSupported));
     return;
   }
 
   RequestQuotaDispatcher* dispatcher = new RequestQuotaDispatcher(
       this, request_id, origin, type, requested_size, render_view_id);
   dispatcher->Start();
 }