Remove all code related to NaCl

platform_tools/nacl/httpd.py

Index: platform_tools/nacl/httpd.py
diff --git a/platform_tools/nacl/httpd.py b/platform_tools/nacl/httpd.py
deleted file mode 100755
index 2ad1d49438e532f2905d6f7edd68a7e7ddce2f39..0000000000000000000000000000000000000000
--- a/platform_tools/nacl/httpd.py
+++ /dev/null
@@ -1,212 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2012 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.
-
-"""A tiny web server.
-
-This is intended to be used for testing, and only run from within the examples
-directory.
-"""
-
-import BaseHTTPServer
-import logging
-import optparse
-import os
-import SimpleHTTPServer
-import SocketServer
-import sys
-import urlparse
-
-
-EXAMPLE_PATH=os.path.dirname(os.path.abspath(__file__))
-NACL_SDK_ROOT = os.getenv('NACL_SDK_ROOT', os.path.dirname(EXAMPLE_PATH))
-
-
-if os.path.exists(NACL_SDK_ROOT):
-  sys.path.append(os.path.join(NACL_SDK_ROOT, 'tools'))
-  import decode_dump
-  import getos
-else:
-  NACL_SDK_ROOT=None
-
-last_nexe = None
-last_nmf = None
-
-logging.getLogger().setLevel(logging.INFO)
-
-# Using 'localhost' means that we only accept connections
-# via the loop back interface.
-SERVER_PORT = 5103
-SERVER_HOST = ''
-
-# We only run from the examples directory so that not too much is exposed
-# via this HTTP server.  Everything in the directory is served, so there should
-# never be anything potentially sensitive in the serving directory, especially
-# if the machine might be a multi-user machine and not all users are trusted.
-# We only serve via the loopback interface.
-def SanityCheckDirectory():
-  httpd_path = os.path.abspath(os.path.dirname(__file__))
-  serve_path = os.path.abspath(os.getcwd())
-
-  # Verify we are serving from the directory this script came from, or bellow
-  if serve_path[:len(httpd_path)] == httpd_path:
-    return
-  logging.error('For security, httpd.py should only be run from within the')
-  logging.error('example directory tree.')
-  logging.error('We are currently in %s.' % serve_path)
-  sys.exit(1)
-
-
-# An HTTP server that will quit when |is_running| is set to False.  We also use
-# SocketServer.ThreadingMixIn in order to handle requests asynchronously for
-# faster responses.
-class QuittableHTTPServer(SocketServer.ThreadingMixIn,
-                          BaseHTTPServer.HTTPServer):
-  def serve_forever(self, timeout=0.5):
-    self.is_running = True
-    self.timeout = timeout
-    while self.is_running:
-      self.handle_request()
-
-  def shutdown(self):
-    self.is_running = False
-    return 1
-
-
-# "Safely" split a string at |sep| into a [key, value] pair.  If |sep| does not
-# exist in |str|, then the entire |str| is the key and the value is set to an
-# empty string.
-def KeyValuePair(str, sep='='):
-  if sep in str:
-    return str.split(sep)
-  else:
-    return [str, '']
-
-
-# A small handler that looks for '?quit=1' query in the path and shuts itself
-# down if it finds that parameter.
-class QuittableHTTPHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
-  def send_head(self):
-    """Common code for GET and HEAD commands.
-
-    This sends the response code and MIME headers.
-
-    Return value is either a file object (which has to be copied
-    to the outputfile by the caller unless the command was HEAD,
-    and must be closed by the caller under all circumstances), or
-    None, in which case the caller has nothing further to do.
-
-    """
-    path = self.translate_path(self.path)
-    f = None
-    if os.path.isdir(path):
-        if not self.path.endswith('/'):
-            # redirect browser - doing basically what apache does
-            self.send_response(301)
-            self.send_header("Location", self.path + "/")
-            self.end_headers()
-            return None
-        for index in "index.html", "index.htm":
-            index = os.path.join(path, index)
-            if os.path.exists(index):
-                path = index
-                break
-        else:
-            return self.list_directory(path)
-    ctype = self.guess_type(path)
-    try:
-        # Always read in binary mode. Opening files in text mode may cause
-        # newline translations, making the actual size of the content
-        # transmitted *less* than the content-length!
-        f = open(path, 'rb')
-    except IOError:
-        self.send_error(404, "File not found")
-        return None
-    self.send_response(200)
-    self.send_header("Content-type", ctype)
-    fs = os.fstat(f.fileno())
-    self.send_header("Content-Length", str(fs[6]))
-    self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))
-    self.send_header('Cache-Control','no-cache, must-revalidate')
-    self.send_header('Expires','-1')
-    self.end_headers()
-    return f
-
-  def do_GET(self):
-    global last_nexe, last_nmf
-    (_, _, path, query, _) = urlparse.urlsplit(self.path)
-    url_params = dict([KeyValuePair(key_value)
-                      for key_value in query.split('&')])
-    if 'quit' in url_params and '1' in url_params['quit']:
-      self.send_response(200, 'OK')
-      self.send_header('Content-type', 'text/html')
-      self.send_header('Content-length', '0')
-      self.end_headers()
-      self.server.shutdown()
-      return
-
-    if path.endswith('.nexe'):
-      last_nexe = path
-    if path.endswith('.nmf'):
-      last_nmf = path
-
-    SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
-
-  def do_POST(self):
-    (_, _,path, query, _) = urlparse.urlsplit(self.path)
-    if 'Content-Length' in self.headers:
-      if not NACL_SDK_ROOT:
-        self.wfile('Could not find NACL_SDK_ROOT to decode trace.')
-        return
-      data = self.rfile.read(int(self.headers['Content-Length']))
-      nexe = '.' + last_nexe
-      nmf = '.' + last_nmf
-      addr = os.path.join(NACL_SDK_ROOT, 'toolchain', 
-                          getos.GetPlatform() + '_x86_newlib', 
-                          'bin', 'x86_64-nacl-addr2line')
-      decoder = decode_dump.CoreDecoder(nexe, nmf, addr, None, None)
-      info = decoder.Decode(data)
-      trace = decoder.StackTrace(info)
-      decoder.PrintTrace(trace, sys.stdout)
-      decoder.PrintTrace(trace, self.wfile)
-
-
-def Run(server_address,
-        server_class=QuittableHTTPServer,
-        handler_class=QuittableHTTPHandler):
-  httpd = server_class(server_address, handler_class)
-  logging.info("Starting local server on port %d", server_address[1])
-  logging.info("To shut down send http://localhost:%d?quit=1",
-               server_address[1])
-  try:
-    httpd.serve_forever()
-  except KeyboardInterrupt:
-    logging.info("Received keyboard interrupt.")
-    httpd.server_close()
-
-  logging.info("Shutting down local server on port %d", server_address[1])
-
-
-def main():
-  usage_str = "usage: %prog [options] [optional_portnum]"
-  parser = optparse.OptionParser(usage=usage_str)
-  parser.add_option(
-    '--no_dir_check', dest='do_safe_check',
-    action='store_false', default=True,
-    help='Do not ensure that httpd.py is being run from a safe directory.')
-  (options, args) = parser.parse_args(sys.argv)
-  if options.do_safe_check:
-    SanityCheckDirectory()
-  if len(args) > 2:
-    print 'Too many arguments specified.'
-    parser.print_help()
-  elif len(args) == 2:
-    Run((SERVER_HOST, int(args[1])))
-  else:
-    Run((SERVER_HOST, SERVER_PORT))
-  return 0
-
-
-if __name__ == '__main__':
-  sys.exit(main())