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

webkit/appcache/appcache_update_job.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_update_job.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "webkit/appcache/appcache_group.h"
@@ skipping 65 matching lines @@
 }
 
 AppCacheUpdateJob::UrlToFetch::~UrlToFetch() {
 }
 
 // Helper class to fetch resources. Depending on the fetch type,
 // can either fetch to an in-memory string or write the response
 // data out to the disk cache.
 AppCacheUpdateJob::URLFetcher::URLFetcher(
     const GURL& url, FetchType fetch_type, AppCacheUpdateJob* job)
-    : url_(url), job_(job), fetch_type_(fetch_type), retry_503_attempts_(0),
+    : url_(url),
+      job_(job),
+      fetch_type_(fetch_type),
+      retry_503_attempts_(0),
       buffer_(new net::IOBuffer(kBufferSize)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          request_(new net::URLRequest(url, this))),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_(this, &URLFetcher::OnWriteComplete)) {
+          request_(new net::URLRequest(url, this))) {
 }
 
 AppCacheUpdateJob::URLFetcher::~URLFetcher() {
 }
 
 void AppCacheUpdateJob::URLFetcher::Start() {
   request_->set_context(job_->service_->request_context());
   request_->set_load_flags(request_->load_flags() |
                            net::LOAD_DISABLE_INTERCEPT);
   if (existing_response_headers_)
@@ skipping 32 matching lines @@
       }
     }
 
     // Write response info to storage for URL fetches. Wait for async write
     // completion before reading any response data.
     if (fetch_type_ == URL_FETCH || fetch_type_ == MASTER_ENTRY_FETCH) {
       response_writer_.reset(job_->CreateResponseWriter());
       scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
           new HttpResponseInfoIOBuffer(
               new net::HttpResponseInfo(request->response_info())));
