Restructure FilesystemCopierAction to use ping-pong buffers.

filesystem_copier_action.h

 // Copyright (c) 2010 The Chromium OS 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 CHROMEOS_PLATFORM_UPDATE_ENGINE_FILESYSTEM_COPIER_ACTION_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_FILESYSTEM_COPIER_ACTION_H__
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
@@ skipping 19 matching lines @@
 class ActionTraits<FilesystemCopierAction> {
  public:
   // Takes the install plan as input
   typedef InstallPlan InputObjectType;
   // Passes the install plan as output
   typedef InstallPlan OutputObjectType;
 };
 
 class FilesystemCopierAction : public Action<FilesystemCopierAction> {
  public:
-  explicit FilesystemCopierAction(bool copying_kernel_install_path)
-      : copying_kernel_install_path_(copying_kernel_install_path),
-        src_stream_(NULL),
-        dst_stream_(NULL),
-        canceller_(NULL),
-        read_in_flight_(false),
-        buffer_valid_size_(0),
-        filesystem_size_(kint64max) {}
+  explicit FilesystemCopierAction(bool copying_kernel_install_path);
+
   typedef ActionTraits<FilesystemCopierAction>::InputObjectType
   InputObjectType;
   typedef ActionTraits<FilesystemCopierAction>::OutputObjectType
   OutputObjectType;
   void PerformAction();
   void TerminateProcessing();
 
   // Used for testing, so we can copy from somewhere other than root
-  void set_copy_source(const std::string& path) {
-    copy_source_ = path;
-  }
+  void set_copy_source(const std::string& path) { copy_source_ = path; }
 
   // Debugging/logging
   static std::string StaticType() { return "FilesystemCopierAction"; }
   std::string Type() const { return StaticType(); }
 
  private:
   friend class FilesystemCopierActionTest;
   FRIEND_TEST(FilesystemCopierActionTest, RunAsRootDetermineFilesystemSizeTest);
 
-  // Callback from glib when the copy operation is done.
-  void AsyncReadyCallback(GObject *source_object, GAsyncResult *res);
-  static void StaticAsyncReadyCallback(GObject *source_object,
-                                       GAsyncResult *res,
-                                       gpointer user_data) {
-    reinterpret_cast<FilesystemCopierAction*>(user_data)->AsyncReadyCallback(
-        source_object, res);
-  }
+  // Ping-pong buffers generally cycle through the following states:
+  // Empty->Reading->Full->Writing->Empty.
+  enum BufferState {
+    kBufferStateEmpty,
+    kBufferStateReading,
+    kBufferStateFull,
+    kBufferStateWriting
+  };
 
-  // Cleans up all the variables we use for async operations and tells
-  // the ActionProcessor we're done w/ success as passed in.
-  // was_cancelled should be true if TerminateProcessing() was called.
-  void Cleanup(bool success, bool was_cancelled);
+  // Callbacks from glib when the read/write operation is done.
+  void AsyncReadReadyCallback(GObject *source_object, GAsyncResult *res);
+  static void StaticAsyncReadReadyCallback(GObject *source_object,
+                                           GAsyncResult *res,
+                                           gpointer user_data);
+
+  void AsyncWriteReadyCallback(GObject *source_object, GAsyncResult *res);
+  static void StaticAsyncWriteReadyCallback(GObject *source_object,
+                                            GAsyncResult *res,
+                                            gpointer user_data);
+
+  // Based on the state of the ping-pong buffers spawns appropriate read/write
+  // actions asynchronously.
+  void SpawnAsyncActions();
+
+  // Cleans up all the variables we use for async operations and tells the
+  // ActionProcessor we're done w/ success as passed in. |cancelled_| should be
+  // true if TerminateProcessing() was called.
+  void Cleanup(bool success);
 
   // Determine, if possible, the source file system size to avoid copying the
   // whole partition. Currently this supports only the root file system assuming
   // it's ext3-compatible.
   void DetermineFilesystemSize(int fd);
 
   // Returns the number of bytes to read based on the size of the buffer and the
   // filesystem size.
   int64_t GetBytesToRead();
 
   // If true, this action is copying to the kernel_install_path from
   // the install plan, otherwise it's copying just to the install_path.
   const bool copying_kernel_install_path_;
 
   // The path to copy from. If empty (the default), the source is from the
   // passed in InstallPlan.
   std::string copy_source_;
 
   // If non-NULL, these are GUnixInputStream objects for the opened
   // source/destination partitions.
   GInputStream* src_stream_;
   GOutputStream* dst_stream_;
 
-  // If non-NULL, the cancellable object for the in-flight async call.
-  GCancellable* canceller_;
+  // Ping-pong buffers for storing data we read/write. Only one buffer is being
+  // read at a time and only one buffer is being written at a time.
+  std::vector<char> buffer_[2];
 
-  // True if we're waiting on a read to complete; false if we're
-  // waiting on a write.
-  bool read_in_flight_;
+  // The state of each buffer.
+  BufferState buffer_state_[2];
 
-  // The buffer for storing data we read/write.
-  std::vector<char> buffer_;
+  // Number of valid elements in |buffer_| if its state is kBufferStateFull.
+  std::vector<char>::size_type buffer_valid_size_[2];
 
-  // Number of valid elements in buffer_.
-  std::vector<char>::size_type buffer_valid_size_;
+  // The cancellable objects for the in-flight async calls.
+  GCancellable* canceller_[2];
+
+  bool read_done_;  // true if reached EOF on the input stream.
+  bool failed_;  // true if the action has failed.
+  bool cancelled_;  // true if the action has been cancelled.
 
   // The install plan we're passed in via the input pipe.
   InstallPlan install_plan_;
 
   // Calculates the hash of the copied data.
   OmahaHashCalculator hasher_;
 
   // Copies and hashes this many bytes from the head of the input stream. This
   // field is initialized when the action is started and decremented as more
   // bytes get copied.
   int64_t filesystem_size_;
 
   DISALLOW_COPY_AND_ASSIGN(FilesystemCopierAction);
 };
 
 }  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_FILESYSTEM_COPIER_ACTION_H__