Add an IO thread index bitmap to disk cache.

net/disk_cache/in_flight_io.h

 // Copyright (c) 2012 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_IO_H_
 #define NET_DISK_CACHE_IN_FLIGHT_IO_H_
 
 #include <set>
 
 #include "base/message_loop_proxy.h"
@@ skipping 34 matching lines @@
     return &io_completed_;
   }
 
  protected:
   virtual ~BackgroundIO();
 
   // Notifies the controller about the end of the operation, from the background
   // thread.
   void NotifyController();
 
+  scoped_refptr<base::MessageLoopProxy> GetCallbackThread();
+
   int result_;  // Final operation result.
 
  private:
   friend class base::RefCountedThreadSafe<BackgroundIO>;
 
   // An event to signal when the operation completes.
   base::WaitableEvent io_completed_;
   InFlightIO* controller_;  // The controller that tracks all operations.
   base::Lock controller_lock_;  // A lock protecting clearing of controller_.
 
@@ skipping 36 matching lines @@
 
   // Called on a background thread when |operation| completes.
   void OnIOComplete(BackgroundIO* operation);
 
   // Invokes the users' completion callback at the end of the IO operation.
   // |cancel_task| is true if the actual task posted to the thread is still
   // queued (because we are inside WaitForPendingIO), and false if said task is
   // the one performing the call.
   void InvokeCallback(BackgroundIO* operation, bool cancel_task);
 
+  scoped_refptr<base::MessageLoopProxy> callback_thread() {
+    return callback_thread_;
+  }
+
  protected:
   // This method is called to signal the completion of the |operation|. |cancel|
   // is true if the operation is being cancelled. This method is called on the
   // thread that created this object.
   virtual void OnOperationComplete(BackgroundIO* operation, bool cancel) = 0;
 
   // Signals this object that the derived class just posted the |operation| to
   // be executed on a background thread. This method must be called on the same
   // thread used to create this object.
   void OnOperationPosted(BackgroundIO* operation);
 
  private:
   typedef std::set<scoped_refptr<BackgroundIO> > IOList;
 
   IOList io_list_;  // List of pending, in-flight io operations.
   scoped_refptr<base::MessageLoopProxy> callback_thread_;
 
   bool running_;  // True after the first posted operation completes.
   bool single_thread_;  // True if we only have one thread.
 
   DISALLOW_COPY_AND_ASSIGN(InFlightIO);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_IN_FLIGHT_IO_H_