Update yapf version

chrome_test/__init__.py

 # Copyright (c) 2014 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
-
 """Test harness for testing chrome apps / extensions."""
 
 import argparse
 import cStringIO
 import contextlib
 import hashlib
 import logging
 import os
 import shutil
 import subprocess
 import sys
 import tempfile
 import threading
 import urllib
 import urllib2
 import urlparse
 import zipfile
 
 SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 SRC_DIR = os.path.dirname(SCRIPT_DIR)
 sys.path.insert(0, os.path.join(SRC_DIR, 'build_tools'))
 sys.path.insert(0, os.path.join(SRC_DIR, 'lib'))
 
 import httpd
 import naclports
 
-
 # Pinned chrome revision. Update this to pull in a new chrome.
 # Try to select a version that exists on all platforms.
 CHROME_REVISION = '311001'
 
 CHROME_SYNC_DIR = os.path.join(naclports.paths.OUT_DIR, 'downloaded_chrome')
 
 GS_URL = 'http://storage.googleapis.com'
 CHROME_URL_FORMAT = GS_URL + '/chromium-browser-continuous/%s/%s/%s'
 
 TESTING_LIB = os.path.join(SCRIPT_DIR, 'chrome_test.js')
 TESTING_EXTENSION = os.path.join(SCRIPT_DIR, 'extension')
-TESTING_TCP_APP = os.path.join(SCRIPT_DIR, 'tcpapp');
+TESTING_TCP_APP = os.path.join(SCRIPT_DIR, 'tcpapp')
 
 RETURNCODE_KILL = -9
 
 LOG_LEVEL_MAP = {
     'ERROR': logging.ERROR,
     'WARNING': logging.WARNING,
     'INFO': logging.INFO,
     'DEBUG': logging.DEBUG,
 }
 
@@ skipping 156 matching lines @@
   the taskkill.exe utility for now.
 
   Args:
     proc: A subprocess.Popen process.
   """
   if sys.platform == 'win32':
     # Do subprocess call as the process may terminate before we manage
     # to invoke taskkill.
     subprocess.call(
         [os.path.join(os.environ['SYSTEMROOT'], 'System32', 'taskkill.exe'),
-        '/F', '/T', '/PID', str(proc.pid)])
+         '/F', '/T', '/PID', str(proc.pid)])
   else:
     # Send SIGKILL=9 to the entire process group associated with the child.
     os.kill(-proc.pid, 9)
 
 
 def CommunicateWithTimeout(proc, timeout):
   """Wait for a subprocess.Popen to end, capturing output, with a timeout.
 
   Args:
     proc: A subprocess.Popen.
     timeout: A timeout in seconds.
   Returns:
     (stdout, stderr, returncode).
   """
   if timeout == 0:
     timeout = None
 
   result = []
+
   def Target():
     result.append(list(proc.communicate()))
 
   thread = threading.Thread(target=Target)
   thread.start()
   try:
     thread.join(timeout)
     if thread.is_alive():
       logging.error('Attempting to kill test due to timeout of %.1f seconds!' %
                     timeout)
@@ skipping 84 matching lines @@
       # Allow the tests to send out log messages.
       if ('log' in params and len(params['log']) == 1 and
           'level' in params and len(params['level']) == 1):
         level = LOG_LEVEL_MAP.get(params['level'][0], logging.ERROR)
         message = params['log'][0]
         logging.log(level, message)
         self.SendEmptyReply()
         return
       # Allow the tests to request the current test filter string.
       elif ('filter' in params and len(params['filter']) == 1 and
-          params['filter'][0] == '1'):
+            params['filter'][0] == '1'):
         self.send_response(200, 'OK')
         self.send_header('Content-type', 'text/html')
         self.send_header('Content-length', str(len(self.server.filter_string)))
         self.end_headers()
         self.wfile.write(self.server.filter_string)
         return
       # Allow the tests to declare their name on start.
       elif ('start' in params and len(params['start']) == 1 and
           params['start'][0] == '1' and
           'name' in params and len(params['name']) == 1):
@@ skipping 91 matching lines @@
     enable_nacl_debug: Boolean indicating that NaCl debugging should be
                        enabled.
     load_extensions: A list of unpacked extensions paths to load on start.
     load_apps: A list of unpacked apps to load on start.
     start_path: The path relative to the current directory to point the browser
                 at on startup.
   """
   # Ensure all extension / app paths are absolute.
   load_extensions = [os.path.abspath(os.path.expanduser(i))
                      for i in load_extensions]
-  load_apps = [os.path.abspath(os.path.expanduser(i))
-               for i in load_apps]
+  load_apps = [os.path.abspath(os.path.expanduser(i)) for i in load_apps]
 
   # Add in the chrome_test extension and compute its id.
   load_extensions += [TESTING_EXTENSION, TESTING_TCP_APP]
   testing_id = ChromeAppIdFromPath(TESTING_EXTENSION)
 
   s = ChromeTestServer(('', 0), ChromeTestHandler)
   for root in roots:
     s.AddRoot(root)
   s.SetFilterString(filter_string)
 
@@ skipping 10 matching lines @@
   try:
     work_dir = tempfile.mkdtemp(prefix='chrome_test_', suffix='.tmp')
     work_dir = os.path.abspath(work_dir)
     logging.info('Created work area in %s' % work_dir)
     try:
       thread = threading.Thread(target=Target)
       thread.start()
 
       cmd = []
       if sys.platform.startswith('linux') and use_xvfb:
-        cmd += ['xvfb-run', '--auto-servernum',
-                '-s', '-screen 0 1024x768x24 -ac']
+        cmd += ['xvfb-run', '--auto-servernum', '-s',
+                '-screen 0 1024x768x24 -ac']
       cmd += [chrome_path]
       cmd += ['--user-data-dir=' + work_dir]
       # We want to pin the pnacl component to the one that we downloaded.
       # This allows us to test features of the pnacl translator that are
       # not yet in the public component.
       cmd += ['--disable-component-update']
       # Pass testing extension id in user agent to make it widely available.
       # TODO(bradnelson): Drop this when hterm is fixed.
       # Hterm currently expects "Chrome/[0-9][0-9]" in the User Agent and
       # faults without it. Using "Chrome/34" so that it goes down one of the
@@ skipping 10 matching lines @@
       if len(load_apps) != 0:
         cmd += ['--load-and-launch-app=' + ','.join(load_apps)]
       cmd += [start_url]
 
       def ProcessGroup():
         if sys.platform != 'win32':
           # On non-windows platforms, start a new process group so that we can
           # be certain we bring down Chrome on a timeout.
           os.setpgid(0, 0)
 
-      p = subprocess.Popen(
-          cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-          preexec_fn=ProcessGroup)
+      p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                           stderr=subprocess.STDOUT, preexec_fn=ProcessGroup)
       logging.info('Started chrome with command line: %s' % (' '.join(cmd)))
       stdout, _, returncode = CommunicateWithTimeout(p, timeout=timeout)
       if logging.getLogger().isEnabledFor(logging.DEBUG):
         sys.stdout.write('\n[[[ STDOUT ]]]\n')
         sys.stdout.write('-' * 70 + '\n')
         sys.stdout.write(stdout)
         sys.stdout.write('\n' + '-' * 70 + '\n')
       logging.info('Chrome exited with return code %d' % returncode)
     finally:
       try:
         with contextlib.closing(urllib2.urlopen(quit_url)) as stream:
           stream.read()
       except Exception:
         pass
     thread.join()
     logging.info('Shutdown web server.')
   finally:
     shutil.rmtree(work_dir)
     logging.info('Removed %s' % work_dir)
   logging.info('Done.')
 
   if returncode == RETURNCODE_KILL:
     print '[ TIMEOUT   ] Timed out, ran %d tests, %d failed.' % (
-        len(s.tests), len(s.failed_tests))
+        len(s.tests), len(s.failed_tests)
+    )
     sys.exit(1)
   elif s.expected_test_count is None:
-    print ('[ XXXXXXXX ] Expected test count never emitted.')
+    print('[ XXXXXXXX ] Expected test count never emitted.')
     sys.exit(1)
   elif s.test_results != s.expected_test_count:
-    print ('[ XXXXXXXX ] '
-           'Expected %d tests, but only %d had results, with %d failures.' % (
-           s.expected_test_count, s.test_results, len(s.failed_tests)))
+    print('[ XXXXXXXX ] '
+          'Expected %d tests, but only %d had results, with %d failures.' % (
+              s.expected_test_count, s.test_results, len(s.failed_tests)
+          ))
     sys.exit(1)
   elif s.result != 0:
-    print '[ Failures ] Ran %d tests, %d failed.' % (
-        len(s.tests), len(s.failed_tests))
+    print '[ Failures ] Ran %d tests, %d failed.' % (len(s.tests),
+                                                     len(s.failed_tests))
     sys.exit(1)
   else:
     print '[ Success! ] Ran %d tests.' % len(s.tests)
 
 
 def Main(argv):
   """Main method to invoke in test harness programs.
   Args:
     argv: Command line options controlling what to run.
           See --help.
   NOTE: Ends the process with sys.exit(1) on failure.
   """
   parser = argparse.ArgumentParser(description=__doc__)
