AU: Include the old/new kernel/rootfs size/hash in the update metadata.

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 196 matching lines @@
                                                     delta_path,
                                                     kUnittestPrivateKeyPath));
   }
 
   // Read delta into memory.
   vector<char> delta;
   EXPECT_TRUE(utils::ReadFile(delta_path, &delta));
 
   uint64_t manifest_metadata_size;
 
-  // Check that the null signature blob exists
+  // Check the metadata.
   {
     LOG(INFO) << "delta size: " << delta.size();
     DeltaArchiveManifest manifest;
     const int kManifestSizeOffset = 12;
     const int kManifestOffset = 20;
     uint64_t manifest_size = 0;
     memcpy(&manifest_size, &delta[kManifestSizeOffset], sizeof(manifest_size));
     manifest_size = be64toh(manifest_size);
     LOG(INFO) << "manifest size: " << manifest_size;
     EXPECT_TRUE(manifest.ParseFromArray(&delta[kManifestOffset],
                                         manifest_size));
     EXPECT_TRUE(manifest.has_signatures_offset());
     manifest_metadata_size = kManifestOffset + manifest_size;
 
     Signatures sigs_message;
     EXPECT_TRUE(sigs_message.ParseFromArray(
         &delta[manifest_metadata_size + manifest.signatures_offset()],
         manifest.signatures_size()));
     EXPECT_EQ(1, sigs_message.signatures_size());
     const Signatures_Signature& signature = sigs_message.signatures(0);
     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());
   }
 
   PrefsMock prefs;
   EXPECT_CALL(prefs, SetInt64(kPrefsManifestMetadataSize,
                               manifest_metadata_size)).WillOnce(Return(true));
   EXPECT_CALL(prefs, SetInt64(kPrefsUpdateStateNextOperation, _))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(prefs, SetInt64(kPrefsUpdateStateNextDataOffset, _))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(prefs, SetString(kPrefsUpdateStateSHA256Context, _))
@@ skipping 86 matching lines @@
               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());
     }
   }
 }
 
 }  // namespace chromeos_update_engine