Reland r113263 rebased after revert of r113249.

base::Bind: Convert chrome_benchmarking_message_filter.cc.

BUG=none
TEST=none
R=csilv,ajwong

Review URL: http://codereview.chromium.org/8897026

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@114072 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/chrome_benchmarking_message_filter.cc

@@ -4,7 +4,10 @@
 
 #include "chrome/browser/chrome_benchmarking_message_filter.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
+#include "base/memory/scoped_ptr.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/predictor.h"
 #include "chrome/browser/profiles/profile.h"
@@ -19,18 +22,17 @@
 
 namespace {
 
-class ClearCacheCompletion : public net::OldCompletionCallback {
+class ClearCacheHelper {
  public:
-  ClearCacheCompletion(ChromeBenchmarkingMessageFilter* filter,
-                       IPC::Message* reply_msg)
+  ClearCacheHelper(ChromeBenchmarkingMessageFilter* filter,
+                   IPC::Message* reply_msg)
       : filter_(filter),
         reply_msg_(reply_msg) {
   }
 
-  virtual void RunWithParams(const Tuple1<int>& params) {
-    ChromeViewHostMsg_ClearCache::WriteReplyParams(reply_msg_, params.a);
+  void Run(int result) {
+    ChromeViewHostMsg_ClearCache::WriteReplyParams(reply_msg_, result);
     filter_->Send(reply_msg_);
-    delete this;
   }
 
  private:
@@ -46,21 +48,25 @@ class DoomEntriesHelper {
       : backend_(backend),
         entry_(NULL),
         iter_(NULL),
-        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(this,
-            &DoomEntriesHelper::CacheCallback)),
-        user_callback_(NULL) {
+        ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&DoomEntriesHelper::CacheCallback,
+                       base::Unretained(this)))),
+        clear_cache_helper_(NULL) {
   }
 
-  void ClearCache(ClearCacheCompletion* callback) {
-    user_callback_ = callback;
+  // Takes ownership of |callback|.
+  void ClearCache(ClearCacheHelper* helper) {
+    clear_cache_helper_.reset(helper);
     return CacheCallback(net::OK);  // Start clearing the cache.
   }
 
+  const net::CompletionCallback& callback() { return callback_; }
+
  private:
   void CacheCallback(int result) {
     do {
       if (result != net::OK) {
-        user_callback_->RunWithParams(Tuple1<int>(result));
+        clear_cache_helper_->Run(result);
         delete this;
         return;
       }
@@ -76,15 +82,15 @@ class DoomEntriesHelper {
         entry_->Close();
         entry_ = NULL;
       }
-      result = backend_->OpenNextEntry(&iter_, &entry_, &callback_);
+      result = backend_->OpenNextEntry(&iter_, &entry_, callback_);
     } while (result != net::ERR_IO_PENDING);
   }
 
   disk_cache::Backend* backend_;
   disk_cache::Entry* entry_;
   void* iter_;
-  net::OldCompletionCallbackImpl<DoomEntriesHelper> callback_;
-  ClearCacheCompletion* user_callback_;
+  net::CompletionCallback callback_;
+  scoped_ptr<ClearCacheHelper> clear_cache_helper_;
 };
 
 }  // namespace
@@ -132,20 +138,20 @@ void ChromeBenchmarkingMessageFilter::OnClearCache(bool preserve_ssl_host_info,
   disk_cache::Backend* backend = request_context_->GetURLRequestContext()->
       http_transaction_factory()->GetCache()->GetCurrentBackend();
   if (backend) {
-    ClearCacheCompletion* callback =
-        new ClearCacheCompletion(this, reply_msg);
+    scoped_ptr<ClearCacheHelper> clear_cache_helper(
+        new ClearCacheHelper(this, reply_msg));
     if (preserve_ssl_host_info) {
       DoomEntriesHelper* helper = new DoomEntriesHelper(backend);
-      helper->ClearCache(callback);  // Will self clean.
+      helper->ClearCache(clear_cache_helper.release());  // Will self clean.
       return;
     } else {
-      rv = backend->DoomAllEntries(callback);
+      rv = backend->DoomAllEntries(
+          base::Bind(&ClearCacheHelper::Run,
+                     base::Owned(clear_cache_helper.release())));
       if (rv == net::ERR_IO_PENDING) {
         // The callback will send the reply.
         return;
       }
-      // Completed synchronously, no need for the callback.
-      delete callback;
     }
   }
   ChromeViewHostMsg_ClearCache::WriteReplyParams(reply_msg, rv);

net/disk_cache/backend_impl.cc

@@ -1437,6 +1437,13 @@ int BackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
   return net::ERR_IO_PENDING;
 }
 
+int BackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
+                               const net::CompletionCallback& callback) {
+  DCHECK(!callback.is_null());
+  background_queue_.OpenNextEntry(iter, next_entry, callback);
+  return net::ERR_IO_PENDING;
+}
+
 void BackendImpl::EndEnumeration(void** iter) {
   background_queue_.EndEnumeration(*iter);
   *iter = NULL;

net/disk_cache/backend_impl.h

@@ -277,6 +277,8 @@ class NET_EXPORT_PRIVATE BackendImpl : public Backend {
                                OldCompletionCallback* callback) OVERRIDE;
   virtual int OpenNextEntry(void** iter, Entry** next_entry,
                             OldCompletionCallback* callback) OVERRIDE;
+  virtual int OpenNextEntry(void** iter, Entry** next_entry,
+                            const net::CompletionCallback& callback) OVERRIDE;
   virtual void EndEnumeration(void** iter) OVERRIDE;
   virtual void GetStats(StatsItems* stats) OVERRIDE;
   virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;

net/disk_cache/disk_cache.h

@@ -131,6 +131,8 @@ class NET_EXPORT Backend {
   // therefore it does not impact the eviction ranking of the entry.
   virtual int OpenNextEntry(void** iter, Entry** next_entry,
                             OldCompletionCallback* callback) = 0;
+  virtual int OpenNextEntry(void** iter, Entry** next_entry,
+                            const net::CompletionCallback& callback) = 0;
 
   // Releases iter without returning the next entry. Whenever OpenNextEntry()
   // returns true, but the caller is not interested in continuing the

net/disk_cache/in_flight_backend_io.cc

@@ -384,6 +384,13 @@ void InFlightBackendIO::OpenNextEntry(void** iter, Entry** next_entry,
   PostOperation(operation);
 }
 
+void InFlightBackendIO::OpenNextEntry(void** iter, Entry** next_entry,
+                                      const net::CompletionCallback& callback) {
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
+  operation->OpenNextEntry(iter, next_entry);
+  PostOperation(operation);
+}
+
 void InFlightBackendIO::OpenPrevEntry(void** iter, Entry** prev_entry,
                                       OldCompletionCallback* callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));

net/disk_cache/in_flight_backend_io.h

@@ -168,6 +168,8 @@ class InFlightBackendIO : public InFlightIO {
                         net::OldCompletionCallback* callback);
   void OpenNextEntry(void** iter, Entry** next_entry,
                      net::OldCompletionCallback* callback);
+  void OpenNextEntry(void** iter, Entry** next_entry,
+                     const net::CompletionCallback& callback);
   void OpenPrevEntry(void** iter, Entry** prev_entry,
                      net::OldCompletionCallback* callback);
   void EndEnumeration(void* iterator);

net/disk_cache/mem_backend_impl.cc

@@ -200,6 +200,14 @@ int MemBackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
   return net::ERR_FAILED;
 }
 