-  parser.add_argument(
-      'start_path', metavar='START_PATH',
-      help='location in which to run tests')
-  parser.add_argument(
-      '-x', '--xvfb', action='store_true',
-      help='Run Chrome thru xvfb on Linux.')
-  parser.add_argument(
-      '-a', '--arch', default='x86_64',
-      help='Chrome architecture: i686 / x86_64.')
-  parser.add_argument(
-      '-v', '--verbose', default=0, action='count',
-      help='Emit verbose output, use twice for more.')
-  parser.add_argument(
-      '-t', '--timeout', default=30, type=float,
-      help='Timeout for all tests (in seconds).')
-  parser.add_argument(
-      '-C', '--chdir', default=[], action='append',
-      help='Add a root directory.')
-  parser.add_argument(
-      '--load-extension', default=[], action='append',
-      help='Add an extension to load on start.')
-  parser.add_argument(
-      '--load-and-launch-app', default=[], action='append',
-      help='Add an app to load on start.')
-  parser.add_argument(
-      '--unlimited-storage', default=False, action='store_true',
-      help='Allow unlimited storage.')
-  parser.add_argument(
-      '--enable-nacl', default=False, action='store_true',
-      help='Enable NaCl generally.')
-  parser.add_argument(
-      '--enable-nacl-debug', default=False, action='store_true',
-      help='Enable NaCl debugging.')
-  parser.add_argument(
-      '-f', '--filter', default='*',
-      help='Filter on tests.')
+  parser.add_argument('start_path', metavar='START_PATH',
+                      help='location in which to run tests')
+  parser.add_argument('-x', '--xvfb', action='store_true',
+                      help='Run Chrome thru xvfb on Linux.')
+  parser.add_argument('-a', '--arch', default='x86_64',
+                      help='Chrome architecture: i686 / x86_64.')
+  parser.add_argument('-v', '--verbose', default=0, action='count',
+                      help='Emit verbose output, use twice for more.')
+  parser.add_argument('-t', '--timeout', default=30, type=float,
+                      help='Timeout for all tests (in seconds).')
+  parser.add_argument('-C', '--chdir', default=[], action='append',
+                      help='Add a root directory.')
+  parser.add_argument('--load-extension', default=[], action='append',
+                      help='Add an extension to load on start.')
+  parser.add_argument('--load-and-launch-app', default=[], action='append',
+                      help='Add an app to load on start.')
+  parser.add_argument('--unlimited-storage', default=False, action='store_true',
+                      help='Allow unlimited storage.')
+  parser.add_argument('--enable-nacl', default=False, action='store_true',
+                      help='Enable NaCl generally.')
+  parser.add_argument('--enable-nacl-debug', default=False, action='store_true',
+                      help='Enable NaCl debugging.')
+  parser.add_argument('-f', '--filter', default='*', help='Filter on tests.')
   parser.add_argument(
       '-p', '--param', default=[], action='append',
       help='Add a parameter to the end of the url, = separated.')
   options = parser.parse_args(argv)
 
   if options.param:
     params = {}
     params['SYS_ARCH'] = options.arch
     for param in options.param:
       key, value = param.split('=', 1)
       params[key] = value
     options.start_path += '?' + urllib.urlencode(params)
 
   if options.verbose > 1:
     logging.getLogger().setLevel(logging.DEBUG)
   elif options.verbose > 0:
     logging.getLogger().setLevel(logging.INFO)
   else:
     logging.getLogger().setLevel(logging.WARNING)
-  logging.basicConfig(
-      format='%(asctime)-15s %(levelname)s: %(message)s',
-      datefmt='%Y-%m-%d %H:%M:%S')
+  logging.basicConfig(format='%(asctime)-15s %(levelname)s: %(message)s',
+                      datefmt='%Y-%m-%d %H:%M:%S')
   if not options.chdir:
     options.chdir.append('.')
 
   if sys.platform.startswith('linux'):
     default_sandbox_locations = [
       '/usr/local/sbin/chrome-devel-sandbox',
       '/opt/chromium/chrome_sandbox',
       '/opt/google/chrome-beta/chrome-sandbox'
     ]
     if 'CHROME_DEVEL_SANDBOX' not in os.environ:
@@ skipping 16 matching lines @@
       filter_string=options.filter,
       roots=options.chdir,
       use_xvfb=options.xvfb,
       unlimited_storage=options.unlimited_storage,
       enable_nacl=options.enable_nacl,
       enable_nacl_debug=options.enable_nacl_debug,
       load_extensions=options.load_extension,
       load_apps=options.load_and_launch_app,
       start_path=options.start_path)
   sys.exit(0)