Copy Crashpad into the Chrome tree instead of importing it via DEPS

third_party/crashpad/crashpad/minidump/minidump_memory_writer.h

Index: third_party/crashpad/crashpad/minidump/minidump_memory_writer.h
diff --git a/third_party/crashpad/crashpad/minidump/minidump_memory_writer.h b/third_party/crashpad/crashpad/minidump/minidump_memory_writer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6b5f2dfe23bfe73e9dd0c473dc11b1ba2dd1cc3b
--- /dev/null
+++ b/third_party/crashpad/crashpad/minidump/minidump_memory_writer.h
@@ -0,0 +1,193 @@
+// 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,
+// 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_MINIDUMP_MINIDUMP_MEMORY_WRITER_H_
+#define CRASHPAD_MINIDUMP_MINIDUMP_MEMORY_WRITER_H_
+
+#include <windows.h>
+#include <dbghelp.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "minidump/minidump_stream_writer.h"
+#include "minidump/minidump_writable.h"
+#include "util/file/file_io.h"
+#include "util/stdlib/pointer_container.h"
+
+namespace crashpad {
+
+class MemorySnapshot;
+
+//! \brief The base class for writers of memory ranges pointed to by
+//!     MINIDUMP_MEMORY_DESCRIPTOR objects in a minidump file.
+//!
+//! This is an abstract base class because users are expected to provide their
+//! own implementations that, when possible, obtain the memory contents
+//! on-demand in their WriteObject() methods. Memory ranges may be large, and
+//! the alternative construction would require the contents of multiple ranges
+//! to be held in memory simultaneously while a minidump file is being written.
+class MinidumpMemoryWriter : public internal::MinidumpWritable {
+ public:
+  ~MinidumpMemoryWriter() override;
+
+  //! \brief Creates a concrete initialized MinidumpMemoryWriter based on \a
+  //!     memory_snapshot.
+  //!
+  //! \param[in] memory_snapshot The memory snapshot to use as source data.
+  //!
+  //! \return An object of a MinidumpMemoryWriter subclass initialized using the
+  //!     source data in \a memory_snapshot.
+  static scoped_ptr<MinidumpMemoryWriter> CreateFromSnapshot(
+      const MemorySnapshot* memory_snapshot);
+
+  //! \brief Returns a MINIDUMP_MEMORY_DESCRIPTOR referencing the data that this
+  //!     object writes.
+  //!
+  //! This method is expected to be called by a MinidumpMemoryListWriter in
+  //! order to obtain a MINIDUMP_MEMORY_DESCRIPTOR to include in its list.
+  //!
+  //! \note Valid in #kStateWritable.
+  const MINIDUMP_MEMORY_DESCRIPTOR* MinidumpMemoryDescriptor() const;
+
+  //! \brief Registers a memory descriptor as one that should point to the
+  //!     object on which this method is called.
+  //!
+  //! This method is expected to be called by objects of other classes, when
+  //! those other classes have their own memory descriptors that need to point
+  //! to memory ranges within a minidump file. MinidumpThreadWriter is one such
+  //! class. This method is public for this reason, otherwise it would suffice
+  //! to be private.
+  //!
+  //! \note Valid in #kStateFrozen or any preceding state.
+  void RegisterMemoryDescriptor(MINIDUMP_MEMORY_DESCRIPTOR* memory_descriptor);
+
+ protected:
+  MinidumpMemoryWriter();
+
+  //! \brief Returns the base address of the memory region in the address space
+  //!     of the process that the snapshot describes.
+  //!
+  //! \note This method will only be called in #kStateFrozen.
+  virtual uint64_t MemoryRangeBaseAddress() const = 0;
+
+  //! \brief Returns the size of the memory region in bytes.
+  //!
+  //! \note This method will only be called in #kStateFrozen or a subsequent
+  //!     state.
+  virtual size_t MemoryRangeSize() const = 0;
+
+  // MinidumpWritable:
+  bool Freeze() override;
+  size_t SizeOfObject() final;
+
+  //! \brief Returns the object’s desired byte-boundary alignment.
+  //!
+  //! Memory regions are aligned to a 16-byte boundary. The actual alignment
+  //! requirements of any data within the memory region are unknown, and may be
+  //! more or less strict than this depending on the platform.
+  //!
+  //! \return `16`.
+  //!
+  //! \note Valid in #kStateFrozen or any subsequent state.
+  size_t Alignment() override;
+
+  bool WillWriteAtOffsetImpl(FileOffset offset) override;
+
+  //! \brief Returns the object’s desired write phase.
+  //!
+  //! Memory regions are written at the end of minidump files, because it is
+  //! expected that unlike most other data in a minidump file, the contents of
+  //! memory regions will be accessed sparsely.
+  //!
+  //! \return #kPhaseLate.
+  //!
+  //! \note Valid in any state.
+  Phase WritePhase() final;
+
+ private:
+  MINIDUMP_MEMORY_DESCRIPTOR memory_descriptor_;
+
+  // weak
+  std::vector<MINIDUMP_MEMORY_DESCRIPTOR*> registered_memory_descriptors_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpMemoryWriter);
+};
+
+//! \brief The writer for a MINIDUMP_MEMORY_LIST stream in a minidump file,
+//!     containing a list of MINIDUMP_MEMORY_DESCRIPTOR objects.
+class MinidumpMemoryListWriter final : public internal::MinidumpStreamWriter {
+ public:
+  MinidumpMemoryListWriter();
+  ~MinidumpMemoryListWriter() override;
+
+  //! \brief Adds a concrete initialized MinidumpMemoryWriter for each memory
+  //!     snapshot in \a memory_snapshots to the MINIDUMP_MEMORY_LIST.
+  //!
+  //! Memory snapshots are added in the fashion of AddMemory().
+  //!
+  //! \param[in] memory_snapshots The memory snapshots to use as source data.
+  //!
+  //! \note Valid in #kStateMutable.
+  void AddFromSnapshot(
+      const std::vector<const MemorySnapshot*>& memory_snapshots);
+
+  //! \brief Adds a MinidumpMemoryWriter to the MINIDUMP_MEMORY_LIST.
+  //!
+  //! This object takes ownership of \a memory_writer and becomes its parent in
+  //! the overall tree of internal::MinidumpWritable objects.
+  //!
+  //! \note Valid in #kStateMutable.
+  void AddMemory(scoped_ptr<MinidumpMemoryWriter> memory_writer);
+
+  //! \brief Adds a MinidumpMemoryWriter that’s a child of another
+  //!     internal::MinidumpWritable object to the MINIDUMP_MEMORY_LIST.
+  //!
+  //! \a memory_writer does not become a child of this object, but the
+  //! MINIDUMP_MEMORY_LIST will still contain a MINIDUMP_MEMORY_DESCRIPTOR for
+  //! it. \a memory_writer must be a child of another object in the
+  //! internal::MinidumpWritable tree.
+  //!
+  //! This method exists to be called by objects that have their own
+  //! MinidumpMemoryWriter children but wish for them to also appear in the
+  //! minidump file’s MINIDUMP_MEMORY_LIST. MinidumpThreadWriter, which has a
+  //! MinidumpMemoryWriter for thread stack memory, is an example.
+  //!
+  //! \note Valid in #kStateMutable.
+  void AddExtraMemory(MinidumpMemoryWriter* memory_writer);
+
+ protected:
+  // MinidumpWritable:
+  bool Freeze() override;
+  size_t SizeOfObject() override;
+  std::vector<MinidumpWritable*> Children() override;
+  bool WriteObject(FileWriterInterface* file_writer) override;
+
+  // MinidumpStreamWriter:
+  MinidumpStreamType StreamType() const override;
+
+ private:
+  std::vector<MinidumpMemoryWriter*> memory_writers_;  // weak
+  PointerVector<MinidumpMemoryWriter> children_;
+  MINIDUMP_MEMORY_LIST memory_list_base_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpMemoryListWriter);
+};
+
+}  // namespace crashpad
+
+#endif  // CRASHPAD_MINIDUMP_MINIDUMP_MEMORY_WRITER_H_