Add CompositeMachMessageServer and its test

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 566 matching lines @@
 
   ~ScopedDefaultValue() { DefaultValue<T>::Clear(); }
 };
 
 TEST(ExcServerVariants, MockExceptionRaise) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
   UniversalMachExcServer universal_mach_exc_server(&server);
 
+  std::set<mach_msg_id_t> ids =
+      universal_mach_exc_server.MachMessageServerRequestIDs();
+  EXPECT_NE(ids.end(), ids.find(2401));  // There is no constant for this.
+
   ExceptionRaiseRequest request;
   EXPECT_LE(request.Head.msgh_size,
             universal_mach_exc_server.MachMessageServerRequestSize());
 
   ExceptionRaiseReply reply;
   EXPECT_LE(sizeof(reply),
             universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_DEFAULT;
 
@@ skipping 21 matching lines @@
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockExceptionRaiseState) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
   UniversalMachExcServer universal_mach_exc_server(&server);
 
+  std::set<mach_msg_id_t> ids =
+      universal_mach_exc_server.MachMessageServerRequestIDs();
+  EXPECT_NE(ids.end(), ids.find(2402));  // There is no constant for this.
+
   ExceptionRaiseStateRequest request;
   EXPECT_LE(request.Head.msgh_size,
             universal_mach_exc_server.MachMessageServerRequestSize());
 
   ExceptionRaiseStateReply reply;
   EXPECT_LE(sizeof(reply),
             universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE;
 
@@ skipping 25 matching lines @@
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockExceptionRaiseStateIdentity) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
   UniversalMachExcServer universal_mach_exc_server(&server);
 
+  std::set<mach_msg_id_t> ids =
+      universal_mach_exc_server.MachMessageServerRequestIDs();
+  EXPECT_NE(ids.end(), ids.find(2403));  // There is no constant for this.
+
   ExceptionRaiseStateIdentityRequest request;
   EXPECT_LE(request.Head.msgh_size,
             universal_mach_exc_server.MachMessageServerRequestSize());
 
   ExceptionRaiseStateIdentityReply reply;
   EXPECT_LE(sizeof(reply),
             universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE_IDENTITY;
 
@@ skipping 22 matching lines @@
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaise) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
   UniversalMachExcServer universal_mach_exc_server(&server);
 
+  std::set<mach_msg_id_t> ids =
+      universal_mach_exc_server.MachMessageServerRequestIDs();
+  EXPECT_NE(ids.end(), ids.find(2405));  // There is no constant for this.
+
   MachExceptionRaiseRequest request;
   EXPECT_LE(request.Head.msgh_size,
             universal_mach_exc_server.MachMessageServerRequestSize());
 
   MachExceptionRaiseReply reply;
   EXPECT_LE(sizeof(reply),
             universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES;
@@ skipping 23 matching lines @@
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaiseState) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
   UniversalMachExcServer universal_mach_exc_server(&server);
 
+  std::set<mach_msg_id_t> ids =
+      universal_mach_exc_server.MachMessageServerRequestIDs();
+  EXPECT_NE(ids.end(), ids.find(2406));  // There is no constant for this.
+
   MachExceptionRaiseStateRequest request;
   EXPECT_LE(request.Head.msgh_size,
             universal_mach_exc_server.MachMessageServerRequestSize());
 
   MachExceptionRaiseStateReply reply;
   EXPECT_LE(sizeof(reply),
             universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE | MACH_EXCEPTION_CODES;
@@ skipping 26 matching lines @@
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaiseStateIdentity) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
   UniversalMachExcServer universal_mach_exc_server(&server);
 
+  std::set<mach_msg_id_t> ids =
+      universal_mach_exc_server.MachMessageServerRequestIDs();
+  EXPECT_NE(ids.end(), ids.find(2407));  // There is no constant for this.
+
   MachExceptionRaiseStateIdentityRequest request;
   EXPECT_LE(request.Head.msgh_size,
             universal_mach_exc_server.MachMessageServerRequestSize());
 
   MachExceptionRaiseStateIdentityReply reply;
   EXPECT_LE(sizeof(reply),
             universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES;
@@ skipping 61 matching lines @@
       2506,
       2507,
       2508,
   };
 
   for (size_t index = 0; index < arraysize(unknown_ids); ++index) {
     mach_msg_id_t id = unknown_ids[index];
 
     SCOPED_TRACE(base::StringPrintf("unknown id %d", id));
 
+    std::set<mach_msg_id_t> ids =
+        universal_mach_exc_server.MachMessageServerRequestIDs();
+    EXPECT_EQ(ids.end(), ids.find(id));
+
     InvalidRequest request(id);
     EXPECT_LE(sizeof(request),
               universal_mach_exc_server.MachMessageServerRequestSize());
 
     BadIDErrorReply reply;
     EXPECT_LE(sizeof(reply),
               universal_mach_exc_server.MachMessageServerReplySize());
 
     bool destroy_complex_request = false;
     EXPECT_FALSE(universal_mach_exc_server.MachMessageServerFunction(
         reinterpret_cast<mach_msg_header_t*>(&request),
         reinterpret_cast<mach_msg_header_t*>(&reply),
         &destroy_complex_request));
 
     // The request wasn’t handled, nothing got a chance to change the value of
     // this variable. MachMessageServer would destroy the request if it was
     // complex, regardless of what was done to this variable, because the
     // return code was not KERN_SUCCESS or MIG_NO_REPLY.
     EXPECT_FALSE(destroy_complex_request);
 
     reply.Verify(id);
   }
 }
 
+TEST(ExcServerVariants, MachMessageServerRequestIDs) {
+  std::set<mach_msg_id_t> expect_request_ids;
+
+  // There are no constants for these.
+  expect_request_ids.insert(2401);
+  expect_request_ids.insert(2402);
+  expect_request_ids.insert(2403);
+  expect_request_ids.insert(2405);
+  expect_request_ids.insert(2406);
+  expect_request_ids.insert(2407);
+
+  MockUniversalMachExcServer server;
+  UniversalMachExcServer universal_mach_exc_server(&server);
+
+  EXPECT_EQ(expect_request_ids,
+            universal_mach_exc_server.MachMessageServerRequestIDs());
+}
+
 class TestExcServerVariants : public MachMultiprocess,
                               public UniversalMachExcServer::Interface {
  public:
   TestExcServerVariants(exception_behavior_t behavior,
                         thread_state_flavor_t flavor,
                         mach_msg_type_number_t state_count)
       : MachMultiprocess(),
         UniversalMachExcServer::Interface(),
         behavior_(behavior),
         flavor_(flavor),
@@ skipping 307 matching lines @@
 
     EXPECT_EQ(test_data.kr,
               ExcServerSuccessfulReturnValue(test_data.behavior,
                                              test_data.set_thread_state));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad