UniversalMachExcServer: eliminate multiple implementation inheritance

util/mach/exception_ports_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 84 matching lines @@
     }
   }
 
   if (expect_port != MACH_PORT_NULL) {
     EXPECT_TRUE(found);
   } else {
     EXPECT_FALSE(found);
   }
 }
 
-class TestExceptionPorts : public UniversalMachExcServer,
-                           public MachMultiprocess {
+class TestExceptionPorts : public MachMultiprocess,
+                           public UniversalMachExcServer::Interface {
  public:
   // Where to call ExceptionPorts::SetExceptionPort() from.
   enum SetType {
     // Call it from the child process on itself.
     kSetInProcess = 0,
 
     // Call it from the parent process on the child.
     kSetOutOfProcess,
   };
 
   // Which entities to set exception ports for.
   enum SetOn {
     kSetOnTaskOnly = 0,
     kSetOnTaskAndThreads,
   };
 
   // Which thread in the child process is expected to crash.
   enum WhoCrashes {
     kNobodyCrashes = 0,
     kMainThreadCrashes,
     kOtherThreadCrashes,
   };
 
   TestExceptionPorts(SetType set_type, SetOn set_on, WhoCrashes who_crashes)
-      : UniversalMachExcServer(),
-        MachMultiprocess(),
+      : MachMultiprocess(),
+        UniversalMachExcServer::Interface(),
         set_type_(set_type),
         set_on_(set_on),
         who_crashes_(who_crashes),
         handled_(false) {}
 
   SetType set_type() const { return set_type_; }
   SetOn set_on() const { return set_on_; }
   WhoCrashes who_crashes() const { return who_crashes_; }
 
-  // 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 283 matching lines @@
       TestGetExceptionPorts(
           other_thread_ports, thread_handler, EXCEPTION_STATE_IDENTITY);
     }
 
     // Let the child process know that everything in the parent process is set
     // up.
     c = '\0';
     CheckedWriteFD(WritePipeFD(), &c, 1);
 
     if (who_crashes_ != kNobodyCrashes) {
+      UniversalMachExcServer universal_mach_exc_server(this);
+
       kern_return_t kr =
-          MachMessageServer::Run(this,
+          MachMessageServer::Run(&universal_mach_exc_server,
                                  local_port,
                                  MACH_MSG_OPTION_NONE,
                                  MachMessageServer::kOneShot,
                                  MachMessageServer::kBlocking,
                                  MachMessageServer::kReceiveLargeError,
                                  0);
       EXPECT_EQ(KERN_SUCCESS, kr)
           << MachErrorMessage(kr, "MachMessageServer::Run");
 
       EXPECT_TRUE(handled_);
@@ skipping 113 matching lines @@
   if (geteuid() == 0) {
     EXPECT_TRUE(rv);
   } else {
     EXPECT_FALSE(rv);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad