UniversalMachExcServer: eliminate multiple implementation inheritance

client/simulate_crash_mac_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 17 matching lines @@
 #include "util/mach/mach_message_server.h"
 #include "util/mach/symbolic_constants_mach.h"
 #include "util/test/mac/mach_errors.h"
 #include "util/test/mac/mach_multiprocess.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 class TestSimulateCrashMac final : public MachMultiprocess,
-                                   public UniversalMachExcServer {
+                                   public UniversalMachExcServer::Interface {
  public:
   // Defines which targets the child should set an EXC_CRASH exception handler
   // for.
   enum ExceptionPortsTarget {
     // The child should clear its EXC_CRASH handler for both its task and thread
     // targets. SimulateCrash() will attempt to deliver the exception to the
     // host target, which will fail if not running as root. In any case, the
     // parent should not expect to receive any exception message from the child.
     kExceptionPortsTargetNone = 0,
 
@@ skipping 12 matching lines @@
     // delivered to the thread target, but returns an error code. The child will
     // then fall back to trying the server registered for the task target,
     // sending a second message to the parent. The server in the parent will
     // handle this one successfully.
     kExceptionPortsTargetBoth,
   };
 
   TestSimulateCrashMac(ExceptionPortsTarget target,
                        exception_behavior_t behavior,
                        thread_state_flavor_t flavor)
-      : target_(target),
+      : MachMultiprocess(),
+        UniversalMachExcServer::Interface(),
+        target_(target),
         behavior_(behavior),
         flavor_(flavor),
         succeed_(true) {
   }
 
   ~TestSimulateCrashMac() {}
 
-  // UniversalMachExcServer:
+  // UniversalMachExcServer::Interface:
   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,
                                    const natural_t* old_state,
                                    mach_msg_type_number_t old_state_count,
@@ skipping 139 matching lines @@
   // MachMultiprocess:
 
   void MachMultiprocessParent() override {
     if (target_ == kExceptionPortsTargetNone) {
       // The child does not have any EXC_CRASH handlers registered for its
       // thread or task targets, so no exception message is expected to be
       // generated. Don’t run the server at all.
       return;
     }
 
+    UniversalMachExcServer universal_mach_exc_server(this);
+
     mach_msg_return_t mr;
     if (target_ == kExceptionPortsTargetBoth) {
       // The client has registered EXC_CRASH handlers for both its thread and
       // task targets. Run a server that will return a failure code when the
       // exception message is sent to the thread target, which will cause the
       // client to fall back to the task target and send another message.
       succeed_ = false;
-      mr = MachMessageServer::Run(this,
+      mr = MachMessageServer::Run(&universal_mach_exc_server,
                                   LocalPort(),
                                   MACH_MSG_OPTION_NONE,
                                   MachMessageServer::kOneShot,
                                   MachMessageServer::kBlocking,
                                   MachMessageServer::kReceiveLargeError,
                                   MACH_MSG_TIMEOUT_NONE);
       EXPECT_EQ(MACH_MSG_SUCCESS, mr)
           << MachErrorMessage(mr, "MachMessageServer::Run");
     }
 
     succeed_ = true;
-    mr = MachMessageServer::Run(this,
+    mr = MachMessageServer::Run(&universal_mach_exc_server,
                                 LocalPort(),
                                 MACH_MSG_OPTION_NONE,
                                 MachMessageServer::kOneShot,
                                 MachMessageServer::kBlocking,
                                 MachMessageServer::kReceiveLargeError,
                                 MACH_MSG_TIMEOUT_NONE);
     EXPECT_EQ(MACH_MSG_SUCCESS, mr)
         << MachErrorMessage(mr, "MachMessageServer::Run");
   }
 
@@ skipping 102 matching lines @@
           test_simulate_crash_mac.Run();
         }
       }
     }
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad