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

webkit/appcache/appcache_response.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_response.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/string_util.h"
+#include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/io_buffer.h"
 #include "webkit/appcache/appcache_service.h"
 
 namespace appcache {
 
 namespace {
 
 // Disk cache entry data indices.
 enum {
@@ skipping 45 matching lines @@
 
 HttpResponseInfoIOBuffer::HttpResponseInfoIOBuffer(net::HttpResponseInfo* info)
     : http_info(info), response_data_size(kUnkownResponseDataSize) {}
 
 HttpResponseInfoIOBuffer::~HttpResponseInfoIOBuffer() {}
 
 // AppCacheResponseIO ----------------------------------------------
 
 AppCacheResponseIO::AppCacheResponseIO(
     int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache)
-    : response_id_(response_id), group_id_(group_id), disk_cache_(disk_cache),
-      entry_(NULL), buffer_len_(0), user_callback_(NULL),
+    : response_id_(response_id),
+      group_id_(group_id),
+      disk_cache_(disk_cache),
+      entry_(NULL),
+      buffer_len_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 AppCacheResponseIO::~AppCacheResponseIO() {
   if (entry_)
     entry_->Close();
 }
 
 void AppCacheResponseIO::ScheduleIOOldCompletionCallback(int result) {
   MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&AppCacheResponseIO::OnIOComplete,
                             weak_factory_.GetWeakPtr(), result));
 }
 
 void AppCacheResponseIO::InvokeUserOldCompletionCallback(int result) {
   // Clear the user callback and buffers prior to invoking the callback
   // so the caller can schedule additional operations in the callback.
   buffer_ = NULL;
   info_buffer_ = NULL;
-  net::OldCompletionCallback* temp_user_callback = user_callback_;
-  user_callback_ = NULL;
-  temp_user_callback->Run(result);
+  net::CompletionCallback cb = callback_;
+  callback_.Reset();
+  cb.Run(result);
 }
 
 void AppCacheResponseIO::ReadRaw(int index, int offset,
                                  net::IOBuffer* buf, int buf_len) {
   DCHECK(entry_);
   int rv = entry_->Read(
       index, offset, buf, buf_len,
       base::Bind(&AppCacheResponseIO::OnRawIOComplete,
                  weak_factory_.GetWeakPtr()));
   if (rv != net::ERR_IO_PENDING)
@@ skipping 25 matching lines @@
       range_offset_(0), range_length_(kint32max),
       read_position_(0) {
 }
 
 AppCacheResponseReader::~AppCacheResponseReader() {
   if (open_callback_)
     open_callback_.release()->Cancel();
 }
 
 void AppCacheResponseReader::ReadInfo(HttpResponseInfoIOBuffer* info_buf,
-                                      net::OldCompletionCallback* callback) {
-  DCHECK(callback && !IsReadPending());
-  DCHECK(info_buf && !info_buf->http_info.get());
-  DCHECK(!buffer_.get() && !info_buffer_.get());
+                                      const net::CompletionCallback& callback) {
+  DCHECK(!callback.is_null());
+  DCHECK(!IsReadPending());
+  DCHECK(info_buf);
+  DCHECK(!info_buf->http_info.get());
+  DCHECK(!buffer_.get());
+  DCHECK(!info_buffer_.get());
 
   info_buffer_ = info_buf;
-  user_callback_ = callback;  // cleared on completion
+  callback_ = callback;  // cleared on completion
   OpenEntryIfNeededAndContinue();
 }
 
 void AppCacheResponseReader::ContinueReadInfo() {
   if (!entry_)  {
     ScheduleIOOldCompletionCallback(net::ERR_CACHE_MISS);
     return;
   }
 
   int size = entry_->GetSize(kResponseInfoIndex);
   if (size <= 0) {
     ScheduleIOOldCompletionCallback(net::ERR_CACHE_MISS);
     return;
   }
 
   buffer_ = new net::IOBuffer(size);
   ReadRaw(kResponseInfoIndex, 0, buffer_.get(), size);
 }
 
 void AppCacheResponseReader::ReadData(net::IOBuffer* buf, int buf_len,
-                                      net::OldCompletionCallback* callback) {
-  DCHECK(callback && !IsReadPending());
-  DCHECK(buf && (buf_len >= 0));
-  DCHECK(!buffer_.get() && !info_buffer_.get());
+                                      const net::CompletionCallback& callback) {
+  DCHECK(!callback.is_null());
+  DCHECK(!IsReadPending());
+  DCHECK(buf);
+  DCHECK(buf_len >= 0);
+  DCHECK(!buffer_.get());
+  DCHECK(!info_buffer_.get());
 
   buffer_ = buf;
   buffer_len_ = buf_len;
-  user_callback_ = callback;  // cleared on completion
+  callback_ = callback;  // cleared on completion
   OpenEntryIfNeededAndContinue();
 }
 
 void AppCacheResponseReader::ContinueReadData() {
   if (!entry_)  {
     ScheduleIOOldCompletionCallback(net::ERR_CACHE_MISS);
     return;
   }
 
   if (read_position_ + buffer_len_ > range_length_) {
@@ skipping 39 matching lines @@
 
 void AppCacheResponseReader::OpenEntryIfNeededAndContinue() {
   int rv;
   if (entry_) {
     rv = net::OK;
   } else if (!disk_cache_) {
     rv = net::ERR_FAILED;
   } else {
     open_callback_ = new EntryCallback<AppCacheResponseReader>(
         this, &AppCacheResponseReader::OnOpenEntryComplete);
-    rv = disk_cache_->OpenEntry(response_id_, &open_callback_->entry_ptr_,
-                                open_callback_.get());
+    rv = disk_cache_->OpenEntry(
+        response_id_, &open_callback_->entry_ptr_,
+        base::Bind(&net::OldCompletionCallbackAdapter, open_callback_));
   }
 
   if (rv != net::ERR_IO_PENDING)
     OnOpenEntryComplete(rv);
 }
 
 void AppCacheResponseReader::OnOpenEntryComplete(int rv) {
   DCHECK(info_buffer_.get() || buffer_.get());
 
   if (open_callback_) {
@@ skipping 17 matching lines @@
     : AppCacheResponseIO(response_id, group_id, disk_cache),
       info_size_(0), write_position_(0), write_amount_(0),
       creation_phase_(INITIAL_ATTEMPT) {
 }
 
 AppCacheResponseWriter::~AppCacheResponseWriter() {
   if (create_callback_)
     create_callback_.release()->Cancel();
 }
 
-void AppCacheResponseWriter::WriteInfo(HttpResponseInfoIOBuffer* info_buf,
-                                       net::OldCompletionCallback* callback) {
-  DCHECK(callback && !IsWritePending());
-  DCHECK(info_buf && info_buf->http_info.get());
-  DCHECK(!buffer_.get() && !info_buffer_.get());
+void AppCacheResponseWriter::WriteInfo(
+    HttpResponseInfoIOBuffer* info_buf,
+    const net::CompletionCallback& callback) {
+  DCHECK(!callback.is_null());
+  DCHECK(!IsWritePending());
+  DCHECK(info_buf);
+  DCHECK(info_buf->http_info.get());
+  DCHECK(!buffer_.get());
+  DCHECK(!info_buffer_.get());
   DCHECK(info_buf->http_info->headers);
 
   info_buffer_ = info_buf;
-  user_callback_ = callback;  // cleared on completion
+  callback_ = callback;  // cleared on completion
   CreateEntryIfNeededAndContinue();
 }
 
 void AppCacheResponseWriter::ContinueWriteInfo() {
   if (!entry_) {
     ScheduleIOOldCompletionCallback(net::ERR_FAILED);
     return;
   }
 
   const bool kSkipTransientHeaders = true;
   const bool kTruncated = false;
   Pickle* pickle = new Pickle;
   info_buffer_->http_info->Persist(pickle, kSkipTransientHeaders, kTruncated);
   write_amount_ = static_cast<int>(pickle->size());
   buffer_ = new WrappedPickleIOBuffer(pickle);  // takes ownership of pickle
   WriteRaw(kResponseInfoIndex, 0, buffer_, write_amount_);
 }
 
-void AppCacheResponseWriter::WriteData(net::IOBuffer* buf, int buf_len,
-                                       net::OldCompletionCallback* callback) {
-  DCHECK(callback && !IsWritePending());
-  DCHECK(buf && (buf_len >= 0));
-  DCHECK(!buffer_.get() && !info_buffer_.get());
+void AppCacheResponseWriter::WriteData(
+    net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) {
+  DCHECK(!callback.is_null());
+  DCHECK(!IsWritePending());
+  DCHECK(buf);
+  DCHECK(buf_len >= 0);
+  DCHECK(!buffer_.get());
+  DCHECK(!info_buffer_.get());
 
   buffer_ = buf;
   write_amount_ = buf_len;
-  user_callback_ = callback;  // cleared on completion
+  callback_ = callback;  // cleared on completion
   CreateEntryIfNeededAndContinue();
 }
 
 void AppCacheResponseWriter::ContinueWriteData() {
   if (!entry_) {
     ScheduleIOOldCompletionCallback(net::ERR_FAILED);
     return;
   }
   WriteRaw(kResponseContentIndex, write_position_, buffer_, write_amount_);
 }
@@ skipping 14 matching lines @@
   if (entry_) {
     creation_phase_ = NO_ATTEMPT;
     rv = net::OK;
   } else if (!disk_cache_) {
     creation_phase_ = NO_ATTEMPT;
     rv = net::ERR_FAILED;
   } else {
     creation_phase_ = INITIAL_ATTEMPT;
     create_callback_ = new EntryCallback<AppCacheResponseWriter>(
         this, &AppCacheResponseWriter::OnCreateEntryComplete);
-    rv = disk_cache_->CreateEntry(response_id_, &create_callback_->entry_ptr_,
-                                  create_callback_.get());
+    rv = disk_cache_->CreateEntry(
+        response_id_, &create_callback_->entry_ptr_,
+        base::Bind(&net::OldCompletionCallbackAdapter, create_callback_));
   }
   if (rv != net::ERR_IO_PENDING)
     OnCreateEntryComplete(rv);
 }
 
 void AppCacheResponseWriter::OnCreateEntryComplete(int rv) {
   DCHECK(info_buffer_.get() || buffer_.get());
 
   if (creation_phase_ == INITIAL_ATTEMPT) {
     if (rv != net::OK) {
       // We may try to overwrite existing entries.
       creation_phase_ = DOOM_EXISTING;
-      rv = disk_cache_->DoomEntry(response_id_, create_callback_.get());
+      rv = disk_cache_->DoomEntry(
+          response_id_, base::Bind(&net::OldCompletionCallbackAdapter,
+                                   create_callback_));
       if (rv != net::ERR_IO_PENDING)
         OnCreateEntryComplete(rv);
       return;
     }
   } else if (creation_phase_ == DOOM_EXISTING) {
     creation_phase_ = SECOND_ATTEMPT;
-    rv = disk_cache_->CreateEntry(response_id_, &create_callback_->entry_ptr_,
-                                  create_callback_.get());
+    rv = disk_cache_->CreateEntry(
+        response_id_, &create_callback_->entry_ptr_,
+        base::Bind(&net::OldCompletionCallbackAdapter, create_callback_));
     if (rv != net::ERR_IO_PENDING)
       OnCreateEntryComplete(rv);
     return;
   }
 
   if (create_callback_) {
     if (rv == net::OK) {
       entry_ = create_callback_->entry_ptr_;
       create_callback_->entry_ptr_ = NULL;
     }
     create_callback_ = NULL;
   }
 
   if (info_buffer_)
     ContinueWriteInfo();
   else
     ContinueWriteData();
 }
 
 }  // namespace appcache
-