base::Bind: Convert AppCacheHelper::DeleteAppCacheGroup.

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"
+#include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_backend_impl.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_histograms.h"
 #include "webkit/appcache/appcache_policy.h"
 #include "webkit/appcache/appcache_quota_client.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_storage_impl.h"
 #include "webkit/quota/quota_manager.h"
@@ skipping 66 matching lines @@
     if (service_)
       service_->pending_helpers_.erase(this);
   }
 
   virtual void Start() = 0;
   virtual void Cancel();
 
  protected:
   void CallCallback(int rv) {
     if (callback_) {
-      // Defer to guarentee async completion.
+      // Defer to guarantee async completion.
       MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(&DeferredCallCallback, callback_, rv));
     }
     callback_ = NULL;
   }
 
   static void DeferredCallCallback(net::OldCompletionCallback* callback,
                                    int rv) {
     callback->Run(rv);
   }
@@ skipping 28 matching lines @@
     if (policy && !policy->CanLoadAppCache(url_, first_party_)) {
       CallCallback(net::ERR_FAILED);
       delete this;
       return;
     }
 
     service_->storage()->FindResponseForMainRequest(url_, GURL(), this);
   }
 
  private:
-  // AppCacheStorage::Delegate override
+  // AppCacheStorage::Delegate implementation.
   virtual void OnMainResponseFound(
       const GURL& url, const AppCacheEntry& entry,
       const GURL& fallback_url, const AppCacheEntry& fallback_entry,
       int64 cache_id, int64 group_id, const GURL& mainfest_url) OVERRIDE;
 
   GURL url_;
   GURL first_party_;
 
   DISALLOW_COPY_AND_ASSIGN(CanHandleOfflineHelper);
 };
 
 void AppCacheService::CanHandleOfflineHelper::OnMainResponseFound(
       const GURL& url, const AppCacheEntry& entry,
       const GURL& fallback_url, const AppCacheEntry& fallback_entry,
       int64 cache_id, int64 group_id, const GURL& manifest_url) {
   bool can = (entry.has_response_id() || fallback_entry.has_response_id());
   CallCallback(can ? net::OK : net::ERR_FAILED);
   delete this;
 }
 
 // DeleteHelper -------
 
-class AppCacheService::DeleteHelper : public AsyncHelper {
+class AppCacheService::DeleteHelper : public NewAsyncHelper {
  public:
   DeleteHelper(
       AppCacheService* service, const GURL& manifest_url,
-      net::OldCompletionCallback* callback)
-      : AsyncHelper(service, callback), manifest_url_(manifest_url) {
+      const net::CompletionCallback& callback)
+      : NewAsyncHelper(service, callback), manifest_url_(manifest_url) {
   }
 
   virtual void Start() {
     service_->storage()->LoadOrCreateGroup(manifest_url_, this);
   }
 
  private:
-  // AppCacheStorage::Delegate methods
+  // AppCacheStorage::Delegate implementation.
   virtual void OnGroupLoaded(
       appcache::AppCacheGroup* group, const GURL& manifest_url);
   virtual void OnGroupMadeObsolete(
       appcache::AppCacheGroup* group, bool success);
 
   GURL manifest_url_;
   DISALLOW_COPY_AND_ASSIGN(DeleteHelper);
 };
 
 void AppCacheService::DeleteHelper::OnGroupLoaded(
@@ skipping 24 matching lines @@
       : AsyncHelper(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 methods
+  // 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_;
@@ skipping 67 matching lines @@
       AppCacheService* service, AppCacheInfoCollection* collection,
       const net::CompletionCallback& callback)
       : NewAsyncHelper(service, callback), collection_(collection) {
   }
 
   virtual void Start() {
     service_->storage()->GetAllInfo(this);
   }
 
  private:
-  // AppCacheStorage::Delegate override
+  // AppCacheStorage::Delegate implementation.
   virtual void OnAllInfo(AppCacheInfoCollection* collection);
 
   scoped_refptr<AppCacheInfoCollection> collection_;
 
   DISALLOW_COPY_AND_ASSIGN(GetInfoHelper);
 };
 
 void AppCacheService::GetInfoHelper::OnAllInfo(
       AppCacheInfoCollection* collection) {
   if (collection)
@@ skipping 68 matching lines @@
     delete this;
     return;
   }
 
   cache_ = group->newest_complete_cache();
   const AppCacheEntry* entry = cache_->GetEntryWithResponseId(response_id_);
   if (!entry) {
     if (cache_->cache_id() == cache_id_) {
       AppCacheHistograms::CountCheckResponseResult(
           AppCacheHistograms::ENTRY_NOT_FOUND);
-      service_->DeleteAppCacheGroup(manifest_url_, NULL);
+      service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
     } else {
       AppCacheHistograms::CountCheckResponseResult(
           AppCacheHistograms::RESPONSE_OUT_OF_DATE);
     }
     delete this;
     return;
   }
 
   // Verify that we can read the response info and data.
   expected_total_size_ = entry->response_size();
   response_reader_.reset(service_->storage()->CreateResponseReader(
       manifest_url_, group->group_id(), response_id_));
   info_buffer_ = new HttpResponseInfoIOBuffer();
   response_reader_->ReadInfo(info_buffer_, &read_info_callback_);
 }
 
 void AppCacheService::CheckResponseHelper::OnReadInfoComplete(int result) {
   if (result < 0) {
     AppCacheHistograms::CountCheckResponseResult(
         AppCacheHistograms::READ_HEADERS_ERROR);
-    service_->DeleteAppCacheGroup(manifest_url_, NULL);
+    service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
     delete this;
     return;
   }
   amount_headers_read_ = result;
 
   // Start reading the data.
   data_buffer_ = new net::IOBuffer(kIOBufferSize);
   response_reader_->ReadData(data_buffer_, kIOBufferSize,
                              &read_data_callback_);
 }
@@ skipping 11 matching lines @@
   if (result < 0)
     check_result = AppCacheHistograms::READ_DATA_ERROR;
   else if (info_buffer_->response_data_size != amount_data_read_ ||
            expected_total_size_ != amount_data_read_ + amount_headers_read_)
     check_result = AppCacheHistograms::UNEXPECTED_DATA_SIZE;
   else
     check_result = AppCacheHistograms::RESPONSE_OK;
   AppCacheHistograms::CountCheckResponseResult(check_result);
 
   if (check_result != AppCacheHistograms::RESPONSE_OK)
-    service_->DeleteAppCacheGroup(manifest_url_, NULL);
+    service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
   delete this;
 }
 
 
 // AppCacheService -------
 
 AppCacheService::AppCacheService(quota::QuotaManagerProxy* quota_manager_proxy)
     : appcache_policy_(NULL), quota_client_(NULL),
       quota_manager_proxy_(quota_manager_proxy),
       request_context_(NULL), clear_local_state_on_exit_(false)  {
@@ skipping 40 matching lines @@
 }
 
 void AppCacheService::GetAllAppCacheInfo(
     AppCacheInfoCollection* collection,
     const net::CompletionCallback& callback) {
   DCHECK(collection);
   GetInfoHelper* helper = new GetInfoHelper(this, collection, callback);
   helper->Start();
 }
 
-void AppCacheService::DeleteAppCacheGroup(const GURL& manifest_url,
-                                          net::OldCompletionCallback* callback) {
+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) {
   DeleteOriginHelper* helper = new DeleteOriginHelper(this, origin, callback);
   helper->Start();
 }
 
@@ skipping 16 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