Use base::Callback in Quota related code.

webkit/fileapi/file_system_quota_client_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 "base/bind.h"
 #include "base/basictypes.h"
 #include "base/file_util.h"
-#include "base/memory/scoped_callback_factory.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/platform_file.h"
 #include "base/scoped_temp_dir.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_quota_client.h"
 #include "webkit/fileapi/file_system_types.h"
@@ skipping 20 matching lines @@
   explicit MockFileSystemPathManager(const FilePath& filesystem_path)
       : FileSystemPathManager(base::MessageLoopProxy::current(),
                               filesystem_path, NULL, false, true) {}
 };
 
 }  // namespace
 
 class FileSystemQuotaClientTest : public testing::Test {
  public:
   FileSystemQuotaClientTest()
-      : callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      : weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         additional_callback_count_(0),
         deletion_status_(quota::kQuotaStatusUnknown) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     file_system_context_ =
         new FileSystemContext(
             base::MessageLoopProxy::current(),
             base::MessageLoopProxy::current(),
@@ skipping 13 matching lines @@
  protected:
   FileSystemQuotaClient* NewQuotaClient(bool is_incognito) {
     return new FileSystemQuotaClient(
         base::MessageLoopProxy::current(),
         file_system_context_, is_incognito);
   }
 
   void GetOriginUsageAsync(FileSystemQuotaClient* quota_client,
                            const std::string& origin_url,
                            quota::StorageType type) {
-    quota_client->GetOriginUsage(GURL(origin_url), type,
-        callback_factory_.NewCallback(
-            &FileSystemQuotaClientTest::OnGetUsage));
+    quota_client->GetOriginUsage(
+        GURL(origin_url), type,
+        base::Bind(&FileSystemQuotaClientTest::OnGetUsage,
+                   weak_factory_.GetWeakPtr()));
   }
 
   int64 GetOriginUsage(FileSystemQuotaClient* quota_client,
                        const std::string& origin_url,
                        quota::StorageType type) {
     GetOriginUsageAsync(quota_client, origin_url, type);
     MessageLoop::current()->RunAllPending();
     return usage_;
   }
 
   const std::set<GURL>& GetOriginsForType(FileSystemQuotaClient* quota_client,
                                           quota::StorageType type) {
     origins_.clear();
-    quota_client->GetOriginsForType(type,
-        callback_factory_.NewCallback(
-            &FileSystemQuotaClientTest::OnGetOrigins));
+    quota_client->GetOriginsForType(
+        type,
+        base::Bind(&FileSystemQuotaClientTest::OnGetOrigins,
+                   weak_factory_.GetWeakPtr()));
     MessageLoop::current()->RunAllPending();
     return origins_;
   }
 
   const std::set<GURL>& GetOriginsForHost(FileSystemQuotaClient* quota_client,
                                           quota::StorageType type,
                                           const std::string& host) {
     origins_.clear();
-    quota_client->GetOriginsForHost(type, host,
-        callback_factory_.NewCallback(
-            &FileSystemQuotaClientTest::OnGetOrigins));
+    quota_client->GetOriginsForHost(
+        type, host,
+        base::Bind(&FileSystemQuotaClientTest::OnGetOrigins,
+                   weak_factory_.GetWeakPtr()));
     MessageLoop::current()->RunAllPending();
     return origins_;
   }
 
   void RunAdditionalOriginUsageTask(FileSystemQuotaClient* quota_client,
                                     const std::string& origin_url,
                                     quota::StorageType type) {
-    quota_client->GetOriginUsage(GURL(origin_url), type,
-        callback_factory_.NewCallback(
-            &FileSystemQuotaClientTest::OnGetAdditionalUsage));
+    quota_client->GetOriginUsage(
+        GURL(origin_url), type,
+        base::Bind(&FileSystemQuotaClientTest::OnGetAdditionalUsage,
+                   weak_factory_.GetWeakPtr()));
   }
 
   FilePath GetOriginBasePath(const std::string& origin_url,
                              quota::StorageType type) {
     // Note: this test assumes sandbox_provider impl is used for
     // temporary and persistent filesystem.
     return file_system_context_->path_manager()->sandbox_provider()->
         GetBaseDirectoryForOriginAndType(
             GURL(origin_url), QuotaStorageTypeToFileSystemType(type), true);
   }
@@ skipping 95 matching lines @@
     }
     return file_paths_cost;
   }
 
   void DeleteOriginData(FileSystemQuotaClient* quota_client,
                         const std::string& origin,
                         quota::StorageType type) {
     deletion_status_ = quota::kQuotaStatusUnknown;
     quota_client->DeleteOriginData(
         GURL(origin), type,
-        callback_factory_.NewCallback(
-            &FileSystemQuotaClientTest::OnDeleteOrigin));
+        base::Bind(&FileSystemQuotaClientTest::OnDeleteOrigin,
+                   weak_factory_.GetWeakPtr()));
   }
 
   int64 usage() const { return usage_; }
   quota::QuotaStatusCode status() { return deletion_status_; }
   int additional_callback_count() const { return additional_callback_count_; }
   void set_additional_callback_count(int count) {
     additional_callback_count_ = count;
   }
 
  private:
@@ skipping 10 matching lines @@
   void OnGetAdditionalUsage(int64 usage_unused) {
     ++additional_callback_count_;
   }
 
   void OnDeleteOrigin(quota::QuotaStatusCode status) {
     deletion_status_ = status;
   }
 
   ScopedTempDir data_dir_;
   scoped_refptr<FileSystemContext> file_system_context_;
-  base::ScopedCallbackFactory<FileSystemQuotaClientTest> callback_factory_;
+  base::WeakPtrFactory<FileSystemQuotaClientTest> weak_factory_;
   int64 usage_;
   int additional_callback_count_;
   std::set<GURL> origins_;
   quota::StorageType type_;
   quota::QuotaStatusCode deletion_status_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemQuotaClientTest);
 };
 
 TEST_F(FileSystemQuotaClientTest, NoFileSystemTest) {
@@ skipping 314 matching lines @@
             GetOriginUsage(quota_client.get(),
                            "https://bar.com/",
                            kPersistent));
   EXPECT_EQ(64 + file_paths_cost_temporary_bar_https,
             GetOriginUsage(quota_client.get(),
                            "https://bar.com/",
                            kTemporary));
 }
 
 }  // namespace fileapi