Use base::Callback in Quota related code.

webkit/quota/quota_manager_unittest.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 <set>
 #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/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 11 matching lines @@
 const StorageType kPerm = kStorageTypePersistent;
 
 class QuotaManagerTest : public testing::Test {
  protected:
   typedef QuotaManager::QuotaTableEntry QuotaTableEntry;
   typedef QuotaManager::QuotaTableEntries QuotaTableEntries;
   typedef QuotaManager::OriginInfoTableEntries OriginInfoTableEntries;
 
  public:
   QuotaManagerTest()
-      : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
-        weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      : weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         mock_time_counter_(0) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     mock_special_storage_policy_ = new MockSpecialStoragePolicy;
     quota_manager_ = new QuotaManager(
         false /* is_incognito */,
         data_dir_.path(),
         MessageLoopProxy::current(),
@@ skipping 16 matching lines @@
     return new MockStorageClient(quota_manager_->proxy(),
                                  mock_data, mock_data_size);
   }
 
   void RegisterClient(MockStorageClient* client) {
     quota_manager_->proxy()->RegisterClient(client);
   }
 
   void GetUsageInfo() {
     usage_info_.clear();
-    quota_manager_->GetUsageInfo(callback_factory_.NewCallback(
-        &QuotaManagerTest::DidGetUsageInfo));
+    quota_manager_->GetUsageInfo(
+        base::Bind(&QuotaManagerTest::DidGetUsageInfo,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetUsageAndQuota(const GURL& origin, StorageType type) {
     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_->SetTemporaryGlobalOverrideQuota(
         new_quota,
-        callback_factory_.NewCallback(
-            &QuotaManagerTest::DidGetQuota));
+        base::Bind(&QuotaManagerTest::DidGetQuota,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetPersistentHostQuota(const std::string& host) {
     quota_status_ = kQuotaStatusUnknown;
     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) {
     quota_status_ = kQuotaStatusUnknown;
     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,
                         const GURL& origin,
                         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() {
     quota_status_ = kQuotaStatusUnknown;
     usage_ = -1;
     unlimited_usage_ = -1;
     quota_ = -1;
     available_space_ = -1;
     quota_manager_->GetUsageAndQuotaForEviction(
         base::Bind(&QuotaManagerTest::DidGetUsageAndQuotaForEviction,
@@ skipping 30 matching lines @@
     quota_manager_->NotifyOriginInUse(origin);
   }
 
   void NotifyOriginNoLongerInUse(const GURL& origin) {
     quota_manager_->NotifyOriginNoLongerInUse(origin);
   }
 
   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 DidGetUsageInfo(const UsageInfoEntries& entries) {
     usage_info_.insert(usage_info_.begin(), entries.begin(), entries.end());
   }
 
   void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
     quota_status_ = status;
     usage_ = usage;
     quota_ = quota;
@@ skipping 105 matching lines @@
   int status_callback_count() const { return status_callback_count_; }
   void reset_status_callback_count() { status_callback_count_ = 0; }
 
  private:
   base::Time IncrementMockTime() {
     ++mock_time_counter_;
     return base::Time::FromDoubleT(mock_time_counter_ * 10.0);
   }
 
   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_;
 
   QuotaStatusCode quota_status_;
   UsageInfoEntries usage_info_;
   std::string host_;
   StorageType type_;
   int64 usage_;
@@ skipping 1247 matching lines @@
   GetPersistentHostQuota(std::string());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, quota());
 
   SetPersistentHostQuota(std::string(), 10);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaErrorNotSupported, status());
 }
 }  // namespace quota