Use implicit_cast<> instead of static_cast<> whenever possible

util/mach/mach_message_server_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 206 matching lines @@
               request->header.msgh_size);
     if (options_.client_reply_port_type == Options::kReplyPortNormal) {
       EXPECT_EQ(RemotePort(), request->header.msgh_remote_port);
     }
     EXPECT_EQ(LocalPort(), request->header.msgh_local_port);
     EXPECT_EQ(kRequestMessageId, request->header.msgh_id);
     if (options_.client_send_complex) {
       EXPECT_EQ(1u, request->body.msgh_descriptor_count);
       EXPECT_NE(kMachPortNull, request->port_descriptor.name);
       parent_complex_message_port_ = request->port_descriptor.name;
-      EXPECT_EQ(static_cast<mach_msg_type_name_t>(MACH_MSG_TYPE_MOVE_SEND),
+      EXPECT_EQ(implicit_cast<mach_msg_type_name_t>(MACH_MSG_TYPE_MOVE_SEND),
                 request->port_descriptor.disposition);
       EXPECT_EQ(
-          static_cast<mach_msg_descriptor_type_t>(MACH_MSG_PORT_DESCRIPTOR),
+          implicit_cast<mach_msg_descriptor_type_t>(MACH_MSG_PORT_DESCRIPTOR),
           request->port_descriptor.type);
     } else {
       EXPECT_EQ(0u, request->body.msgh_descriptor_count);
       EXPECT_EQ(kMachPortNull, request->port_descriptor.name);
       EXPECT_EQ(0u, request->port_descriptor.disposition);
       EXPECT_EQ(0u, request->port_descriptor.type);
     }
     EXPECT_EQ(0, memcmp(&request->ndr, &NDR_record, sizeof(NDR_record)));
     EXPECT_EQ(requests_, request->number);
 
     // Look for the trailer in the right spot, depending on whether the request
     // message was a RequestMessage or a LargeRequestMessage.
     const mach_msg_trailer_t* trailer;
     if (options_.client_send_large) {
       const ReceiveLargeRequestMessage* large_request =
           reinterpret_cast<const ReceiveLargeRequestMessage*>(request);
       for (size_t index = 0; index < sizeof(large_request->data); ++index) {
         EXPECT_EQ('!', large_request->data[index]);
       }
       trailer = &large_request->trailer;
     } else {
       trailer = &request->trailer;
     }
 
-    EXPECT_EQ(static_cast<mach_msg_trailer_type_t>(MACH_MSG_TRAILER_FORMAT_0),
+    EXPECT_EQ(implicit_cast<mach_msg_trailer_type_t>(MACH_MSG_TRAILER_FORMAT_0),
               trailer->msgh_trailer_type);
     EXPECT_EQ(MACH_MSG_TRAILER_MINIMUM_SIZE, trailer->msgh_trailer_size);
 
     ++requests_;
 
     ReplyMessage* reply = reinterpret_cast<ReplyMessage*>(out);
     reply->Head.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
     reply->Head.msgh_size = sizeof(*reply);
     reply->Head.msgh_remote_port = request->header.msgh_remote_port;
     reply->Head.msgh_local_port = MACH_PORT_NULL;
@@ skipping 252 matching lines @@
     ReceiveReplyMessage reply = {};
     kern_return_t kr = mach_msg(&reply.Head,
                                 MACH_RCV_MSG,
                                 0,
                                 sizeof(reply),
                                 LocalPort(),
                                 MACH_MSG_TIMEOUT_NONE,
                                 MACH_PORT_NULL);
     ASSERT_EQ(MACH_MSG_SUCCESS, kr) << MachErrorMessage(kr, "mach_msg");
 
-    ASSERT_EQ(static_cast<mach_msg_bits_t>(
+    ASSERT_EQ(implicit_cast<mach_msg_bits_t>(
         MACH_MSGH_BITS(0, MACH_MSG_TYPE_MOVE_SEND)), reply.Head.msgh_bits);
     ASSERT_EQ(sizeof(ReplyMessage), reply.Head.msgh_size);
     ASSERT_EQ(kMachPortNull, reply.Head.msgh_remote_port);
     ASSERT_EQ(LocalPort(), reply.Head.msgh_local_port);
     ASSERT_EQ(kReplyMessageId, reply.Head.msgh_id);
     ASSERT_EQ(0, memcmp(&reply.NDR, &NDR_record, sizeof(NDR_record)));
     ASSERT_EQ(options_.server_mig_retcode, reply.RetCode);
     ASSERT_EQ(replies_, reply.number);
-    ASSERT_EQ(static_cast<mach_msg_trailer_type_t>(MACH_MSG_TRAILER_FORMAT_0),
+    ASSERT_EQ(implicit_cast<mach_msg_trailer_type_t>(MACH_MSG_TRAILER_FORMAT_0),
               reply.trailer.msgh_trailer_type);
     ASSERT_EQ(MACH_MSG_TRAILER_MINIMUM_SIZE, reply.trailer.msgh_trailer_size);
 
     ++replies_;
   }
 
   // For test types where the child needs to notify the server in the parent
   // that the child is ready, this method will send a byte via the POSIX pipe.
   // The parent will be waiting in a read() on this pipe, and will proceed to
   // running MachMessageServer() once it’s received.
@@ skipping 276 matching lines @@
   TestMachMessageServer::Options options;
   options.server_options = MACH_RCV_LARGE;
   options.client_send_large = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad