Don't convert HEAD requests to GETs on 303 redirects.

net/tools/testserver/testserver.py

 #!/usr/bin/env python
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """This is a simple HTTP/FTP/SYNC/TCP/UDP/ server used for testing Chrome.
 
 It supports several test URLs, as specified by the handlers in TestPageHandler.
 By default, it listens on an ephemeral port and sends the port number back to
 the originating process over a pipe. The originating process can specify an
@@ skipping 248 matching lines @@
     self.stop = False
     self.nonce_time = None
     while not self.stop:
       self.handle_request()
     self.socket.close()
 
 
 class BasePageHandler(BaseHTTPServer.BaseHTTPRequestHandler):
 
   def __init__(self, request, client_address, socket_server,
-               connect_handlers, get_handlers, post_handlers, put_handlers):
+               connect_handlers, get_handlers, head_handlers, post_handlers,
+               put_handlers):
     self._connect_handlers = connect_handlers
     self._get_handlers = get_handlers
+    self._head_handlers = head_handlers
     self._post_handlers = post_handlers
     self._put_handlers = put_handlers
     BaseHTTPServer.BaseHTTPRequestHandler.__init__(
       self, request, client_address, socket_server)
 
   def log_request(self, *args, **kwargs):
     # Disable request logging to declutter test log output.
     pass
 
   def _ShouldHandleRequest(self, handler_name):
     """Determines if the path can be handled by the handler.
 
     We consider a handler valid if the path begins with the
     handler name. It can optionally be followed by "?*", "/*".
     """
 
     pattern = re.compile('%s($|\?|/).*' % handler_name)
     return pattern.match(self.path)
 
   def do_CONNECT(self):
     for handler in self._connect_handlers:
       if handler():
         return
 
   def do_GET(self):
     for handler in self._get_handlers:
       if handler():
         return
 
+  def do_HEAD(self):
+    for handler in self._head_handlers:
+      if handler():
+        return
+
   def do_POST(self):
     for handler in self._post_handlers:
       if handler():
         return
 
   def do_PUT(self):
     for handler in self._put_handlers:
       if handler():
         return
 
@@ skipping 33 matching lines @@
       self.ChunkedServerHandler,
       self.ContentTypeHandler,
       self.NoContentHandler,
       self.ServerRedirectHandler,
       self.ClientRedirectHandler,
       self.MultipartHandler,
       self.MultipartSlowHandler,
       self.DefaultResponseHandler]
     post_handlers = [
       self.EchoTitleHandler,
-      self.EchoAllHandler,
       self.EchoHandler,
       self.DeviceManagementHandler] + get_handlers
     put_handlers = [
       self.EchoTitleHandler,
-      self.EchoAllHandler,
       self.EchoHandler] + get_handlers
+    head_handlers = [
+      self.FileHandler,
+      self.DefaultResponseHandler]
 
     self._mime_types = {
       'crx' : 'application/x-chrome-extension',
       'exe' : 'application/octet-stream',
       'gif': 'image/gif',
       'jpeg' : 'image/jpeg',
       'jpg' : 'image/jpeg',
       'pdf' : 'application/pdf',
       'xml' : 'text/xml'
     }
     self._default_mime_type = 'text/html'
 
     BasePageHandler.__init__(self, request, client_address, socket_server,
-                             connect_handlers, get_handlers, post_handlers,
-                             put_handlers)
+                             connect_handlers, get_handlers, head_handlers,
+                             post_handlers, put_handlers)
 
   def GetMIMETypeFromName(self, file_name):
     """Returns the mime type for the specified file_name. So far it only looks
     at the file extension."""
 
     (shortname, extension) = os.path.splitext(file_name.split("?")[0])
     if len(extension) == 0:
       # no extension.
       return self._default_mime_type
 
     # extension starts with a dot, so we need to remove it
     return self._mime_types.get(extension[1:], self._default_mime_type)
 
   def NoCacheMaxAgeTimeHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and no caching requested."""
 
     if not self._ShouldHandleRequest("/nocachetime/maxage"):
       return False
 
     self.send_response(200)
     self.send_header('Cache-Control', 'max-age=0')
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def NoCacheTimeHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and no caching requested."""
 
     if not self._ShouldHandleRequest("/nocachetime"):
       return False
 
     self.send_response(200)
     self.send_header('Cache-Control', 'no-cache')
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CacheTimeHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and allows caching for one minute."""
 
     if not self._ShouldHandleRequest("/cachetime"):
       return False
 
     self.send_response(200)
     self.send_header('Cache-Control', 'max-age=60')
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CacheExpiresHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and set the page to expire on 1 Jan 2099."""
 
     if not self._ShouldHandleRequest("/cache/expires"):
       return False
 
     self.send_response(200)
     self.send_header('Expires', 'Thu, 1 Jan 2099 00:00:00 GMT')
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CacheProxyRevalidateHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and allows caching for 60 seconds"""
 
     if not self._ShouldHandleRequest("/cache/proxy-revalidate"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'max-age=60, proxy-revalidate')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CachePrivateHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and allows caching for 5 seconds."""
 
     if not self._ShouldHandleRequest("/cache/private"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'max-age=3, private')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CachePublicHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and allows caching for 5 seconds."""
 
     if not self._ShouldHandleRequest("/cache/public"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'max-age=3, public')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CacheSMaxAgeHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and does not allow for caching."""
 
     if not self._ShouldHandleRequest("/cache/s-maxage"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'public, s-maxage = 60, max-age = 0')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CacheMustRevalidateHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and does not allow caching."""
 
     if not self._ShouldHandleRequest("/cache/must-revalidate"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'must-revalidate')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CacheMustRevalidateMaxAgeHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and does not allow caching event though max-age of 60
     seconds is specified."""
 
     if not self._ShouldHandleRequest("/cache/must-revalidate/max-age"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'max-age=60, must-revalidate')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CacheNoStoreHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and does not allow the page to be stored."""
 
     if not self._ShouldHandleRequest("/cache/no-store"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'no-store')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def CacheNoStoreMaxAgeHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and does not allow the page to be stored even though max-age
     of 60 seconds is specified."""
 
     if not self._ShouldHandleRequest("/cache/no-store/max-age"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'max-age=60, no-store')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
 
   def CacheNoTransformHandler(self):
     """This request handler yields a page with the title set to the current
     system time, and does not allow the content to transformed during
     user-agent caching"""
 
     if not self._ShouldHandleRequest("/cache/no-transform"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'no-transform')
     self.end_headers()
 
     self.wfile.write('<html><head><title>%s</title></head></html>' %
                      time.time())
 
     return True
 
   def EchoHeader(self):
     """This handler echoes back the value of a specific request header."""
     return self.EchoHeaderHelper("/echoheader")
 
     """This function echoes back the value of a specific request header"""
     """while allowing caching for 16 hours."""
   def EchoHeaderCache(self):
     return self.EchoHeaderHelper("/echoheadercache")
 
   def EchoHeaderHelper(self, echo_header):
     """This function echoes back the value of the request header passed in."""
     if not self._ShouldHandleRequest(echo_header):
       return False
 
     query_char = self.path.find('?')
     if query_char != -1:
       header_name = self.path[query_char+1:]
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/plain')
+    self.send_header('Content-Type', 'text/plain')
     if echo_header == '/echoheadercache':
       self.send_header('Cache-control', 'max-age=60000')
     else:
       self.send_header('Cache-control', 'no-cache')
     # insert a vary header to properly indicate that the cachability of this
     # request is subject to value of the request header being echoed.
     if len(header_name) > 0:
       self.send_header('Vary', header_name)
     self.end_headers()
 
@@ skipping 23 matching lines @@
     return body
 
   def EchoHandler(self):
     """This handler just echoes back the payload of the request, for testing
     form submission."""
 
     if not self._ShouldHandleRequest("/echo"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
     self.wfile.write(self.ReadRequestBody())
     return True
 
   def EchoTitleHandler(self):
     """This handler is like Echo, but sets the page title to the request."""
 
     if not self._ShouldHandleRequest("/echotitle"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
     request = self.ReadRequestBody()
     self.wfile.write('<html><head><title>')
     self.wfile.write(request)
     self.wfile.write('</title></head></html>')
     return True
 
   def EchoAllHandler(self):
     """This handler yields a (more) human-readable page listing information
     about the request header & contents."""
 
     if not self._ShouldHandleRequest("/echoall"):
       return False
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
     self.wfile.write('<html><head><style>'
       'pre { border: 1px solid black; margin: 5px; padding: 5px }'
       '</style></head><body>'
       '<div style="float: right">'
       '<a href="/echo">back to referring page</a></div>'
       '<h1>Request Body:</h1><pre>')
 
     if self.command == 'POST' or self.command == 'PUT':
       qs = self.ReadRequestBody()
@@ skipping 25 matching lines @@
     # small chunks of data to the client.  Use a fairly large buffer
     # so that we'll fill chrome's IO buffer enough to force it to
     # actually write the data.
     # See also the comments in the client-side of this test in
     # download_uitest.cc
     #
     size_chunk1 = 35*1024
     size_chunk2 = 10*1024
 
     self.send_response(200)
-    self.send_header('Content-type', 'application/octet-stream')
+    self.send_header('Content-Type', 'application/octet-stream')
     self.send_header('Cache-Control', 'max-age=0')
     if send_length:
       self.send_header('Content-Length', size_chunk1 + size_chunk2)
     self.end_headers()
 
     # First chunk of data:
     self.wfile.write("*" * size_chunk1)
     self.wfile.flush()
 
     # handle requests until one of them clears this flag.
     self.server.waitForDownload = True
     while self.server.waitForDownload:
       self.server.handle_request()
 
     # Second chunk of data:
     self.wfile.write("*" * size_chunk2)
     return True
 
   def DownloadFinishHandler(self):
     """This handler just tells the server to finish the current download."""
 
     if not self._ShouldHandleRequest("/download-finish"):
       return False
 
     self.server.waitForDownload = False
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.send_header('Cache-Control', 'max-age=0')
     self.end_headers()
     return True
 
   def _ReplaceFileData(self, data, query_parameters):
     """Replaces matching substrings in a file.
 
     If the 'replace_text' URL query parameter is present, it is expected to be
     of the form old_text:new_text, which indicates that any old_text strings in
     the file are replaced with new_text. Multiple 'replace_text' parameters may