-      response_writer_->WriteInfo(io_buffer, &write_callback_);
+      response_writer_->WriteInfo(
+          io_buffer,
+          base::Bind(&URLFetcher::OnWriteComplete, base::Unretained(this)));
     } else {
       ReadResponseData();
     }
   } else {
     OnResponseCompleted();
   }
 }
 
 void AppCacheUpdateJob::URLFetcher::OnReadCompleted(
     net::URLRequest* request, int bytes_read) {
@@ skipping 68 matching lines @@
 bool AppCacheUpdateJob::URLFetcher::ConsumeResponseData(int bytes_read) {
   DCHECK_GT(bytes_read, 0);
   switch (fetch_type_) {
     case MANIFEST_FETCH:
     case MANIFEST_REFETCH:
       manifest_data_.append(buffer_->data(), bytes_read);
       break;
     case URL_FETCH:
     case MASTER_ENTRY_FETCH:
       DCHECK(response_writer_.get());
-      response_writer_->WriteData(buffer_, bytes_read,  &write_callback_);
+      response_writer_->WriteData(
+          buffer_, bytes_read,
+          base::Bind(&URLFetcher::OnWriteComplete, base::Unretained(this)));
       return false;  // wait for async write completion to continue reading
     default:
       NOTREACHED();
   }
   return true;
 }
 
 void AppCacheUpdateJob::URLFetcher::OnResponseCompleted() {
   // Retry for 503s where retry-after is 0.
   if (request_->status().is_success() &&
@@ skipping 36 matching lines @@
 AppCacheUpdateJob::AppCacheUpdateJob(AppCacheService* service,
                                      AppCacheGroup* group)
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       service_(service),
       group_(group),
       update_type_(UNKNOWN_TYPE),
       internal_state_(FETCH_MANIFEST),
       master_entries_completed_(0),
       url_fetches_completed_(0),
       manifest_fetcher_(NULL),
-      stored_state_(UNSTORED),
-      ALLOW_THIS_IN_INITIALIZER_LIST(manifest_info_write_callback_(
-          this, &AppCacheUpdateJob::OnManifestInfoWriteComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(manifest_data_write_callback_(
-          this, &AppCacheUpdateJob::OnManifestDataWriteComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(manifest_data_read_callback_(
-          this, &AppCacheUpdateJob::OnManifestDataReadComplete)) {
+      stored_state_(UNSTORED) {
   DCHECK(group_);
   manifest_url_ = group_->manifest_url();
 }
 
 AppCacheUpdateJob::~AppCacheUpdateJob() {
   if (internal_state_ != COMPLETED)
     Cancel();
 
   DCHECK(!manifest_fetcher_);
   DCHECK(pending_url_fetches_.empty());
@@ skipping 381 matching lines @@
     // Only need to store response in storage if manifest is not already
     // an entry in the cache.
     AppCacheEntry* entry = inprogress_cache_->GetEntry(manifest_url_);
     if (entry) {
       entry->add_types(AppCacheEntry::MANIFEST);
       StoreGroupAndCache();
     } else {
       manifest_response_writer_.reset(CreateResponseWriter());
       scoped_refptr<HttpResponseInfoIOBuffer> io_buffer(
           new HttpResponseInfoIOBuffer(manifest_response_info_.release()));
-      manifest_response_writer_->WriteInfo(io_buffer,
-                                           &manifest_info_write_callback_);
+      manifest_response_writer_->WriteInfo(
+          io_buffer,
+          base::Bind(&AppCacheUpdateJob::OnManifestInfoWriteComplete,
+                     base::Unretained(this)));
     }
   } else {
     VLOG(1) << "Request status: " << request->status().status()
             << " error: " << request->status().error()
             << " response code: " << response_code;
     ScheduleUpdateRetry(kRerunDelayMs);
     HandleCacheFailure("Manifest changed during update, scheduling retry");
   }
 }
 
 void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) {
   if (result > 0) {
     scoped_refptr<net::StringIOBuffer> io_buffer(
         new net::StringIOBuffer(manifest_data_));
-    manifest_response_writer_->WriteData(io_buffer, manifest_data_.length(),
-                                         &manifest_data_write_callback_);
+    manifest_response_writer_->WriteData(
+        io_buffer, manifest_data_.length(),
+        base::Bind(&AppCacheUpdateJob::OnManifestDataWriteComplete,
+                   base::Unretained(this)));
   } else {
     HandleCacheFailure("Failed to write the manifest headers to storage");
   }
 }
 
 void AppCacheUpdateJob::OnManifestDataWriteComplete(int result) {
   if (result > 0) {
     AppCacheEntry entry(AppCacheEntry::MANIFEST,
         manifest_response_writer_->response_id(),
         manifest_response_writer_->amount_written());
@@ skipping 106 matching lines @@
   AppCacheEntry* entry =
       group_->newest_complete_cache()->GetEntry(manifest_url_);
   DCHECK(entry);
 
   // Load manifest data from storage to compare against fetched manifest.
   manifest_response_reader_.reset(
       service_->storage()->CreateResponseReader(manifest_url_,
                                                 group_->group_id(),
                                                 entry->response_id()));
   read_manifest_buffer_ = new net::IOBuffer(kBufferSize);
-  manifest_response_reader_->ReadData(read_manifest_buffer_, kBufferSize,
-      &manifest_data_read_callback_);  // async read
+  manifest_response_reader_->ReadData(
+      read_manifest_buffer_, kBufferSize,
+      base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete,
+                 base::Unretained(this)));  // async read
 }
 
 void AppCacheUpdateJob::OnManifestDataReadComplete(int result) {
   if (result > 0) {
     loaded_manifest_data_.append(read_manifest_buffer_->data(), result);
-    manifest_response_reader_->ReadData(read_manifest_buffer_, kBufferSize,
-        &manifest_data_read_callback_);  // read more
+    manifest_response_reader_->ReadData(
+        read_manifest_buffer_, kBufferSize,
+        base::Bind(&AppCacheUpdateJob::OnManifestDataReadComplete,
+                   base::Unretained(this)));  // read more
   } else {
     read_manifest_buffer_ = NULL;
     manifest_response_reader_.reset();
     ContinueHandleManifestFetchCompleted(
         result < 0 || manifest_data_ != loaded_manifest_data_);
   }
 }
 
 void AppCacheUpdateJob::BuildUrlFileList(const Manifest& manifest) {
   for (base::hash_set<std::string>::const_iterator it =
@@ skipping 453 matching lines @@
 
   // Break the connection with the group so the group cannot call delete
   // on this object after we've posted a task to delete ourselves.
   group_->SetUpdateStatus(AppCacheGroup::IDLE);
   group_ = NULL;
 
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace appcache