Add exc_server_variants including UniversalMachExcServer and its test

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,
 // 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 "util/mach/mach_message_server.h"
 
 #include <mach/mach.h>
 #include <string.h>
 
 #include "base/basictypes.h"
 #include "base/mac/scoped_mach_port.h"
 #include "gtest/gtest.h"
 #include "util/file/fd_io.h"
+#include "util/mach/mach_extensions.h"
 #include "util/test/errors.h"
 #include "util/test/mac/mach_errors.h"
 #include "util/test/mac/mach_multiprocess.h"
 
 namespace {
 
 using namespace crashpad;
 using namespace crashpad::test;
 
 class TestMachMessageServer : public MachMessageServer::Interface,
@@ skipping 173 matching lines @@
     EXPECT_EQ(options_.client_send_large ? sizeof(LargeRequestMessage) :
                                            sizeof(RequestMessage),
               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(static_cast<mach_port_t>(MACH_PORT_NULL),
-                request->port_descriptor.name);
+      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),
                 request->port_descriptor.disposition);
       EXPECT_EQ(
           static_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(static_cast<mach_port_t>(MACH_PORT_NULL),
-                request->port_descriptor.name);
+      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) {
@@ skipping 72 matching lines @@
     ASSERT_EQ(options_.expect_server_result,
               (kr = MachMessageServer::Run(this,
                                            LocalPort(),
                                            options_.server_options,
                                            options_.server_persistent,
                                            options_.server_nonblocking,
                                            options_.server_timeout_ms)))
         << MachErrorMessage(kr, "MachMessageServer");
 
     if (options_.client_send_complex) {
-      EXPECT_NE(static_cast<mach_port_t>(MACH_PORT_NULL),
-                parent_complex_message_port_);
+      EXPECT_NE(kMachPortNull, parent_complex_message_port_);
       mach_port_type_t type;
 
       if (!options_.expect_server_destroyed_complex) {
         // MachMessageServer should not have destroyed the resources sent in the
         // complex request message.
         kr = mach_port_type(
             mach_task_self(), parent_complex_message_port_, &type);
         EXPECT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "mach_port_type");
         EXPECT_EQ(MACH_PORT_TYPE_SEND, type);
 
@@ skipping 165 matching lines @@
                                 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>(
         MACH_MSGH_BITS(0, MACH_MSG_TYPE_MOVE_SEND)), reply.Head.msgh_bits);
     ASSERT_EQ(sizeof(ReplyMessage), reply.Head.msgh_size);
-    ASSERT_EQ(static_cast<mach_port_t>(MACH_PORT_NULL),
-              reply.Head.msgh_remote_port);
+    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),
               reply.trailer.msgh_trailer_type);
     ASSERT_EQ(MACH_MSG_TRAILER_MINIMUM_SIZE, reply.trailer.msgh_trailer_size);
 
     ++replies_;
@@ skipping 281 matching lines @@
   // so a new buffer is allocated to receive the message. The server receives
   // the large request message, processes it, and returns a reply to the client.
   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