AU: Really delta compress the kernel if an old kernel is provided.

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 93 matching lines @@
 bool WriteSparseFile(const string& path, off_t size) {
   int fd = open(path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, 0644);
   TEST_AND_RETURN_FALSE_ERRNO(fd >= 0);
   ScopedFdCloser fd_closer(&fd);
   off_t rc = lseek(fd, size + 1, SEEK_SET);
   TEST_AND_RETURN_FALSE_ERRNO(rc != static_cast<off_t>(-1));
   int return_code = ftruncate(fd, size);
   TEST_AND_RETURN_FALSE_ERRNO(return_code == 0);
   return true;
 }
-}
 
-TEST(DeltaPerformerTest, RunAsRootSmallImageTest) {
+void DoSmallImageTest(bool full_kernel) {
   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));
@@ skipping 79 matching lines @@
   string delta_path;
   EXPECT_TRUE(utils::MakeTempFile("/tmp/delta.XXXXXX", &delta_path, NULL));
   LOG(INFO) << "delta path: " << delta_path;
   ScopedPathUnlinker delta_path_unlinker(delta_path);
   {
     string a_mnt, b_mnt;
     ScopedLoopMounter a_mounter(a_img, &a_mnt, MS_RDONLY);
     ScopedLoopMounter b_mounter(b_img, &b_mnt, MS_RDONLY);
 
     EXPECT_TRUE(
-        DeltaDiffGenerator::GenerateDeltaUpdateFile(a_mnt,
-                                                    a_img,
-                                                    b_mnt,
-                                                    b_img,
-                                                    old_kernel,
-                                                    new_kernel,
-                                                    delta_path,
-                                                    kUnittestPrivateKeyPath));
+        DeltaDiffGenerator::GenerateDeltaUpdateFile(
+            a_mnt,
+            a_img,
+            b_mnt,
+            b_img,
+            full_kernel ? "" : old_kernel,
+            new_kernel,
+            delta_path,
+            kUnittestPrivateKeyPath));
   }
 
   // Read delta into memory.
   vector<char> delta;
   EXPECT_TRUE(utils::ReadFile(delta_path, &delta));
 
   uint64_t manifest_metadata_size;
 
   // Check the metadata.
   {
@@ skipping 80 matching lines @@
   EXPECT_EQ(0, strncmp(&updated_kernel_partition[0], new_data_string,
                        strlen(new_data_string)));
 
   EXPECT_TRUE(utils::FileExists(kUnittestPublicKeyPath));
   EXPECT_TRUE(performer.VerifyPayload(
       kUnittestPublicKeyPath,
       OmahaHashCalculator::OmahaHashOfData(delta),
       delta.size()));
   EXPECT_TRUE(performer.VerifyAppliedUpdate(a_img, old_kernel));
 }
+}
+
+TEST(DeltaPerformerTest, RunAsRootSmallImageTest) {
+  DoSmallImageTest(false);
+}
+
+TEST(DeltaPerformerTest, RunAsRootFullKernelSmallImageTest) {
+  DoSmallImageTest(true);
+}
 
 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;
 
@@ skipping 62 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