Use base::Callback in Quota related code.

webkit/appcache/appcache_storage_impl_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 <stack>
 
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
@@ skipping 113 matching lines @@
    public:
     MockQuotaManager()
       : QuotaManager(true /* is_incognito */, FilePath(),
                      io_thread->message_loop_proxy(),
                      db_thread->message_loop_proxy(),
                      NULL),
         async_(false) {}
 
     virtual void GetUsageAndQuota(
         const GURL& origin, quota::StorageType type,
-        GetUsageAndQuotaCallback* callback) {
+        const GetUsageAndQuotaCallback& callback) OVERRIDE {
       EXPECT_EQ(kOrigin, origin);
       EXPECT_EQ(quota::kStorageTypeTemporary, type);
       if (async_) {
         MessageLoop::current()->PostTask(FROM_HERE,
-            NewRunnableMethod(this, &MockQuotaManager::CallCallbackAndDelete,
+            NewRunnableMethod(this, &MockQuotaManager::CallCallback,
                               callback));
         return;
       }
-      CallCallbackAndDelete(callback);
+      CallCallback(callback);
     }
 
-    void CallCallbackAndDelete(GetUsageAndQuotaCallback* callback) {
-      callback->Run(quota::kQuotaStatusOk, 0, kMockQuota);
-      delete callback;
+    void CallCallback(const GetUsageAndQuotaCallback& callback) {
+      callback.Run(quota::kQuotaStatusOk, 0, kMockQuota);
     }
 
     bool async_;
   };
 
   class MockQuotaManagerProxy : public quota::QuotaManagerProxy {
    public:
     MockQuotaManagerProxy()
         : QuotaManagerProxy(NULL, NULL),
           notify_storage_accessed_count_(0),
           notify_storage_modified_count_(0),
           last_delta_(0),
           mock_manager_(new MockQuotaManager) {
       manager_ = mock_manager_;
     }
 
     virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
                                        const GURL& origin,
-                                       quota::StorageType type) {
+                                       quota::StorageType type) OVERRIDE {
       EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
       EXPECT_EQ(quota::kStorageTypeTemporary, type);
       ++notify_storage_accessed_count_;
       last_origin_ = origin;
     }
 
     virtual void NotifyStorageModified(quota::QuotaClient::ID client_id,
                                        const GURL& origin,
                                        quota::StorageType type,
-                                       int64 delta) {
+                                       int64 delta) OVERRIDE {
       EXPECT_EQ(quota::QuotaClient::kAppcache, client_id);
       EXPECT_EQ(quota::kStorageTypeTemporary, type);
       ++notify_storage_modified_count_;
       last_origin_ = origin;
       last_delta_ = delta;
     }
 
     // Not needed for our tests.
-    virtual void RegisterClient(quota::QuotaClient* client) {}
-    virtual void NotifyOriginInUse(const GURL& origin) {}
-    virtual void NotifyOriginNoLongerInUse(const GURL& origin) {}
+    virtual void RegisterClient(quota::QuotaClient* client) OVERRIDE {}
+    virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
+    virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
 
     int notify_storage_accessed_count_;
     int notify_storage_modified_count_;
     GURL last_origin_;
     int last_delta_;
     scoped_refptr<MockQuotaManager> mock_manager_;
   };
 
   // Helper class run a test on our io_thread. The io_thread
   // is spun up once and reused for all tests.
   template <class Method>
   class WrapperTask : public Task {
    public:
     WrapperTask(AppCacheStorageImplTest* test, Method method)
         : test_(test), method_(method) {
     }
 
-    virtual void Run() {
+    virtual void Run() OVERRIDE {
       test_->SetUpTest();
 
       // Ensure InitTask execution prior to conducting a test.
       test_->FlushDbThreadTasks();
 
       // We also have to wait for InitTask completion call to be performed
       // on the IO thread prior to running the test. Its guaranteed to be
       // queued by this time.
       MessageLoop::current()->PostTask(FROM_HERE,
           NewRunnableFunction(&RunMethod, test_, method_));
@@ skipping 1098 matching lines @@
       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
 }
 
 // That's all folks!
 
 }  // namespace appcache
 
 // AppCacheStorageImplTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheStorageImplTest);