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.DefaultHeadResponseHandler]
 
     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
 
@@ skipping 551 matching lines @@
         data = data[start: end + 1]
       else:
         self.send_response(200)
 
       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('?')
@@ skipping 386 matching lines @@
     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')

[wtc, 2011/10/31 23:02:51]

Nit: capitalize "Type".

[mmenke, 2011/10/31 23:29:12]

Done.  Fixed a bunch of other cases of that, too.

     self.send_header("Content-Length", len(contents))
     self.end_headers()
     self.wfile.write(contents)
     return True
 
+  def DefaultHeadResponseHandler(self):
+    """This is the catch-all response handler for HEAD requests that aren't
+    handled by one of the special handlers above."""
+
+    self.send_response(200)
+    self.send_header('Content-Type', 'text/html')
+    self.send_header('Content-Length', '0')

[wtc, 2011/10/31 23:02:51]

An alternative to sending a Content-Length of 0 is to
copy more code from DefaultResponseHandler() above:

    contents = "Default response given for path: " + self.path
    ...
    self.send_header("Content-Length", len(contents))

Essentially, make this function the same as DefaultResponseHandler
except that self.wfile.write(contents) is omitted.

I wonder if we can just use DefaultResponseHandler for
HEAD requests, and add an if around self.wfile.write(contents):

    if (self.command != 'HEAD'):
      self.wfile.write(contents)

[mmenke, 2011/10/31 23:29:12]

The last suggestion sounds like a good idea to me.  Done.

+    self.end_headers()
+    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
 
     dest = "http://www.destination.com/foo.js"
 
@@ skipping 86 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))