@@ skipping 63 matching lines @@
     if query == 'U':
       content_length = uncompressed_len
     elif query == 'S':
       content_length = compressed_len / 2
     elif query == 'M':
       content_length = (compressed_len + uncompressed_len) / 2
     elif query == 'L':
       content_length = compressed_len + uncompressed_len
 
     self.send_response(200)
-    self.send_header('Content-type', 'application/msword')
+    self.send_header('Content-Type', 'application/msword')
     self.send_header('Content-encoding', 'deflate')
     self.send_header('Connection', 'close')
     self.send_header('Content-Length', content_length)
     self.send_header('ETag', '\'' + file_path + '\'')
     self.end_headers()
 
     self.wfile.write(data)
 
     return True
 
@@ skipping 58 matching lines @@
         end = int(range[1])
 
         self.send_response(206)
         content_range = 'bytes ' + str(start) + '-' + str(end) + '/' + \
                         str(len(data))
         self.send_header('Content-Range', content_range)
         data = data[start: end + 1]
       else:
         self.send_response(200)
 
-      self.send_header('Content-type', self.GetMIMETypeFromName(file_path))
+      self.send_header('Content-Type', self.GetMIMETypeFromName(file_path))
       self.send_header('Accept-Ranges', 'bytes')
       self.send_header('Content-Length', len(data))
       self.send_header('ETag', '\'' + file_path + '\'')
     self.end_headers()
 
