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):

[wtc, 2011/10/31 19:21:00]

Nit: list 'head_handlers' and 'do_HEAD' in alphabetical order
in this file.

[mmenke, 2011/10/31 20:46:40]

Done.

     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,
       self.EchoHandler,
       self.DeviceManagementHandler] + get_handlers
     put_handlers = [
       self.EchoTitleHandler,
-      self.EchoAllHandler,

[wtc, 2011/10/31 19:21:00]

Why did you remove self.EchoAllHandler from post_handlers
and put_handlers?  The reason is not obvious to me.

[mmenke, 2011/10/31 20:46:40]

It's in get_handlers already, so there's no reason to add it again.  Had a
comment to this effect earlier, but uploaded multiple CLs since then, burying
it.

       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)
+                             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)

[wtc, 2011/10/31 19:21:00]

Just wanted to confirm that this statement should NOT be inside
the if statement above.

[mmenke, 2011/10/31 20:46:40]

It didn't matter, either way.  Removed the if statement, as per your comment
below.

 
     # 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"
       response = f.readline()
       status_code = re.findall('HTTP/\d+.\d+ (\d+)', response)[0]
@@ skipping 21 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))

[wtc, 2011/10/31 19:21:00]

Just curious: are HEAD responses forbidden to have a
Content-Length header (of value 0)?

[wtc, 2011/10/31 19:59:41]

julian.reschke: thank you for the reply.

mmenke: based on julian.reschke's reply, I believe your changes
to this function (FileHandler) for HEAD requests are
incorrect.

I believe that the only change this function needs for
HEAD requests is to omit the actual sending of file data
(I guess that's the self.wfile.write(data) statment on
line 958 below).

The new DefaultHeadResponseHandler function below has
the same problem.

[mmenke, 2011/10/31 20:46:40]

Done.  You're right.  I misread the RFC.

       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

[wtc, 2011/10/31 19:21:00]

Capitalize "HEAD".

[mmenke, 2011/10/31 20:46:40]

Done.

+    handled by one of the special handlers above."""
+
+    self.send_response(200)
+    self.send_header('Content-type', 'text/html')

[wtc, 2011/10/31 19:21:00]

Since there is no |contents|, it seems that we should omit
the Content-type response header, too.

[mmenke, 2011/10/31 20:46:40]

Not done (As per spec - "The Content-Type entity-header field indicates the
media type of the entity-body sent to the recipient or, in the case of the HEAD
method, the media type that would have been sent had the request been a GET."). 
'Content-length' added instead.

[mmenke, 2011/10/31 20:49:25]

On second thought, you're right, with a 0 content-length.  Removed.

[mmenke, 2011/10/31 20:52:14]

Or maybe not?  Honestly, I have no idea.  Suppose a 0-length file could
technically be called a text file.

+    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))