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, post_handlers, put_handlers,
+               head_handlers):
     self._connect_handlers = connect_handlers
     self._get_handlers = get_handlers
     self._post_handlers = post_handlers
     self._put_handlers = put_handlers
+    self._head_handlers = head_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.
 
@@ skipping 17 matching lines @@
   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
 
+  def do_HEAD(self):
+    for handler in self._head_handlers:
+      if handler():
+        return
+
 
 class TestPageHandler(BasePageHandler):
 
   def __init__(self, request, client_address, socket_server):
     connect_handlers = [
       self.RedirectConnectHandler,
       self.ServerAuthConnectHandler,
       self.DefaultConnectResponseHandler]
     get_handlers = [
       self.NoCacheMaxAgeTimeHandler,
@@ skipping 23 matching lines @@
       self.ChunkedServerHandler,
       self.ContentTypeHandler,
       self.NoContentHandler,
       self.ServerRedirectHandler,
       self.ClientRedirectHandler,
       self.MultipartHandler,
       self.MultipartSlowHandler,
       self.DefaultResponseHandler]
     post_handlers = [
       self.EchoTitleHandler,
-      self.EchoAllHandler,

[mmenke, 2011/10/28 19:53:24]

Removed these because they're included in get_handlers.

       self.EchoHandler,
       self.DeviceManagementHandler] + get_handlers
     put_handlers = [
       self.EchoTitleHandler,
-      self.EchoAllHandler,
       self.EchoHandler] + get_handlers
+    head_handlers = [
+      self.FileHandler,
+      self.DefaultHeadResponseHandler] + get_handlers
 
     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)
+                             put_handlers, head_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 501 matching lines @@
     entries = sub_path.split('/')
     file_path = os.path.join(self.server.data_dir, *entries)
     if os.path.isdir(file_path):
       file_path = os.path.join(file_path, 'index.html')
 
     if not os.path.isfile(file_path):
       print "File not found " + sub_path + " full path:" + file_path
       self.send_error(404)
       return True
 
-    f = open(file_path, "rb")
-    data = f.read()
-    f.close()
+    data = '';
+    if (self.command != 'HEAD'):
+      f = open(file_path, "rb")
+      data = f.read()
+      f.close()
 
     data = self._ReplaceFileData(data, query)
 
     # If file.mock-http-headers exists, it contains the headers we
     # should send.  Read them in and parse them.
     headers_path = file_path + '.mock-http-headers'
     if os.path.isfile(headers_path):
       f = open(headers_path, "r")
 
       # "HTTP/1.1 200 OK"
@@ skipping 23 matching lines @@
         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('Accept-Ranges', 'bytes')
-      self.send_header('Content-Length', len(data))
+      if (self.command != 'HEAD'):
+        self.send_header('Content-Length', len(data))
       self.send_header('ETag', '\'' + file_path + '\'')
     self.end_headers()
 
     self.wfile.write(data)
 
     return True
 
   def SetCookieHandler(self):
     """This handler just sets a cookie, for testing cookie handling."""
 
@@ skipping 396 matching lines @@
     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.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.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 87 matching lines @@
                     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,
-                             post_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):
       return False
@@ skipping 437 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))