MachMessageServer: Make request messages const

util/mach/mach_message_server.h

 // 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 19 matching lines @@
   //! \brief A Mach RPC callback interface, called by Run().
   class Interface {
    public:
     //! \brief Handles a Mach RPC request.
     //!
     //! This method is a stand-in for a MIG-generated Mach RPC server “demux”
     //! function such as `exc_server()` and `mach_exc_server()`. Implementations
     //! may call such a function directly. This method is expected to behave
     //! exactly as these functions behave.
     //!
-    //! \param[in] in The request message, received as a Mach message.
+    //! \param[in] in The request message, received as a Mach message. Note that
+    //!     this interface uses a `const` parameter for this purpose, whereas
+    //!     MIG-generated “demux” functions do not.
     //! \param[out] out The reply message. The caller allocates storage, and the
     //!     callee is expected to populate the reply message appropriately.
     //!     After returning, the caller will send this reply as a Mach message
     //!     via the message’s reply port.
     //! \param[out] destroy_complex_request `true` if a complex request message
     //!     is to be destroyed even when handled successfully, `false`
     //!     otherwise. The traditional behavior is `false`. In this case, the
     //!     caller only destroys the request message in \a in when the reply
     //!     message in \a out is not complex and when it indicates a return code
     //!     other than `KERN_SUCCESS` or `MIG_NO_REPLY`. The assumption is that
     //!     the rights or out-of-line data carried in a complex message may be
     //!     retained by the server in this situation, and that it is the
     //!     responsibility of the server to release these resources as needed.
     //!     However, in many cases, these resources are not needed beyond the
     //!     duration of a request-reply transaction, and in such cases, it is
     //!     less error-prone to always have the caller,
     //!     MachMessageServer::Run(), destroy complex request messages. To
     //!     choose this behavior, this parameter should be set to `true`.
     //!
     //! \return `true` on success and `false` on failure, although the caller
     //!     ignores the return value. However, the return code to be included in
     //!     the reply message should be set as `mig_reply_error_t::RetCode`. The
     //!     non-`void` return value is used for increased compatibility with
     //!     MIG-generated functions.
-    virtual bool MachMessageServerFunction(mach_msg_header_t* in,
+    virtual bool MachMessageServerFunction(const mach_msg_header_t* in,
                                            mach_msg_header_t* out,
                                            bool* destroy_complex_request) = 0;
 
     //! \return The expected or maximum size, in bytes, of a request message to
     //!     be received as the \a in parameter of MachMessageServerFunction().
     virtual mach_msg_size_t MachMessageServerRequestSize() = 0;
 
     //! \return The maximum size, in bytes, of a reply message to be sent via
     //!     the \a out parameter of MachMessageServerFunction(). This value does
     //!     not need to include the size of any trailer to be sent with the
@@ skipping 70 matching lines @@
                                Nonblocking nonblocking,
                                mach_msg_timeout_t timeout_ms);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(MachMessageServer);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_UTIL_MACH_MACH_MESSAGE_SERVER_H_