Update Crashpad to 32981a3ee9d7c2769fb27afa038fe2e194cfa329

third_party/crashpad/crashpad/util/mach/mach_message.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 35 matching lines @@
 //!
 //! A value of this type may be one of the special constants
 //! #kMachMessageDeadlineNonblocking or #kMachMessageDeadlineWaitIndefinitely.
 //! Any other values should be produced by calling
 //! MachMessageDeadlineFromTimeout().
 //!
 //! Internally, these are currently specified on the same time base as
 //! ClockMonotonicNanoseconds(), although this is an implementation detail.
 using MachMessageDeadline = uint64_t;
 
-//! \brief Special constants used as \ref MachMessageDeadline values.
+//! \brief Special constants used as \ref crashpad::MachMessageDeadline
+//!     "MachMessageDeadline" values.
 enum : MachMessageDeadline {
   //! \brief MachMessageWithDeadline() should not block at all in its operation.
   kMachMessageDeadlineNonblocking = 0,
 
   //! \brief MachMessageWithDeadline() should wait indefinitely for the
   //!     requested operation to complete.
   kMachMessageDeadlineWaitIndefinitely = 0xffffffffffffffff,
 };
 
 //! \brief Computes the deadline for a specified timeout value.
@@ skipping 24 matching lines @@
 //! Like the `mach_msg()` wrapper in `libsyscall`, this function will retry
 //! operations when experiencing `MACH_SEND_INTERRUPTED` and
 //! `MACH_RCV_INTERRUPTED`, unless \a options contains `MACH_SEND_INTERRUPT` or
 //! `MACH_RCV_INTERRUPT`. Unlike `mach_msg()`, which restarts the call with the
 //! full timeout when this occurs, this function continues enforcing the
 //! user-specified \a deadline.
 //!
 //! Except as noted, the parameters and return value are identical to those of
 //! `mach_msg()`.
 //!
+//! \param[in,out] message
+//! \param[in] options
+//! \param[in] receive_size
+//! \param[in] receive_port
 //! \param[in] deadline The time by which this call should complete. If the
 //!     deadline is exceeded, this call will return `MACH_SEND_TIMED_OUT` or
 //!     `MACH_RCV_TIMED_OUT`.
+//! \param[in] notify_port
 //! \param[in] run_even_if_expired If `true`, a deadline that is expired when
 //!     this function is called will be treated as though a deadline of
 //!     #kMachMessageDeadlineNonblocking had been specified. When `false`, an
 //!     expired deadline will result in a `MACH_SEND_TIMED_OUT` or
 //!     `MACH_RCV_TIMED_OUT` return value, even if the deadline is already
 //!     expired when the function is called.
+//!
+//! \return The return value of `mach_msg()`
 mach_msg_return_t MachMessageWithDeadline(mach_msg_header_t* message,
                                           mach_msg_option_t options,
                                           mach_msg_size_t receive_size,
                                           mach_port_name_t receive_port,
                                           MachMessageDeadline deadline,
                                           mach_port_name_t notify_port,
                                           bool run_even_if_expired);
 
 //! \brief Initializes a reply message for a MIG server routine based on its
 //!     corresponding request.
 //!
 //! If a request is handled by a server routine, it may be necessary to revise
 //! some of the fields set by this function, such as `msgh_size` and any fields
 //! defined in a routine’s reply structure type.
 //!
 //! \param[in] in_header The request message to base the reply on.
 //! \param[out] out_header The reply message to initialize. \a out_header will
 //!     be treated as a `mig_reply_error_t*` and all of its fields will be set
 //!     except for `RetCode`, which must be set by SetMIGReplyError(). This
 //!     argument is accepted as a `mach_msg_header_t*` instead of a
 //!     `mig_reply_error_t*` because that is the type that callers are expected
 //!     to possess in the C API.
 void PrepareMIGReplyFromRequest(const mach_msg_header_t* in_header,
                                 mach_msg_header_t* out_header);
 
 //! \brief Sets the error code in a reply message for a MIG server routine.
 //!
-//! \param[inout] out_header The reply message to operate on. \a out_header will
-//!     be treated as a `mig_reply_error_t*` and its `RetCode` field will be
-//!     set. This argument is accepted as a `mach_msg_header_t*` instead of a
+//! \param[in,out] out_header The reply message to operate on. \a out_header
+//!     will be treated as a `mig_reply_error_t*` and its `RetCode` field will
+//!     be set. This argument is accepted as a `mach_msg_header_t*` instead of a
 //!     `mig_reply_error_t*` because that is the type that callers are expected
 //!     to possess in the C API.
 //! \param[in] error The error code to store in \a out_header.
 //!
 //! \sa PrepareMIGReplyFromRequest()
 void SetMIGReplyError(mach_msg_header_t* out_header, kern_return_t error);
 
 //! \brief Returns a Mach message trailer for a message that has been received.
 //!
 //! This function must only be called on Mach messages that have been received
@@ skipping 35 matching lines @@
 //!     `MACH_MSG_TYPE_PORT_RECEIVE`, `MACH_MSG_TYPE_PORT_SEND`, or
 //!     `MACH_MSG_TYPE_PORT_SEND_ONCE`.
 //!
 //! \return `true` on success, or `false` on failure with a message logged.
 bool MachMessageDestroyReceivedPort(mach_port_t port,
                                     mach_msg_type_name_t port_right_type);
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_UTIL_MACH_MACH_MESSAGE_H_