src/net/disk_cache/blockfile/in_flight_io.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_IO_H_
   6 #define NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_IO_H_
   7
   8 #include <set>
   9
  10 #include "base/memory/ref_counted.h"
  11 #include "base/synchronization/lock.h"
  12 #include "base/synchronization/waitable_event.h"
  13
  14 namespace base {
  15 class TaskRunner;
  16 }  // namespace base
  17
  18 namespace disk_cache {
  19
  20 class InFlightIO;
  21
  22 // This class represents a single asynchronous IO operation while it is being
  23 // bounced between threads.
  24 class BackgroundIO : public base::RefCountedThreadSafe<BackgroundIO> {
  25  public:
  26   // Other than the actual parameters for the IO operation (including the
  27   // |callback| that must be notified at the end), we need the controller that
  28   // is keeping track of all operations. When done, we notify the controller
  29   // (we do NOT invoke the callback), in the worker thead that completed the
  30   // operation.
  31   explicit BackgroundIO(InFlightIO* controller);
  32
  33   // This method signals the controller that this operation is finished, in the
  34   // original thread. In practice, this is a RunableMethod that allows
  35   // cancellation.
  36   void OnIOSignalled();
  37
  38   // Allows the cancellation of the task to notify the controller (step number 8
  39   // in the diagram below). In practice, if the controller waits for the
  40   // operation to finish it doesn't have to wait for the final task to be
  41   // processed by the message loop so calling this method prevents its delivery.
  42   // Note that this method is not intended to cancel the actual IO operation or
  43   // to prevent the first notification to take place (OnIOComplete).
  44   void Cancel();
  45
  46   int result() { return result_; }
  47
  48   base::WaitableEvent* io_completed() {
  49     return &io_completed_;
  50   }
  51
  52  protected:
  53   virtual ~BackgroundIO();
  54
  55   // Notifies the controller about the end of the operation, from the background
  56   // thread.
  57   void NotifyController();
  58
  59   int result_;  // Final operation result.
  60
  61  private:
  62   friend class base::RefCountedThreadSafe<BackgroundIO>;
  63
  64   // An event to signal when the operation completes.
  65   base::WaitableEvent io_completed_;
  66   InFlightIO* controller_;  // The controller that tracks all operations.
  67   base::Lock controller_lock_;  // A lock protecting clearing of controller_.
  68
  69   DISALLOW_COPY_AND_ASSIGN(BackgroundIO);
  70 };
  71
  72 // This class keeps track of asynchronous IO operations. A single instance
  73 // of this class is meant to be used to start an asynchronous operation (using
  74 // PostXX, exposed by a derived class). This class will post the operation to a
  75 // worker thread, hanlde the notification when the operation finishes and
  76 // perform the callback on the same thread that was used to start the operation.
  77 //
  78 // The regular sequence of calls is:
  79 //                 Thread_1                          Worker_thread
  80 //    1.     DerivedInFlightIO::PostXX()
  81 //    2.                         -> PostTask ->
  82 //    3.    InFlightIO::OnOperationPosted()
  83 //    4.                                        DerivedBackgroundIO::XX()
  84 //    5.                                         IO operation completes
  85 //    6.                                       InFlightIO::OnIOComplete()
  86 //    7.                         <- PostTask <-
  87 //    8.  BackgroundIO::OnIOSignalled()
  88 //    9.  InFlightIO::InvokeCallback()
  89 //   10. DerivedInFlightIO::OnOperationComplete()
  90 //   11.       invoke callback
  91 //
  92 // Shutdown is a special case that is handled though WaitForPendingIO() instead
  93 // of just waiting for step 7.
  94 class InFlightIO {
  95  public:
  96   InFlightIO();
  97   virtual ~InFlightIO();
  98
  99   // Blocks the current thread until all IO operations tracked by this object
 100   // complete.
 101   void WaitForPendingIO();
 102
 103   // Drops current pending operations without waiting for them to complete.
 104   void DropPendingIO();
 105
 106   // Called on a background thread when |operation| completes.
 107   void OnIOComplete(BackgroundIO* operation);
 108
 109   // Invokes the users' completion callback at the end of the IO operation.
 110   // |cancel_task| is true if the actual task posted to the thread is still
 111   // queued (because we are inside WaitForPendingIO), and false if said task is
 112   // the one performing the call.
 113   void InvokeCallback(BackgroundIO* operation, bool cancel_task);
 114
 115  protected:
 116   // This method is called to signal the completion of the |operation|. |cancel|
 117   // is true if the operation is being cancelled. This method is called on the
 118   // thread that created this object.
 119   virtual void OnOperationComplete(BackgroundIO* operation, bool cancel) = 0;
 120
 121   // Signals this object that the derived class just posted the |operation| to
 122   // be executed on a background thread. This method must be called on the same
 123   // thread used to create this object.
 124   void OnOperationPosted(BackgroundIO* operation);
 125
 126  private:
 127   typedef std::set<scoped_refptr<BackgroundIO> > IOList;
 128
 129   IOList io_list_;  // List of pending, in-flight io operations.
 130   scoped_refptr<base::TaskRunner> callback_task_runner_;
 131
 132   bool running_;  // True after the first posted operation completes.
 133   bool single_thread_;  // True if we only have one thread.
 134
 135   DISALLOW_COPY_AND_ASSIGN(InFlightIO);
 136 };
 137
 138 }  // namespace disk_cache
 139
 140 #endif  // NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_IO_H_