base::Bind: Convert AppCacheHelper::DeleteAppCachesForOrigin.

webkit/appcache/appcache_service.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 "webkit/appcache/appcache_service.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 192 matching lines @@
 }
 
 void AppCacheService::DeleteHelper::OnGroupMadeObsolete(
       appcache::AppCacheGroup* group, bool success) {
   CallCallback(success ? net::OK : net::ERR_FAILED);
   delete this;
 }
 
 // DeleteOriginHelper -------
 
-class AppCacheService::DeleteOriginHelper : public AsyncHelper {
+class AppCacheService::DeleteOriginHelper : public NewAsyncHelper {
  public:
   DeleteOriginHelper(
       AppCacheService* service, const GURL& origin,
-      net::OldCompletionCallback* callback)
-      : AsyncHelper(service, callback), origin_(origin),
+      const net::CompletionCallback& callback)
+      : NewAsyncHelper(service, callback), origin_(origin),
         num_caches_to_delete_(0), successes_(0), failures_(0) {
   }
 
   virtual void Start() {
     // We start by listing all caches, continues in OnAllInfo().
     service_->storage()->GetAllInfo(this);
   }
 
  private:
   // AppCacheStorage::Delegate implementation.
   virtual void OnAllInfo(AppCacheInfoCollection* collection);
   virtual void OnGroupLoaded(
       appcache::AppCacheGroup* group, const GURL& manifest_url);
   virtual void OnGroupMadeObsolete(
       appcache::AppCacheGroup* group, bool success);
 
   void CacheCompleted(bool success);
 
   GURL origin_;
   int num_caches_to_delete_;
   int successes_;
   int failures_;
+
   DISALLOW_COPY_AND_ASSIGN(DeleteOriginHelper);
 };
 
 void AppCacheService::DeleteOriginHelper::OnAllInfo(
-      AppCacheInfoCollection* collection) {
+    AppCacheInfoCollection* collection) {
   if (!collection) {
     // Failed to get a listing.
     CallCallback(net::ERR_FAILED);
     delete this;
     return;
   }
+
   std::map<GURL, AppCacheInfoVector>::iterator found =
       collection->infos_by_origin.find(origin_);
   if (found == collection->infos_by_origin.end() || found->second.empty()) {
     // No caches for this origin.
     CallCallback(net::OK);
     delete this;
     return;
   }
 
   // We have some caches to delete.
@@ skipping 255 matching lines @@
 }
 
 void AppCacheService::DeleteAppCacheGroup(
     const GURL& manifest_url,
     const net::CompletionCallback& callback) {
   DeleteHelper* helper = new DeleteHelper(this, manifest_url, callback);
   helper->Start();
 }
 
 void AppCacheService::DeleteAppCachesForOrigin(
-    const GURL& origin,  net::OldCompletionCallback* callback) {
+    const GURL& origin,  const net::CompletionCallback& callback) {
   DeleteOriginHelper* helper = new DeleteOriginHelper(this, origin, callback);
   helper->Start();
 }
 
 void AppCacheService::CheckAppCacheResponse(const GURL& manifest_url,
                                             int64 cache_id,
                                             int64 response_id) {
   CheckResponseHelper* helper = new CheckResponseHelper(
       this, manifest_url, cache_id, response_id);
   helper->Start();
@@ skipping 10 matching lines @@
   backends_.insert(
       BackendMap::value_type(backend_impl->process_id(), backend_impl));
 }
 
 void AppCacheService::UnregisterBackend(
     AppCacheBackendImpl* backend_impl) {
   backends_.erase(backend_impl->process_id());
 }
 
 }  // namespace appcache