Add CompositeMachMessageServer 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 <set>
+
 #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/mac/mach_errors.h"
 #include "util/test/mac/mach_multiprocess.h"
 
 namespace crashpad {
 namespace test {
@@ skipping 185 matching lines @@
         MACH_MSGH_BITS(MACH_MSG_TYPE_MOVE_SEND, MACH_MSG_TYPE_MOVE_SEND) |
         (options_.client_send_complex ? MACH_MSGH_BITS_COMPLEX : 0);
     EXPECT_EQ(expect_msgh_bits, request->header.msgh_bits);
     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);
+    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(implicit_cast<mach_msg_type_name_t>(MACH_MSG_TYPE_MOVE_SEND),
                 request->port_descriptor.disposition);
       EXPECT_EQ(
           implicit_cast<mach_msg_descriptor_type_t>(MACH_MSG_PORT_DESCRIPTOR),
           request->port_descriptor.type);
     } else {
@@ skipping 23 matching lines @@
               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;
-    reply->Head.msgh_id = kReplyMessageId;
+    reply->Head.msgh_id = kReplyMessageID;
     reply->NDR = NDR_record;
     reply->RetCode = options_.server_mig_retcode;
     reply->number = replies_++;
 
     return true;
   }
 
+  std::set<mach_msg_id_t> MachMessageServerRequestIDs() override {
+    const mach_msg_id_t request_ids[] = {kRequestMessageID};
+    return std::set<mach_msg_id_t>(
+        &request_ids[0], &request_ids[arraysize(request_ids)]);
+  }
+
   mach_msg_size_t MachMessageServerRequestSize() override {
     return sizeof(RequestMessage);
   }
 
   mach_msg_size_t MachMessageServerReplySize() override {
     return sizeof(ReplyMessage);
   }
 
  private:
   struct RequestMessage : public mach_msg_base_t {
@@ skipping 175 matching lines @@
         // looks at the right, it will have become a dead name.
         kr = mach_port_allocate(mach_task_self(),
                                 MACH_PORT_RIGHT_RECEIVE,
                                 &request.header.msgh_local_port);
         ASSERT_EQ(KERN_SUCCESS, kr)
             << MachErrorMessage(kr, "mach_port_allocate");
         local_receive_port_owner.reset(request.header.msgh_local_port);
         break;
       }
     }
-    request.header.msgh_id = kRequestMessageId;
+    request.header.msgh_id = kRequestMessageID;
     if (options_.client_send_complex) {
       // Allocate a new receive right in this process and make a send right that
       // will appear in the parent process. This is used to test that the server
       // properly handles ownership of resources received in complex messages.
       request.body.msgh_descriptor_count = 1;
       kr = mach_port_allocate(mach_task_self(),
                               MACH_PORT_RIGHT_RECEIVE,
                               &request.port_descriptor.name);
       ASSERT_EQ(KERN_SUCCESS, kr)
           << MachErrorMessage(kr, "mach_port_allocate");
@@ skipping 44 matching lines @@
                                 LocalPort(),
                                 MACH_MSG_TIMEOUT_NONE,
                                 MACH_PORT_NULL);
     ASSERT_EQ(MACH_MSG_SUCCESS, kr) << MachErrorMessage(kr, "mach_msg");
 
     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(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(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_;
   }
 
@@ skipping 29 matching lines @@
   base::mac::ScopedMachReceiveRight child_complex_message_port_;
 
   // The send right received in the parent process. This right is stored in a
   // member variable to test that resources carried in complex messages are
   // properly destroyed in the server when expected.
   mach_port_t parent_complex_message_port_;
 
   static uint32_t requests_;
   static uint32_t replies_;
 
-  static const mach_msg_id_t kRequestMessageId = 16237;
-  static const mach_msg_id_t kReplyMessageId = kRequestMessageId + 100;
+  static const mach_msg_id_t kRequestMessageID = 16237;
+  static const mach_msg_id_t kReplyMessageID = kRequestMessageID + 100;
 
   DISALLOW_COPY_AND_ASSIGN(TestMachMessageServer);
 };
 
 uint32_t TestMachMessageServer::requests_;
 uint32_t TestMachMessageServer::replies_;
-const mach_msg_id_t TestMachMessageServer::kRequestMessageId;
-const mach_msg_id_t TestMachMessageServer::kReplyMessageId;
+const mach_msg_id_t TestMachMessageServer::kRequestMessageID;
+const mach_msg_id_t TestMachMessageServer::kReplyMessageID;
 
 TEST(MachMessageServer, Basic) {
   // The client sends one message to the server, which will wait indefinitely in
   // blocking mode for it.
   TestMachMessageServer::Options options;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 TEST(MachMessageServer, NonblockingNoMessage) {
@@ skipping 238 matching lines @@
   options.expect_server_transaction_count = 0;
   options.client_send_large = true;
   options.client_expect_reply = false;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad