Update Crashpad to 4a2043ea65e2641ef1a921801c0aaa15ada02fc7

third_party/crashpad/crashpad/util/net/http_transport_test_server.py

 #!/usr/bin/env python
 # coding: utf-8
 
 # 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
@@ skipping 15 matching lines @@
 write the entire request to stdout. It will then terminate.
 
 This server is written in Python since it provides a simple HTTP stack, and
 because parsing chunked encoding is safer and easier in a memory-safe language.
 This could easily have been written in C++ instead.
 """
 
 import BaseHTTPServer
 import struct
 import sys
+import zlib
 
 class BufferedReadFile(object):
   """A File-like object that stores all read contents into a buffer."""
 
   def __init__(self, real_file):
     self.file = real_file
     self.buffer = ""
 
   def read(self, size=-1):
     buf = self.file.read(size)
@@ skipping 28 matching lines @@
     # Wrap the rfile in the buffering file object so that the raw header block
     # can be written to stdout after it is parsed.
     self.rfile = BufferedReadFile(self.rfile)
     BaseHTTPServer.BaseHTTPRequestHandler.handle_one_request(self)
 
   def do_POST(self):
     RequestHandler.raw_request = self.rfile.buffer
     self.rfile.buffer = ''
 
     if self.headers.get('Transfer-Encoding', '').lower() == 'chunked':
+      if 'Content-Length' in self.headers:
+        raise AssertionError
       body = self.handle_chunked_encoding()
     else:
       length = int(self.headers.get('Content-Length', -1))
       body = self.rfile.read(length)
 
+    if self.headers.get('Content-Encoding', '').lower() == 'gzip':
+      # 15 is the value of |wbits|, which should be at the maximum possible
+      # value to ensure that any gzip stream can be decoded. The offset of 16
+      # specifies that the stream to decompress will be formatted with a gzip
+      # wrapper.
+      body = zlib.decompress(body, 16 + 15)
+
     RequestHandler.raw_request += body
 
     self.send_response(self.response_code)
     self.end_headers()
     if self.response_code == 200:
       self.wfile.write(self.response_body)
       self.wfile.write('\r\n')
 
   def handle_chunked_encoding(self):
     """This parses a "Transfer-Encoding: Chunked" body in accordance with
@@ skipping 55 matching lines @@
 
   # Handle the request.
   server.handle_request()
 
   # Share the entire request with the test program, which will validate it.
   sys.stdout.write(RequestHandler.raw_request)
   sys.stdout.flush()
 
 if __name__ == '__main__':
   Main()