base::Bind: Final cleanups in webkit/quota.

webkit/quota/quota_temporary_storage_evictor_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 <list>
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/callback.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/task.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/quota/mock_storage_client.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_temporary_storage_evictor.h"
 
 namespace quota {
 
@@ skipping 24 matching lines @@
       available_space_ += origin_usage;
     callback.Run(quota::kQuotaStatusOk);
   }
 
   virtual void GetUsageAndQuotaForEviction(
       const GetUsageAndQuotaForEvictionCallback& callback) OVERRIDE {
     if (error_on_get_usage_and_quota_) {
       callback.Run(quota::kQuotaErrorInvalidAccess, QuotaAndUsage());
       return;
     }
-    if (task_for_get_usage_and_quota_.get())
-      task_for_get_usage_and_quota_->Run();
+    if (!task_for_get_usage_and_quota_.is_null())
+      task_for_get_usage_and_quota_.Run();
     QuotaAndUsage quota_and_usage = {
         GetUsage(), unlimited_usage_, quota_, available_space_ };
     callback.Run(quota::kQuotaStatusOk, quota_and_usage);
   }
 
   virtual void GetLRUOrigin(
       StorageType type,
       const GetLRUOriginCallback& callback) OVERRIDE {
     if (origin_order_.empty())
       callback.Run(GURL());
@@ skipping 12 matching lines @@
 
   void set_quota(int64 quota) {
     quota_ = quota;
   }
   void set_unlimited_usage(int64 usage) {
     unlimited_usage_ = usage;
   }
   void set_available_space(int64 available_space) {
     available_space_ = available_space;
   }
-  void set_task_for_get_usage_and_quota(CancelableTask* task) {
-    task_for_get_usage_and_quota_.reset(task);
+  void set_task_for_get_usage_and_quota(const base::Closure& task) {
+    task_for_get_usage_and_quota_= task;
   }
   void set_error_on_evict_origin_data(bool error_on_evict_origin_data) {
     error_on_evict_origin_data_ = error_on_evict_origin_data;
   }
   void set_error_on_get_usage_and_quota(bool error_on_get_usage_and_quota) {
     error_on_get_usage_and_quota_ = error_on_get_usage_and_quota;
   }
 
   // Simulates an access to |origin|.  It reorders the internal LRU list.
   // It internally uses AddOrigin().
@@ skipping 27 matching lines @@
 
   int64 quota_;
   int64 unlimited_usage_;
   int64 available_space_;
   std::list<GURL> origin_order_;
   std::map<GURL, int64> origins_;
   bool error_on_evict_origin_data_;
   bool error_on_get_usage_and_quota_;
 
   QuotaTemporaryStorageEvictorTest *test_;
-  scoped_ptr<CancelableTask> task_for_get_usage_and_quota_;
+  base::Closure task_for_get_usage_and_quota_;
 };
 
 }  // anonymous namespace
 
 class QuotaTemporaryStorageEvictorTest : public testing::Test {
  public:
   QuotaTemporaryStorageEvictorTest()
       : num_get_usage_and_quota_for_eviction_(0),
-        runnable_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {}
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
   void SetUp() {
     quota_eviction_handler_.reset(new MockQuotaEvictionHandler(this));
 
     // Run multiple evictions in a single RunAllPending() when interval_ms == 0
     temporary_storage_evictor_.reset(new QuotaTemporaryStorageEvictor(
         quota_eviction_handler_.get(), 0));
   }
 
   void TearDown() {
@@ skipping 61 matching lines @@
   void reset_min_available_disk_space_to_start_eviction() const {
     temporary_storage_evictor_->
         reset_min_available_disk_space_to_start_eviction();
   }
 
   scoped_ptr<QuotaEvictionHandler> quota_eviction_handler_;
   scoped_ptr<QuotaTemporaryStorageEvictor> temporary_storage_evictor_;
 
   int num_get_usage_and_quota_for_eviction_;
 
-  ScopedRunnableMethodFactory<QuotaTemporaryStorageEvictorTest>
-      runnable_factory_;
+  base::WeakPtrFactory<QuotaTemporaryStorageEvictorTest> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaTemporaryStorageEvictorTest);
 };
 
 TEST_F(QuotaTemporaryStorageEvictorTest, SimpleEvictionTest) {
   quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 3000);
   quota_eviction_handler()->AddOrigin(GURL("http://www.y.com"), 200);
   quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 500);
   quota_eviction_handler()->set_quota(4000);
   quota_eviction_handler()->set_available_space(1000000000);