-    self.wfile.write(data)
+    if (self.command != 'HEAD'):
+      self.wfile.write(data)
 
     return True
 
   def SetCookieHandler(self):
     """This handler just sets a cookie, for testing cookie handling."""
 
     if not self._ShouldHandleRequest("/set-cookie"):
       return False
 
     query_char = self.path.find('?')
     if query_char != -1:
       cookie_values = self.path[query_char + 1:].split('&')
     else:
       cookie_values = ("",)
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     for cookie_value in cookie_values:
       self.send_header('Set-Cookie', '%s' % cookie_value)
     self.end_headers()
     for cookie_value in cookie_values:
       self.wfile.write('%s' % cookie_value)
     return True
 
   def AuthBasicHandler(self):
     """This handler tests 'Basic' authentication.  It just sends a page with
     title 'user/pass' if you succeed."""
@@ skipping 21 matching lines @@
         raise Exception('no auth')
       b64str = re.findall(r'Basic (\S+)', auth)[0]
       userpass = base64.b64decode(b64str)
       username, password = re.findall(r'([^:]+):(\S+)', userpass)[0]
       if password != expected_password:
         raise Exception('wrong password')
     except Exception, e:
       # Authentication failed.
       self.send_response(401)
       self.send_header('WWW-Authenticate', 'Basic realm="%s"' % realm)
-      self.send_header('Content-type', 'text/html')
+      self.send_header('Content-Type', 'text/html')
       if set_cookie_if_challenged:
         self.send_header('Set-Cookie', 'got_challenged=true')
       self.end_headers()
       self.wfile.write('<html><head>')
       self.wfile.write('<title>Denied: %s</title>' % e)
       self.wfile.write('</head><body>')
       self.wfile.write('auth=%s<p>' % auth)
       self.wfile.write('b64str=%s<p>' % b64str)
       self.wfile.write('username: %s<p>' % username)
       self.wfile.write('userpass: %s<p>' % userpass)
@@ skipping 18 matching lines @@
       if not os.path.isfile(gif_path):
         self.send_error(404)
         self.protocol_version = old_protocol_version
         return True
 
       f = open(gif_path, "rb")
       data = f.read()
       f.close()
 
       self.send_response(200)
-      self.send_header('Content-type', 'image/gif')
+      self.send_header('Content-Type', 'image/gif')
       self.send_header('Cache-control', 'max-age=60000')
       self.send_header('Etag', 'abc')
       self.end_headers()
       self.wfile.write(data)
     else:
       self.send_response(200)
-      self.send_header('Content-type', 'text/html')
+      self.send_header('Content-Type', 'text/html')
       self.send_header('Cache-control', 'max-age=60000')
       self.send_header('Etag', 'abc')
       self.end_headers()
       self.wfile.write('<html><head>')
       self.wfile.write('<title>%s/%s</title>' % (username, password))
       self.wfile.write('</head><body>')
       self.wfile.write('auth=%s<p>' % auth)
       self.wfile.write('You sent:<br>%s<p>' % self.headers)
       self.wfile.write('</body></html>')
 
@@ skipping 67 matching lines @@
       hdr = ('Digest '
              'realm="%s", '
              'domain="/", '
              'qop="auth", '
              'algorithm=MD5, '
              'nonce="%s", '
              'opaque="%s"') % (realm, nonce, opaque)
       if stale:
         hdr += ', stale="TRUE"'
       self.send_header('WWW-Authenticate', hdr)
-      self.send_header('Content-type', 'text/html')
+      self.send_header('Content-Type', 'text/html')
       self.end_headers()
       self.wfile.write('<html><head>')
       self.wfile.write('<title>Denied: %s</title>' % e)
       self.wfile.write('</head><body>')
       self.wfile.write('auth=%s<p>' % auth)
       self.wfile.write('pairs=%s<p>' % pairs)
       self.wfile.write('You sent:<br>%s<p>' % self.headers)
       self.wfile.write('We are replying:<br>%s<p>' % hdr)
       self.wfile.write('</body></html>')
       return True
 
     # Authentication successful.
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
     self.wfile.write('<html><head>')
     self.wfile.write('<title>%s/%s</title>' % (pairs['username'], password))
     self.wfile.write('</head><body>')
     self.wfile.write('auth=%s<p>' % auth)
     self.wfile.write('pairs=%s<p>' % pairs)
     self.wfile.write('</body></html>')
 
     return True
 
   def SlowServerHandler(self):
     """Wait for the user suggested time before responding. The syntax is
     /slow?0.5 to wait for half a second."""
     if not self._ShouldHandleRequest("/slow"):
       return False
     query_char = self.path.find('?')
     wait_sec = 1.0
     if query_char >= 0:
       try:
         wait_sec = int(self.path[query_char + 1:])
       except ValueError:
         pass
     time.sleep(wait_sec)
     self.send_response(200)
