Update Crashpad to 32981a3ee9d7c2769fb27afa038fe2e194cfa329

third_party/crashpad/crashpad/client/crashpad_client.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 26 matching lines @@
 //! \brief The primary interface for an application to have Crashpad monitor
 //!     it for crashes.
 class CrashpadClient {
  public:
   CrashpadClient();
   ~CrashpadClient();
 
   //! \brief Starts a Crashpad handler process, performing any necessary
   //!     handshake to configure it.
   //!
-  //! This method directs crashes to the Crashpad handler. On Mac OS X, this
-  //! is applicable to this process and all child processes. On Windows, child
-  //! processes must also register by using SetHandlerIPCPipe().
+  //! This method directs crashes to the Crashpad handler. On macOS, this is
+  //! applicable to this process and all subsequent child processes. On Windows,
+  //! child processes must also register by using SetHandlerIPCPipe().
   //!
-  //! On Mac OS X, this method starts a Crashpad handler and obtains a Mach send
+  //! On macOS, this method starts a Crashpad handler and obtains a Mach send
   //! right corresponding to a receive right held by the handler process. The
   //! handler process runs an exception server on this port. This method sets
   //! the task’s exception port for `EXC_CRASH`, `EXC_RESOURCE`, and `EXC_GUARD`
   //! exceptions to the Mach send right obtained. The handler will be installed
   //! with behavior `EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES` and thread
   //! state flavor `MACHINE_THREAD_STATE`. Exception ports are inherited, so a
   //! Crashpad handler started here will remain the handler for any child
-  //! processes created after StartHandler() is called. Child processes do not
-  //! need to call StartHandler() or be aware of Crashpad in any way. The
+  //! processes created after StartHandler() is called. These child processes do
+  //! not need to call StartHandler() or be aware of Crashpad in any way. The
   //! Crashpad handler will receive crashes from child processes that have
   //! inherited it as their exception handler even after the process that called
   //! StartHandler() exits.
   //!
   //! On Windows, if \a asynchronous_start is `true`, this function will not
   //! directly call `CreateProcess()`, making it suitable for use in a
   //! `DllMain()`. In that case, the handler is started from a background
   //! thread, deferring the handler's startup. Nevertheless, regardless of the
   //! value of \a asynchronous_start, after calling this method, the global
   //! unhandled exception filter is set up, and all crashes will be handled by
@@ skipping 31 matching lines @@
                     const std::string& url,
                     const std::map<std::string, std::string>& annotations,
                     const std::vector<std::string>& arguments,
                     bool restartable,
                     bool asynchronous_start);
 
 #if defined(OS_MACOSX) || DOXYGEN
   //! \brief Sets the process’ crash handler to a Mach service registered with
   //!     the bootstrap server.
   //!
-  //! This method is only defined on OS X.
+  //! This method is only defined on macOS.
   //!
   //! See StartHandler() for more detail on how the port and handler are
   //! configured.
   //!
   //! \param[in] service_name The service name of a Crashpad exception handler
   //!     service previously registered with the bootstrap server.
   //!
   //! \return `true` on success, `false` on failure with a message logged.
   bool SetHandlerMachService(const std::string& service_name);
 
   //! \brief Sets the process’ crash handler to a Mach port.
   //!
-  //! This method is only defined on OS X.
+  //! This method is only defined on macOS.
   //!
   //! See StartHandler() for more detail on how the port and handler are
   //! configured.
   //!
   //! \param[in] exception_port An `exception_port_t` corresponding to a
   //!     Crashpad exception handler service.
   //!
   //! \return `true` on success, `false` on failure with a message logged.
   bool SetHandlerMachPort(base::mac::ScopedMachSendRight exception_port);
 #endif
@@ skipping 91 matching lines @@
     //!     confusion with real exception codes which tend to have those bits
     //!     set.
     kTriggeredExceptionCode = 0xcca11ed,
   };
 #endif
 
 #if defined(OS_MACOSX) || DOXYGEN
   //! \brief Configures the process to direct its crashes to the default handler
   //!     for the operating system.
   //!
-  //! On OS X, this sets the task’s exception port as in SetHandlerMachPort(),
+  //! On macOS, this sets the task’s exception port as in SetHandlerMachPort(),
   //! but the exception handler used is obtained from
   //! SystemCrashReporterHandler(). If the system’s crash reporter handler
   //! cannot be determined or set, the task’s exception ports for crash-type
   //! exceptions are cleared.
   //!
   //! Use of this function is strongly discouraged.
   //!
   //! \warning After a call to this function, Crashpad will no longer monitor
   //!     the process for crashes until a subsequent call to
   //!     SetHandlerMachPort().
@@ skipping 10 matching lines @@
   std::wstring ipc_pipe_;
   ScopedKernelHANDLE handler_start_thread_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(CrashpadClient);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_CLIENT_CRASHPAD_CLIENT_H_