Use implicit_cast<> instead of static_cast<> whenever possible

util/mach/exc_server_variants_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 33 matching lines @@
 const thread_t kExceptionThreadPort = 0x03030303;
 const task_t kExceptionTaskPort = 0x04040404;
 
 // Other fake exception values.
 const exception_type_t kExceptionType = EXC_BAD_ACCESS;
 
 // Test using an exception code with the high bit set to ensure that it gets
 // promoted to the wider mach_exception_data_type_t type as a signed quantity.
 const exception_data_type_t kTestExceptonCodes[] = {
     KERN_PROTECTION_FAILURE,
-    static_cast<exception_data_type_t>(0xfedcba98),
+    implicit_cast<exception_data_type_t>(0xfedcba98),
 };
 
 const mach_exception_data_type_t kTestMachExceptionCodes[] = {
     KERN_PROTECTION_FAILURE,
-    static_cast<mach_exception_data_type_t>(0xfedcba9876543210),
+    implicit_cast<mach_exception_data_type_t>(0xfedcba9876543210),
 };
 
 const thread_state_flavor_t kThreadStateFlavor = MACHINE_THREAD_STATE;
 const mach_msg_type_number_t kThreadStateFlavorCount =
     MACHINE_THREAD_STATE_COUNT;
 
 void InitializeMachMsgPortDescriptor(mach_msg_port_descriptor_t* descriptor,
                                      mach_port_t port) {
   descriptor->name = port;
   descriptor->disposition = MACH_MSG_TYPE_MOVE_SEND;
@@ skipping 45 matching lines @@
   void InitializeForTesting() {
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   // Verify accepts a |behavior| parameter because the same message format and
   // verification function is used for ExceptionRaiseReply and
   // MachExceptionRaiseReply. Knowing which behavior is expected allows the
   // message ID to be checked.
   void Verify(exception_behavior_t behavior) {
-    EXPECT_EQ(static_cast<mach_msg_bits_t>(
+    EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
                   MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0)),
               Head.msgh_bits);
     EXPECT_EQ(sizeof(*this), Head.msgh_size);
     EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
     EXPECT_EQ(kMachPortNull, Head.msgh_local_port);
     switch (behavior) {
       case EXCEPTION_DEFAULT:
         EXPECT_EQ(2501, Head.msgh_id);
         break;
       case EXCEPTION_DEFAULT | kMachExceptionCodes:
@@ skipping 53 matching lines @@
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   // Verify accepts a |behavior| parameter because the same message format and
   // verification function is used for ExceptionRaiseStateReply,
   // ExceptionRaiseStateIdentityReply, MachExceptionRaiseStateReply, and
   // MachExceptionRaiseStateIdentityReply. Knowing which behavior is expected
   // allows the message ID to be checked.
   void Verify(exception_behavior_t behavior) {
-    EXPECT_EQ(static_cast<mach_msg_bits_t>(
+    EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
                   MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0)),
               Head.msgh_bits);
     EXPECT_EQ(sizeof(*this), Head.msgh_size);
     EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
     EXPECT_EQ(kMachPortNull, Head.msgh_local_port);
     switch (behavior) {
       case EXCEPTION_STATE:
         EXPECT_EQ(2502, Head.msgh_id);
         break;
       case EXCEPTION_STATE_IDENTITY:
@@ skipping 192 matching lines @@
 };
 
 struct __attribute__((packed, aligned(4))) BadIDErrorReply
     : public mig_reply_error_t {
   void InitializeForTesting() {
     memset(this, 0x5a, sizeof(*this));
     RetCode = KERN_FAILURE;
   }
 
   void Verify(mach_msg_id_t id) {
-    EXPECT_EQ(static_cast<mach_msg_bits_t>(
+    EXPECT_EQ(implicit_cast<mach_msg_bits_t>(
                   MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0)),
               Head.msgh_bits);
     EXPECT_EQ(sizeof(*this), Head.msgh_size);
     EXPECT_EQ(kClientRemotePort, Head.msgh_remote_port);
     EXPECT_EQ(kMachPortNull, Head.msgh_local_port);
     EXPECT_EQ(id + 100, Head.msgh_id);
     EXPECT_EQ(0, memcmp(&NDR, &NDR_record, sizeof(NDR)));
     EXPECT_EQ(MIG_BAD_ID, RetCode);
   }
 };
@@ skipping 493 matching lines @@
       int signal;
       ExcCrashRecoverOriginalException(code[0], nullptr, &signal);
       SetExpectedChildTermination(kTerminationSignal, signal);
     }
 
     const bool has_state = ExceptionBehaviorHasState(behavior);
     if (has_state) {
       EXPECT_EQ(flavor_, *flavor);
       EXPECT_EQ(state_count_, old_state_count);
       EXPECT_NE(nullptr, old_state);
-      EXPECT_EQ(static_cast<mach_msg_type_number_t>(THREAD_STATE_MAX),
+      EXPECT_EQ(implicit_cast<mach_msg_type_number_t>(THREAD_STATE_MAX),
                 *new_state_count);
       EXPECT_NE(nullptr, new_state);
     } else {
       EXPECT_EQ(THREAD_STATE_NONE, *flavor);
       EXPECT_EQ(0u, old_state_count);
       EXPECT_EQ(nullptr, old_state);
       EXPECT_EQ(0u, *new_state_count);
       EXPECT_EQ(nullptr, new_state);
     }
 
@@ skipping 230 matching lines @@
 
     EXPECT_EQ(test_data.kr,
               ExcServerSuccessfulReturnValue(test_data.behavior,
                                              test_data.set_thread_state));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad