Remove Command.bind_to_tool.

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 46 matching lines @@
 
     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': []}
+        self._tool = None
 
     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)
 
     def _print_scm_changes(self):
         print(json.dumps(self._scm_changes))
 
@@ skipping 88 matching lines @@
             old_baseline = old_baselines[i]
             new_baseline = new_baselines[i]
 
             _log.debug("Copying baseline from %s to %s.", old_baseline, new_baseline)
             self._tool.filesystem.maybe_make_directory(self._tool.filesystem.dirname(new_baseline))
             self._tool.filesystem.copyfile(old_baseline, new_baseline)
             if not self._tool.scm().exists(new_baseline):
                 self._add_to_scm_later(new_baseline)
 
     def execute(self, options, args, tool):
+        self._tool = tool
         for suffix in options.suffixes.split(','):
             self._copy_existing_baseline(options.builder, options.test, suffix)
         self._print_scm_changes()
 
 
 class RebaselineTest(BaseInternalRebaselineCommand):
     name = "rebaseline-test-internal"
     help_text = "Rebaseline a single test from a buildbot. Only intended for use by other webkit-patch commands."
 
     def _save_baseline(self, data, target_baseline):
@@ skipping 30 matching lines @@
         if options.results_directory:
             results_url = 'file://' + options.results_directory
         else:
             results_url = self._tool.buildbot.results_url(options.builder, build_number=options.build_number)
 
         for suffix in self._baseline_suffix_list:
             self._rebaseline_test(options.builder, options.test, suffix, results_url)
         self._scm_changes['remove-lines'].append({'builder': options.builder, 'test': options.test})
 
     def execute(self, options, args, tool):
+        self._tool = tool
         self._rebaseline_test_and_update_expectations(options)
         self._print_scm_changes()
 
 
 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)
@@ skipping 292 matching lines @@
     name = "rebaseline-json"
     help_text = "Rebaseline based off JSON passed to stdin. Intended to only be called from other scripts."
 
     def __init__(self,):
         super(RebaselineJson, self).__init__(options=[
             self.no_optimize_option,
             self.results_directory_option,
         ])
 
     def execute(self, options, args, tool):
+        self._tool = tool
         self._rebaseline(options, json.loads(sys.stdin.read()))
 
 
 class RebaselineExpectations(AbstractParallelRebaselineCommand):
     name = "rebaseline-expectations"
     help_text = "Rebaselines the tests indicated in TestExpectations."
     show_in_main_help = True
 
     def __init__(self):
         super(RebaselineExpectations, self).__init__(options=[
@@ skipping 20 matching lines @@
         if tests:
             _log.info("Retrieving results for %s from %s.", port_name, builder_name)
 
         for test_name, suffixes in tests:
             _log.info("    %s (%s)", test_name, ','.join(suffixes))
             if test_name not in self._test_prefix_list:
                 self._test_prefix_list[test_name] = {}
             self._test_prefix_list[test_name][Build(builder_name)] = suffixes
 
     def execute(self, options, args, tool):
+        self._tool = tool
         options.results_directory = None
         self._test_prefix_list = {}
         port_names = tool.port_factory.all_port_names(options.platform)
         for port_name in port_names:
             self._add_tests_to_rebaseline(port_name)
         if not self._test_prefix_list:
             _log.warning("Did not find any tests marked Rebaseline.")
             return
 
         self._rebaseline(options, self._test_prefix_list)
@@ skipping 14 matching lines @@
             optparse.make_option("--builders", default=None, action="append",
                                  help=("Comma-separated-list of builders to pull new baselines from "
                                        "(can also be provided multiple times).")),
         ])
 
     def _builders_to_pull_from(self):
         return self._tool.user.prompt_with_list(
             "Which builder to pull results from:", self._release_builders(), can_choose_multiple=True)
 
     def execute(self, options, args, tool):
+        self._tool = tool
         if not args:
             _log.error("Must list tests to rebaseline.")
             return
 
         if options.builders:
             builders_to_check = []
             for builder_names in options.builders:
                 builders_to_check += builder_names.split(",")
         else:
             builders_to_check = self._builders_to_pull_from()
 
         test_prefix_list = {}
         suffixes_to_update = options.suffixes.split(",")
 
         for builder in builders_to_check:
             for test in args:
                 if test not in test_prefix_list:
                     test_prefix_list[test] = {}
                 build = Build(builder)
                 test_prefix_list[test][build] = suffixes_to_update
 
         if options.verbose:
             _log.debug("rebaseline-json: " + str(test_prefix_list))
 
         self._rebaseline(options, test_prefix_list)