Run auto-formatter (autopep8) on webkitpy.

third_party/WebKit/Tools/Scripts/webkitpy/performance_tests/perftest.py

 # Copyright (C) 2012 Google Inc. All rights reserved.
 # Copyright (C) 2012 Zoltan Horvath, Adobe Systems Incorporated. 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
@@ skipping 31 matching lines @@
 from webkitpy.layout_tests.controllers.test_result_writer import TestResultWriter
 from webkitpy.layout_tests.port.driver import DriverInput
 from webkitpy.layout_tests.port.driver import DriverOutput
 
 DEFAULT_TEST_RUNNER_COUNT = 4
 
 _log = logging.getLogger(__name__)
 
 
 class PerfTestMetric(object):
+
     def __init__(self, metric, unit=None, iterations=None):
         # FIXME: Fix runner.js to report correct metric names
         self._iterations = iterations or []
         self._unit = unit or self.metric_to_unit(metric)
         self._metric = self.time_unit_to_metric(self._unit) if metric == 'Time' else metric
 
     def name(self):
         return self._metric
 
     def has_values(self):
@@ skipping 64 matching lines @@
         if should_log and self._description:
             _log.info('DESCRIPTION: %s' % self._description)
 
         results = {}
         for metric_name in self._ordered_metrics_name:
             metric = self._metrics[metric_name]
             results[metric.name()] = metric.grouped_iteration_values()
             if should_log:
                 legacy_chromium_bot_compatible_name = self.test_name_without_file_extension().replace('/', ': ')
                 self.log_statistics(legacy_chromium_bot_compatible_name + ': ' + metric.name(),
-                    metric.flattened_iteration_values(), metric.unit())
+                                    metric.flattened_iteration_values(), metric.unit())
 
         return results
 
     @staticmethod
     def log_statistics(test_name, values, unit):
         sorted_values = sorted(values)
 
         # Compute the mean and variance using Knuth's online algorithm (has good numerical stability).
         square_sum = 0
         mean = 0
         for i, time in enumerate(sorted_values):
             delta = time - mean
             sweep = i + 1.0
             mean += delta / sweep
             square_sum += delta * (time - mean)
 
         middle = int(len(sorted_values) / 2)
         mean = sum(sorted_values) / len(values)
         median = sorted_values[middle] if len(sorted_values) % 2 else (sorted_values[middle - 1] + sorted_values[middle]) / 2
         stdev = math.sqrt(square_sum / (len(sorted_values) - 1)) if len(sorted_values) > 1 else 0
 
         _log.info('RESULT %s= %s %s' % (test_name, mean, unit))
         _log.info('median= %s %s, stdev= %s %s, min= %s %s, max= %s %s' %
-            (median, unit, stdev, unit, sorted_values[0], unit, sorted_values[-1], unit))
+                  (median, unit, stdev, unit, sorted_values[0], unit, sorted_values[-1], unit))
 
     _description_regex = re.compile(r'^Description: (?P<description>.*)$', re.IGNORECASE)
     _metrics_regex = re.compile(r'^(?P<metric>Time|Malloc|JS Heap):')
     _statistics_keys = ['avg', 'median', 'stdev', 'min', 'max', 'unit', 'values']
     _score_regex = re.compile(r'^(?P<key>' + r'|'.join(_statistics_keys) + r')\s+(?P<value>([0-9\.]+(,\s+)?)+)\s*(?P<unit>.*)')
     _console_regex = re.compile(r'^CONSOLE (MESSAGE|WARNING):')
 
     def _run_with_driver(self, driver, time_out_ms):
         output = self.run_single(driver, self.test_path(), time_out_ms)
         self._filter_output(output)
@@ skipping 73 matching lines @@
         re.compile(r'^\s*Running \d+ times$'),
         re.compile(r'^\s*Ignoring warm-up '),
         re.compile(r'^\s*Info:'),
         re.compile(r'^\s*\d+(.\d+)?(\s*(runs\/s|ms|fps))?$'),
         # Following are for handle existing test like Dromaeo
         re.compile(re.escape("""main frame - has 1 onunload handler(s)""")),
         re.compile(re.escape("""frame "<!--framePath //<!--frame0-->-->" - has 1 onunload handler(s)""")),
         re.compile(re.escape("""frame "<!--framePath //<!--frame0-->/<!--frame0-->-->" - has 1 onunload handler(s)""")),
         # Following is for html5.html
         re.compile(re.escape("""Blocked access to external URL http://www.whatwg.org/specs/web-apps/current-work/""")),
-        re.compile(r"CONSOLE MESSAGE: (line \d+: )?Blocked script execution in '[A-Za-z0-9\-\.:]+' because the document's frame is sandboxed and the 'allow-scripts' permission is not set."),
+        re.compile(
+            r"CONSOLE MESSAGE: (line \d+: )?Blocked script execution in '[A-Za-z0-9\-\.:]+' because the document's frame is sandboxed and the 'allow-scripts' permission is not set."),
         re.compile(r"CONSOLE MESSAGE: (line \d+: )?Not allowed to load local resource"),
         # Dromaeo reports values for subtests. Ignore them for now.
         re.compile(r'(?P<name>.+): \[(?P<values>(\d+(.\d+)?,\s+)*\d+(.\d+)?)\]'),
     ]
 
     def _filter_output(self, output):
         if output.error:
-            output.error = '\n'.join([line for line in re.split('\n', output.error) if not self._should_ignore_line(self._lines_to_ignore_in_stderr, line)])
+            output.error = '\n'.join([line for line in re.split('\n', output.error)
+                                      if not self._should_ignore_line(self._lines_to_ignore_in_stderr, line)])
         if output.text:
-            output.text = '\n'.join([line for line in re.split('\n', output.text) if not self._should_ignore_line(self._lines_to_ignore_in_parser_result, line)])
+            output.text = '\n'.join([line for line in re.split('\n', output.text)
+                                     if not self._should_ignore_line(self._lines_to_ignore_in_parser_result, line)])
 
 
 class SingleProcessPerfTest(PerfTest):
+
     def __init__(self, port, test_name, test_path, test_runner_count=1):
         super(SingleProcessPerfTest, self).__init__(port, test_name, test_path, test_runner_count)
 
 
 class ChromiumStylePerfTest(PerfTest):
     _chromium_style_result_regex = re.compile(r'^RESULT\s+(?P<name>[^=]+)\s*=\s+(?P<value>\d+(\.\d+)?)\s*(?P<unit>\w+)$')
 
     def __init__(self, port, test_name, test_path, test_runner_count=DEFAULT_TEST_RUNNER_COUNT):
         super(ChromiumStylePerfTest, self).__init__(port, test_name, test_path, test_runner_count)
 
@@ skipping 31 matching lines @@
         (re.compile(r'^Dromaeo/'), SingleProcessPerfTest),
         (re.compile(r'^inspector/'), ChromiumStylePerfTest),
     ]
 
     @classmethod
     def create_perf_test(cls, port, test_name, path, test_runner_count=DEFAULT_TEST_RUNNER_COUNT):
         for (pattern, test_class) in cls._pattern_map:
             if pattern.match(test_name):
                 return test_class(port, test_name, path, test_runner_count)
         return PerfTest(port, test_name, path, test_runner_count)