Use base::Callback in Quota related code.

webkit/quota/quota_manager_unittest.cc

Index: webkit/quota/quota_manager_unittest.cc
diff --git a/webkit/quota/quota_manager_unittest.cc b/webkit/quota/quota_manager_unittest.cc
index 2c828b3c54b4c0f856e967936a0e9ee92623cf28..7f16904116c3543365e29fd9d02a6617e510cf58 100644
--- a/webkit/quota/quota_manager_unittest.cc
+++ b/webkit/quota/quota_manager_unittest.cc
@@ -6,8 +6,8 @@
 #include <sstream>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/file_util.h"
-#include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ -42,7 +42,7 @@ class QuotaManagerTest : public testing::Test {
 
  public:
   QuotaManagerTest()
-      : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      : weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         mock_time_counter_(0) {
   }
 
@@ -81,25 +81,27 @@ class QuotaManagerTest : public testing::Test {
     quota_status_ = kQuotaStatusUnknown;
     usage_ = -1;
     quota_ = -1;
-    quota_manager_->GetUsageAndQuota(origin, type,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetUsageAndQuota));
+    quota_manager_->GetUsageAndQuota(
+        origin, type,
+        base::Bind(&QuotaManagerTest::DidGetUsageAndQuota,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetTemporaryGlobalQuota() {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
     quota_manager_->GetTemporaryGlobalQuota(
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetQuota));
+        base::Bind(&QuotaManagerTest::DidGetQuota,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void SetTemporaryGlobalQuota(int64 new_quota) {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
-    quota_manager_->SetTemporaryGlobalQuota(new_quota,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetQuota));
+    quota_manager_->SetTemporaryGlobalQuota(
+        new_quota,
+        base::Bind(&QuotaManagerTest::DidGetQuota,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetPersistentHostQuota(const std::string& host) {
@@ -107,9 +109,10 @@ class QuotaManagerTest : public testing::Test {
     host_.clear();
     type_ = kStorageTypeUnknown;
     quota_ = -1;
-    quota_manager_->GetPersistentHostQuota(host,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetHostQuota));
+    quota_manager_->GetPersistentHostQuota(
+        host,
+        base::Bind(&QuotaManagerTest::DidGetHostQuota,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void SetPersistentHostQuota(const std::string& host, int64 new_quota) {
@@ -117,33 +120,37 @@ class QuotaManagerTest : public testing::Test {
     host_.clear();
     type_ = kStorageTypeUnknown;
     quota_ = -1;
-    quota_manager_->SetPersistentHostQuota(host, new_quota,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetHostQuota));
+    quota_manager_->SetPersistentHostQuota(
+        host, new_quota,
+        base::Bind(&QuotaManagerTest::DidGetHostQuota,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetGlobalUsage(StorageType type) {
     type_ = kStorageTypeUnknown;
     usage_ = -1;
     unlimited_usage_ = -1;
-    quota_manager_->GetGlobalUsage(type,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetGlobalUsage));
+    quota_manager_->GetGlobalUsage(
+        type,
+        base::Bind(&QuotaManagerTest::DidGetGlobalUsage,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetHostUsage(const std::string& host, StorageType type) {
     host_.clear();
     type_ = kStorageTypeUnknown;
     usage_ = -1;
-    quota_manager_->GetHostUsage(host, type,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetHostUsage));
+    quota_manager_->GetHostUsage(
+        host, type,
+        base::Bind(&QuotaManagerTest::DidGetHostUsage,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void RunAdditionalUsageAndQuotaTask(const GURL& origin, StorageType type) {
-    quota_manager_->GetUsageAndQuota(origin, type,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetUsageAndQuotaAdditional));
+    quota_manager_->GetUsageAndQuota(
+        origin, type,
+        base::Bind(&QuotaManagerTest::DidGetUsageAndQuotaAdditional,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void DeleteClientOriginData(QuotaClient* client,
@@ -151,33 +158,36 @@ class QuotaManagerTest : public testing::Test {
                         StorageType type) {
     DCHECK(client);
     quota_status_ = kQuotaStatusUnknown;
-    client->DeleteOriginData(origin, type,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::StatusCallback));
+    client->DeleteOriginData(
+        origin, type,
+        base::Bind(&QuotaManagerTest::StatusCallback,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void EvictOriginData(const GURL& origin,
                        StorageType type) {
     quota_status_ = kQuotaStatusUnknown;
-    quota_manager_->EvictOriginData(origin, type,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::StatusCallback));
+    quota_manager_->EvictOriginData(
+        origin, type,
+        base::Bind(&QuotaManagerTest::StatusCallback,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void DeleteOriginData(const GURL& origin,
                         StorageType type) {
     quota_status_ = kQuotaStatusUnknown;
-    quota_manager_->DeleteOriginData(origin, type,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::StatusCallback));
+    quota_manager_->DeleteOriginData(
+        origin, type,
+        base::Bind(&QuotaManagerTest::StatusCallback,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetAvailableSpace() {
     quota_status_ = kQuotaStatusUnknown;
     available_space_ = -1;
     quota_manager_->GetAvailableSpace(
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetAvailableSpace));
+        base::Bind(&QuotaManagerTest::DidGetAvailableSpace,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetUsageAndQuotaForEviction() {
@@ -187,8 +197,8 @@ class QuotaManagerTest : public testing::Test {
     quota_ = -1;
     available_space_ = -1;
     quota_manager_->GetUsageAndQuotaForEviction(
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetUsageAndQuotaForEviction));
+        base::Bind(&QuotaManagerTest::DidGetUsageAndQuotaForEviction,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetCachedOrigins(StorageType type, std::set<GURL>* origins) {
@@ -211,8 +221,10 @@ class QuotaManagerTest : public testing::Test {
 
   void GetLRUOrigin(StorageType type) {
     lru_origin_ = GURL();
-    quota_manager_->GetLRUOrigin(type,
-        callback_factory_.NewCallback(&QuotaManagerTest::DidGetLRUOrigin));
+    quota_manager_->GetLRUOrigin(
+        type,
+        base::Bind(&QuotaManagerTest::DidGetLRUOrigin,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void NotifyOriginInUse(const GURL& origin) {
@@ -226,23 +238,24 @@ class QuotaManagerTest : public testing::Test {
   void GetOriginsModifiedSince(StorageType type, base::Time modified_since) {
     modified_origins_.clear();
     modified_origins_type_ = kStorageTypeUnknown;
-    quota_manager_->GetOriginsModifiedSince(type, modified_since,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetModifiedOrigins));
+    quota_manager_->GetOriginsModifiedSince(
+        type, modified_since,
+        base::Bind(&QuotaManagerTest::DidGetModifiedOrigins,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void DumpQuotaTable() {
     quota_entries_.clear();
     quota_manager_->DumpQuotaTable(
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidDumpQuotaTable));
+        base::Bind(&QuotaManagerTest::DidDumpQuotaTable,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void DumpOriginInfoTable() {
     origin_info_entries_.clear();
     quota_manager_->DumpOriginInfoTable(
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidDumpOriginInfoTable));
+        base::Bind(&QuotaManagerTest::DidDumpOriginInfoTable,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
@@ -363,7 +376,7 @@ class QuotaManagerTest : public testing::Test {
   }
 
   ScopedTempDir data_dir_;
-  base::ScopedCallbackFactory<QuotaManagerTest> callback_factory_;
+  base::WeakPtrFactory<QuotaManagerTest> weak_factory_;
 
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<MockSpecialStoragePolicy> mock_special_storage_policy_;