win: fixes for Windows x64

minidump/minidump_exception_writer_test.cc

 // Copyright 2014 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 163 matching lines @@
       GetExceptionStream(string_file.string(), &observed_exception_stream));
 
   MINIDUMP_EXCEPTION_STREAM expected_exception_stream = {};
   expected_exception_stream.ThreadId = kThreadID;
   expected_exception_stream.ExceptionRecord.ExceptionCode = kExceptionCode;
   expected_exception_stream.ExceptionRecord.ExceptionFlags = kExceptionFlags;
   expected_exception_stream.ExceptionRecord.ExceptionRecord = kExceptionRecord;
   expected_exception_stream.ExceptionRecord.ExceptionAddress =
       kExceptionAddress;
   expected_exception_stream.ExceptionRecord.NumberParameters =
-      exception_information.size();
+      static_cast<uint32_t>(exception_information.size());
   for (size_t index = 0; index < exception_information.size(); ++index) {
     expected_exception_stream.ExceptionRecord.ExceptionInformation[index] =
         exception_information[index];
   }
   expected_exception_stream.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
   const MinidumpContextX86* observed_context = nullptr;
   ASSERT_NO_FATAL_FAILURE(ExpectExceptionStream(&expected_exception_stream,
                                                 observed_exception_stream,
                                                 string_file.string(),
                                                 &observed_context));
 
   ASSERT_NO_FATAL_FAILURE(
       ExpectMinidumpContextX86(kSeed, observed_context, false));
 }
 
 TEST(MinidumpExceptionWriter, InitializeFromSnapshot) {
   std::vector<uint64_t> exception_codes;
   exception_codes.push_back(0x1000000000000000);
   exception_codes.push_back(0x5555555555555555);
 
   MINIDUMP_EXCEPTION_STREAM expect_exception = {};
 
   expect_exception.ThreadId = 123;
   expect_exception.ExceptionRecord.ExceptionCode = 100;
   expect_exception.ExceptionRecord.ExceptionFlags = 1;
   expect_exception.ExceptionRecord.ExceptionAddress = 0xfedcba9876543210;
-  expect_exception.ExceptionRecord.NumberParameters = exception_codes.size();
+  expect_exception.ExceptionRecord.NumberParameters =
+      static_cast<uint32_t>(exception_codes.size());
   for (size_t index = 0; index < exception_codes.size(); ++index) {
     expect_exception.ExceptionRecord.ExceptionInformation[index] =
         exception_codes[index];
   }
   const uint64_t kThreadID = 0xaaaaaaaaaaaaaaaa;
   const uint32_t kSeed = 65;
 
   TestExceptionSnapshot exception_snapshot;
   exception_snapshot.SetThreadID(kThreadID);
   exception_snapshot.SetException(
@@ skipping 45 matching lines @@
   MinidumpExceptionWriter exception_writer;
   std::vector<uint64_t> exception_information(EXCEPTION_MAXIMUM_PARAMETERS + 1,
                                               0x5a5a5a5a5a5a5a5a);
   ASSERT_DEATH(exception_writer.SetExceptionInformation(exception_information),
                "kMaxParameters");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad