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

third_party/WebKit/Tools/Scripts/webkitpy/tool/commands/rebaseline.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 39 matching lines @@
 
 _log = logging.getLogger(__name__)
 
 
 # FIXME: Should TestResultWriter know how to compute this string?
 def _baseline_name(fs, test_name, suffix):
     return fs.splitext(test_name)[0] + TestResultWriter.FILENAME_SUFFIX_EXPECTED + "." + suffix
 
 
 class AbstractRebaseliningCommand(Command):
+
     """Base class for rebaseline-related commands."""
     # Not overriding execute() - pylint: disable=abstract-method
 
     no_optimize_option = optparse.make_option('--no-optimize', dest='optimize', action='store_false', default=True,
                                               help=('Do not optimize/de-dup the expectations after rebaselining (default is to de-dup automatically). '
                                                     'You can use "webkit-patch optimize-baselines" to optimize separately.'))
 
     platform_options = factory.platform_options(use_globs=True)
 
     results_directory_option = optparse.make_option("--results-directory", help="Local results directory to use.")
 
     suffixes_option = optparse.make_option("--suffixes", default=','.join(BASELINE_SUFFIX_LIST), action="store",
                                            help="Comma-separated-list of file types to rebaseline.")
 
     def __init__(self, options=None):
         super(AbstractRebaseliningCommand, self).__init__(options=options)
         self._baseline_suffix_list = BASELINE_SUFFIX_LIST
         self._scm_changes = {'add': [], 'delete': [], 'remove-lines': []}
 
     def _add_to_scm_later(self, path):
         self._scm_changes['add'].append(path)
 
     def _delete_from_scm_later(self, path):
         self._scm_changes['delete'].append(path)
 
 
 class BaseInternalRebaselineCommand(AbstractRebaseliningCommand):
+
     """Base class for rebaseline-related commands that are intended to be used by other commands."""
     # Not overriding execute() - pylint: disable=abstract-method
 
     def __init__(self):
         super(BaseInternalRebaselineCommand, self).__init__(options=[
             self.results_directory_option,
             self.suffixes_option,
             optparse.make_option("--builder", help="Builder to pull new baselines from."),
             optparse.make_option("--test", help="Test to rebaseline."),
         ])
@@ skipping 218 matching lines @@
         if not port_names:
             print "No port names match '%s'" % options.platform
             return
         self._port = tool.port_factory.get(port_names[0])
         self._baseline_optimizer = self._optimizer_class(tool, self._port, port_names, skip_scm_commands=False)
         for test_name in self._port.tests(args):
             self._analyze_baseline(options, test_name)
 
 
 class AbstractParallelRebaselineCommand(AbstractRebaseliningCommand):
+
     """Base class for rebaseline commands that do some tasks in parallel."""
     # Not overriding execute() - pylint: disable=abstract-method
 
     def __init__(self, options=None):
         super(AbstractParallelRebaselineCommand, self).__init__(options=options)
         self._builder_data = {}
 
     def builder_data(self):
         if not self._builder_data:
             for builder_name in self._release_builders():
@@ skipping 496 matching lines @@
             subprocess_command.append('--verbose')
         if options.auth_refresh_token_json:
             subprocess_command.append('--auth-refresh-token-json')
             subprocess_command.append(options.auth_refresh_token_json)
 
         process = self._tool.executive.popen(subprocess_command, stdout=self._tool.executive.PIPE,
                                              stderr=self._tool.executive.STDOUT)
         last_output_time = time.time()
 
         # git cl sometimes completely hangs. Bail if we haven't gotten any output to stdout/stderr in a while.
-        while process.poll() == None and time.time() < last_output_time + self.SECONDS_BEFORE_GIVING_UP:
+        while process.poll() is None and time.time() < last_output_time + self.SECONDS_BEFORE_GIVING_UP:
             # FIXME: This doesn't make any sense. readline blocks, so all this code to
             # try and bail is useless. Instead, we should do the readline calls on a
             # subthread. Then the rest of this code would make sense.
             out = process.stdout.readline().rstrip('\n')
             if out:
                 last_output_time = time.time()
                 _log.info(out)
 
-        if process.poll() == None:
+        if process.poll() is None:
             _log.error('Command hung: %s' % subprocess_command)
             return False
         return True
 
     # FIXME: Move this somewhere more general.
     def tree_status(self):
         blink_tree_status_url = "http://chromium-status.appspot.com/status"
         status = urllib2.urlopen(blink_tree_status_url).read().lower()
         if 'closed' in status or status == "0":
             return 'closed'
@@ skipping 80 matching lines @@
                     issue_already_closed = tool.executive.run_command(
                         ['git', 'config', 'branch.%s.rietveldissue' % rebaseline_branch_name],
                         return_exit_code=True)
                     if not issue_already_closed:
                         self._run_git_cl_command(options, ['set_close'])
 
                 tool.scm().ensure_cleanly_tracking_remote_master()
                 if old_branch_name_or_ref:
                     tool.scm().checkout_branch(old_branch_name_or_ref)
                 tool.scm().delete_branch(rebaseline_branch_name)