Use base::Callback in Quota related code.

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 "testing/gtest/include/gtest/gtest.h"
-
 #include <list>
 #include <map>
+#include <utility>
 
 #include "base/memory/scoped_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 {
 
 class QuotaTemporaryStorageEvictorTest;
 
 namespace {
 
 class MockQuotaEvictionHandler : public quota::QuotaEvictionHandler {
  public:
-  MockQuotaEvictionHandler(QuotaTemporaryStorageEvictorTest *test)
+  explicit MockQuotaEvictionHandler(QuotaTemporaryStorageEvictorTest *test)
       : quota_(0),
         unlimited_usage_(0),
         available_space_(0),
         error_on_evict_origin_data_(false),
         error_on_get_usage_and_quota_(false),
         test_(test) {}
 
   virtual void EvictOriginData(
       const GURL& origin,
       StorageType type,
-      EvictOriginDataCallback* callback) OVERRIDE {
+      EvictOriginDataCallback callback) OVERRIDE {
     if (error_on_evict_origin_data_) {
-      callback->Run(quota::kQuotaErrorInvalidModification);
-      delete callback;
+      callback.Run(quota::kQuotaErrorInvalidModification);
       return;
     }
     int64 origin_usage = EnsureOriginRemoved(origin);
     if (origin_usage >= 0)
       available_space_ += origin_usage;
-    callback->Run(quota::kQuotaStatusOk);
-    delete callback;
+    callback.Run(quota::kQuotaStatusOk);
   }
 
   virtual void GetUsageAndQuotaForEviction(
-      GetUsageAndQuotaForEvictionCallback* callback) OVERRIDE {
+      GetUsageAndQuotaForEvictionCallback callback) OVERRIDE {
     if (error_on_get_usage_and_quota_) {
-      callback->Run(quota::kQuotaErrorInvalidAccess, 0, 0, 0, 0);
-      delete callback;
+      callback.Run(quota::kQuotaErrorInvalidAccess, 0, 0, 0, 0);
       return;
     }
     if (task_for_get_usage_and_quota_.get())
       task_for_get_usage_and_quota_->Run();
-    callback->Run(quota::kQuotaStatusOk, GetUsage(), unlimited_usage_,
+    callback.Run(quota::kQuotaStatusOk, GetUsage(), unlimited_usage_,
                   quota_, available_space_);
-    delete callback;
   }
 
   virtual void GetLRUOrigin(
       StorageType type,
-      GetLRUOriginCallback* callback) OVERRIDE {
+      GetLRUOriginCallback callback) OVERRIDE {
     if (origin_order_.empty())
-      callback->Run(GURL());
+      callback.Run(GURL());
     else
-      callback->Run(GURL(origin_order_.front()));
-    delete callback;
+      callback.Run(GURL(origin_order_.front()));
   }
 
   int64 GetUsage() const {
     int64 total_usage = 0;
     for (std::map<GURL, int64>::const_iterator p = origins_.begin();
          p != origins_.end();
          ++p)
       total_usage += p->second;
     return total_usage;
   }
@@ skipping 318 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