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

delta_performer_unittest.cc

 // Copyright (c) 2009 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.
 
 #include <sys/mount.h>
 #include <inttypes.h>
 
 #include <algorithm>
 #include <string>
 #include <vector>
@@ skipping 105 matching lines @@
 TEST(DeltaPerformerTest, RunAsRootSmallImageTest) {
   string a_img, b_img;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/a_img.XXXXXX", &a_img, NULL));
   ScopedPathUnlinker a_img_unlinker(a_img);
   EXPECT_TRUE(utils::MakeTempFile("/tmp/b_img.XXXXXX", &b_img, NULL));
   ScopedPathUnlinker b_img_unlinker(b_img);
 
   CreateExtImageAtPath(a_img, NULL);
   CreateExtImageAtPath(b_img, NULL);
 
+  int image_size = static_cast<int>(utils::FileSize(a_img));
+
+  // Extend the "partitions" holding the file system a bit.
+  EXPECT_EQ(0, System(base::StringPrintf(
+      "dd if=/dev/zero of=%s seek=%d bs=1 count=1",
+      a_img.c_str(),
+      image_size + 1024 * 1024 - 1)));
+  EXPECT_EQ(0, System(base::StringPrintf(
+      "dd if=/dev/zero of=%s seek=%d bs=1 count=1",
+      b_img.c_str(),
+      image_size + 1024 * 1024 - 1)));
+  EXPECT_EQ(image_size + 1024 * 1024, utils::FileSize(a_img));
+  EXPECT_EQ(image_size + 1024 * 1024, utils::FileSize(b_img));
+
   // Make some changes to the A image.
   {
     string a_mnt;
     ScopedLoopMounter b_mounter(a_img, &a_mnt, 0);
 
     EXPECT_TRUE(utils::WriteFile(StringPrintf("%s/hardtocompress",
                                               a_mnt.c_str()).c_str(),
                                  reinterpret_cast<const char*>(kRandomString),
                                  sizeof(kRandomString) - 1));
     // Write 1 MiB of 0xff to try to catch the case where writing a bsdiff
@@ skipping 103 matching lines @@
     EXPECT_EQ(1, signature.version());
 
     uint64_t expected_sig_data_length = 0;
     EXPECT_TRUE(PayloadSigner::SignatureBlobLength(kUnittestPrivateKeyPath,
                                                    &expected_sig_data_length));
     EXPECT_EQ(expected_sig_data_length, manifest.signatures_size());
     EXPECT_FALSE(signature.data().empty());
 
     EXPECT_EQ(old_kernel_data.size(), manifest.old_kernel_info().size());
     EXPECT_EQ(new_kernel_data.size(), manifest.new_kernel_info().size());
-    EXPECT_EQ(utils::FileSize(a_img), manifest.old_rootfs_info().size());
-    EXPECT_EQ(utils::FileSize(b_img), manifest.new_rootfs_info().size());
+    EXPECT_EQ(image_size, manifest.old_rootfs_info().size());
+    EXPECT_EQ(image_size, manifest.new_rootfs_info().size());
 
     EXPECT_FALSE(manifest.old_kernel_info().hash().empty());
     EXPECT_FALSE(manifest.new_kernel_info().hash().empty());
     EXPECT_FALSE(manifest.old_rootfs_info().hash().empty());
     EXPECT_FALSE(manifest.new_rootfs_info().hash().empty());
   }
 
   PrefsMock prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsManifestMetadataSize,
                               manifest_metadata_size)).WillOnce(Return(true));
@@ skipping 39 matching lines @@
       delta.size()));
   EXPECT_TRUE(performer.VerifyAppliedUpdate(a_img, old_kernel));
 }
 
 TEST(DeltaPerformerTest, NewFullUpdateTest) {
   vector<char> new_root(20 * 1024 * 1024);
   vector<char> new_kern(16 * 1024 * 1024);
   const off_t kChunkSize = 128 * 1024;
   FillWithData(&new_root);
   FillWithData(&new_kern);
+  // Assume hashes take 2 MiB beyond the rootfs.
+  off_t new_rootfs_size = new_root.size() - 2 * 1024 * 1024;
 
   string new_root_path;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/NewFullUpdateTest_R.XXXXXX",
                                   &new_root_path,
                                   NULL));
   ScopedPathUnlinker new_root_path_unlinker(new_root_path);
   EXPECT_TRUE(WriteFileVector(new_root_path, new_root));
 
   string new_kern_path;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/NewFullUpdateTest_K.XXXXXX",
@@ skipping 12 matching lines @@
 
   off_t out_blobs_length = 0;
 
   Graph graph;
   vector<DeltaArchiveManifest_InstallOperation> kernel_ops;
   vector<Vertex::Index> final_order;
 
   EXPECT_TRUE(DeltaDiffGenerator::ReadFullUpdateFromDisk(&graph,
                                                          new_kern_path,
                                                          new_root_path,
+                                                         new_rootfs_size,
                                                          out_blobs_fd,
                                                          &out_blobs_length,
                                                          kChunkSize,
                                                          &kernel_ops,
                                                          &final_order));
-  EXPECT_EQ(new_root.size() / kChunkSize, graph.size());
-  EXPECT_EQ(new_root.size() / kChunkSize, final_order.size());
+  EXPECT_EQ(new_rootfs_size / kChunkSize, graph.size());
+  EXPECT_EQ(new_rootfs_size / kChunkSize, final_order.size());
   EXPECT_EQ(new_kern.size() / kChunkSize, kernel_ops.size());
-  for (size_t i = 0; i < (new_root.size() / kChunkSize); ++i) {
+  for (off_t i = 0; i < (new_rootfs_size / kChunkSize); ++i) {
     EXPECT_EQ(i, final_order[i]);
     EXPECT_EQ(1, graph[i].op.dst_extents_size());
     EXPECT_EQ(i * kChunkSize / kBlockSize,
               graph[i].op.dst_extents(0).start_block()) << "i = " << i;
     EXPECT_EQ(kChunkSize / kBlockSize,
               graph[i].op.dst_extents(0).num_blocks());
     if (graph[i].op.type() !=
         DeltaArchiveManifest_InstallOperation_Type_REPLACE) {
       EXPECT_EQ(DeltaArchiveManifest_InstallOperation_Type_REPLACE_BZ,
                 graph[i].op.type());
@@ skipping 11 matching lines @@
   op.clear_src_extents();
   *(op.add_src_extents()) = ExtentForRange(5, 3);
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_dst_extents()) = ExtentForRange(20, 6);
   EXPECT_TRUE(DeltaPerformer::IsIdempotentOperation(op));
   *(op.add_src_extents()) = ExtentForRange(19, 2);
   EXPECT_FALSE(DeltaPerformer::IsIdempotentOperation(op));
 }
 
 }  // namespace chromeos_update_engine