Reland r113261 rebased after revert of r113249.

net/disk_cache/in_flight_backend_io.h

 // 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.
 
 #ifndef NET_DISK_CACHE_IN_FLIGHT_BACKEND_IO_H_
 #define NET_DISK_CACHE_IN_FLIGHT_BACKEND_IO_H_
 #pragma once
 
 #include <list>
 #include <string>
 
 #include "base/message_loop_proxy.h"
 #include "base/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/disk_cache/in_flight_io.h"
 
 namespace disk_cache {
 
 class BackendImpl;
 class Entry;
 class EntryImpl;
 
 // This class represents a single asynchronous disk cache IO operation while it
 // is being bounced between threads.
 class BackendIO : public BackgroundIO {
  public:
   BackendIO(InFlightIO* controller, BackendImpl* backend,
             net::OldCompletionCallback* callback);
+  BackendIO(InFlightIO* controller, BackendImpl* backend,
+            const net::CompletionCallback& callback);
 
   // Runs the actual operation on the background thread.
   void ExecuteOperation();
 
   // Callback implementation.
   void OnIOComplete(int result);
 
   // Returns true if this operation is directed to an entry (vs. the backend).
   bool IsEntryOperation();
 
-  net::OldCompletionCallback* callback() { return callback_; }
+  net::OldCompletionCallback* old_callback() const { return old_callback_; }
+  net::CompletionCallback callback() const { return callback_; }
 
   // Grabs an extra reference of entry_.
   void ReferenceEntry();
 
   // Returns the time that has passed since the operation was created.
   base::TimeDelta ElapsedTime() const;
 
   // The operations we proxy:
   void Init();
   void OpenEntry(const std::string& key, Entry** entry);
@@ skipping 55 matching lines @@
     OP_CANCEL_IO,
     OP_IS_READY
   };
 
   virtual ~BackendIO();
 
   void ExecuteBackendOperation();
   void ExecuteEntryOperation();
 
   BackendImpl* backend_;
-  net::OldCompletionCallback* callback_;
+  net::OldCompletionCallback* old_callback_;
+  net::CompletionCallback callback_;
   Operation operation_;
   net::OldCompletionCallbackImpl<BackendIO> my_callback_;
 
   // The arguments of all the operations we proxy:
   std::string key_;
   Entry** entry_ptr_;
   base::Time initial_time_;
   base::Time end_time_;
   void** iter_ptr_;
   void* iter_;
@@ skipping 19 matching lines @@
   virtual ~InFlightBackendIO();
 
   // The operations we proxy:
   void Init(net::OldCompletionCallback* callback);
   void OpenEntry(const std::string& key, Entry** entry,
                  net::OldCompletionCallback* callback);
   void CreateEntry(const std::string& key, Entry** entry,
                    net::OldCompletionCallback* callback);
   void DoomEntry(const std::string& key, net::OldCompletionCallback* callback);
   void DoomAllEntries(net::OldCompletionCallback* callback);
+  void DoomAllEntries(const net::CompletionCallback& callback);
   void DoomEntriesBetween(const base::Time initial_time,
                           const base::Time end_time,
                           net::OldCompletionCallback* callback);
+  void DoomEntriesBetween(const base::Time initial_time,
+                          const base::Time end_time,
+                          const net::CompletionCallback& callback);
   void DoomEntriesSince(const base::Time initial_time,
                         net::OldCompletionCallback* callback);
   void OpenNextEntry(void** iter, Entry** next_entry,
                      net::OldCompletionCallback* callback);
   void OpenPrevEntry(void** iter, Entry** prev_entry,
                      net::OldCompletionCallback* callback);
   void EndEnumeration(void* iterator);
   void OnExternalCacheHit(const std::string& key);
   void CloseEntryImpl(EntryImpl* entry);
   void DoomEntryImpl(EntryImpl* entry);
@@ skipping 33 matching lines @@
 
   BackendImpl* backend_;
   scoped_refptr<base::MessageLoopProxy> background_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(InFlightBackendIO);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_IN_FLIGHT_BACKEND_IO_H_