win: fixes for Windows x64

snapshot/minidump/process_snapshot_minidump_test.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 45 matching lines @@
 
   ProcessSnapshotMinidump process_snapshot;
   EXPECT_TRUE(process_snapshot.Initialize(&string_file));
 }
 
 // Writes |string| to |writer| as a MinidumpUTF8String, and returns the file
 // offst of the beginning of the string.
 RVA WriteString(FileWriterInterface* writer, const std::string& string) {
   RVA rva = static_cast<RVA>(writer->SeekGet());
 
-  uint32_t string_size = string.size();
+  uint32_t string_size = static_cast<uint32_t>(string.size());
   EXPECT_TRUE(writer->Write(&string_size, sizeof(string_size)));
 
   // Include the trailing NUL character.
   EXPECT_TRUE(writer->Write(string.c_str(), string.size() + 1));
 
   return rva;
 }
 
 // Writes |dictionary| to |writer| as a MinidumpSimpleStringDictionary, and
 // populates |location| with a location descriptor identifying what was written.
 void WriteMinidumpSimpleStringDictionary(
     MINIDUMP_LOCATION_DESCRIPTOR* location,
     FileWriterInterface* writer,
     const std::map<std::string, std::string>& dictionary) {
   std::vector<MinidumpSimpleStringDictionaryEntry> entries;
   for (const auto& it : dictionary) {
     MinidumpSimpleStringDictionaryEntry entry;
     entry.key = WriteString(writer, it.first);
     entry.value = WriteString(writer, it.second);
     entries.push_back(entry);
   }
 
   location->Rva = static_cast<RVA>(writer->SeekGet());
 
-  const uint32_t simple_string_dictionary_entries = entries.size();
+  const uint32_t simple_string_dictionary_entries =
+      static_cast<uint32_t>(entries.size());
   EXPECT_TRUE(writer->Write(&simple_string_dictionary_entries,
                             sizeof(simple_string_dictionary_entries)));
   for (const MinidumpSimpleStringDictionaryEntry& entry : entries) {
     EXPECT_TRUE(writer->Write(&entry, sizeof(entry)));
   }
 
-  location->DataSize =
+  location->DataSize = static_cast<uint32_t>(
       sizeof(simple_string_dictionary_entries) +
-      entries.size() * sizeof(MinidumpSimpleStringDictionaryEntry);
+      entries.size() * sizeof(MinidumpSimpleStringDictionaryEntry));
 }
 
 // Writes |strings| to |writer| as a MinidumpRVAList referencing
 // MinidumpUTF8String objects, and populates |location| with a location
 // descriptor identifying what was written.
 void WriteMinidumpStringList(MINIDUMP_LOCATION_DESCRIPTOR* location,
                              FileWriterInterface* writer,
                              const std::vector<std::string>& strings) {
   std::vector<RVA> rvas;
   for (const std::string& string : strings) {
     rvas.push_back(WriteString(writer, string));
   }
 
   location->Rva = static_cast<RVA>(writer->SeekGet());
 
-  const uint32_t string_list_entries = rvas.size();
+  const uint32_t string_list_entries = static_cast<uint32_t>(rvas.size());
   EXPECT_TRUE(writer->Write(&string_list_entries, sizeof(string_list_entries)));
   for (RVA rva : rvas) {
     EXPECT_TRUE(writer->Write(&rva, sizeof(rva)));
   }
 
-  location->DataSize = sizeof(string_list_entries) + rvas.size() * sizeof(RVA);
+  location->DataSize = static_cast<uint32_t>(sizeof(string_list_entries) +
+                                             rvas.size() * sizeof(RVA));
 }
 
 TEST(ProcessSnapshotMinidump, AnnotationsSimpleMap) {
   StringFile string_file;
 
   MINIDUMP_HEADER header = {};
   EXPECT_TRUE(string_file.Write(&header, sizeof(header)));
 
   MinidumpCrashpadInfo crashpad_info = {};
   crashpad_info.version = MinidumpCrashpadInfo::kVersion;
@@ skipping 143 matching lines @@
   annotations_simple_map = modules[2]->AnnotationsSimpleMap();
   EXPECT_EQ(dictionary_2, annotations_simple_map);
 
   annotations_vector = modules[2]->AnnotationsVector();
   EXPECT_EQ(list_annotations_2, annotations_vector);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad