Update Crashpad to 1f28a123a4c9449e3d7ddad4ff00dacd366d5216

third_party/crashpad/crashpad/minidump/minidump_user_stream_writer.cc

 // 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,
@@ skipping 38 matching lines @@
     return writer_->Write(data, size);
   }
 
  private:
   const MemorySnapshot* snapshot_;
   FileWriterInterface* writer_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotContentsWriter);
 };
 
-class MinidumpUserStreamWriter::BufferContentsWriter final
-    : public MinidumpUserStreamWriter::ContentsWriter {
+class MinidumpUserStreamWriter::ExtensionStreamContentsWriter final
+    : public MinidumpUserStreamWriter::ContentsWriter,
+      public MinidumpUserExtensionStreamDataSource::Delegate {
  public:
-  BufferContentsWriter(const void* buffer, size_t buffer_size)
-      : buffer_(buffer), buffer_size_(buffer_size) {}
+  explicit ExtensionStreamContentsWriter(
+      std::unique_ptr<MinidumpUserExtensionStreamDataSource> data_source)
+      : data_source_(std::move(data_source)), writer_(nullptr) {}
 
   bool WriteContents(FileWriterInterface* writer) override {
-    return writer->Write(buffer_, buffer_size_);
+    DCHECK(!writer_);
+
+    writer_ = writer;
+    return data_source_->ReadStreamData(this);
   }
-  size_t GetSize() const override { return buffer_size_; }
+
+  size_t GetSize() const override { return data_source_->StreamDataSize(); }
+
+  bool ExtensionStreamDataSourceRead(const void* data, size_t size) override {
+    return writer_->Write(data, size);
+  }
 
  private:
-  const void* buffer_;
-  size_t buffer_size_;
+  std::unique_ptr<MinidumpUserExtensionStreamDataSource> data_source_;
+  FileWriterInterface* writer_;
 
-  DISALLOW_COPY_AND_ASSIGN(BufferContentsWriter);
+  DISALLOW_COPY_AND_ASSIGN(ExtensionStreamContentsWriter);
 };
 
 MinidumpUserStreamWriter::MinidumpUserStreamWriter() : stream_type_() {}
 
 MinidumpUserStreamWriter::~MinidumpUserStreamWriter() {
 }
 
 void MinidumpUserStreamWriter::InitializeFromSnapshot(
     const UserMinidumpStream* stream) {
   DCHECK_EQ(state(), kStateMutable);
   DCHECK(!contents_writer_.get());
 
   stream_type_ = static_cast<MinidumpStreamType>(stream->stream_type());
   contents_writer_ =
       base::WrapUnique(new SnapshotContentsWriter(stream->memory()));
 }
 
-void MinidumpUserStreamWriter::InitializeFromBuffer(
-    MinidumpStreamType stream_type,
-    const void* buffer,
-    size_t buffer_size) {
+void MinidumpUserStreamWriter::InitializeFromUserExtensionStream(
+    std::unique_ptr<MinidumpUserExtensionStreamDataSource> data_source) {
   DCHECK_EQ(state(), kStateMutable);
   DCHECK(!contents_writer_.get());
 
-  stream_type_ = stream_type;
-  contents_writer_ =
-      base::WrapUnique(new BufferContentsWriter(buffer, buffer_size));
+  stream_type_ = data_source->stream_type();
+  contents_writer_ = base::WrapUnique(
+      new ExtensionStreamContentsWriter(std::move(data_source)));
 }
 
 bool MinidumpUserStreamWriter::Freeze() {
   DCHECK_EQ(state(), kStateMutable);
   DCHECK_NE(stream_type_, 0u);
   return MinidumpStreamWriter::Freeze();
 }
 
 size_t MinidumpUserStreamWriter::SizeOfObject() {
   DCHECK_GE(state(), kStateFrozen);
@@ skipping 11 matching lines @@
   DCHECK_EQ(state(), kStateWritable);
 
   return contents_writer_->WriteContents(file_writer);
 }
 
 MinidumpStreamType MinidumpUserStreamWriter::StreamType() const {
   return static_cast<MinidumpStreamType>(stream_type_);
 }
 
 }  // namespace crashpad