[Zucchini]: Fix OffsetMapper implicit conversion.

Fix compile error with -Wshorten-64-to-32. Image size is new stored as an
offset_t to avoid implicit conversion.

Bug: 881008
Change-Id: I82b12ce17d8368f05d6a5537fd1734ee32b37dbe
Reviewed-on: https://chromium-review.googlesource.com/1213549Reviewed-by: Samuel Huang <huangs@chromium.org>
Commit-Queue: Etienne Pierre-Doray <etiennep@chromium.org>
Cr-Commit-Position: refs/heads/master@{#589938}

components/zucchini/equivalence_map.cc

@@ -215,8 +215,8 @@ EquivalenceCandidate VisitEquivalenceSeed(
 /******** OffsetMapper ********/
 
 OffsetMapper::OffsetMapper(std::vector<Equivalence>&& equivalences,
-                           size_t old_image_size,
-                           size_t new_image_size)
+                           offset_t old_image_size,
+                           offset_t new_image_size)
     : equivalences_(std::move(equivalences)),
       old_image_size_(old_image_size),
       new_image_size_(new_image_size) {
@@ -229,8 +229,8 @@ OffsetMapper::OffsetMapper(std::vector<Equivalence>&& equivalences,
 }
 
 OffsetMapper::OffsetMapper(EquivalenceSource&& equivalence_source,
-                           size_t old_image_size,
-                           size_t new_image_size)
+                           offset_t old_image_size,
+                           offset_t new_image_size)
     : old_image_size_(old_image_size), new_image_size_(new_image_size) {
   DCHECK_GT(new_image_size_, 0U);
   for (auto e = equivalence_source.GetNext(); e.has_value();
@@ -241,8 +241,8 @@ OffsetMapper::OffsetMapper(EquivalenceSource&& equivalence_source,
 }
 
 OffsetMapper::OffsetMapper(const EquivalenceMap& equivalence_map,
-                           size_t old_image_size,
-                           size_t new_image_size)
+                           offset_t old_image_size,
+                           offset_t new_image_size)
     : equivalences_(equivalence_map.size()),
       old_image_size_(old_image_size),
       new_image_size_(new_image_size) {

components/zucchini/equivalence_map.h

@@ -89,17 +89,17 @@ class OffsetMapper {
   // - From a list of |equivalences|, already sorted (by |src_offset|) and
   //   pruned, useful for tests.
   OffsetMapper(std::vector<Equivalence>&& equivalences,
-               size_t old_image_size,
-               size_t new_image_size);
+               offset_t old_image_size,
+               offset_t new_image_size);
   // - From a generator, useful for Zucchini-apply.
   OffsetMapper(EquivalenceSource&& equivalence_source,
-               size_t old_image_size,
-               size_t new_image_size);
+               offset_t old_image_size,
+               offset_t new_image_size);
   // - From an EquivalenceMap that needs to be processed, useful for
   //   Zucchini-gen.
   OffsetMapper(const EquivalenceMap& equivalence_map,
-               size_t old_image_size,
-               size_t new_image_size);
+               offset_t old_image_size,
+               offset_t new_image_size);
   ~OffsetMapper();
 
   size_t size() const { return equivalences_.size(); }
@@ -145,9 +145,9 @@ class OffsetMapper {
  private:
   // |equivalences_| is pruned, i.e., no "old" blocks overlap (and no "new"
   // block overlaps). Also, it is sorted by "old" offsets.
-  std::vector<Equivalence> equivalences_;  // P
-  const size_t old_image_size_;
-  const size_t new_image_size_;
+  std::vector<Equivalence> equivalences_;
+  const offset_t old_image_size_;
+  const offset_t new_image_size_;
 };
 
 // Container of equivalences between |old_image_index| and |new_image_index|,

components/zucchini/zucchini_apply.cc

@@ -10,6 +10,7 @@
 #include <utility>
 
 #include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
 #include "components/zucchini/disassembler.h"
 #include "components/zucchini/element_detection.h"
 #include "components/zucchini/equivalence_map.h"
@@ -112,8 +113,9 @@ bool ApplyReferencesCorrection(ExecutableType exe_type,
   for (const auto& ref_group : old_disasm->MakeReferenceGroups())
     pool_groups[ref_group.pool_tag()].push_back(ref_group);
 
-  OffsetMapper offset_mapper(patch.GetEquivalenceSource(), old_image.size(),
-                             new_image.size());
+  OffsetMapper offset_mapper(patch.GetEquivalenceSource(),
+                             base::checked_cast<offset_t>(old_image.size()),
+                             base::checked_cast<offset_t>(new_image.size()));
 
   std::vector<ReferenceGroup> new_groups = new_disasm->MakeReferenceGroups();
   for (const auto& pool_and_sub_groups : pool_groups) {

components/zucchini/zucchini_gen.cc

@@ -287,7 +287,9 @@ bool GenerateExecutableElement(ExecutableType exe_type,
   EquivalenceMap equivalences =
       CreateEquivalenceMap(old_image_index, new_image_index,
                            new_disasm->num_equivalence_iterations());
-  OffsetMapper offset_mapper(equivalences, old_image.size(), new_image.size());
+  OffsetMapper offset_mapper(equivalences,
+                             base::checked_cast<offset_t>(old_image.size()),
+                             base::checked_cast<offset_t>(new_image.size()));
 
   ReferenceDeltaSink reference_delta_sink;
   for (const auto& old_targets : old_image_index.target_pools()) {

components/zucchini/zucchini_gen_unittest.cc

@@ -35,8 +35,8 @@ std::vector<int32_t> GenerateReferencesDeltaTest(
     EquivalenceMap&& equivalence_map) {
   // OffsetMapper needs image sizes for forward-projection overflow check. These
   // are tested elsewhere, so just use arbitrary large value.
-  constexpr size_t kOldImageSize = 1000000;
-  constexpr size_t kNewImageSize = 1001000;
+  constexpr offset_t kOldImageSize = 1000000;
+  constexpr offset_t kNewImageSize = 1001000;
 
   ReferenceDeltaSink reference_delta_sink;