-    self.send_header('Content-type', 'text/plain')
+    self.send_header('Content-Type', 'text/plain')
     self.end_headers()
     self.wfile.write("waited %d seconds" % wait_sec)
     return True
 
   def ChunkedServerHandler(self):
     """Send chunked response. Allows to specify chunks parameters:
      - waitBeforeHeaders - ms to wait before sending headers
      - waitBetweenChunks - ms to wait between chunks
      - chunkSize - size of each chunk in bytes
      - chunksNumber - number of chunks
@@ skipping 11 matching lines @@
       for param in params:
         keyValue = param.split('=')
         if len(keyValue) == 2:
           try:
             chunkedSettings[keyValue[0]] = int(keyValue[1])
           except ValueError:
             pass
     time.sleep(0.001 * chunkedSettings['waitBeforeHeaders']);
     self.protocol_version = 'HTTP/1.1' # Needed for chunked encoding
     self.send_response(200)
-    self.send_header('Content-type', 'text/plain')
+    self.send_header('Content-Type', 'text/plain')
     self.send_header('Connection', 'close')
     self.send_header('Transfer-Encoding', 'chunked')
     self.end_headers()
     # Chunked encoding: sending all chunks, then final zero-length chunk and
     # then final CRLF.
     for i in range(0, chunkedSettings['chunksNumber']):
       if i > 0:
         time.sleep(0.001 * chunkedSettings['waitBetweenChunks'])
       self.sendChunkHelp('*' * chunkedSettings['chunkSize'])
       self.wfile.flush(); # Keep in mind that we start flushing only after 1kb.
@@ skipping 34 matching lines @@
       return False
 
     query_char = self.path.find('?')
     if query_char < 0 or len(self.path) <= query_char + 1:
       self.sendRedirectHelp(test_name)
       return True
     dest = self.path[query_char + 1:]
 
     self.send_response(301)  # moved permanently
     self.send_header('Location', dest)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
     self.wfile.write('<html><head>')
     self.wfile.write('</head><body>Redirecting to %s</body></html>' % dest)
 
     return True
 
   def ClientRedirectHandler(self):
     """Sends a client redirect to the given URL. The syntax is
     '/client-redirect?http://foo.bar/asdf' to redirect to
     'http://foo.bar/asdf'"""
 
     test_name = "/client-redirect"
     if not self._ShouldHandleRequest(test_name):
       return False
 
     query_char = self.path.find('?');
     if query_char < 0 or len(self.path) <= query_char + 1:
       self.sendRedirectHelp(test_name)
       return True
     dest = self.path[query_char + 1:]
 
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
     self.wfile.write('<html><head>')
     self.wfile.write('<meta http-equiv="refresh" content="0;url=%s">' % dest)
     self.wfile.write('</head><body>Redirecting to %s</body></html>' % dest)
 
     return True
 
   def MultipartHandler(self):
     """Send a multipart response (10 text/html pages)."""
     test_name = '/multipart'
     if not self._ShouldHandleRequest(test_name):
       return False
 
     num_frames = 10
     bound = '12345'
     self.send_response(200)
-    self.send_header('Content-type',
+    self.send_header('Content-Type',
                      'multipart/x-mixed-replace;boundary=' + bound)
     self.end_headers()
 
     for i in xrange(num_frames):
       self.wfile.write('--' + bound + '\r\n')
-      self.wfile.write('Content-type: text/html\r\n\r\n')
+      self.wfile.write('Content-Type: text/html\r\n\r\n')
       self.wfile.write('<title>page ' + str(i) + '</title>')
       self.wfile.write('page ' + str(i))
 
     self.wfile.write('--' + bound + '--')
     return True
 
   def MultipartSlowHandler(self):
     """Send a multipart response (3 text/html pages) with a slight delay
     between each page.  This is similar to how some pages show status using
     multipart."""
     test_name = '/multipart-slow'
     if not self._ShouldHandleRequest(test_name):
       return False
 
     num_frames = 3
     bound = '12345'
     self.send_response(200)
-    self.send_header('Content-type',
+    self.send_header('Content-Type',
                      'multipart/x-mixed-replace;boundary=' + bound)
     self.end_headers()
 
     for i in xrange(num_frames):
       self.wfile.write('--' + bound + '\r\n')
-      self.wfile.write('Content-type: text/html\r\n\r\n')
+      self.wfile.write('Content-Type: text/html\r\n\r\n')
       time.sleep(0.25)
       if i == 2:
         self.wfile.write('<title>PASS</title>')
       else:
         self.wfile.write('<title>page ' + str(i) + '</title>')
       self.wfile.write('page ' + str(i) + '<!-- ' + ('x' * 2048) + '-->')
 
     self.wfile.write('--' + bound + '--')
     return True
 
   def DefaultResponseHandler(self):
     """This is the catch-all response handler for requests that aren't handled
     by one of the special handlers above.
     Note that we specify the content-length as without it the https connection
     is not closed properly (and the browser keeps expecting data)."""
 
     contents = "Default response given for path: " + self.path
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
-    self.send_header("Content-Length", len(contents))
+    self.send_header('Content-Type', 'text/html')
+    self.send_header('Content-Length', len(contents))
     self.end_headers()
-    self.wfile.write(contents)
+    if (self.command != 'HEAD'):
+      self.wfile.write(contents)
     return True
 
   def RedirectConnectHandler(self):
     """Sends a redirect to the CONNECT request for www.redirect.com. This
     response is not specified by the RFC, so the browser should not follow
     the redirect."""
 
     if (self.path.find("www.redirect.com") < 0):
       return False
 
@@ skipping 21 matching lines @@
     self.end_headers()
     return True
 
   def DefaultConnectResponseHandler(self):
     """This is the catch-all response handler for CONNECT requests that aren't
     handled by one of the special handlers above.  Real Web servers respond
     with 400 to CONNECT requests."""
 
     contents = "Your client has issued a malformed or illegal request."
     self.send_response(400)  # bad request
-    self.send_header('Content-type', 'text/html')
-    self.send_header("Content-Length", len(contents))
+    self.send_header('Content-Type', 'text/html')
+    self.send_header('Content-Length', len(contents))
     self.end_headers()
     self.wfile.write(contents)
     return True
 
   def DeviceManagementHandler(self):
     """Delegates to the device management service used for cloud policy."""
     if not self._ShouldHandleRequest("/device_management"):
       return False
 
     raw_request = self.ReadRequestBody()
 
     if not self.server._device_management_handler:
       import device_management
       policy_path = os.path.join(self.server.data_dir, 'device_management')
       self.server._device_management_handler = (
           device_management.TestServer(policy_path,
                                        self.server.policy_keys,
                                        self.server.policy_user))
 
     http_response, raw_reply = (
         self.server._device_management_handler.HandleRequest(self.path,
                                                              self.headers,
                                                              raw_request))
     self.send_response(http_response)
     if (http_response == 200):
-      self.send_header('Content-type', 'application/x-protobuffer')
+      self.send_header('Content-Type', 'application/x-protobuffer')
     self.end_headers()
     self.wfile.write(raw_reply)
     return True
 
   # called by the redirect handling function when there is no parameter
   def sendRedirectHelp(self, redirect_name):
     self.send_response(200)
-    self.send_header('Content-type', 'text/html')
+    self.send_header('Content-Type', 'text/html')
     self.end_headers()
     self.wfile.write('<html><body><h1>Error: no redirect destination</h1>')
     self.wfile.write('Use <pre>%s?http://dest...</pre>' % redirect_name)
     self.wfile.write('</body></html>')
 
   # called by chunked handling function
   def sendChunkHelp(self, chunk):
     # Each chunk consists of: chunk size (hex), CRLF, chunk body, CRLF
     self.wfile.write('%X\r\n' % len(chunk))
     self.wfile.write(chunk)
@@ skipping 11 matching lines @@
                     self.ChromiumSyncSendNotificationOpHandler,
                     self.ChromiumSyncBirthdayErrorOpHandler,
                     self.ChromiumSyncTransientErrorOpHandler,
                     self.ChromiumSyncSyncTabsOpHandler,
                     self.ChromiumSyncErrorOpHandler,
                     self.ChromiumSyncCredHandler]
 
     post_handlers = [self.ChromiumSyncCommandHandler,
                      self.ChromiumSyncTimeHandler]
     BasePageHandler.__init__(self, request, client_address,
-                             sync_http_server, [], get_handlers,
+                             sync_http_server, [], get_handlers, [],
                              post_handlers, [])
 
 
   def ChromiumSyncTimeHandler(self):
     """Handle Chromium sync .../time requests.
 
     The syncer sometimes checks server reachability by examining /time.
     """
     test_name = "/chromiumsync/time"
     if not self._ShouldHandleRequest(test_name):
@@ skipping 438 matching lines @@
                            'random key if none is specified on the command '
                            'line.')
   option_parser.add_option('', '--policy-user', default='user@example.com',
                            dest='policy_user',
                            help='Specify the user name the server should '
                            'report back to the client as the user owning the '
                            'token used for making the policy request.')
   options, args = option_parser.parse_args()
 
   sys.exit(main(options, args))