+int MemBackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
+                                  const net::CompletionCallback& callback) {
+  if (OpenNextEntry(iter, next_entry))
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 void MemBackendImpl::EndEnumeration(void** iter) {
   *iter = NULL;
 }

net/disk_cache/mem_backend_impl.h

@@ -83,6 +83,8 @@ class NET_EXPORT_PRIVATE MemBackendImpl : public Backend {
                                OldCompletionCallback* callback) OVERRIDE;
   virtual int OpenNextEntry(void** iter, Entry** next_entry,
                             OldCompletionCallback* callback) OVERRIDE;
+  virtual int OpenNextEntry(void** iter, Entry** next_entry,
+                            const net::CompletionCallback& callback) OVERRIDE;
   virtual void EndEnumeration(void** iter) OVERRIDE;
   virtual void GetStats(
       std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE {}

net/http/mock_http_cache.cc

@@ -468,6 +468,11 @@ int MockDiskCache::OpenNextEntry(void** iter, disk_cache::Entry** next_entry,
   return net::ERR_NOT_IMPLEMENTED;
 }
 
+int MockDiskCache::OpenNextEntry(void** iter, disk_cache::Entry** next_entry,
+                                 const net::CompletionCallback& callback) {
+  return net::ERR_NOT_IMPLEMENTED;
+}
+
 void MockDiskCache::EndEnumeration(void** iter) {
 }
 

net/http/mock_http_cache.h

@@ -115,6 +115,8 @@ class MockDiskCache : public disk_cache::Backend {
                                net::OldCompletionCallback* callback) OVERRIDE;
   virtual int OpenNextEntry(void** iter, disk_cache::Entry** next_entry,
                             net::OldCompletionCallback* callback) OVERRIDE;
+  virtual int OpenNextEntry(void** iter, disk_cache::Entry** next_entry,
+                            const net::CompletionCallback& callback) OVERRIDE;
   virtual void EndEnumeration(void** iter) OVERRIDE;
   virtual void GetStats(
       std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE;