UniversalMachExcServer: eliminate multiple implementation inheritance

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 431 matching lines @@
               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);
   }
 };
 
-class MockUniversalMachExcServer : public UniversalMachExcServer {
+class MockUniversalMachExcServer : public UniversalMachExcServer::Interface {
  public:
   struct ConstExceptionCodes {
     const mach_exception_data_type_t* code;
     mach_msg_type_number_t code_count;
   };
   struct ThreadState {
     thread_state_t state;
     mach_msg_type_number_t* state_count;
   };
   struct ConstThreadState {
     const natural_t* state;
     mach_msg_type_number_t* state_count;
   };
 
+  // UniversalMachExcServer::Interface:
+
   // CatchMachException is the method to mock, but it has 13 parameters, and
   // gmock can only mock methods with up to 10 parameters. Coalesce some related
   // parameters together into structs, and call a mocked method.
   virtual kern_return_t CatchMachException(
       exception_behavior_t behavior,
       exception_handler_t exception_port,
       thread_t thread,
       task_t task,
       exception_type_t exception,
       const mach_exception_data_type_t* code,
@@ skipping 96 matching lines @@
     DefaultValue<T>::Set(default_value);
   }
 
   ~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);
 
   ExceptionRaiseRequest request;
-  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size,
+            universal_mach_exc_server.MachMessageServerRequestSize());
 
   ExceptionRaiseReply reply;
