Add MinidumpMemoryListWriter::AddFromSnapshot(), everything downstream and its test

minidump/minidump_memory_writer.cc

 // 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.
 
 #include "minidump/minidump_memory_writer.h"
 
+#include "base/auto_reset.h"
 #include "base/logging.h"
+#include "snapshot/memory_snapshot.h"
 #include "util/file/file_writer.h"
 #include "util/numeric/safe_assignment.h"
 
 namespace crashpad {
+namespace {
+
+class SnapshotMinidumpMemoryWriter final : public MinidumpMemoryWriter,
+                                           public MemorySnapshot::Delegate {
+ public:
+  explicit SnapshotMinidumpMemoryWriter(const MemorySnapshot* memory_snapshot)
+      : MinidumpMemoryWriter(),
+        MemorySnapshot::Delegate(),
+        memory_snapshot_(memory_snapshot),
+        file_writer_(nullptr) {
+  }
+
+  ~SnapshotMinidumpMemoryWriter() override {}
+
+  // MemorySnapshot::Delegate:
+
+  bool MemorySnapshotDelegateRead(void* data, size_t size) override {
+    DCHECK_EQ(state(), kStateWritable);
+    DCHECK_EQ(size, MemoryRangeSize());
+    return file_writer_->Write(data, size);
+  }
+
+ protected:
+  // MinidumpMemoryWriter:
+
+  bool WriteObject(FileWriterInterface* file_writer) override {
+    DCHECK_EQ(state(), kStateWritable);
+    DCHECK(!file_writer_);
+
+    base::AutoReset<FileWriterInterface*> file_writer_reset(&file_writer_,
+                                                            file_writer);
+
+    // This will result in MemorySnapshotDelegateRead() being called.
+    return memory_snapshot_->Read(this);
+  }
+
+  uint64_t MemoryRangeBaseAddress() const override {
+    DCHECK_EQ(state(), kStateFrozen);
+    return memory_snapshot_->Address();
+  }
+
+  size_t MemoryRangeSize() const override {
+    DCHECK_GE(state(), kStateFrozen);
+    return memory_snapshot_->Size();
+  }
+
+ private:
+  const MemorySnapshot* memory_snapshot_;
+  FileWriterInterface* file_writer_;
+
+  DISALLOW_COPY_AND_ASSIGN(SnapshotMinidumpMemoryWriter);
+};
+
+}  // namespace
 
 MinidumpMemoryWriter::~MinidumpMemoryWriter() {
 }
 
+scoped_ptr<MinidumpMemoryWriter> MinidumpMemoryWriter::CreateFromSnapshot(
+    const MemorySnapshot* memory_snapshot) {
+  return make_scoped_ptr(new SnapshotMinidumpMemoryWriter(memory_snapshot));
+}
+
 const MINIDUMP_MEMORY_DESCRIPTOR*
 MinidumpMemoryWriter::MinidumpMemoryDescriptor() const {
   DCHECK_EQ(state(), kStateWritable);
 
   return &memory_descriptor_;
 }
 
 void MinidumpMemoryWriter::RegisterMemoryDescriptor(
     MINIDUMP_MEMORY_DESCRIPTOR* memory_descriptor) {
   DCHECK_LE(state(), kStateFrozen);
@@ skipping 66 matching lines @@
 MinidumpMemoryListWriter::MinidumpMemoryListWriter()
     : MinidumpStreamWriter(),
       memory_list_base_(),
       memory_writers_(),
       children_() {
 }
 
 MinidumpMemoryListWriter::~MinidumpMemoryListWriter() {
 }
 
+void MinidumpMemoryListWriter::AddFromSnapshot(
+    const std::vector<const MemorySnapshot*>& memory_snapshots) {
+  DCHECK_EQ(state(), kStateMutable);
+
+  for (const MemorySnapshot* memory_snapshot : memory_snapshots) {
+    scoped_ptr<MinidumpMemoryWriter> memory =
+        MinidumpMemoryWriter::CreateFromSnapshot(memory_snapshot);
+    AddMemory(memory.Pass());
+  }
+}
+
 void MinidumpMemoryListWriter::AddMemory(
     scoped_ptr<MinidumpMemoryWriter> memory_writer) {
   DCHECK_EQ(state(), kStateMutable);
 
   AddExtraMemory(memory_writer.get());
   children_.push_back(memory_writer.release());
 }
 
 void MinidumpMemoryListWriter::AddExtraMemory(
     MinidumpMemoryWriter* memory_writer) {
@@ skipping 57 matching lines @@
   }
 
   return file_writer->WriteIoVec(&iovecs);
 }
 
 MinidumpStreamType MinidumpMemoryListWriter::StreamType() const {
   return kMinidumpStreamTypeMemoryList;
 }
 
 }  // namespace crashpad