FBTF: Moves code to the headers.

net/disk_cache/in_flight_io.h

 // Copyright (c) 2006-2010 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_
 #pragma once
 
 #include <set>
 
 #include "base/message_loop_proxy.h"
 #include "base/waitable_event.h"
 
 namespace disk_cache {
 
 class InFlightIO;
 
 // This class represents a single asynchronous IO operation while it is being
 // bounced between threads.
 class BackgroundIO : public base::RefCountedThreadSafe<BackgroundIO> {
  public:
   // Other than the actual parameters for the IO operation (including the
   // |callback| that must be notified at the end), we need the controller that
   // is keeping track of all operations. When done, we notify the controller
   // (we do NOT invoke the callback), in the worker thead that completed the
   // operation.
-  explicit BackgroundIO(InFlightIO* controller)
-      : controller_(controller), result_(-1), io_completed_(true, false) {}
+  explicit BackgroundIO(InFlightIO* controller);
 
   // This method signals the controller that this operation is finished, in the
   // original thread. In practice, this is a RunableMethod that allows
   // cancellation.
   void OnIOSignalled();
 
   // Allows the cancellation of the task to notify the controller (step number 8
   // in the diagram below). In practice, if the controller waits for the
   // operation to finish it doesn't have to wait for the final task to be
   // processed by the message loop so calling this method prevents its delivery.
   // Note that this method is not intended to cancel the actual IO operation or
   // to prevent the first notification to take place (OnIOComplete).
   void Cancel();
 
   int result() { return result_; }
 
   base::WaitableEvent* io_completed() {
     return &io_completed_;
   }
 
  protected:
-  virtual ~BackgroundIO() {}
+  virtual ~BackgroundIO();
 
   InFlightIO* controller_;  // The controller that tracks all operations.
   int result_;  // Final operation result.
 
  private:
   friend class base::RefCountedThreadSafe<BackgroundIO>;
 
   // Notifies the controller about the end of the operation, from the background
   // thread.
   void NotifyController();
@@ skipping 21 matching lines @@
 //    7.                         <- PostTask <-
 //    8.  BackgroundIO::OnIOSignalled()
 //    9.  InFlightIO::InvokeCallback()
 //   10. DerivedInFlightIO::OnOperationComplete()
 //   11.       invoke callback
 //
 // Shutdown is a special case that is handled though WaitForPendingIO() instead
 // of just waiting for step 7.
 class InFlightIO {
  public:
-  InFlightIO()
-      : callback_thread_(base::MessageLoopProxy::CreateForCurrentThread()),
-        running_(false), single_thread_(false) {}
-  virtual ~InFlightIO() {}
+  InFlightIO();
+  virtual ~InFlightIO();
 
   // Blocks the current thread until all IO operations tracked by this object
   // complete.
   void WaitForPendingIO();
 
   // 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
@@ skipping 20 matching lines @@
 
   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_