-  EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
+  EXPECT_LE(sizeof(reply),
+            universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_DEFAULT;
 
   EXPECT_CALL(server,
               MockCatchMachException(kExceptionBehavior,
                                      kServerLocalPort,
                                      kExceptionThreadPort,
                                      kExceptionTaskPort,
                                      kExceptionType,
                                      AreExceptionCodes(kTestExceptonCodes[0],
                                                        kTestExceptonCodes[1]),
                                      Pointee(Eq(THREAD_STATE_NONE)),
                                      IsThreadStateCount(0u),
                                      IsThreadStateCount(0u),
                                      Eq(&request.trailer)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
-  EXPECT_TRUE(server.MachMessageServerFunction(
+  EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockExceptionRaiseState) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
+  UniversalMachExcServer universal_mach_exc_server(&server);
 
   ExceptionRaiseStateRequest request;
-  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size,
+            universal_mach_exc_server.MachMessageServerRequestSize());
 
   ExceptionRaiseStateReply reply;
-  EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
+  EXPECT_LE(sizeof(reply),
+            universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           THREAD_NULL,
           TASK_NULL,
           kExceptionType,
           AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
           Pointee(Eq(kThreadStateFlavor)),
           IsThreadStateCount(kThreadStateFlavorCount),
           IsThreadStateCount(arraysize(reply.new_state)),
           Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
-  EXPECT_TRUE(server.MachMessageServerFunction(
+  EXPECT_TRUE(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 complex, so nothing got a chance to change the value of
   // this variable.
   EXPECT_FALSE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockExceptionRaiseStateIdentity) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
+  UniversalMachExcServer universal_mach_exc_server(&server);
 
   ExceptionRaiseStateIdentityRequest request;
-  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size,
+            universal_mach_exc_server.MachMessageServerRequestSize());
 
   ExceptionRaiseStateIdentityReply reply;
-  EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
+  EXPECT_LE(sizeof(reply),
+            universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior = EXCEPTION_STATE_IDENTITY;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           kExceptionThreadPort,
           kExceptionTaskPort,
           kExceptionType,
           AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
           Pointee(Eq(kThreadStateFlavor)),
           IsThreadStateCount(kThreadStateFlavorCount),
           IsThreadStateCount(arraysize(reply.new_state)),
           Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
-  EXPECT_TRUE(server.MachMessageServerFunction(
+  EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaise) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
+  UniversalMachExcServer universal_mach_exc_server(&server);
 
   MachExceptionRaiseRequest request;
-  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size,
+            universal_mach_exc_server.MachMessageServerRequestSize());
 
   MachExceptionRaiseReply reply;
-  EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
+  EXPECT_LE(sizeof(reply),
+            universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              kExceptionThreadPort,
                              kExceptionTaskPort,
                              kExceptionType,
                              AreExceptionCodes(kTestMachExceptionCodes[0],
                                                kTestMachExceptionCodes[1]),
                              Pointee(Eq(THREAD_STATE_NONE)),
                              IsThreadStateCount(0u),
                              IsThreadStateCount(0u),
                              Eq(&request.trailer)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
-  EXPECT_TRUE(server.MachMessageServerFunction(
+  EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaiseState) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
+  UniversalMachExcServer universal_mach_exc_server(&server);
 
   MachExceptionRaiseStateRequest request;
-  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size,
+            universal_mach_exc_server.MachMessageServerRequestSize());
 
   MachExceptionRaiseStateReply reply;
-  EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
+  EXPECT_LE(sizeof(reply),
+            universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              THREAD_NULL,
                              TASK_NULL,
                              kExceptionType,
                              AreExceptionCodes(kTestMachExceptionCodes[0],
                                                kTestMachExceptionCodes[1]),
                              Pointee(Eq(kThreadStateFlavor)),
                              IsThreadStateCount(kThreadStateFlavorCount),
                              IsThreadStateCount(arraysize(reply.new_state)),
                              Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
-  EXPECT_TRUE(server.MachMessageServerFunction(
+  EXPECT_TRUE(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 complex, so nothing got a chance to change the value of
   // this variable.
   EXPECT_FALSE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockMachExceptionRaiseStateIdentity) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
+  UniversalMachExcServer universal_mach_exc_server(&server);
 
   MachExceptionRaiseStateIdentityRequest request;
-  EXPECT_LE(request.Head.msgh_size, server.MachMessageServerRequestSize());
+  EXPECT_LE(request.Head.msgh_size,
+            universal_mach_exc_server.MachMessageServerRequestSize());
 
   MachExceptionRaiseStateIdentityReply reply;
-  EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
+  EXPECT_LE(sizeof(reply),
+            universal_mach_exc_server.MachMessageServerReplySize());
 
   const exception_behavior_t kExceptionBehavior =
       EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES;
 
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              kExceptionThreadPort,
                              kExceptionTaskPort,
                              kExceptionType,
                              AreExceptionCodes(kTestMachExceptionCodes[0],
                                                kTestMachExceptionCodes[1]),
                              Pointee(Eq(kThreadStateFlavor)),
                              IsThreadStateCount(kThreadStateFlavorCount),
                              IsThreadStateCount(arraysize(reply.new_state)),
                              Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
-  EXPECT_TRUE(server.MachMessageServerFunction(
+  EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
 
   reply.Verify(kExceptionBehavior);
 }
 
 TEST(ExcServerVariants, MockUnknownID) {
   ScopedDefaultValue<kern_return_t> default_kern_return_t(KERN_FAILURE);
 
   MockUniversalMachExcServer server;
+  UniversalMachExcServer universal_mach_exc_server(&server);
 
   // Make sure that a message with an unknown ID is handled appropriately.
   // UniversalMachExcServer should not dispatch the message to
   // MachMessageServerFunction, but should generate a MIG_BAD_ID error reply.
 
   const mach_msg_id_t unknown_ids[] = {
       // Reasonable things to check.
       -101,
       -100,
       -99,
@@ skipping 20 matching lines @@
       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));
 
     InvalidRequest request(id);
-    EXPECT_LE(sizeof(request), server.MachMessageServerRequestSize());
+    EXPECT_LE(sizeof(request),
+              universal_mach_exc_server.MachMessageServerRequestSize());
 
     BadIDErrorReply reply;
-    EXPECT_LE(sizeof(reply), server.MachMessageServerReplySize());
+    EXPECT_LE(sizeof(reply),
+              universal_mach_exc_server.MachMessageServerReplySize());
 
     bool destroy_complex_request = false;
-    EXPECT_FALSE(server.MachMessageServerFunction(
+    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);
   }
 }
 
-class TestExcServerVariants : public UniversalMachExcServer,
-                              public MachMultiprocess {
+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)
-      : UniversalMachExcServer(),
-        MachMultiprocess(),
+      : MachMultiprocess(),
+        UniversalMachExcServer::Interface(),
         behavior_(behavior),
         flavor_(flavor),
         state_count_(state_count),
         handled_(false) {}
 
-  // UniversalMachExcServer:
+  // UniversalMachExcServer::Interface:
 
   virtual kern_return_t CatchMachException(
       exception_behavior_t behavior,
       exception_handler_t exception_port,
       thread_t thread,
       task_t task,
       exception_type_t exception,
       const mach_exception_data_type_t* code,
       mach_msg_type_number_t code_count,
       thread_state_flavor_t* flavor,
@@ skipping 53 matching lines @@
     EXPECT_EQ(REQUESTED_TRAILER_SIZE(kMachMessageOptions),
               trailer->msgh_trailer_size);
 
     return ExcServerSuccessfulReturnValue(behavior, false);
   }
 
  private:
   // MachMultiprocess:
 
   void MachMultiprocessParent() override {
+    UniversalMachExcServer universal_mach_exc_server(this);
+
     kern_return_t kr =
-        MachMessageServer::Run(this,
+        MachMessageServer::Run(&universal_mach_exc_server,
                                LocalPort(),
                                kMachMessageOptions,
                                MachMessageServer::kOneShot,
                                MachMessageServer::kBlocking,
                                MachMessageServer::kReceiveLargeError,
                                0);
     EXPECT_EQ(KERN_SUCCESS, kr)
         << MachErrorMessage(kr, "MachMessageServer::Run");
 
     EXPECT_TRUE(handled_);
@@ skipping 216 matching lines @@
 
     EXPECT_EQ(test_data.kr,
               ExcServerSuccessfulReturnValue(test_data.behavior,
                                              test_data.set_thread_state));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad