AU: Include the manifest size in the delta payload usage report.

delta_diff_generator.cc

 // 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.
 
 #include "update_engine/delta_diff_generator.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <sys/stat.h>
@@ skipping 446 matching lines @@
 };
 
 static const char* kInstallOperationTypes[] = {
   "REPLACE",
   "REPLACE_BZ",
   "MOVE",
   "BSDIFF"
 };
 
 void ReportPayloadUsage(const Graph& graph,
-                        const DeltaArchiveManifest& manifest) {
+                        const DeltaArchiveManifest& manifest,
+                        const int64_t manifest_metadata_size) {
   vector<DeltaObject> objects;
   off_t total_size = 0;
 
   // Graph nodes with information about file names.
   for (Vertex::Index node = 0; node < graph.size(); node++) {
     const Vertex& vertex = graph[node];
     if (!vertex.valid) {
       continue;
     }
     objects.push_back(DeltaObject(vertex.file_name,
                                   vertex.op.type(),
                                   vertex.op.data_length()));
     total_size += vertex.op.data_length();
   }
 
   // Kernel install operations.
   for (int i = 0; i < manifest.kernel_install_operations_size(); ++i) {
     const DeltaArchiveManifest_InstallOperation& op =
         manifest.kernel_install_operations(i);
     objects.push_back(DeltaObject(StringPrintf("<kernel-operation-%d>", i),
                                   op.type(),
                                   op.data_length()));
     total_size += op.data_length();
   }
 
+  objects.push_back(DeltaObject("<manifest-metadata>",
+                                -1,
+                                manifest_metadata_size));
+  total_size += manifest_metadata_size;
+
   std::sort(objects.begin(), objects.end());
 
   static const char kFormatString[] = "%6.2f%% %10llu %-10s %s\n";
   for (vector<DeltaObject>::const_iterator it = objects.begin();
        it != objects.end(); ++it) {
     const DeltaObject& object = *it;
     fprintf(stderr, kFormatString,
             object.size * 100.0 / total_size,
             object.size,
-            kInstallOperationTypes[object.type],
+            object.type >= 0 ? kInstallOperationTypes[object.type] : "-",
             object.name.c_str());
   }
   fprintf(stderr, kFormatString, 100.0, total_size, "", "<total>");
 }
 
 }  // namespace {}
 
 bool DeltaDiffGenerator::ReadFileToDiff(
     const string& old_filename,
     const string& new_filename,
@@ skipping 962 matching lines @@
     LOG(INFO) << "Signing the update...";
     vector<char> signature_blob;
     TEST_AND_RETURN_FALSE(PayloadSigner::SignPayload(output_path,
                                                      private_key_path,
                                                      &signature_blob));
     TEST_AND_RETURN_FALSE(writer.Write(&signature_blob[0],
                                        signature_blob.size()) ==
                           static_cast<ssize_t>(signature_blob.size()));
   }
 
-  ReportPayloadUsage(graph, manifest);
+  int64_t manifest_metadata_size =
+      strlen(kDeltaMagic) + 2 * sizeof(uint64_t) + serialized_manifest.size();
+  ReportPayloadUsage(graph, manifest, manifest_metadata_size);
 
   LOG(INFO) << "All done. Successfully created delta file.";
   return true;
 }
 
 const char* const kBsdiffPath = "/usr/bin/bsdiff";
 const char* const kBspatchPath = "/usr/bin/bspatch";
 const char* const kDeltaMagic = "CrAU";
 
 };  // namespace chromeos_update_engine