Run format-webkit on webkitpy code (without string conversion).

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/port/base.py

 # Copyright (C) 2010 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 22 matching lines @@
 import difflib
 import errno
 import itertools
 import json
 import logging
 import os
 import operator
 import optparse
 import re
 import sys
+from functools import reduce
 
 try:
     from collections import OrderedDict
 except ImportError:
     # Needed for Python < 2.7
     from webkitpy.thirdparty.ordered_dict import OrderedDict
 
 
 from webkitpy.common import find_files
 from webkitpy.common import read_checksum_from_png
@@ skipping 12 matching lines @@
 from webkitpy.layout_tests.port.factory import PortFactory
 from webkitpy.layout_tests.servers import apache_http
 from webkitpy.layout_tests.servers import pywebsocket
 from webkitpy.layout_tests.servers import wptserve
 
 _log = logging.getLogger(__name__)
 
 
 # FIXME: This class should merge with WebKitPort now that Chromium behaves mostly like other webkit ports.
 class Port(object):
+
     """Abstract class for Port-specific hooks for the layout_test package."""
 
     # Subclasses override this. This should indicate the basic implementation
     # part of the port name, e.g., 'mac', 'win', 'gtk'; there is probably (?)
     # one unique value per class.
 
     # FIXME: We should probably rename this to something like 'implementation_name'.
     port_name = None
 
     # Test names resemble unix relative paths, and use '/' as a directory separator.
@@ skipping 125 matching lines @@
         if not hasattr(options, 'configuration') or not options.configuration:
             self.set_option_default('configuration', self.default_configuration())
         if not hasattr(options, 'target') or not options.target:
             self.set_option_default('target', self._options.configuration)
         self._test_configuration = None
         self._reftest_list = {}
         self._results_directory = None
         self._virtual_test_suites = None
 
     def __str__(self):
-        return "Port{name=%s, version=%s, architecture=%s, test_configuration=%s}" % (self._name, self._version, self._architecture, self._test_configuration)
+        return "Port{name=%s, version=%s, architecture=%s, test_configuration=%s}" % (
+            self._name, self._version, self._architecture, self._test_configuration)
 
     def buildbot_archives_baselines(self):
         return True
 
     def additional_driver_flag(self):
         if self.driver_name() == self.CONTENT_SHELL_NAME:
             return ['--run-layout-test']
         return []
 
     def supports_per_test_timeout(self):
@@ skipping 183 matching lines @@
         image_diff_path = self._path_to_image_diff()
         if not self._filesystem.exists(image_diff_path):
             _log.error("image_diff was not found at %s" % image_diff_path)
             return False
         return True
 
     def check_pretty_patch(self, logging=True):
         """Checks whether we can use the PrettyPatch ruby script."""
         try:
             _ = self._executive.run_command(['ruby', '--version'])
-        except OSError, e:
+        except OSError as e:
             if e.errno in [errno.ENOENT, errno.EACCES, errno.ECHILD]:
                 if logging:
                     _log.warning("Ruby is not installed; can't generate pretty patches.")
                     _log.warning('')
                 return False
 
         if not self._filesystem.exists(self._pretty_patch_path):
             if logging:
                 _log.warning("Unable to find %s; can't generate pretty patches." % self._pretty_patch_path)
                 _log.warning('')
@@ skipping 79 matching lines @@
         err_str = None
         try:
             exit_code = self._executive.run_command(command, return_exit_code=True)
             if exit_code == 0:
                 # The images are the same.
                 result = None
             elif exit_code == 1:
                 result = self._filesystem.read_binary_file(native_diff_filename)
             else:
                 err_str = "Image diff returned an exit code of %s. See http://crbug.com/278596" % exit_code
-        except OSError, e:
+        except OSError as e:
             err_str = 'error running image diff: %s' % str(e)
         finally:
             self._filesystem.rmtree(str(tempdir))
 
         return (result, err_str or None)
 
     def diff_text(self, expected_text, actual_text, expected_filename, actual_filename):
         """Returns a string containing the diff of the two text strings
         in 'unified diff' format."""
 
@@ skipping 244 matching lines @@
         return False
 
     @staticmethod
     def _has_supported_extension(filesystem, filename):
         """Return true if filename is one of the file extensions we want to run a test on."""
         extension = filesystem.splitext(filename)[1]
         return extension in Port._supported_file_extensions
 
     @staticmethod
     def is_test_file(filesystem, dirname, filename):
