AU: Don't send rootfs hashes along with the delta payload.

delta_diff_generator.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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_DELTA_DIFF_GENERATOR_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_DELTA_DIFF_GENERATOR_H__
 
 #include <string>
 #include <vector>
 #include "base/basictypes.h"
 #include "update_engine/graph_types.h"
@@ skipping 106 matching lines @@
   // from T rather than the blocks in the edge. Modify A to depend on X,
   // but not on B. Free space is found by looking in 'blocks'.
   // Returns true on success.
   static bool CutEdges(Graph* graph,
                        const std::set<Edge>& edges,
                        std::vector<CutEdgeVertexes>* out_cuts);
 
   // Stores all Extents in 'extents' into 'out'.
   static void StoreExtents(const std::vector<Extent>& extents,
                            google::protobuf::RepeatedPtrField<Extent>* out);
-                           
+
   // Creates all the edges for the graph. Writers of a block point to
   // readers of the same block. This is because for an edge A->B, B
   // must complete before A executes.
   static void CreateEdges(Graph* graph, const std::vector<Block>& blocks);
 
   // Given a topologically sorted graph |op_indexes| and |graph|, alters
   // |op_indexes| to move all the full operations to the end of the vector.
   // Full operations should not be depended on, so this is safe.
   static void MoveFullOpsToBack(Graph* graph,
                                 std::vector<Vertex::Index>* op_indexes);
 
   // Sorts the vector |cuts| by its |cuts[].old_dest| member. Order is
   // determined by the order of elements in op_indexes.
   static void SortCutsByTopoOrder(std::vector<Vertex::Index>& op_indexes,
                                   std::vector<CutEdgeVertexes>* cuts);
 
   // Returns true iff there are no extents in the graph that refer to temp
   // blocks. Temp blocks are in the range [kTempBlockStart, kSparseHole).
   static bool NoTempBlocksRemain(const Graph& graph);
-  
+
   // Install operations in the manifest may reference data blobs, which
   // are in data_blobs_path. This function creates a new data blobs file
   // with the data blobs in the same order as the referencing install
   // operations in the manifest. E.g. if manifest[0] has a data blob
   // "X" at offset 1, manifest[1] has a data blob "Y" at offset 0,
   // and data_blobs_path's file contains "YX", new_data_blobs_path
   // will set to be a file that contains "XY".
   static bool ReorderDataBlobs(DeltaArchiveManifest* manifest,
                                const std::string& data_blobs_path,
                                const std::string& new_data_blobs_path);
-                               
+
   // Handles allocation of temp blocks to a cut edge by converting the
   // dest node to a full op. This removes the need for temp blocks, but
   // comes at the cost of a worse compression ratio.
   // For example, say we have A->B->A. It would first be cut to form:
   // A->B->N<-A, where N copies blocks to temp space. If there are no
   // temp blocks, this function can be called to convert it to the form:
   // A->B. Now, A is a full operation.
   static bool ConvertCutToFullOp(Graph* graph,
                                  const CutEdgeVertexes& cut,
                                  const std::string& new_root,
                                  int data_fd,
                                  off_t* data_file_size);
-                                 
+
   // Takes |op_indexes|, which is effectively a mapping from order in
   // which the op is performed -> graph vertex index, and produces the
   // reverse: a mapping from graph vertex index -> op_indexes index.
   static void GenerateReverseTopoOrderMap(
       std::vector<Vertex::Index>& op_indexes,
       std::vector<std::vector<Vertex::Index>::size_type>* reverse_op_indexes);
-                                 
+
   // Takes a |graph|, which has edges that must be cut, as listed in
   // |cuts|.  Cuts the edges. Maintains a list in which the operations
   // will be performed (in |op_indexes|) and the reverse (in
   // |reverse_op_indexes|).  Cutting edges requires scratch space, and
   // if insufficient scratch is found, the file is reread and will be
   // send down (either as REPLACE or REPLACE_BZ).  Returns true on
   // success.
   static bool AssignTempBlocks(
       Graph* graph,
       const std::string& new_root,
       int data_fd,
       off_t* data_file_size,
       std::vector<Vertex::Index>* op_indexes,
       std::vector<std::vector<Vertex::Index>::size_type>* reverse_op_indexes,
       std::vector<CutEdgeVertexes>& cuts);
 
-  // Given a new rootfs and kernel (|new_image|, |new_kernel_part|),
-  // Reads them sequentially, creating a full update of chunk_size chunks.
-  // Populates |graph|, |kernel_ops|, and |final_order|, with data
-  // about the update operations, and writes relevant data to |fd|,
-  // updating |data_file_size| as it does.
+  // Given a new rootfs and kernel (|new_image|, |new_kernel_part|), Reads them
+  // sequentially, creating a full update of chunk_size chunks.  Populates
+  // |graph|, |kernel_ops|, and |final_order|, with data about the update
+  // operations, and writes relevant data to |fd|, updating |data_file_size| as
+  // it does. Only the first |image_size| bytes are read from |new_image|
+  // assuming that this is the actual file system.
   static bool ReadFullUpdateFromDisk(
       Graph* graph,
       const std::string& new_kernel_part,
       const std::string& new_image,
+      off_t image_size,
       int fd,
       off_t* data_file_size,
       off_t chunk_size,
       std::vector<DeltaArchiveManifest_InstallOperation>* kernel_ops,
       std::vector<Vertex::Index>* final_order);
 
  private:
   // This should never be constructed
   DISALLOW_IMPLICIT_CONSTRUCTORS(DeltaDiffGenerator);
 };
 
 extern const char* const kBsdiffPath;
 extern const char* const kBspatchPath;
 extern const char* const kDeltaMagic;
 
 };  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_DELTA_DIFF_GENERATOR_H__