AU: Split applied update verification into a separate step.

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);
+  FilesystemCopierAction(bool copying_kernel_install_path,
+                         bool verify_hash);
 
   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; }
 
   // Debugging/logging
   static std::string StaticType() { return "FilesystemCopierAction"; }
   std::string Type() const { return StaticType(); }
 
  private:
   friend class FilesystemCopierActionTest;
   FRIEND_TEST(FilesystemCopierActionTest, RunAsRootDetermineFilesystemSizeTest);
 
   // Ping-pong buffers generally cycle through the following states:
-  // Empty->Reading->Full->Writing->Empty.
+  // Empty->Reading->Full->Writing->Empty. In hash verification mode the state
+  // is never set to Writing.
   enum BufferState {
     kBufferStateEmpty,
     kBufferStateReading,
     kBufferStateFull,
     kBufferStateWriting
   };
 
   // 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
+  // ActionProcessor we're done w/ |code| as passed in. |cancelled_| should be
   // true if TerminateProcessing() was called.
-  void Cleanup(bool success);
+  void Cleanup(ActionExitCode code);
 
   // 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_;
 
+  // If true, this action is running in applied update hash verification mode --
+  // it computes a hash for the target install path and compares it against the
+  // expected value.
+  const bool verify_hash_;
+
   // 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_;
 
   // Ping-pong buffers for storing data we read/write. Only one buffer is being
@@ skipping 23 matching lines @@
   // 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__