Use implicit_cast<> instead of static_cast<> whenever possible

minidump/test/minidump_writable_test_util.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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "minidump/test/minidump_writable_test_util.h"
 
 #include <string>
 
+#include "base/basictypes.h"
 #include "base/strings/string16.h"
 #include "gtest/gtest.h"
 
 namespace crashpad {
 namespace test {
 
 const void* MinidumpWritableAtRVAInternal(const std::string& file_contents,
                                           RVA rva) {
   if (rva >= file_contents.size()) {
     EXPECT_LT(rva, file_contents.size());
@@ skipping 39 matching lines @@
     const std::string& file_contents,
     const MINIDUMP_LOCATION_DESCRIPTOR& location) {
   const IMAGE_DEBUG_MISC* misc =
       TMinidumpWritableAtLocationDescriptor<IMAGE_DEBUG_MISC>(file_contents,
                                                               location);
   if (!misc) {
     return nullptr;
   }
 
   if (misc->DataType != IMAGE_DEBUG_MISC_EXENAME) {
-    EXPECT_EQ(static_cast<uint32_t>(IMAGE_DEBUG_MISC_EXENAME), misc->DataType);
+    EXPECT_EQ(implicit_cast<uint32_t>(IMAGE_DEBUG_MISC_EXENAME),
+              misc->DataType);
     return nullptr;
   }
 
   if (misc->Length != location.DataSize) {
     EXPECT_EQ(location.DataSize, misc->Length);
     return nullptr;
   }
 
   if (misc->Unicode == 0) {
     size_t string_length = misc->Length - offsetof(IMAGE_DEBUG_MISC, Data) - 1;
@@ skipping 27 matching lines @@
     const std::string& file_contents,
     const MINIDUMP_LOCATION_DESCRIPTOR& location) {
   const MINIDUMP_HEADER* header =
       TMinidumpWritableAtLocationDescriptor<MINIDUMP_HEADER>(file_contents,
                                                              location);
   if (!header) {
     return nullptr;
   }
 
   if (header->Signature != MINIDUMP_SIGNATURE) {
-    EXPECT_EQ(static_cast<uint32_t>(MINIDUMP_SIGNATURE), header->Signature);
+    EXPECT_EQ(implicit_cast<uint32_t>(MINIDUMP_SIGNATURE), header->Signature);
     return nullptr;
   }
   if (header->Version != MINIDUMP_VERSION) {
-    EXPECT_EQ(static_cast<uint32_t>(MINIDUMP_VERSION), header->Version);
+    EXPECT_EQ(implicit_cast<uint32_t>(MINIDUMP_VERSION), header->Version);
     return nullptr;
   }
 
   return header;
 }
 
 namespace {
 
 struct MinidumpMemoryListTraits {
   using ListType = MINIDUMP_MEMORY_LIST;
@@ skipping 142 matching lines @@
 const MinidumpModuleCodeViewRecordPDB70*
 MinidumpWritableAtLocationDescriptor<MinidumpModuleCodeViewRecordPDB70>(
     const std::string& file_contents,
     const MINIDUMP_LOCATION_DESCRIPTOR& location) {
   return MinidumpCVPDBAtLocationDescriptor<MinidumpModuleCodeViewRecordPDB70>(
       file_contents, location);
 }
 
 }  // namespace test
 }  // namespace crashpad