Replace webkitpy standalone builders functions with instantiable class.

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 26 matching lines @@
 import traceback
 import urllib
 import urllib2
 
 from webkitpy.common.checkout.baselineoptimizer import BaselineOptimizer
 from webkitpy.common.memoized import memoized
 from webkitpy.common.system.executive import ScriptError
 from webkitpy.layout_tests.controllers.test_result_writer import TestResultWriter
 from webkitpy.layout_tests.models import test_failures
 from webkitpy.layout_tests.models.test_expectations import TestExpectations, BASELINE_SUFFIX_LIST, SKIP
-from webkitpy.layout_tests.port import builders
 from webkitpy.layout_tests.port import factory
+from webkitpy.layout_tests.builders import Builders
 from webkitpy.tool.multicommandtool import AbstractDeclarativeCommand
 
 
 _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
 
@@ skipping 37 matching lines @@
     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"),
         ])
 
     def _baseline_directory(self, builder_name):
         port = self._tool.port_factory.get_from_builder_name(builder_name)
-        override_dir = builders.rebaseline_override_dir(builder_name)
+        override_dir = self._tool.builders.rebaseline_override_dir(builder_name)
         if override_dir:
             return self._tool.filesystem.join(port.layout_tests_dir(), 'platform', override_dir)
         return port.baseline_version_dir()
 
     def _test_root(self, test_name):
         return self._tool.filesystem.splitext(test_name)[0]
 
     def _file_name_for_actual_result(self, test_name, suffix):
         return "%s-actual.%s" % (self._test_root(test_name), suffix)
 
@@ skipping 221 matching lines @@
                 builder_results = builder.latest_layout_test_results()
                 if builder_results:
                     self._builder_data[builder_name] = builder_results
                 else:
                     raise Exception("No result for builder %s." % builder_name)
         return self._builder_data
 
     # The release builders cycle much faster than the debug ones and cover all the platforms.
     def _release_builders(self):
         release_builders = []
-        for builder_name in builders.all_builder_names():
+        for builder_name in self._tool.builders.all_builder_names():
             if builder_name.find('ASAN') != -1:
                 continue
             port = self._tool.port_factory.get_from_builder_name(builder_name)
             if port.test_configuration().build_type == 'release':
                 release_builders.append(builder_name)
         return release_builders
 
     def _run_webkit_patch(self, args, verbose):
         try:
             verbose_args = ['--verbose'] if verbose else []
@@ skipping 234 matching lines @@
     def _tests_to_rebaseline(self, port):
         tests_to_rebaseline = {}
         for path, value in port.expectations_dict().items():
             expectations = TestExpectations(port, include_overrides=False, expectations_dict={path: value})
             for test in expectations.get_rebaselining_failures():
                 suffixes = TestExpectations.suffixes_for_expectations(expectations.get_expectations(test))
                 tests_to_rebaseline[test] = suffixes or BASELINE_SUFFIX_LIST
         return tests_to_rebaseline
 
     def _add_tests_to_rebaseline_for_port(self, port_name):
-        builder_name = builders.builder_name_for_port_name(port_name)
+        builder_name = self._tool.builders.builder_name_for_port_name(port_name)
         if not builder_name:
             return
         tests = self._tests_to_rebaseline(self._tool.port_factory.get(port_name)).items()
 
         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:
@@ skipping 185 matching lines @@
 %s
 
 %sTBR=%s
 """ % (revision, self.link_to_patch(commit), bug_string, author)
 
     def get_test_prefix_list(self, tests):
         test_prefix_list = {}
         lines_to_remove = {}
 
         for builder_name in self._release_builders():
-            port_name = builders.port_name_for_builder_name(builder_name)
+            port_name = self._tool.builders.port_name_for_builder_name(builder_name)
             port = self._tool.port_factory.get(port_name)
             expectations = TestExpectations(port, include_overrides=True)
             for test in expectations.get_needs_rebaseline_failures():
                 if test not in tests:
                     continue
 
                 if test not in test_prefix_list:
                     lines_to_remove[test] = []
                     test_prefix_list[test] = {}
                 lines_to_remove[test].append(builder_name)
@@ skipping 200 matching lines @@
                 self._tool.scm().checkout_branch(old_branch_name_or_ref)
         else:
             self._log_queue.put(self.QUIT_LOG)
         log_thread.join()
 
     def execute(self, options, args, tool):
         self._verbose = options.verbose
         while True:
             self._do_one_rebaseline()
             time.sleep(self.SLEEP_TIME_IN_SECONDS)