Update Crashpad to 4a2043ea65e2641ef1a921801c0aaa15ada02fc7

third_party/crashpad/crashpad/handler/crash_report_upload_thread.cc

 // Copyright 2015 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 121 matching lines @@
   CrashReportDatabase* database_;  // weak
   const CrashReportDatabase::Report* report_;  // weak
 
   DISALLOW_COPY_AND_ASSIGN(CallRecordUploadAttempt);
 };
 
 }  // namespace
 
 CrashReportUploadThread::CrashReportUploadThread(CrashReportDatabase* database,
                                                  const std::string& url,
-                                                 bool rate_limit)
+                                                 bool rate_limit,
+                                                 bool upload_gzip)
     : url_(url),
       // Check for pending reports every 15 minutes, even in the absence of a
       // signal from the handler thread. This allows for failed uploads to be
       // retried periodically, and for pending reports written by other
       // processes to be recognized.
       thread_(15 * 60, this),
       database_(database),
-      rate_limit_(rate_limit) {
+      rate_limit_(rate_limit),
+      upload_gzip_(upload_gzip) {
 }
 
 CrashReportUploadThread::~CrashReportUploadThread() {
 }
 
 void CrashReportUploadThread::Start() {
   thread_.Start(0);
 }
 
 void CrashReportUploadThread::Stop() {
@@ skipping 140 matching lines @@
     }
 
     // If the minidump file could be opened, ignore any errors that might occur
     // when attempting to interpret it. This may result in its being uploaded
     // with few or no parameters, but as long as there’s a dump file, the server
     // can decide what to do with it.
     parameters = BreakpadHTTPFormParametersFromMinidump(&minidump_file_reader);
   }
 
   HTTPMultipartBuilder http_multipart_builder;
+  http_multipart_builder.SetGzipEnabled(upload_gzip_);
 
   const char kMinidumpKey[] = "upload_file_minidump";
 
   for (const auto& kv : parameters) {
     if (kv.first == kMinidumpKey) {
       LOG(WARNING) << "reserved key " << kv.first << ", discarding value "
                    << kv.second;
     } else {
       http_multipart_builder.SetFormData(kv.first, kv.second);
     }
   }
 
   http_multipart_builder.SetFileAttachment(
       kMinidumpKey,
 #if defined(OS_WIN)
       base::UTF16ToUTF8(report->file_path.BaseName().value()),
 #else
       report->file_path.BaseName().value(),
 #endif
       report->file_path,
       "application/octet-stream");
 
   std::unique_ptr<HTTPTransport> http_transport(HTTPTransport::Create());
   http_transport->SetURL(url_);
-  HTTPHeaders::value_type content_type =
-      http_multipart_builder.GetContentType();
-  http_transport->SetHeader(content_type.first, content_type.second);
+  HTTPHeaders content_headers;
+  http_multipart_builder.PopulateContentHeaders(&content_headers);
+  for (const auto& content_header : content_headers) {
+    http_transport->SetHeader(content_header.first, content_header.second);
+  }
   http_transport->SetBodyStream(http_multipart_builder.GetBodyStream());
   // TODO(mark): The timeout should be configurable by the client.
   http_transport->SetTimeout(60.0);  // 1 minute.
 
   if (!http_transport->ExecuteSynchronously(response_body)) {
     return UploadResult::kRetry;
   }
 
   return UploadResult::kSuccess;
 }
 
 void CrashReportUploadThread::DoWork(const WorkerThread* thread) {
   ProcessPendingReports();
 }
 
 }  // namespace crashpad