@@ skipping 38 matching lines @@
   const int64 initial_total_size = a_size + b_size + c_size + d_size;
   const int64 e_size = 275;
 
   quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
   quota_eviction_handler()->set_quota(1000);
   quota_eviction_handler()->set_available_space(1000000000);
   quota_eviction_handler()->set_task_for_get_usage_and_quota(
-      runnable_factory_.NewRunnableMethod(
-          &QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
-          std::make_pair(GURL("http://www.e.com"), e_size),
-          GURL(),
-          initial_total_size - d_size,
-          initial_total_size - d_size + e_size - c_size));
+      base::Bind(&QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
+                 weak_factory_.GetWeakPtr(),
+                 std::make_pair(GURL("http://www.e.com"), e_size), GURL(),
+                 initial_total_size - d_size,
+                 initial_total_size - d_size + e_size - c_size));
   EXPECT_EQ(initial_total_size, quota_eviction_handler()->GetUsage());
   temporary_storage_evictor()->Start();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(initial_total_size - d_size + e_size - c_size - b_size,
             quota_eviction_handler()->GetUsage());
   EXPECT_EQ(5, num_get_usage_and_quota_for_eviction());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(3, statistics().num_evicted_origins);
   EXPECT_EQ(2, statistics().num_eviction_rounds);
   EXPECT_EQ(0, statistics().num_skipped_eviction_rounds);
 }
 
 TEST_F(QuotaTemporaryStorageEvictorTest, RepeatedEvictionSkippedTest) {
   const int64 a_size = 400;
   const int64 b_size = 150;
   const int64 c_size = 120;
   const int64 d_size = 292;
   const int64 initial_total_size = a_size + b_size + c_size + d_size;
 
   quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
   quota_eviction_handler()->set_quota(1000);
   quota_eviction_handler()->set_available_space(1000000000);
   quota_eviction_handler()->set_task_for_get_usage_and_quota(
-      runnable_factory_.NewRunnableMethod(
-          &QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
-          std::make_pair(GURL(), 0),
-          GURL(),
-          initial_total_size - d_size,
-          initial_total_size - d_size));
+      base::Bind(&QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
+                 weak_factory_.GetWeakPtr(), std::make_pair(GURL(), 0), GURL(),
+                 initial_total_size - d_size, initial_total_size - d_size));
   EXPECT_EQ(initial_total_size, quota_eviction_handler()->GetUsage());
   set_repeated_eviction(true);
   temporary_storage_evictor()->Start();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(initial_total_size - d_size,
             quota_eviction_handler()->GetUsage());
   EXPECT_EQ(4, num_get_usage_and_quota_for_eviction());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
@@ skipping 10 matching lines @@
   const int64 initial_total_size = a_size + b_size + c_size + d_size;
   const int64 e_size = 275;
 
   quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
   quota_eviction_handler()->set_quota(1000);
   quota_eviction_handler()->set_available_space(1000000000);
   quota_eviction_handler()->set_task_for_get_usage_and_quota(
-      runnable_factory_.NewRunnableMethod(
-          &QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
-          std::make_pair(GURL("http://www.e.com"), e_size),
-          GURL("http://www.c.com"),
-          initial_total_size - d_size,
-          initial_total_size - d_size + e_size - b_size));
+      base::Bind(&QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
+                 weak_factory_.GetWeakPtr(),
+                 std::make_pair(GURL("http://www.e.com"), e_size),
+                 GURL("http://www.c.com"),
+                 initial_total_size - d_size,
+                 initial_total_size - d_size + e_size - b_size));
   EXPECT_EQ(initial_total_size, quota_eviction_handler()->GetUsage());
   temporary_storage_evictor()->Start();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(initial_total_size - d_size + e_size - b_size - a_size,
             quota_eviction_handler()->GetUsage());
   EXPECT_EQ(5, num_get_usage_and_quota_for_eviction());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(3, statistics().num_evicted_origins);
@@ skipping 53 matching lines @@
   quota_eviction_handler()->set_available_space(1000000000);
   EXPECT_EQ(3000 + 200 + 500000, quota_eviction_handler()->GetUsage());
   set_repeated_eviction(false);
   temporary_storage_evictor()->Start();
   MessageLoop::current()->RunAllPending();
   // Nothing should have been evicted.
   EXPECT_EQ(3000 + 200 + 500000, quota_eviction_handler()->GetUsage());
 }
 
 }  // namespace quota