Rename WebKitFinder -> BlinkFinder.

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 30 matching lines @@
 import operator
 import optparse
 import re
 import sys
 
 from webkitpy.common import find_files
 from webkitpy.common import read_checksum_from_png
 from webkitpy.common.memoized import memoized
 from webkitpy.common.system.executive import ScriptError
 from webkitpy.common.system.path import cygpath, abspath_to_uri
-from webkitpy.common.webkit_finder import WebKitFinder
+from webkitpy.common.blink_finder import BlinkFinder
 from webkitpy.layout_tests.layout_package.bot_test_expectations import BotTestExpectationsFactory
 from webkitpy.layout_tests.models import test_run_results
 from webkitpy.layout_tests.models.test_configuration import TestConfiguration
 from webkitpy.layout_tests.models.test_expectations import SKIP
 from webkitpy.layout_tests.port import driver
 from webkitpy.layout_tests.port import server_process
 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
@@ skipping 103 matching lines @@
         self._architecture = 'x86'
 
         # FIXME: Ideally we'd have a package-wide way to get a
         # well-formed options object that had all of the necessary
         # options defined on it.
         self._options = options or optparse.Values()
 
         self.host = host
         self._executive = host.executive
         self._filesystem = host.filesystem
-        self._webkit_finder = WebKitFinder(host.filesystem)
+        self._blink_finder = BlinkFinder(host.filesystem)
 
         self._http_server = None
         self._websocket_server = None
         self._is_wptserve_enabled = getattr(options, 'enable_wptserve', False)
         self._wpt_server = None
         self._image_differ = None
         self._server_process_constructor = server_process.ServerProcess  # overridable for testing
         self._http_lock = None  # FIXME: Why does this live on the port object?
         self._dump_reader = None
 
         # Python's Popen has a bug that causes any pipes opened to a
         # process that can't be executed to be leaked.  Since this
         # code is specifically designed to tolerate exec failures
         # to gracefully handle cases where wdiff is not installed,
         # the bug results in a massive file descriptor leak. As a
         # workaround, if an exec failure is ever experienced for
         # wdiff, assume it's not available.  This will leak one
         # file descriptor but that's better than leaking each time
         # wdiff would be run.
         #
         # http://mail.python.org/pipermail/python-list/
         #    2008-August/505753.html
         # http://bugs.python.org/issue3210
         self._wdiff_available = None
 
         # FIXME: prettypatch.py knows this path, why is it copied here?
-        self._pretty_patch_path = self.path_from_webkit_base("Tools", "Scripts", "webkitruby", "PrettyPatch", "prettify.rb")
+        self._pretty_patch_path = self.path_from_blink_base("Tools", "Scripts", "webkitruby", "PrettyPatch", "prettify.rb")
         self._pretty_patch_available = None
 
         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
@@ skipping 727 matching lines @@
 
         Args:
             baseline_path: the actual path to use for baseline, not the path to
               the test. This function is used to update either generic or
               platform-specific baselines, but we can't infer which here.
             data: contents of the baseline.
         """
         self._filesystem.write_binary_file(baseline_path, data)
 
     # FIXME: update callers to create a finder and call it instead of these next five routines (which should be protected).
-    def webkit_base(self):
-        return self._webkit_finder.webkit_base()
+    def blink_base(self):
+        return self._blink_finder.blink_base()
 
-    def path_from_webkit_base(self, *comps):
-        return self._webkit_finder.path_from_webkit_base(*comps)
+    def path_from_blink_base(self, *comps):
+        return self._blink_finder.path_from_blink_base(*comps)
 
     def path_from_chromium_base(self, *comps):
-        return self._webkit_finder.path_from_chromium_base(*comps)
+        return self._blink_finder.path_from_chromium_base(*comps)
 
     def path_to_script(self, script_name):
-        return self._webkit_finder.path_to_script(script_name)
+        return self._blink_finder.path_to_script(script_name)
 
     def layout_tests_dir(self):
         custom_layout_tests_dir = self.get_option('layout_tests_directory')
         if custom_layout_tests_dir:
             return custom_layout_tests_dir
-        return self._webkit_finder.layout_tests_dir()
+        return self._blink_finder.layout_tests_dir()
 
     def perf_tests_dir(self):
-        return self._webkit_finder.perf_tests_dir()
+        return self._blink_finder.perf_tests_dir()
 
     def skipped_layout_tests(self, test_list):
         """Returns tests skipped outside of the TestExpectations files."""
         return set(self._skipped_tests_for_unsupported_features(test_list))
 
     def skips_test(self, test, generic_expectations, full_expectations):
         """Checks whether the given test is skipped for this port.
 
         This should return True if the test is skipped because the port
         runs smoke tests only, or because the test is skipped in a file like
@@ skipping 113 matching lines @@
     def bot_test_times_path(self):
         return self._build_path('webkit_test_times', 'bot_times_ms.json')
 
     def perf_results_directory(self):
         return self._build_path()
 
     def inspector_build_directory(self):
         return self._build_path('resources', 'inspector')
 
     def inspector_debug_directory(self):
-        return self.path_from_webkit_base('Source', 'devtools', 'front_end')
+        return self.path_from_blink_base('Source', 'devtools', 'front_end')
 
     def apache_config_directory(self):
-        return self.path_from_webkit_base('Tools', 'Scripts', 'apache_config')
+        return self.path_from_blink_base('Tools', 'Scripts', 'apache_config')
 
     def default_results_directory(self):
         """Absolute path to the default place to store the test results."""
         return self._build_path('layout-test-results')
 
     def setup_test_run(self):
         """Perform port-specific work at the beginning of a test run."""
         # Delete the disk cache if any to ensure a clean test run.
         dump_render_tree_binary_path = self._path_to_driver()
         cachedir = self._filesystem.dirname(dump_render_tree_binary_path)
@@ skipping 693 matching lines @@
         # This will fail if we don't have both a debug and release binary.
         # That's fine because, in this case, we must already be running the
         # most up-to-date one.
         except OSError:
             pass
         return True
 
     def _chromium_baseline_path(self, platform):
         if platform is None:
             platform = self.name()
-        return self.path_from_webkit_base('LayoutTests', 'platform', platform)
+        return self.path_from_blink_base('LayoutTests', 'platform', platform)
 
 
 class VirtualTestSuite(object):
 
     def __init__(self, prefix=None, base=None, args=None, references_use_default_args=False):
         assert base
         assert args
         assert '/' not in prefix, "Virtual test suites prefixes cannot contain /'s: %s" % prefix
         self.name = 'virtual/' + prefix + '/' + base
         self.base = base
         self.args = args
         self.reference_args = [] if references_use_default_args else args
         self.tests = {}
 
     def __repr__(self):
         return "VirtualTestSuite('%s', '%s', %s, %s)" % (self.name, self.base, self.args, self.reference_args)
 
 
 class PhysicalTestSuite(object):
 
     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)