-        return Port._has_supported_extension(filesystem, filename) and not Port.is_reference_html_file(filesystem, dirname, filename)
+        return Port._has_supported_extension(
+            filesystem, filename) and not Port.is_reference_html_file(filesystem, dirname, filename)
 
     ALL_TEST_TYPES = ['audio', 'harness', 'pixel', 'ref', 'text', 'unknown']
 
     def test_type(self, test_name):
         fs = self._filesystem
         if fs.exists(self.expected_filename(test_name, '.png')):
             return 'pixel'
         if fs.exists(self.expected_filename(test_name, '.wav')):
             return 'audio'
         if self.reference_files(test_name):
@@ skipping 398 matching lines @@
     def stop_helper(self):
         """Shut down the test helper if it is running. Do nothing if
         it isn't, or it isn't available. If a port overrides start_helper()
         it must override this routine as well."""
         if self._helper:
             _log.debug("Stopping layout test helper")
             try:
                 self._helper.stdin.write("x\n")
                 self._helper.stdin.close()
                 self._helper.wait()
-            except IOError, e:
+            except IOError as e:
                 pass
             finally:
                 self._helper = None
 
     def stop_http_server(self):
         """Shut down the http server if it is running. Do nothing if it isn't."""
         if self._http_server:
             self._http_server.stop()
             self._http_server = None
 
@@ skipping 182 matching lines @@
         if self._pretty_patch_available is None:
             self._pretty_patch_available = self.check_pretty_patch(logging=False)
         if not self._pretty_patch_available:
             return self._pretty_patch_error_html
         command = ("ruby", "-I", self._filesystem.dirname(self._pretty_patch_path),
                    self._pretty_patch_path, diff_path)
         try:
             # Diffs are treated as binary (we pass decode_output=False) as they
             # may contain multiple files of conflicting encodings.
             return self._executive.run_command(command, decode_output=False)
-        except OSError, e:
+        except OSError as e:
             # If the system is missing ruby log the error and stop trying.
             self._pretty_patch_available = False
             _log.error("Failed to run PrettyPatch (%s): %s" % (command, e))
             return self._pretty_patch_error_html
-        except ScriptError, e:
+        except ScriptError as e:
             # If ruby failed to run for some reason, log the command
             # output and stop trying.
             self._pretty_patch_available = False
             _log.error("Failed to run PrettyPatch (%s):\n%s" % (command, e.message_with_output()))
             return self._pretty_patch_error_html
 
     def default_configuration(self):
         return self._config.default_configuration()
 
     def clobber_old_port_specific_results(self):
@@ skipping 237 matching lines @@
         path = self._path_to_webcore_library()
         if path:
             return [path]
         return []
 
     def _symbols_string(self):
         symbols = ''
         for path_to_module in self._modules_to_search_for_symbols():
             try:
                 symbols += self._executive.run_command(['nm', path_to_module], error_handler=self._executive.ignore_error)
-            except OSError, e:
+            except OSError as e:
                 _log.warn("Failed to run nm: %s.  Can't determine supported features correctly." % e)
         return symbols
 
     # Ports which use compile-time feature detection should define this method and return
     # a dictionary mapping from symbol substrings to possibly disabled test directories.
     # When the symbol substrings are not matched, the directories will be skipped.
     # If ports don't ever enable certain features, then those directories can just be
     # in the Skipped list instead of compile-time-checked here.
     def _missing_symbol_to_skipped_tests(self):
         if self.PORT_HAS_AUDIO_CODECS_BUILT_IN:
@@ skipping 15 matching lines @@
         return False
 
     def _skipped_tests_for_unsupported_features(self, test_list):
         # Only check the symbols of there are tests in the test_list that might get skipped.
         # This is a performance optimization to avoid the calling nm.
         # Runtime feature detection not supported, fallback to static detection:
         # Disable any tests for symbols missing from the executable or libraries.
         if self._has_test_in_directories(self._missing_symbol_to_skipped_tests().values(), test_list):
             symbols_string = self._symbols_string()
             if symbols_string is not None:
-                return reduce(operator.add, [directories for symbol_substring, directories in self._missing_symbol_to_skipped_tests().items() if symbol_substring not in symbols_string], [])
+                return reduce(operator.add, [directories for symbol_substring, directories in self._missing_symbol_to_skipped_tests(
+                ).items() if symbol_substring not in symbols_string], [])
         return []
 
     def _convert_path(self, path):
         """Handles filename conversion for subprocess command line args."""
         # See note above in diff_image() for why we need this.
         if sys.platform == 'cygwin':
             return cygpath(path)
         return path
 
     def _build_path(self, *comps):
@@ skipping 61 matching lines @@
 
     def __init__(self, base, args, reference_args=None):
         self.name = base
         self.base = base
         self.args = args
         self.reference_args = args if reference_args is None else reference_args
         self.tests = set()
 
     def __repr__(self):
         return "PhysicalTestSuite('%s', '%s', %s, %s)" % (self.name, self.base, self.args, self.reference_args)