base::Bind: Convert most of webkit/appcache.

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/bind_helpers.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"
@@ skipping 320 matching lines @@
   CheckResponseHelper(
       AppCacheService* service, const GURL& manifest_url, int64 cache_id,
       int64 response_id)
       : AsyncHelper(service, NULL),
         manifest_url_(manifest_url),
         cache_id_(cache_id),
         response_id_(response_id),
         kIOBufferSize(32 * 1024),
         expected_total_size_(0),
         amount_headers_read_(0),
-        amount_data_read_(0),
-        ALLOW_THIS_IN_INITIALIZER_LIST(read_info_callback_(
-            this, &CheckResponseHelper::OnReadInfoComplete)),
-        ALLOW_THIS_IN_INITIALIZER_LIST(read_data_callback_(
-            this, &CheckResponseHelper::OnReadDataComplete)) {
+        amount_data_read_(0) {
   }
 
   virtual void Start() {
     service_->storage()->LoadOrCreateGroup(manifest_url_, this);
   }
 
   virtual void Cancel() {
     AppCacheHistograms::CountCheckResponseResult(
         AppCacheHistograms::CHECK_CANCELED);
     response_reader_.reset();
@@ skipping 12 matching lines @@
 
   // Internals used to perform the checks.
   const int kIOBufferSize;
   scoped_refptr<AppCache> cache_;
   scoped_ptr<AppCacheResponseReader> response_reader_;
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_;
   scoped_refptr<net::IOBuffer> data_buffer_;
   int64 expected_total_size_;
   int amount_headers_read_;
   int amount_data_read_;
-  net::OldCompletionCallbackImpl<CheckResponseHelper> read_info_callback_;
-  net::OldCompletionCallbackImpl<CheckResponseHelper> read_data_callback_;
   DISALLOW_COPY_AND_ASSIGN(CheckResponseHelper);
 };
 
 void AppCacheService::CheckResponseHelper::OnGroupLoaded(
     AppCacheGroup* group, const GURL& manifest_url) {
   DCHECK_EQ(manifest_url_, manifest_url);
   if (!group || !group->newest_complete_cache() || group->is_being_deleted() ||
       group->is_obsolete()) {
     AppCacheHistograms::CountCheckResponseResult(
         AppCacheHistograms::MANIFEST_OUT_OF_DATE);
@@ skipping 14 matching lines @@
     }
     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_);
+  response_reader_->ReadInfo(
+      info_buffer_, base::Bind(&CheckResponseHelper::OnReadInfoComplete,
+                               base::Unretained(this)));
 }
 
 void AppCacheService::CheckResponseHelper::OnReadInfoComplete(int result) {
   if (result < 0) {
     AppCacheHistograms::CountCheckResponseResult(
         AppCacheHistograms::READ_HEADERS_ERROR);
     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_);
+  response_reader_->ReadData(
+      data_buffer_, kIOBufferSize,
+      base::Bind(&CheckResponseHelper::OnReadDataComplete,
+                 base::Unretained(this)));
 }
 
 void AppCacheService::CheckResponseHelper::OnReadDataComplete(int result) {
   if (result > 0) {
     // Keep reading until we've read thru everything or failed to read.
     amount_data_read_ += result;
-    response_reader_->ReadData(data_buffer_, kIOBufferSize,
-                               &read_data_callback_);
+    response_reader_->ReadData(
+        data_buffer_, kIOBufferSize,
+        base::Bind(&CheckResponseHelper::OnReadDataComplete,
+                   base::Unretained(this)));
     return;
   }
 
   AppCacheHistograms::CheckResponseResultType check_result;
   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
@@ skipping 95 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