Use base::Callback in Quota related code.

webkit/quota/quota_types.h

 // 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.
 
 #ifndef WEBKIT_QUOTA_QUOTA_TYPES_H_
 #define WEBKIT_QUOTA_QUOTA_TYPES_H_
 #pragma once
 
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
-#include "base/callback_old.h"
-#include "base/stl_util.h"
+#include "base/callback.h"
 
 class GURL;
 
 namespace quota {
 
 enum StorageType {
   kStorageTypeTemporary,
   kStorageTypePersistent,
   kStorageTypeUnknown,
 };
 
 // The numbers should match with the error code defined in
 // third_party/WebKit/Source/WebCore/dom/ExceptionCode.h.
 enum QuotaStatusCode {
   kQuotaStatusOk = 0,
   kQuotaErrorNotSupported = 9,          // NOT_SUPPORTED_ERR
   kQuotaErrorInvalidModification = 13,  // INVALID_MODIFICATION_ERR
   kQuotaErrorInvalidAccess = 15,        // INVALID_ACCESS_ERR
   kQuotaErrorAbort = 20,                // ABORT_ERR
   kQuotaStatusUnknown = -1,
 };
 
 // Common callback types that are used throughout in the quota module.
-typedef Callback2<StorageType, int64>::Type UsageCallback;
-typedef Callback3<StorageType, int64, int64>::Type GlobalUsageCallback;
-typedef Callback3<QuotaStatusCode,
-                  StorageType,
-                  int64>::Type QuotaCallback;
-typedef Callback3<const std::string& /* host */,
-                  StorageType,
-                  int64>::Type HostUsageCallback;
-typedef Callback4<QuotaStatusCode,
-                  const std::string& /* host */,
-                  StorageType,
-                  int64>::Type HostQuotaCallback;
-typedef Callback2<QuotaStatusCode,
-                  int64>::Type AvailableSpaceCallback;
-typedef Callback1<QuotaStatusCode>::Type StatusCallback;
-typedef Callback2<const std::set<GURL>&, StorageType>::Type GetOriginsCallback;
+typedef base::Callback<void (StorageType, int64)> UsageCallback;

[awong, 2011/09/29 18:05:15]

remove space after void.

[tzik, 2011/10/11 04:53:57]

Done.

+typedef base::Callback<void (StorageType, int64, int64)> GlobalUsageCallback;
+typedef base::Callback<void (QuotaStatusCode, StorageType, int64)>
+    QuotaCallback;
+typedef base::Callback<void (const std::string&, StorageType, int64)>
+    HostUsageCallback;
+typedef base::Callback<void (QuotaStatusCode,
+                             const std::string&,
+                             StorageType,
+                             int64)> HostQuotaCallback;
+typedef base::Callback<void (QuotaStatusCode, int64)> AvailableSpaceCallback;
+typedef base::Callback<void (QuotaStatusCode)> StatusCallback;
+typedef base::Callback<void (const std::set<GURL>&, StorageType)>
+    GetOriginsCallback;
 
 // Simple template wrapper for a callback queue.
 template <typename CallbackType>
 class CallbackQueueBase {
  public:
   typedef typename std::deque<CallbackType> Queue;
   typedef typename Queue::iterator iterator;
 
-  virtual ~CallbackQueueBase() {
-    STLDeleteContainerPointers(callbacks_.begin(), callbacks_.end());
-  }
+  virtual ~CallbackQueueBase() {}
 
   // Returns true if the given |callback| is the first one added to the queue.
   bool Add(CallbackType callback) {
     callbacks_.push_back(callback);
     return (callbacks_.size() == 1);
   }
 
   bool HasCallbacks() const {
     return !callbacks_.empty();
   }
 
  protected:
   std::deque<CallbackType> callbacks_;
 };
 
 template <typename CallbackType1, typename A1>
 class CallbackQueue1 : public CallbackQueueBase<CallbackType1> {
  public:
   typedef typename CallbackQueueBase<CallbackType1>::Queue Queue;
   // Runs the callbacks added to the queue and clears the queue.
   void Run(A1 arg) {
     // Note: template-derived class needs 'this->' to access its base class.
     for (typename Queue::iterator iter = this->callbacks_.begin();
          iter != this->callbacks_.end(); ++iter) {
-      (*iter)->Run(arg);
-      delete *iter;
+      iter->Run(arg);
     }
     this->callbacks_.clear();
   }
 };
 
 template <typename CallbackType2, typename A1, typename A2>
 class CallbackQueue2 : public CallbackQueueBase<CallbackType2> {
  public:
   typedef typename CallbackQueueBase<CallbackType2>::Queue Queue;
   // Runs the callbacks added to the queue and clears the queue.
   void Run(A1 arg1, A2 arg2) {
     for (typename Queue::iterator iter = this->callbacks_.begin();
          iter != this->callbacks_.end(); ++iter) {
-      (*iter)->Run(arg1, arg2);
-      delete *iter;
+      iter->Run(arg1, arg2);
     }
     this->callbacks_.clear();
   }
 };
 
 template <typename CallbackType3, typename A1, typename A2, typename A3>
 class CallbackQueue3 : public CallbackQueueBase<CallbackType3> {
  public:
   typedef typename CallbackQueueBase<CallbackType3>::Queue Queue;
   // Runs the callbacks added to the queue and clears the queue.
   void Run(A1 arg1, A2 arg2, A3 arg3) {
     for (typename Queue::iterator iter = this->callbacks_.begin();
          iter != this->callbacks_.end(); ++iter) {
-      (*iter)->Run(arg1, arg2, arg3);
-      delete *iter;
+      iter->Run(arg1, arg2, arg3);
     }
     this->callbacks_.clear();
   }
 };
 
 template <typename CallbackType4,
           typename A1, typename A2, typename A3, typename A4>
 class CallbackQueue4 : public CallbackQueueBase<CallbackType4> {
  public:
   typedef typename CallbackQueueBase<CallbackType4>::Queue Queue;
   // Runs the callbacks added to the queue and clears the queue.
   void Run(A1 arg1, A2 arg2, A3 arg3, A4 arg4) {
     for (typename Queue::iterator iter = this->callbacks_.begin();
          iter != this->callbacks_.end(); ++iter) {
-      (*iter)->Run(arg1, arg2, arg3, arg4);
-      delete *iter;
+      iter->Run(arg1, arg2, arg3, arg4);
     }
     this->callbacks_.clear();
   }
 };
 
-typedef CallbackQueue2<UsageCallback*,
+typedef CallbackQueue2<UsageCallback,
                        StorageType, int64> UsageCallbackQueue;
-typedef CallbackQueue3<GlobalUsageCallback*,
+typedef CallbackQueue3<GlobalUsageCallback,
                        StorageType, int64, int64> GlobalUsageCallbackQueue;
-typedef CallbackQueue3<QuotaCallback*,
+typedef CallbackQueue3<QuotaCallback,
                        QuotaStatusCode,
                        StorageType, int64> QuotaCallbackQueue;
 
 template <typename CallbackType, typename CallbackQueueType, typename KEY>
 class CallbackQueueMapBase {
  public:
   typedef std::map<KEY, CallbackQueueType> CallbackMap;
   typedef typename CallbackMap::iterator iterator;
 
   bool Add(const KEY& key, CallbackType callback) {
@@ skipping 106 matching lines @@
   // from the map.
   void Run(const KEY& key, ARG1 arg1, ARG2 arg2, ARG3 arg3, ARG4 arg4) {
     if (!this->HasCallbacks(key))
       return;
     Queue& queue = this->callback_map_[key];
     queue.Run(arg1, arg2, arg3, arg4);
     this->callback_map_.erase(key);
   }
 };
 
-typedef CallbackQueueMap3<HostUsageCallback*, std::string,
+typedef CallbackQueueMap3<HostUsageCallback, std::string,
                           const std::string&,
                           StorageType, int64> HostUsageCallbackMap;
-typedef CallbackQueueMap4<HostQuotaCallback*, std::string,
+typedef CallbackQueueMap4<HostQuotaCallback, std::string,
                           QuotaStatusCode,
                           const std::string&,
                           StorageType, int64> HostQuotaCallbackMap;
 
 }  // namespace quota
 
 #endif  // WEBKIT_QUOTA_QUOTA_TYPES_H_