Use exactly one of final, override, and virtual

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,
@@ skipping 253 matching lines @@
     reply->Head.msgh_remote_port = request->header.msgh_remote_port;
     reply->Head.msgh_local_port = MACH_PORT_NULL;
     reply->Head.msgh_id = kReplyMessageId;
     reply->NDR = NDR_record;
     reply->RetCode = options_.server_mig_retcode;
     reply->number = replies_++;
 
     return true;
   }
 
-  virtual mach_msg_size_t MachMessageServerRequestSize() override {
+  mach_msg_size_t MachMessageServerRequestSize() override {
     return sizeof(RequestMessage);
   }
 
-  virtual mach_msg_size_t MachMessageServerReplySize() override {
+  mach_msg_size_t MachMessageServerReplySize() override {
     return sizeof(ReplyMessage);
   }
 
  private:
   struct RequestMessage : public mach_msg_base_t {
     // If body.msgh_descriptor_count is 0, port_descriptor will still be
     // present, but it will be zeroed out. It wouldn’t normally be present in a
     // message froma MIG-generated interface, but it’s harmless and simpler to
     // leave it here and just treat it as more data.
     mach_msg_port_descriptor_t port_descriptor;
 
     NDR_record_t ndr;
     uint32_t number;
   };
 
   // LargeRequestMessage is larger enough than a regular RequestMessage to
   // ensure that whatever buffer was allocated to receive a RequestMessage is
   // not large enough to receive a LargeRequestMessage.
   struct LargeRequestMessage : public RequestMessage {
     uint8_t data[4 * PAGE_SIZE];
   };
 
   struct ReplyMessage : public mig_reply_error_t {
     uint32_t number;
   };
 
   // MachMultiprocess:
 
-  virtual void MachMultiprocessParent() override {
+  void MachMultiprocessParent() override {
     mach_port_t local_port = LocalPort();
 
     kern_return_t kr;
     if (options_.child_send_all_requests_before_receiving_any_replies) {
       // On Mac OS X 10.10, the queue limit of a new Mach port seems to be 2
       // by default, which is below the value of MACH_PORT_QLIMIT_DEFAULT. Set
       // the port’s queue limit explicitly here.
       mach_port_limits limits = {};
       limits.mpl_qlimit = MACH_PORT_QLIMIT_DEFAULT;
       kr = mach_port_set_attributes(mach_task_self(),
@@ skipping 56 matching lines @@
           << MachErrorMessage(kr, "mach_port_type");
     }
 
     if (options_.child_wait_for_parent_pipe_late) {
       // Let the child know it’s safe to exit.
       char c = '\0';
       CheckedWriteFD(WritePipeFD(), &c, 1);
     }
   }
 
-  virtual void MachMultiprocessChild() override {
+  void MachMultiprocessChild() override {
     if (options_.child_wait_for_parent_pipe_early) {
       // Wait until the parent is done setting things up on its end.
       char c;
       CheckedReadFD(ReadPipeFD(), &c, 1);
       EXPECT_EQ('\0', c);
     }
 
     for (size_t index = 0;
          index < options_.client_send_request_count;
          ++index) {
@@ skipping 429 matching lines @@
   TestMachMessageServer::Options options;
   options.server_options = MACH_RCV_LARGE;
   options.client_send_large = true;
   TestMachMessageServer test_mach_message_server(options);
   test_mach_message_server.Test();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad