base::Bind: Cleanup almost-unused OldCompletionCallbacks.

net/disk_cache/disk_cache_test_base.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 "net/disk_cache/disk_cache_test_base.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 107 matching lines @@
   return cb.GetResult(rv);
 }
 
 int DiskCacheTestWithCache::DoomEntry(const std::string& key) {
   TestOldCompletionCallback cb;
   int rv = cache_->DoomEntry(key, &cb);
   return cb.GetResult(rv);
 }
 
 int DiskCacheTestWithCache::DoomAllEntries() {
-  TestOldCompletionCallback cb;
-  int rv = cache_->DoomAllEntries(&cb);
+  net::TestCompletionCallback cb;
+  int rv = cache_->DoomAllEntries(cb.callback());
   return cb.GetResult(rv);
 }
 
 int DiskCacheTestWithCache::DoomEntriesBetween(const base::Time initial_time,
                                                const base::Time end_time) {
-  TestOldCompletionCallback cb;
-  int rv = cache_->DoomEntriesBetween(initial_time, end_time, &cb);
+  net::TestCompletionCallback cb;
+  int rv = cache_->DoomEntriesBetween(initial_time, end_time, cb.callback());
   return cb.GetResult(rv);
 }
 
 int DiskCacheTestWithCache::DoomEntriesSince(const base::Time initial_time) {
   TestOldCompletionCallback cb;
   int rv = cache_->DoomEntriesSince(initial_time, &cb);
   return cb.GetResult(rv);
 }
 
 int DiskCacheTestWithCache::OpenNextEntry(void** iter,
                                           disk_cache::Entry** next_entry) {
-  TestOldCompletionCallback cb;
-  int rv = cache_->OpenNextEntry(iter, next_entry, &cb);
+  net::TestCompletionCallback cb;
+  int rv = cache_->OpenNextEntry(iter, next_entry, cb.callback());
   return cb.GetResult(rv);
 }
 
 void DiskCacheTestWithCache::FlushQueueForTest() {
   if (memory_only_ || !cache_impl_)
     return;
 
   TestOldCompletionCallback cb;
   int rv = cache_impl_->FlushQueueForTest(&cb);
   EXPECT_EQ(net::OK, cb.GetResult(rv));
@@ skipping 11 matching lines @@
   EXPECT_EQ(net::OK, cb.GetResult(rv));
 }
 
 int DiskCacheTestWithCache::ReadData(disk_cache::Entry* entry, int index,
                                      int offset, net::IOBuffer* buf, int len) {
   TestOldCompletionCallback cb;
   int rv = entry->ReadData(index, offset, buf, len, &cb);
   return cb.GetResult(rv);
 }
 
-
 int DiskCacheTestWithCache::WriteData(disk_cache::Entry* entry, int index,
                                       int offset, net::IOBuffer* buf, int len,
                                       bool truncate) {
   TestOldCompletionCallback cb;
   int rv = entry->WriteData(index, offset, buf, len, &cb, truncate);
   return cb.GetResult(rv);
 }
 
 int DiskCacheTestWithCache::ReadSparseData(disk_cache::Entry* entry,
                                            int64 offset, net::IOBuffer* buf,
@@ skipping 110 matching lines @@
 
   if (new_eviction_)
     cache_impl_->SetNewEviction();
 
   cache_impl_->SetType(type_);
   cache_impl_->SetFlags(disk_cache::kNoRandom);
   TestOldCompletionCallback cb;
   int rv = cache_impl_->Init(&cb);
   ASSERT_EQ(net::OK, cb.GetResult(rv));
 }