Remove //net (except for Android test stuff) and sdch

net/tools/testserver/testserver_base.py

Index: net/tools/testserver/testserver_base.py
diff --git a/net/tools/testserver/testserver_base.py b/net/tools/testserver/testserver_base.py
deleted file mode 100644
index 0d3f65fdca95a2482530367083ba8d7f6df4f0a4..0000000000000000000000000000000000000000
--- a/net/tools/testserver/testserver_base.py
+++ /dev/null
@@ -1,258 +0,0 @@
-# Copyright 2013 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.
-
-import BaseHTTPServer
-import errno
-import json
-import optparse
-import os
-import re
-import socket
-import SocketServer
-import struct
-import sys
-import warnings
-
-import tlslite.errors
-
-# Ignore deprecation warnings, they make our output more cluttered.
-warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-if sys.platform == 'win32':
-  import msvcrt
-
-# Using debug() seems to cause hangs on XP: see http://crbug.com/64515.
-debug_output = sys.stderr
-def debug(string):
-  debug_output.write(string + "\n")
-  debug_output.flush()
-
-
-class Error(Exception):
-  """Error class for this module."""
-
-
-class OptionError(Error):
-  """Error for bad command line options."""
-
-
-class FileMultiplexer(object):
-  def __init__(self, fd1, fd2) :
-    self.__fd1 = fd1
-    self.__fd2 = fd2
-
-  def __del__(self) :
-    if self.__fd1 != sys.stdout and self.__fd1 != sys.stderr:
-      self.__fd1.close()
-    if self.__fd2 != sys.stdout and self.__fd2 != sys.stderr:
-      self.__fd2.close()
-
-  def write(self, text) :
-    self.__fd1.write(text)
-    self.__fd2.write(text)
-
-  def flush(self) :
-    self.__fd1.flush()
-    self.__fd2.flush()
-
-
-class ClientRestrictingServerMixIn:
-  """Implements verify_request to limit connections to our configured IP
-  address."""
-
-  def verify_request(self, _request, client_address):
-    return client_address[0] == self.server_address[0]
-
-
-class BrokenPipeHandlerMixIn:
-  """Allows the server to deal with "broken pipe" errors (which happen if the
-  browser quits with outstanding requests, like for the favicon). This mix-in
-  requires the class to derive from SocketServer.BaseServer and not override its
-  handle_error() method. """
-
-  def handle_error(self, request, client_address):
-    value = sys.exc_info()[1]
-    if isinstance(value, tlslite.errors.TLSClosedConnectionError):
-      print "testserver.py: Closed connection"
-      return
-    if isinstance(value, socket.error):
-      err = value.args[0]
-      if sys.platform in ('win32', 'cygwin'):
-        # "An established connection was aborted by the software in your host."
-        pipe_err = 10053
-      else:
-        pipe_err = errno.EPIPE
-      if err == pipe_err:
-        print "testserver.py: Broken pipe"
-        return
-      if err == errno.ECONNRESET:
-        print "testserver.py: Connection reset by peer"
-        return
-    SocketServer.BaseServer.handle_error(self, request, client_address)
-
-
-class StoppableHTTPServer(BaseHTTPServer.HTTPServer):
-  """This is a specialization of BaseHTTPServer to allow it
-  to be exited cleanly (by setting its "stop" member to True)."""
-
-  def serve_forever(self):
-    self.stop = False
-    self.nonce_time = None
-    while not self.stop:
-      self.handle_request()
-    self.socket.close()
-
-
-def MultiplexerHack(std_fd, log_fd):
-  """Creates a FileMultiplexer that will write to both specified files.
-
-  When running on Windows XP bots, stdout and stderr will be invalid file
-  handles, so log_fd will be returned directly.  (This does not occur if you
-  run the test suite directly from a console, but only if the output of the
-  test executable is redirected.)
-  """
-  if std_fd.fileno() <= 0:
-    return log_fd
-  return FileMultiplexer(std_fd, log_fd)
-
-
-class BasePageHandler(BaseHTTPServer.BaseHTTPRequestHandler):
-
-  def __init__(self, request, client_address, socket_server,
-               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
-
-
-class TestServerRunner(object):
-  """Runs a test server and communicates with the controlling C++ test code.
-
-  Subclasses should override the create_server method to create their server
-  object, and the add_options method to add their own options.
-  """
-
-  def __init__(self):
-    self.option_parser = optparse.OptionParser()
-    self.add_options()
-
-  def main(self):
-    self.options, self.args = self.option_parser.parse_args()
-
-    logfile = open(self.options.log_file, 'w')
-    sys.stderr = MultiplexerHack(sys.stderr, logfile)
-    if self.options.log_to_console:
-      sys.stdout = MultiplexerHack(sys.stdout, logfile)
-    else:
-      sys.stdout = logfile
-
-    server_data = {
-      'host': self.options.host,
-    }
-    self.server = self.create_server(server_data)
-    self._notify_startup_complete(server_data)
-    self.run_server()
-
-  def create_server(self, server_data):
-    """Creates a server object and returns it.
-
-    Must populate server_data['port'], and can set additional server_data
-    elements if desired."""
-    raise NotImplementedError()
-
-  def run_server(self):
-    try:
-      self.server.serve_forever()
-    except KeyboardInterrupt:
-      print 'shutting down server'
-      self.server.stop = True
-
-  def add_options(self):
-    self.option_parser.add_option('--startup-pipe', type='int',
-                                  dest='startup_pipe',
-                                  help='File handle of pipe to parent process')
-    self.option_parser.add_option('--log-to-console', action='store_const',
-                                  const=True, default=False,
-                                  dest='log_to_console',
-                                  help='Enables or disables sys.stdout logging '
-                                  'to the console.')
-    self.option_parser.add_option('--log-file', default='testserver.log',
-                                  dest='log_file',
-                                  help='The name of the server log file.')
-    self.option_parser.add_option('--port', default=0, type='int',
-                                  help='Port used by the server. If '
-                                  'unspecified, the server will listen on an '
-                                  'ephemeral port.')
-    self.option_parser.add_option('--host', default='127.0.0.1',
-                                  dest='host',
-                                  help='Hostname or IP upon which the server '
-                                  'will listen. Client connections will also '
-                                  'only be allowed from this address.')
-    self.option_parser.add_option('--data-dir', dest='data_dir',
-                                  help='Directory from which to read the '
-                                  'files.')
-
-  def _notify_startup_complete(self, server_data):
-    # Notify the parent that we've started. (BaseServer subclasses
-    # bind their sockets on construction.)
-    if self.options.startup_pipe is not None:
-      server_data_json = json.dumps(server_data)
-      server_data_len = len(server_data_json)
-      print 'sending server_data: %s (%d bytes)' % (
-        server_data_json, server_data_len)
-      if sys.platform == 'win32':
-        fd = msvcrt.open_osfhandle(self.options.startup_pipe, 0)
-      else:
-        fd = self.options.startup_pipe
-      startup_pipe = os.fdopen(fd, "w")
-      # First write the data length as an unsigned 4-byte value.  This
-      # is _not_ using network byte ordering since the other end of the
-      # pipe is on the same machine.
-      startup_pipe.write(struct.pack('=L', server_data_len))
-      startup_pipe.write(server_data_json)
-      startup_pipe.close()