[NaCl SDK] Convert python scripts from optparse to argparse.

native_client_sdk/src/build_tools/test_projects.py

 #!/usr/bin/env python
 # Copyright (c) 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 optparse
+import argparse
 import os
 import subprocess
 import sys
 import time
 
 import build_projects
 import build_version
 import buildbot_common
 import parse_dsc
 
 from build_paths import OUT_DIR, SRC_DIR, SDK_SRC_DIR, SCRIPT_DIR
 
 sys.path.append(os.path.join(SDK_SRC_DIR, 'tools'))
 import getos
 platform = getos.GetPlatform()
 
 # TODO(binji): ugly hack -- can I get the browser in a cleaner way?
 sys.path.append(os.path.join(SRC_DIR, 'chrome', 'test', 'nacl_test_injection'))
 import find_chrome
 browser_path = find_chrome.FindChrome(SRC_DIR, ['Debug', 'Release'])
 
 # Fall back to using CHROME_PATH (same as in common.mk)
 if not browser_path:
-  browser_path = os.environ['CHROME_PATH']
+  browser_path = os.environ.get('CHROME_PATH')
 
 
 pepper_ver = str(int(build_version.ChromeMajorVersion()))
 pepperdir = os.path.join(OUT_DIR, 'pepper_' + pepper_ver)
 
 browser_tester_py = os.path.join(SRC_DIR, 'ppapi', 'native_client', 'tools',
     'browser_tester', 'browser_tester.py')
 
 
 ALL_CONFIGS = ['Debug', 'Release']
@@ skipping 265 matching lines @@
   # Everything in src is a library, and cannot be run.
   exclude = {'DEST': 'src'}
   try:
     return parse_dsc.LoadProjectTree(SDK_SRC_DIR, include=include,
                                      exclude=exclude)
   except parse_dsc.ValidationError as e:
     buildbot_common.ErrorExit(str(e))
 
 
 def main(args):
-  parser = optparse.OptionParser()
-  parser.add_option('-c', '--config',
+  parser = argparse.ArgumentParser(description=__doc__)
+  parser.add_argument('-c', '--config',
       help='Choose configuration to run (Debug or Release).  Runs both '
            'by default', action='append')
-  parser.add_option('-x', '--experimental',
+  parser.add_argument('-x', '--experimental',
       help='Run experimental projects', action='store_true')
-  parser.add_option('-t', '--toolchain',
+  parser.add_argument('-t', '--toolchain',
       help='Run using toolchain. Can be passed more than once.',
       action='append', default=[])
-  parser.add_option('-d', '--dest',
+  parser.add_argument('-d', '--dest',
       help='Select which destinations (project types) are valid.',
       action='append')
-  parser.add_option('-b', '--build',
+  parser.add_argument('-b', '--build',
       help='Build each project before testing.', action='store_true')
-  parser.add_option('--retry-times',
+  parser.add_argument('--retry-times',
       help='Number of types to retry on failure (Default: %default)',
-          type='int', default=1)
+      type=int, default=1)
+  parser.add_argument('projects', nargs='*')
 
-  options, args = parser.parse_args(args)
+  options = parser.parse_args(args)
 
   if not options.toolchain:
     options.toolchain = ['newlib', 'glibc', 'pnacl', 'host']
 
   if 'host' in options.toolchain:
     options.toolchain.remove('host')
     options.toolchain.append(platform)
     print 'Adding platform: ' + platform
 
   ValidateToolchains(options.toolchain)
 
   include = {}
   if options.toolchain:
     include['TOOLS'] = options.toolchain
     print 'Filter by toolchain: ' + str(options.toolchain)
   if not options.experimental:
     include['EXPERIMENTAL'] = False
   if options.dest:
     include['DEST'] = options.dest
     print 'Filter by type: ' + str(options.dest)
-  if args:
-    include['NAME'] = args
-    print 'Filter by name: ' + str(args)
+  if options.projects:
+    include['NAME'] = options.projects
+    print 'Filter by name: ' + str(options.projects)
   if not options.config:
     options.config = ALL_CONFIGS
 
   project_tree = GetProjectTree(include)
   if options.build:
     BuildAllTestsInTree(project_tree, options.toolchain, options.config)
 
   return RunAllTestsInTree(project_tree, options.toolchain, options.config,
                            options.retry_times)
 
 
 if __name__ == '__main__':
   script_name = os.path.basename(sys.argv[0])
   try:
     sys.exit(main(sys.argv[1:]))
   except parse_dsc.ValidationError as e:
     buildbot_common.ErrorExit('%s: %s' % (script_name, e))
   except KeyboardInterrupt:
     buildbot_common.ErrorExit('%s: interrupted' % script_name)