Update Crashpad to b47bf6c250c6b825dee1c5fbad9152c2c962e828

third_party/crashpad/crashpad/util/win/initial_client_data.h

+// Copyright 2016 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,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef CRASHPAD_UTIL_WIN_INITIAL_CLIENT_DATA_H_
+#define CRASHPAD_UTIL_WIN_INITIAL_CLIENT_DATA_H_
+
+#include <windows.h>
+
+#include <string>
+
+#include "base/macros.h"
+#include "util/win/address_types.h"
+
+namespace crashpad {
+
+//! \brief A container for the data associated with the `--initial-client-data`
+//!     method for initializing the handler process on Windows.
+class InitialClientData {
+ public:
+  //! \brief Constructs an unintialized instance to be used with
+  //!     InitializeFromString().
+  InitialClientData();
+
+  //! \brief Constructs an instance of InitialClientData. This object does not
+  //!     take ownership of any of the referenced HANDLEs.
+  //!
+  //! \param[in] request_crash_dump An event signalled from the client on crash.
+  //! \param[in] request_non_crash_dump An event signalled from the client when
+  //!     it would like a dump to be taken, but allowed to continue afterwards.
+  //! \param[in] non_crash_dump_completed An event signalled from the handler to
+  //!     tell the client that the non-crash dump has completed, and it can
+  //!     continue execution.
+  //! \param[in] first_pipe_instance The server end and first instance of a pipe
+  //!     that will be used for communication with all other clients after this
+  //!     initial one.
+  //! \param[in] client_process A process handle for the client being
+  //!     registered.
+  //! \param[in] crash_exception_information The address, in the client's
+  //!     address space, of an ExceptionInformation structure, used when
+  //!     handling a crash dump request.
+  //! \param[in] non_crash_exception_information The address, in the client's
+  //!     address space, of an ExceptionInformation structure, used when
+  //!     handling a non-crashing dump request.
+  //! \param[in] debug_critical_section_address The address, in the client
+  //!     process's address space, of a `CRITICAL_SECTION` allocated with a
+  //!     valid .DebugInfo field. This can be accomplished by using
+  //!     InitializeCriticalSectionWithDebugInfoIfPossible() or equivalent. This
+  //!     value can be `0`, however then limited lock data will be available in
+  //!     minidumps.
+  InitialClientData(HANDLE request_crash_dump,
+                    HANDLE request_non_crash_dump,
+                    HANDLE non_crash_dump_completed,
+                    HANDLE first_pipe_instance,
+                    HANDLE client_process,
+                    WinVMAddress crash_exception_information,
+                    WinVMAddress non_crash_exception_information,
+                    WinVMAddress debug_critical_section_address);
+
+  //! \brief Returns whether the object has been initialized successfully.
+  bool IsValid() const { return is_valid_; }
+
+  //! Initializes this object from a string representation presumed to have been
+  //!     created by StringRepresentation().
+  //!
+  //! \param[in] str The output of StringRepresentation().
+  //!
+  //! \return `true` on success, or `false` with a message logged on failure.
+  bool InitializeFromString(const std::string& str);
+
+  //! \brief Returns a string representation of the data of this object,
+  //!     suitable for passing on the command line.
+  std::string StringRepresentation() const;
+
+  HANDLE request_crash_dump() const { return request_crash_dump_; }
+  HANDLE request_non_crash_dump() const { return request_non_crash_dump_; }
+  HANDLE non_crash_dump_completed() const { return non_crash_dump_completed_; }
+  HANDLE first_pipe_instance() const { return first_pipe_instance_; }
+  HANDLE client_process() const { return client_process_; }
+  WinVMAddress crash_exception_information() const {
+    return crash_exception_information_;
+  }
+  WinVMAddress non_crash_exception_information() const {
+    return non_crash_exception_information_;
+  }
+  WinVMAddress debug_critical_section_address() const {
+    return debug_critical_section_address_;
+  }
+
+ private:
+  WinVMAddress crash_exception_information_;
+  WinVMAddress non_crash_exception_information_;
+  WinVMAddress debug_critical_section_address_;
+  HANDLE request_crash_dump_;
+  HANDLE request_non_crash_dump_;
+  HANDLE non_crash_dump_completed_;
+  HANDLE first_pipe_instance_;
+  HANDLE client_process_;
+  bool is_valid_;
+
+#if _MSC_VER < 1900
+  // The default copy and assignment constructors are fine, as we don't take
+  // ownership of the handles. They also shouldn't be required for how we use
+  // this class, however, VS2013 seems to think they are.
+#else
+  DISALLOW_COPY_AND_ASSIGN(InitialClientData);
+#endif  // _MSC_VER < 1900
+};
+
+}  // namespace crashpad
+
+#endif  // CRASHPAD_UTIL_WIN_INITIAL_CLIENT_DATA_H_