Attachment 121529 Details for Bug 75764 – Patch

[patch] Patch

bug-75764-20120106181429.patch (text/plain), 119.13 KB, created by Dirk Pranke on 2012-01-06 18:14:31 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Dirk Pranke

Created: 2012-01-06 18:14:31 PST

Size: 119.13 KB

patch

obsolete

>Subversion Revision: 104341
>diff --git a/Tools/ChangeLog b/Tools/ChangeLog
>index 1bae16b06f1cb6f9cbc8dfa354c67d6de3c36925..79479cd1e2c0e5aa6060892fd27f312ea2fe439e 100644
>--- a/Tools/ChangeLog
>+++ b/Tools/ChangeLog
>@@ -1,3 +1,222 @@
>+2012-01-06  Dirk Pranke  <dpranke@chromium.org>
>+
>+        webkitpy: clean up version handling logic in port constructors
>+        https://bugs.webkit.org/show_bug.cgi?id=75764
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        This change cleans up a lot of the version parsing logic in the
>+        layout_tests.port classes.
>+
>+        We add two new 'os_name' and 'os_version' properties to the
>+        platforminfo object that will use generic/sanitized names, and
>+        then adds a static determine_port_name() method to each port
>+        class that will take a (possibly partially-specified) port name,
>+        a host object, and an options object, and return a
>+        fully-specified port name.
>+
>+        The port constructors themselves are then changed to require
>+        fully specified port names.
>+
>+        There's a lot of other clean up and mess in the current version
>+        of this patch, but all the unit tests pass. NOT FOR LANDING!
>+
>+        * Scripts/webkitpy/common/system/platforminfo.py:
>+        (PlatformInfo.__init__):
>+        (PlatformInfo):
>+        (PlatformInfo._determine_os_name):
>+        (PlatformInfo._determine_mac_version):
>+        (PlatformInfo._determine_linux_version):
>+        (PlatformInfo._determine_win_version):
>+        * Scripts/webkitpy/common/system/platforminfo_mock.py:
>+        (MockPlatformInfo.__init__):
>+        * Scripts/webkitpy/common/system/systemhost.py:
>+        (SystemHost.__init__):
>+        * Scripts/webkitpy/layout_tests/port/apple.py:
>+        (ApplePort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/base.py:
>+        (Port):
>+        (Port._operating_system_for_platform):
>+        (Port.determine_port_name):
>+        (Port.__init__):
>+        * Scripts/webkitpy/layout_tests/port/base_unittest.py:
>+        (PortTest.make_port):
>+        (PortTest):
>+        (PortTest.make_test_port):
>+        (PortTest.test_pretty_patch_os_error):
>+        (PortTest.test_pretty_patch_script_error):
>+        (PortTest.test_get_option__default):
>+        (PortTest.test_additional_platform_directory):
>+        (PortTest.test_uses_test_expectations_file):
>+        (PortTest.test_find_no_paths_specified):
>+        (PortTest.test_find_one_test):
>+        (PortTest.test_find_glob):
>+        (PortTest.test_find_with_skipped_directories):
>+        (PortTest.test_find_with_skipped_directories_2):
>+        (PortTest.test_parse_reftest_list):
>+        (VirtualTest.test_virtual_methods):
>+        (VirtualTest.test_virtual_driver_methods):
>+        (DriverTest._assert_wrapper):
>+        * Scripts/webkitpy/layout_tests/port/chromium.py:
>+        (ChromiumPort.for):
>+        (ChromiumPort.__init__):
>+        (ChromiumPort):
>+        (ChromiumPort._chromium_base_dir):
>+        (ChromiumPort.path_from_chromium_base):
>+        * Scripts/webkitpy/layout_tests/port/chromium_gpu_unittest.py:
>+        (ChromiumGpuTest.assert_port_works):
>+        (ChromiumGpuTest._assert_baseline_path):
>+        (ChromiumGpuTest.test_graphics_type):
>+        (ChromiumGpuTest.test_default_tests_paths):
>+        (ChromiumGpuTest.test_default_tests_paths.test_paths):
>+        (ChromiumGpuTest.test_test_files):
>+        (ChromiumGpuTest.test_test_files.test_paths):
>+        (ChromiumGpuTest):
>+        * Scripts/webkitpy/layout_tests/port/chromium_linux.py:
>+        (ChromiumLinuxPort):
>+        (ChromiumLinuxPort.determine_port_name):
>+        (ChromiumLinuxPort._determine_driver_path_statically):
>+        (ChromiumLinuxPort._static_build_path):
>+        (ChromiumLinuxPort._determine_architecture):
>+        (ChromiumLinuxPort.__init__):
>+        (ChromiumLinuxPort._build_path):
>+        * Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py:
>+        (ChromiumLinuxPortTest):
>+        (ChromiumLinuxPortTest.assert_architecture):
>+        (ChromiumLinuxPortTest.test_check_illegal_port_names):
>+        (ChromiumLinuxPortTest.test_determine_architecture_fails):
>+        * Scripts/webkitpy/layout_tests/port/chromium_mac.py:
>+        (ChromiumMacPort):
>+        (ChromiumMacPort.determine_port_name):
>+        (ChromiumMacPort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py:
>+        (ChromiumMacPortTest):
>+        (ChromiumMacPortTest.assert_name):
>+        (ChromiumMacPortTest.test_versions):
>+        * Scripts/webkitpy/layout_tests/port/chromium_unittest.py:
>+        (ChromiumPortTest.test_all_test_configurations):
>+        (ChromiumPortTest.TestMacPort.__init__):
>+        (ChromiumPortTest.TestLinuxPort.__init__):
>+        (ChromiumPortTest.TestWinPort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/chromium_win.py:
>+        (os_version):
>+        (ChromiumWinPort):
>+        (ChromiumWinPort.determine_port_name):
>+        (ChromiumWinPort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py:
>+        (ChromiumWinTest):
>+        (ChromiumWinTest.assert_name):
>+        (ChromiumWinTest.test_versions):
>+        (ChromiumWinTest.test_baseline_path):
>+        (ChromiumWinTest.test_build_path):
>+        * Scripts/webkitpy/layout_tests/port/driver_unittest.py:
>+        (DriverTest.make_port):
>+        (DriverTest._assert_wrapper):
>+        * Scripts/webkitpy/layout_tests/port/dryrun.py:
>+        (DryRunPort):
>+        (DryRunPort.determine_port_name):
>+        (DryRunPort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/efl.py:
>+        (EflPort):
>+        * Scripts/webkitpy/layout_tests/port/factory.py:
>+        (PortFactory._port_name_from_arguments_and_options):
>+        (PortFactory):
>+        (PortFactory.get):
>+        * Scripts/webkitpy/layout_tests/port/factory_unittest.py:
>+        (FactoryTest):
>+        (FactoryTest.assert_port):
>+        (FactoryTest.assert_platform_port):
>+        (FactoryTest.test_mac):
>+        (FactoryTest.test_win):
>+        (FactoryTest.test_chromium_gpu):
>+        (FactoryTest.test_chromium_gpu_linux):
>+        (FactoryTest.test_chromium_gpu_mac):
>+        (FactoryTest.test_chromium_gpu_win):
>+        (FactoryTest.test_chromium_mac):
>+        (FactoryTest.test_chromium_linux):
>+        (FactoryTest.test_chromium_win):
>+        (FactoryTest.test_unknown_port_name):
>+        (FactoryTest.test_unknown_os_name):
>+        * Scripts/webkitpy/layout_tests/port/google_chrome.py:
>+        (GoogleChromeLinux32Port):
>+        (GoogleChromeLinux32Port.determine_port_name):
>+        (GoogleChromeLinux64Port):
>+        (GoogleChromeLinux64Port.determine_port_name):
>+        (GoogleChromeMacPort):
>+        (GoogleChromeMacPort.determine_port_name):
>+        (GoogleChromeWinPort):
>+        (GoogleChromeWinPort.determine_port_name):
>+        * Scripts/webkitpy/layout_tests/port/google_chrome_unittest.py:
>+        (GetGoogleChromePortTest._verify_baseline_path):
>+        (GetGoogleChromePortTest._verify_expectations_overrides):
>+        * Scripts/webkitpy/layout_tests/port/gtk.py:
>+        (GtkPort):
>+        * Scripts/webkitpy/layout_tests/port/mac.py:
>+        (MacPort):
>+        (MacPort.determine_port_name):
>+        (MacPort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/mac_unittest.py:
>+        (MacTest):
>+        (assert_name):
>+        (test_tests_for_other_platforms):
>+        (test_version):
>+        (test_versions):
>+        (test_is_version_methods):
>+        (test_setup_environ_for_server):
>+        (_assert_search_path):
>+        (test_show_results_html_file):
>+        * Scripts/webkitpy/layout_tests/port/mock_drt.py:
>+        (MockDRTPort):
>+        (MockDRTPort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py:
>+        (MockDRTPortTest.make_port):
>+        (MockDRTPortTest.test_port_name_in_constructor):
>+        (MockDRTTest.assertTest):
>+        (MockDRTTest.test_main):
>+        (MockChromiumDRTTest.test_pixeltest__fails):
>+        * Scripts/webkitpy/layout_tests/port/port_testcase.py:
>+        (PortTestCase):
>+        (PortTestCase.make_port):
>+        * Scripts/webkitpy/layout_tests/port/qt.py:
>+        (QtPort):
>+        (QtPort.determine_port_name):
>+        (QtPort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/qt_unittest.py:
>+        (QtPortTest):
>+        (QtPortTest._assert_search_path):
>+        (QtPortTest.test_baseline_search_path):
>+        (QtPortTest.test_operating_system):
>+        * Scripts/webkitpy/layout_tests/port/test.py:
>+        (TestPort):
>+        (TestPort.determine_port_name):
>+        (TestPort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/webkit.py:
>+        (WebKitPort.__init__):
>+        * Scripts/webkitpy/layout_tests/port/webkit_unittest.py:
>+        (TestWebKitPort.__init__):
>+        (WebKitPortUnitTests.test_default_options):
>+        (WebKitPortTest):
>+        (test_runtime_feature_list):
>+        (test_skipped_layout_tests):
>+        (test_test_expectations):
>+        * Scripts/webkitpy/layout_tests/port/win.py:
>+        (WinPort):
>+        (WinPort.determine_port_name):
>+        * Scripts/webkitpy/layout_tests/port/win_unittest.py:
>+        (WinOsVersionTest):
>+        (WinOsVersionTest.disabled_test_show_results_html_file):
>+        (WinOsVersionTest.disabled_test_os_version):
>+        (WinOsVersionTest.disabled_test_os_version.mock_run_command):
>+        (WinPortTest):
>+        (WinPortTest.test_show_results_html_file):
>+        (WinPortTest._assert_search_path):
>+        (WinPortTest.test_baseline_search_path):
>+        (WinPortTest._assert_version):
>+        * Scripts/webkitpy/tool/servers/rebaselineserver.py:
>+        (get_test_baselines.AllPlatformsPort.__init__):
>+        * Scripts/webkitpy/tool/servers/rebaselineserver_unittest.py:
>+        (get_test_config):
>+
> 2012-01-05  Dirk Pranke  <dpranke@chromium.org>
> 
>         webkitpy: clean up test/uri conversion routines
>diff --git a/Tools/Scripts/webkitpy/common/system/platforminfo.py b/Tools/Scripts/webkitpy/common/system/platforminfo.py
>index 64e805df25948368e5e1fa88d6471408a6dfdce0..2a21c89919378bf98db6ce14c4262ebcf5edec31 100644
>--- a/Tools/Scripts/webkitpy/common/system/platforminfo.py
>+++ b/Tools/Scripts/webkitpy/common/system/platforminfo.py
>@@ -28,6 +28,7 @@
> 
> import platform
> import re
>+import sys
> 
> 
> # We use this instead of calls to platform directly to allow mocking.
>@@ -35,6 +36,57 @@ class PlatformInfo(object):
>     def __init__(self, executive):
>         self._executive = executive
> 
>+        self.os_name = self._determine_os_name(sys.platform)
>+        if self.os_name == 'linux':
>+            self.os_version = self._determine_linux_version()
>+        if self.os_name.startswith('mac'):
>+            self.os_version = self._determine_mac_version(platform.mac_ver()[0])
>+        if self.os_version.startswith('win'):
>+            self.os_version = self._determine_win_version()
>+
>+    def _determine_os_name(self, sys_platform):
>+        if sys_platform == 'darwin':
>+            return 'mac'
>+        if sys_platform.startswith('linux'):
>+            return 'linux'
>+        if sys_platform in ('win32', 'cygwin'):
>+            return 'win'
>+        raise AssertionError('unrecognized platform string "%s"' % sys_platform)
>+
>+    def _determine_mac_version(self, mac_version_string):
>+        release_version = mac_version_string.split('.')[1]
>+        version_strings = {
>+            5: 'leopard',
>+            6: 'snowleopard',
>+            7: 'lion',
>+        }
>+        # FIXME: Should this routine enforce minimum versions and handle 'future', or let callers do that?
>+        assert release_version >= min(version_strings.keys())
>+        return version_strings.get(release_version, 'future')
>+
>+    def _determine_linux_version(self):
>+        # FIXME: we ignore whatever the real version is and pretend it's lucid for now.
>+        return 'lucid'
>+
>+    def _determine_win_version(self):
>+        if hasattr(sys, 'getwindowsversion'):
>+            win_version_tuple = sys.getwindowsversion()
>+        else:
>+            # Note that this should only ever be called on windows, so this should always work.
>+            ver_output = self.executive.run_command(['cmd', '/c', 'ver'])
>+            match_object = re.search(r'(?P<major>\d)\.(?P<minor>\d)\.(?P<build>\d+)', ver_output)
>+            assert match_object, 'cmd returned an unexpected version string: ' + ver_output
>+            win_version_tuple = tuple(map(int, match_object.groups()))
>+
>+        if win_version_tuple[:3] == (6, 1, 7600):
>+            return '7sp0'
>+        if win_version_tuple[:2] == (6, 0):
>+            return 'vista'
>+        if win_version_tuple[:2] == (5, 1):
>+            return 'xp'
>+        assert win_version_tuple[0] > 6 or win_version_tuple[1] >= 1, 'Unrecognized Windows version tuple: "%s"' % win_version_tuple
>+        return 'future'
>+
>     def display_name(self):
>         # platform.platform() returns Darwin information for Mac, which is just confusing.
>         if platform.system() == "Darwin":
>diff --git a/Tools/Scripts/webkitpy/common/system/platforminfo_mock.py b/Tools/Scripts/webkitpy/common/system/platforminfo_mock.py
>index 14fedd062b543cfa990204f0d152cb6d506a2612..4f1c2a1dc24bfbb3c015a8b557cf3c618f67a9e1 100644
>--- a/Tools/Scripts/webkitpy/common/system/platforminfo_mock.py
>+++ b/Tools/Scripts/webkitpy/common/system/platforminfo_mock.py
>@@ -28,6 +28,10 @@
> 
> 
> class MockPlatformInfo(object):
>+    def __init__(self):
>+        self.os_name = 'mac'
>+        self.os_version = 'leopard'
>+
>     def display_name(self):
>         return "MockPlatform 1.0"
> 
>diff --git a/Tools/Scripts/webkitpy/common/system/systemhost.py b/Tools/Scripts/webkitpy/common/system/systemhost.py
>index 9b84bbd43bfa264974425c5226c0fa9655db0fd0..a1685b9b6482772272f643d194d8a6dc381f0c6a 100644
>--- a/Tools/Scripts/webkitpy/common/system/systemhost.py
>+++ b/Tools/Scripts/webkitpy/common/system/systemhost.py
>@@ -30,14 +30,12 @@ import os
> 
> from webkitpy.common.system import environment, executive, filesystem, platforminfo, user, workspace
> 
>-
> class SystemHost(object):
>     def __init__(self):
>         self.executive = executive.Executive()
>         self.filesystem = filesystem.FileSystem()
>         self.user = user.User()
>         self.platform = platforminfo.PlatformInfo(self.executive)
>-        self.workspace = workspace.Workspace(self.filesystem, self.executive)
> 
>     def copy_current_environment(self):
>         return environment.Environment(os.environ.copy())
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/apple.py b/Tools/Scripts/webkitpy/layout_tests/port/apple.py
>index 29ca987b5c8bbf134414edee3e138a088f607c29..c72e6fdea757aa0551188914a76f0a973f58a919 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/apple.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/apple.py
>@@ -56,23 +56,12 @@ class ApplePort(WebKitPort):
>         # instead of the individual port constructors.
>         return port_name[len(self.port_name + '-'):]
> 
>-    def __init__(self, host, port_name=None, os_version_string=None, **kwargs):
>-        port_name = port_name or self.port_name
>-        WebKitPort.__init__(self, host, port_name=port_name, **kwargs)
>+    def __init__(self, host, port_name, **kwargs):
>+        WebKitPort.__init__(self, host, port_name, **kwargs)
> 
>-        # FIXME: This sort of parsing belongs in factory.py!
>-        if port_name == '%s-wk2' % self.port_name:
>-            port_name = self.port_name
>-            # FIXME: This may be wrong, since options is a global property, and the port_name is specific to this object?
>-            self.set_option_default('webkit_test_runner', True)
>-
>-        if port_name == self.port_name:
>-            self._version = self._detect_version(os_version_string) or self.FUTURE_VERSION
>-            self._name = self.port_name + '-' + self._version
>-        else:
>-            allowed_port_names = self.VERSION_FALLBACK_ORDER + [self.operating_system() + "-future"]
>-            assert port_name in allowed_port_names, "%s is not in %s" % (port_name, allowed_port_names)
>-            self._version = self._strip_port_name_prefix(port_name)
>+        allowed_port_names = self.VERSION_FALLBACK_ORDER + [self.operating_system() + "-future"]
>+        assert port_name in allowed_port_names, "%s is not in %s" % (port_name, allowed_port_names)
>+        self._version = self._strip_port_name_prefix(port_name)
> 
>     # FIXME: A more sophisitcated version of this function should move to WebKitPort and replace all calls to name().
>     def _port_name_with_version(self):
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/base.py b/Tools/Scripts/webkitpy/layout_tests/port/base.py
>index 9bcf0553e8833c789df332d7c006e3f2df4757bd..6621d8c270d375561d420cebaec8610d4a6c1398 100755
>--- a/Tools/Scripts/webkitpy/layout_tests/port/base.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/base.py
>@@ -81,17 +81,40 @@ class DummyOptions(object):
> class Port(object):
>     """Abstract class for Port-specific hooks for the layout_test package."""
> 
>-    port_name = None  # Subclasses override this
>+    # Subclasses override this. This should indicate the basic implementation
>+    # part of the port name, e.g., 'chromium-mac', 'win', 'gtk'; there is probably (?)
>+    # one unique value per class.
>+    port_name = None
> 
>     # Test names resemble unix relative paths, and use '/' as a directory separator.
>     TEST_PATH_SEPARATOR = '/'
> 
>     ALL_BUILD_TYPES = ('debug', 'release')
> 
>-    def __init__(self, host, port_name=None, options=None, config=None, **kwargs):
>+    # FIXME: This should move into webkitpy.common.system somewhere (config?).
>+    @staticmethod
>+    def _operating_system_for_platform(platform):
>+        if platform.startswith('linux'):
>+            return "linux"
>+        elif platform in ('win32', 'cygwin'):
>+            return "win"
>+        elif platform == 'darwin':
>+            return "mac"
>+        return None
>+
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        """Return a fully-specified port name that can be used to construct objects."""
>+        # Subclasses will usually override this.
>+        return cls.port_name
>+
>+    def __init__(self, host, port_name, options=None, config=None, **kwargs):
>+
>+        # This value may be different from cls.port_name by having version modifiers
>+        # and other fields appended to it (for example, 'qt-arm' or 'mac-wk2').
>+        self._name = port_name
> 
>         # These are default values that should be overridden in a subclasses.
>-        self._name = port_name or self.port_name  # Subclasses may append a -VERSION (like mac-leopard) or other qualifiers.
>         self._version = ''
>         self._architecture = 'x86'
>         self._graphics_type = 'cpu'
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/base_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/base_unittest.py
>index 43f9b0f643cf52378e064e8bbf4a8baf355a6549..760028525f33457f77e3322f20101dfd044a3d5b 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/base_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/base_unittest.py
>@@ -27,32 +27,33 @@
> # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> 
> import optparse
>-import sys
> import tempfile
> import unittest
> 
> from webkitpy.common.system.executive import Executive, ScriptError
>-from webkitpy.common.system import executive_mock
>+from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2
> from webkitpy.common.system.filesystem_mock import MockFileSystem
> from webkitpy.common.system.outputcapture import OutputCapture
> from webkitpy.common.system.path import abspath_to_uri
>-from webkitpy.thirdparty.mock import Mock
>-from webkitpy.tool.mocktool import MockOptions
>-from webkitpy.common.system.executive_mock import MockExecutive
>-from webkitpy.common.host_mock import MockHost
>-
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
>+from webkitpy.layout_tests.port import config
>+from webkitpy.layout_tests.port import config_mock
> from webkitpy.layout_tests.port import Port, Driver, DriverOutput
>-from webkitpy.layout_tests.port.test import TestPort
>+from webkitpy.layout_tests.port.test import TestPort, add_unit_tests_to_mock_filesystem
>+from webkitpy.tool.mocktool import MockOptions
> 
>-import config
>-import config_mock
> 
> class PortTest(unittest.TestCase):
>     def make_port(self, executive=None, **kwargs):
>-        host = MockHost()
>+        host = MockSystemHost()
>         if executive:
>             host.executive = executive
>-        return Port(host, **kwargs)
>+        return Port(host, 'PortTest', **kwargs)
>+
>+    def make_test_port(self, executive=None, **kwargs):
>+        host = MockSystemHost()
>+        add_unit_tests_to_mock_filesystem(host.filesystem)
>+        return TestPort(host, 'test-mac-leopard', **kwargs)
> 
>     def test_default_child_processes(self):
>         port = self.make_port()
>@@ -100,7 +101,7 @@ class PortTest(unittest.TestCase):
>         return new_file
> 
>     def test_pretty_patch_os_error(self):
>-        port = self.make_port(executive=executive_mock.MockExecutive2(exception=OSError))
>+        port = self.make_port(executive=MockExecutive2(exception=OSError))
>         oc = OutputCapture()
>         oc.capture_output()
>         self.assertEqual(port.pretty_patch_text("patch.txt"),
>@@ -113,7 +114,7 @@ class PortTest(unittest.TestCase):
> 
>     def test_pretty_patch_script_error(self):
>         # FIXME: This is some ugly white-box test hacking ...
>-        port = self.make_port(executive=executive_mock.MockExecutive2(exception=ScriptError))
>+        port = self.make_port(executive=MockExecutive2(exception=ScriptError))
>         port._pretty_patch_available = True
>         self.assertEqual(port.pretty_patch_text("patch.txt"),
>                          port._pretty_patch_error_html)
>@@ -240,16 +241,8 @@ class PortTest(unittest.TestCase):
>         port = self.make_port()
>         self.assertEqual(port.get_option('foo', 'bar'), 'bar')
> 
>-    def test_name__unset(self):
>-        port = self.make_port()
>-        self.assertEqual(port.name(), None)
>-
>-    def test_name__set(self):
>-        port = self.make_port(port_name='foo')
>-        self.assertEqual(port.name(), 'foo')
>-
>     def test_additional_platform_directory(self):
>-        port = self.make_port(port_name='foo')
>+        port = self.make_port()
>         port.baseline_search_path = lambda: ['LayoutTests/platform/foo']
>         layout_test_dir = port.layout_tests_dir()
>         test_file = 'fast/test.html'
>@@ -276,35 +269,35 @@ class PortTest(unittest.TestCase):
>         self.assertEqual(port.baseline_path(), '/foo')
> 
>     def test_uses_test_expectations_file(self):
>-        port = self.make_port(port_name='foo')
>+        port = self.make_port()
>         port.path_to_test_expectations_file = lambda: '/mock-results/test_expectations.txt'
>         self.assertFalse(port.uses_test_expectations_file())
>         port._filesystem = MockFileSystem({'/mock-results/test_expectations.txt': ''})
>         self.assertTrue(port.uses_test_expectations_file())
> 
>     def test_find_no_paths_specified(self):
>-        port = TestPort(MockHost())
>+        port = self.make_test_port()
>         layout_tests_dir = port.layout_tests_dir()
>         tests = port.tests([])
>         self.assertNotEqual(len(tests), 0)
> 
>     def test_find_one_test(self):
>-        port = TestPort(MockHost())
>+        port = self.make_test_port()
>         tests = port.tests(['failures/expected/image.html'])
>         self.assertEqual(len(tests), 1)
> 
>     def test_find_glob(self):
>-        port = TestPort(MockHost())
>+        port = self.make_test_port()
>         tests = port.tests(['failures/expected/im*'])
>         self.assertEqual(len(tests), 2)
> 
>     def test_find_with_skipped_directories(self):
>-        port = TestPort(MockHost())
>+        port = self.make_test_port()
>         tests = port.tests('userscripts')
>         self.assertTrue('userscripts/resources/iframe.html' not in tests)
> 
>     def test_find_with_skipped_directories_2(self):
>-        port = TestPort(MockHost())
>+        port = self.make_test_port()
>         tests = port.tests(['userscripts/resources'])
>         self.assertEqual(tests, set([]))
> 
>@@ -324,7 +317,7 @@ class PortTest(unittest.TestCase):
>         self.assertFalse(Port._is_test_file(filesystem, '', 'notref-foo.xhr'))
> 
>     def test_parse_reftest_list(self):
>-        port = TestPort(MockHost())
>+        port = self.make_port()
>         port.host.filesystem.files['bar/reftest.list'] = "\n".join(["== test.html test-ref.html",
>         "",
>         "# some comment",
>@@ -348,7 +341,7 @@ class VirtualTest(unittest.TestCase):
>         self.assertRaises(NotImplementedError, method, *args, **kwargs)
> 
>     def test_virtual_methods(self):
>-        port = Port(MockHost())
>+        port = Port(MockSystemHost(), 'TestPort')
>         self.assertVirtual(port.baseline_path)
>         self.assertVirtual(port.baseline_search_path)
>         self.assertVirtual(port.check_build, None)
>@@ -369,7 +362,7 @@ class VirtualTest(unittest.TestCase):
>         self.assertVirtual(port._path_to_wdiff)
> 
>     def test_virtual_driver_methods(self):
>-        driver = Driver(Port(MockHost()), None, pixel_tests=False)
>+        driver = Driver(Port(MockSystemHost(), 'TestPort'), None, pixel_tests=False)
>         self.assertVirtual(driver.run_test, None)
>         self.assertVirtual(driver.stop)
>         self.assertVirtual(driver.cmd_line)
>@@ -379,7 +372,7 @@ class VirtualTest(unittest.TestCase):
> class DriverTest(unittest.TestCase):
> 
>     def _assert_wrapper(self, wrapper_string, expected_wrapper):
>-        wrapper = Driver(Port(MockHost()), None, pixel_tests=False)._command_wrapper(wrapper_string)
>+        wrapper = Driver(Port(MockSystemHost(), 'TestPort'), None, pixel_tests=False)._command_wrapper(wrapper_string)
>         self.assertEqual(wrapper, expected_wrapper)
> 
>     def test_command_wrapper(self):
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium.py
>index 64b7044fc8ac86d554847dcad3206955d096bda9..797ead2c0985a25cb64aaf6f9cb945384161dadf 100755
>--- a/Tools/Scripts/webkitpy/layout_tests/port/chromium.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium.py
>@@ -58,8 +58,6 @@ _log = logging.getLogger(__name__)
> class ChromiumPort(Port):
>     """Abstract base class for Chromium implementations of the Port class."""
> 
>-    port_name = "chromium"
>-
>     ALL_SYSTEMS = (
>         ('leopard', 'x86'),
>         ('snowleopard', 'x86'),
>@@ -88,11 +86,9 @@ class ChromiumPort(Port):
>         'linux': ['lucid'],
>     }
> 
>-    def __init__(self, host, **kwargs):
>-        Port.__init__(self, host, **kwargs)
>-        # All sub-classes override this, but we need an initial value for testing.
>-        self._version = 'xp'
>-        self._chromium_base_dir = None
>+    def __init__(self, host, port_name, **kwargs):
>+        Port.__init__(self, host, port_name, **kwargs)
>+        self._chromium_base_dir_path = None
> 
>     def _check_file_exists(self, path_to_file, file_description,
>                            override_step=None, logging=True):
>@@ -220,17 +216,22 @@ class ChromiumPort(Port):
>             self._filesystem.rmtree(str(tempdir))
>         return (result, 0)  # FIXME: how to get % diff?
> 
>+    @classmethod
>+    def _chromium_base_dir(cls, filesystem, *comps):
>+        module_path = filesystem.path_to_module(cls.__module__)
>+        offset = module_path.find('third_party')
>+        if offset == -1:
>+            return filesystem.join(module_path[0:module_path.find('Tools')], 'Source', 'WebKit', 'chromium')
>+        else:
>+            return module_path[0:offset]
>+
>+
>     def path_from_chromium_base(self, *comps):
>         """Returns the full path to path made by joining the top of the
>         Chromium source tree and the list of path components in |*comps|."""
>-        if not self._chromium_base_dir:
>-            chromium_module_path = self._filesystem.path_to_module(self.__module__)
>-            offset = chromium_module_path.find('third_party')
>-            if offset == -1:
>-                self._chromium_base_dir = self._filesystem.join(chromium_module_path[0:chromium_module_path.find('Tools')], 'Source', 'WebKit', 'chromium')
>-            else:
>-                self._chromium_base_dir = chromium_module_path[0:offset]
>-        return self._filesystem.join(self._chromium_base_dir, *comps)
>+        if not self._chromium_base_dir_path:
>+            self._chromium_base_dir_path = self._chromium_base_dir(self._filesystem)
>+        return self._filesystem.join(self._chromium_base_dir_path, *comps)
> 
>     def path_to_test_expectations_file(self):
>         return self.path_from_webkit_base('LayoutTests', 'platform', 'chromium', 'test_expectations.txt')
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_gpu_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_gpu_unittest.py
>index 965fb586d8e543a57e041f887520c482b4a8f8ad..e80cde2b980e4422837aadb372bc9274118008c9 100755
>--- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_gpu_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_gpu_unittest.py
>@@ -27,7 +27,7 @@
> import sys
> import unittest
> 
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> from webkitpy.common.system.filesystem_mock import MockFileSystem
> from webkitpy.layout_tests.port import chromium_gpu
> from webkitpy.layout_tests.port import port_testcase
>@@ -53,7 +53,7 @@ class ChromiumGpuTest(unittest.TestCase):
>         self.assert_port_works('chromium-gpu-win', 'chromium-gpu', 'cygwin')
> 
>     def assert_port_works(self, port_name, input_name=None, platform=None):
>-        host = MockHost()
>+        host = MockSystemHost()
>         host.filesystem = FileSystem()  # FIXME: This test should not use a real filesystem!
> 
>         # test that we got the right port
>@@ -97,8 +97,8 @@ class ChromiumGpuTest(unittest.TestCase):
>             self.assertFalse(path in files)
> 
>     def _assert_baseline_path(self, port_name, baseline_path):
>-        host = MockHost()
>-        port = host.port_factory.get(port_name)
>+        host = MockSystemHost()
>+        port = PortFactory(host).get(port_name)
>         self.assertEquals(port.name(), port_name)
>         self.assertEquals(port.baseline_path(), port._webkit_baseline_path(baseline_path))
> 
>@@ -110,24 +110,24 @@ class ChromiumGpuTest(unittest.TestCase):
>         self._assert_baseline_path('chromium-gpu-cg-mac-snowleopard', 'chromium-gpu-cg-mac')
> 
>     def test_graphics_type(self):
>-        host = MockHost()
>-        port = host.port_factory.get('chromium-gpu-cg-mac')
>+        host = MockSystemHost()
>+        port = PortFactory(host).get('chromium-gpu-cg-mac')
>         self.assertEquals('gpu-cg', port.graphics_type())
>-        port = host.port_factory.get('chromium-gpu-mac')
>+        port = PortFactory(host).get('chromium-gpu-mac')
>         self.assertEquals('gpu', port.graphics_type())
> 
>     def test_default_tests_paths(self):
>-        host = MockHost()
>+        host = MockSystemHost()
> 
>         def test_paths(port_name):
>-            return chromium_gpu._default_tests_paths(host.port_factory.get(port_name))
>+            return chromium_gpu._default_tests_paths(PortFactory(host).get(port_name))
> 
>         self.assertEqual(test_paths('chromium-gpu-linux'), ['media', 'fast/canvas', 'canvas/philip'])
>         self.assertEqual(test_paths('chromium-gpu-mac-leopard'), ['fast/canvas', 'canvas/philip'])
>         self.assertEqual(test_paths('chromium-gpu-cg-mac-leopard'), ['fast/html'])
> 
>     def test_test_files(self):
>-        host = MockHost()
>+        host = MockSystemHost()
>         files = {
>             '/mock-checkout/LayoutTests/canvas/philip/test.html': '',
>             '/mock-checkout/LayoutTests/fast/canvas/test.html': '',
>@@ -138,7 +138,7 @@ class ChromiumGpuTest(unittest.TestCase):
>         host.filesystem = MockFileSystem(files)
> 
>         def test_paths(port_name):
>-            return host.port_factory.get(port_name).tests([])
>+            return PortFactory(host).get(port_name).tests([])
> 
>         self.assertEqual(test_paths('chromium-gpu-linux'), set(['canvas/philip/test.html', 'fast/canvas/test.html', 'media/test.html']))
>         self.assertEqual(test_paths('chromium-gpu-mac-leopard'), set(['canvas/philip/test.html', 'fast/canvas/test.html']))
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py
>index 6b6e8ef494b06fa57f477f44c35a47161d8a2176..aac6a34958b9f75594c97fdcf279085ea30027f2 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux.py
>@@ -28,13 +28,17 @@
> # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> 
> import logging
>-import chromium
>+
>+from webkitpy.layout_tests.port import chromium
>+from webkitpy.layout_tests.port import config
> 
> 
> _log = logging.getLogger(__name__)
> 
> 
> class ChromiumLinuxPort(chromium.ChromiumPort):
>+    port_name = 'chromium-linux'
>+
>     SUPPORTED_ARCHITECTURES = ('x86', 'x86_64')
> 
>     FALLBACK_PATHS = {
>@@ -55,33 +59,39 @@ class ChromiumLinuxPort(chromium.ChromiumPort):
>         ],
>     }
> 
>-    def __init__(self, host, port_name=None, **kwargs):
>-        port_name = port_name or 'chromium-linux'
>-        chromium.ChromiumPort.__init__(self, host, port_name=port_name, **kwargs)
>-        # We re-set the port name once the base object is fully initialized
>-        # in order to be able to find the DRT binary properly.
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>         if port_name.endswith('-linux'):
>-            self._architecture = self._determine_architecture()
>-            # FIXME: This is an ugly hack to avoid renaming the GPU port.
>-            if port_name == 'chromium-linux':
>-                port_name = port_name + '-' + self._architecture
>-        else:
>-            base, arch = port_name.rsplit('-', 1)
>-            assert base in ('chromium-linux', 'chromium-gpu-linux')
>-            self._architecture = arch
>-        assert self._architecture in self.SUPPORTED_ARCHITECTURES
>-        assert port_name in ('chromium-linux', 'chromium-gpu-linux',
>-                             'chromium-linux-x86', 'chromium-linux-x86_64',
>-                             'chromium-gpu-linux-x86_64')
>-        self._name = port_name
>-        self._version = 'lucid'  # We only support lucid right now.
>-
>-    def _determine_architecture(self):
>-        driver_path = self._path_to_driver()
>+            return port_name + '-' + cls._determine_architecture(host.filesystem, host.executive, cls._determine_driver_path_statically(host, options))
>+        return port_name
>+
>+    @classmethod
>+    def _determine_driver_path_statically(cls, host, options):
>+        config_object = config.Config(host.executive, host.filesystem)
>+        build_directory = getattr(options, 'build_directory', None)
>+        webkit_base = config_object.path_from_webkit_base()
>+        chromium_base = cls._chromium_base_dir(host.filesystem)
>+        configuration = getattr(options, 'configuration', config_object.default_configuration())
>+        return cls._static_build_path(host.filesystem, build_directory, chromium_base, webkit_base, configuration, 'DumpRenderTree')
>+
>+    @staticmethod
>+    def _static_build_path(filesystem, build_directory, chromium_base, webkit_base, *comps):
>+        if build_directory:
>+            return filesystem.join(build_directory, *comps)
>+        if filesystem.exists(filesystem.join(chromium_base, 'sconsbuild')):
>+            return filesystem.join(chromium_base, 'sconsbuild', *comps)
>+        if filesystem.exists(filesystem.join(chromium_base, 'out', *comps)):
>+            return filesystem.join(chromium_base, 'out', *comps)
>+        if filesystem.exists(filesystem.join(webkit_base, 'sconsbuild')):
>+            return filesystem.join(webkit_base, 'sconsbuild', *comps)
>+        return filesystem.join(webkit_base, 'out', *comps)
>+
>+    @staticmethod
>+    def _determine_architecture(filesystem, executive, driver_path):
>         file_output = ''
>-        if self._filesystem.exists(driver_path):
>+        if filesystem.exists(driver_path):
>             # The --dereference flag tells file to follow symlinks
>-            file_output = self._executive.run_command(['file', '--dereference', driver_path], return_stderr=True)
>+            file_output = executive.run_command(['file', '--dereference', driver_path], return_stderr=True)
> 
>         if 'ELF 32-bit LSB executable' in file_output:
>             return 'x86'
>@@ -96,6 +106,18 @@ class ChromiumLinuxPort(chromium.ChromiumPort):
>         # if we actually try to use the binary, check_build() should fail.
>         return 'x86_64'
> 
>+    def __init__(self, host, port_name, **kwargs):
>+        chromium.ChromiumPort.__init__(self, host, port_name, **kwargs)
>+        (base, arch) = port_name.rsplit('-', 1)
>+        assert base in ('chromium-linux', 'chromium-gpu-linux')
>+        assert arch in self.SUPPORTED_ARCHITECTURES
>+        assert port_name in ('chromium-linux', 'chromium-gpu-linux',
>+                             'chromium-linux-x86', 'chromium-linux-x86_64',
>+                             'chromium-gpu-linux-x86_64')
>+        self._name = port_name
>+        self._version = 'lucid'  # We only support lucid right now.
>+        self._architecture = arch
>+
>     def baseline_search_path(self):
>         port_names = self.FALLBACK_PATHS[self._architecture]
>         return map(self._webkit_baseline_path, port_names)
>@@ -118,18 +140,7 @@ class ChromiumLinuxPort(chromium.ChromiumPort):
>     #
> 
>     def _build_path(self, *comps):
>-        if self.get_option('build_directory'):
>-            return self._filesystem.join(self.get_option('build_directory'), *comps)
>-
>-        base = self.path_from_chromium_base()
>-        if self._filesystem.exists(self._filesystem.join(base, 'sconsbuild')):
>-            return self._filesystem.join(base, 'sconsbuild', *comps)
>-        if self._filesystem.exists(self._filesystem.join(base, 'out', *comps)):
>-            return self._filesystem.join(base, 'out', *comps)
>-        base = self.path_from_webkit_base()
>-        if self._filesystem.exists(self._filesystem.join(base, 'sconsbuild')):
>-            return self._filesystem.join(base, 'sconsbuild', *comps)
>-        return self._filesystem.join(base, 'out', *comps)
>+        return self._static_build_path(self._filesystem, self.get_option('build_directory'), self.path_from_chromium_base(), self.path_from_webkit_base(), *comps)
> 
>     def _check_apache_install(self):
>         result = self._check_file_exists(self._path_to_apache(), "apache2")
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py
>index 79e65cf7fcbbf9777b8e4812a0505d53e7eb9d4a..ec44c90696c9fe2493b5faff84f2e513b891629d 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_linux_unittest.py
>@@ -29,21 +29,23 @@
> import unittest
> 
> from webkitpy.common.system import executive_mock
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> 
> from webkitpy.layout_tests.port import chromium_linux
> from webkitpy.layout_tests.port import port_testcase
> 
> 
> class ChromiumLinuxPortTest(port_testcase.PortTestCase):
>+    port_name = 'chromium-linux-x86'
>     port_maker = chromium_linux.ChromiumLinuxPort
> 
>     def assert_architecture(self, port_name=None, file_output=None, expected_architecture=None):
>-        host = MockHost()
>+        host = MockSystemHost()
>         host.filesystem.exists = lambda x: 'DumpRenderTree' in x
>         if file_output:
>             host.executive = executive_mock.MockExecutive2(file_output)
> 
>+        port_name = chromium_linux.ChromiumLinuxPort.determine_port_name(host, None, port_name or 'chromium-linux')
>         port = chromium_linux.ChromiumLinuxPort(host, port_name=port_name)
>         self.assertEquals(port.architecture(), expected_architecture)
>         if expected_architecture == 'x86':
>@@ -67,24 +69,27 @@ class ChromiumLinuxPortTest(port_testcase.PortTestCase):
>     def test_check_illegal_port_names(self):
>         # FIXME: Check that, for now, these are illegal port names.
>         # Eventually we should be able to do the right thing here.
>-        self.assertRaises(AssertionError, chromium_linux.ChromiumLinuxPort, MockHost(), port_name='chromium-x86-linux')
>-        self.assertRaises(AssertionError, chromium_linux.ChromiumLinuxPort, MockHost(), port_name='chromium-linux-x86-gpu')
>+        self.assertRaises(AssertionError, chromium_linux.ChromiumLinuxPort, MockSystemHost(), port_name='chromium-x86-linux')
>+        self.assertRaises(AssertionError, chromium_linux.ChromiumLinuxPort, MockSystemHost(), port_name='chromium-linux-x86-gpu')
> 
>     def test_determine_architecture_fails(self):
>         # Test that we default to 'x86' if the driver doesn't exist.
>-        port = chromium_linux.ChromiumLinuxPort(MockHost())
>+        host = MockSystemHost()
>+        port_name = chromium_linux.ChromiumLinuxPort.determine_port_name(host, None, 'chromium-linux')
>+        port = chromium_linux.ChromiumLinuxPort(host, port_name)
>         self.assertEquals(port.architecture(), 'x86_64')
> 
>         # Test that we default to 'x86' on an unknown architecture.
>-        host = MockHost()
>+        host = MockSystemHost()
>         host.filesystem.exists = lambda x: True
>         host.executive = executive_mock.MockExecutive2('win32')
>-        port = chromium_linux.ChromiumLinuxPort(host)
>+        port_name = chromium_linux.ChromiumLinuxPort.determine_port_name(host, None, 'chromium-linux')
>+        port = chromium_linux.ChromiumLinuxPort(host, port_name)
>         self.assertEquals(port.architecture(), 'x86_64')
> 
>         # Test that we raise errors if something weird happens.
>         host.executive = executive_mock.MockExecutive2(exception=AssertionError)
>-        self.assertRaises(AssertionError, chromium_linux.ChromiumLinuxPort, host)
>+        self.assertRaises(AssertionError, chromium_linux.ChromiumLinuxPort, host, 'chromium-linux')
> 
>     def test_operating_system(self):
>         self.assertEqual('linux', self.make_port().operating_system())
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py
>index ef036cff47da89242d59b54ca9c4d3867d0b478e..512ce9933d5b9babdfe9788ef6cacde923c84e2f 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac.py
>@@ -43,6 +43,8 @@ _log = logging.getLogger(__name__)
> 
> 
> class ChromiumMacPort(chromium.ChromiumPort):
>+    port_name = 'chromium-mac'
>+
>     SUPPORTED_OS_VERSIONS = ('leopard', 'snowleopard', 'lion', 'future')
> 
>     FALLBACK_PATHS = {
>@@ -109,17 +111,20 @@ class ChromiumMacPort(chromium.ChromiumPort):
>         ],
>     }
> 
>-    def __init__(self, host, port_name=None, os_version_string=None, **kwargs):
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        if port_name.endswith('-mac'):
>+            return port_name + '-' + host.platform.os_version
>+        return port_name
>+
>+    def __init__(self, host, port_name, **kwargs):
>+        chromium.ChromiumPort.__init__(self, host, port_name, **kwargs)
>+
>         # We're a little generic here because this code is reused by the
>         # 'google-chrome' port as well as the 'mock-' and 'dryrun-' ports.
>-        port_name = port_name or 'chromium-mac'
>-        chromium.ChromiumPort.__init__(self, host, port_name=port_name, **kwargs)
>-        if port_name.endswith('-mac'):
>-            self._version = mac.os_version(os_version_string, self.SUPPORTED_OS_VERSIONS)
>-            self._name = port_name + '-' + self._version
>-        else:
>-            self._version = port_name[port_name.index('-mac-') + len('-mac-'):]
>-            assert self._version in self.SUPPORTED_OS_VERSIONS
>+        self._version = port_name[port_name.index('-mac-') + len('-mac-'):]
>+        assert self._version in self.SUPPORTED_OS_VERSIONS
>+
>         self._using_core_graphics = port_name.find('-cg-') != -1
>         if self._using_core_graphics:
>             self._graphics_type = 'cpu-cg'
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py
>index b21142c4266dbf9ce8e5fabed3c3ea393913445f..12067ecbf1afd06e98df9f431308c580e9aa8cb1 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_mac_unittest.py
>@@ -29,45 +29,43 @@
> import unittest
> 
> from webkitpy.thirdparty.mock import Mock
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> 
> from webkitpy.layout_tests.port import chromium_mac
> from webkitpy.layout_tests.port import port_testcase
> 
> 
> class ChromiumMacPortTest(port_testcase.PortTestCase):
>+    port_name = 'chromium-mac-leopard'
>     port_maker = chromium_mac.ChromiumMacPort
> 
>     def test_check_wdiff(self):
>         self.assertTrue(self.make_port().check_wdiff())
> 
>-    def assert_name(self, port_name, os_version_string, expected):
>-        port = self.make_port(port_name=port_name, os_version_string=os_version_string)
>+    def assert_name(self, port_name, os_version, expected):
>+        port = self.make_port(port_name=port_name, os_version=os_version)
>         self.assertEquals(expected, port.name())
> 
>     def test_versions(self):
>         self.assertTrue(self.make_port().name() in ('chromium-mac-leopard', 'chromium-mac-snowleopard', 'chromium-mac-lion', 'chromium-mac-future'))
> 
>-        self.assert_name(None, '10.5.3', 'chromium-mac-leopard')
>-        self.assert_name('chromium-mac', '10.5.3', 'chromium-mac-leopard')
>-        self.assert_name('chromium-mac-leopard', '10.5.3', 'chromium-mac-leopard')
>-        self.assert_name('chromium-mac-leopard', '10.6.3', 'chromium-mac-leopard')
>-
>-        self.assert_name(None, '10.6.3', 'chromium-mac-snowleopard')
>-        self.assert_name('chromium-mac', '10.6.3', 'chromium-mac-snowleopard')
>-        self.assert_name('chromium-mac-snowleopard', '10.5.3', 'chromium-mac-snowleopard')
>-        self.assert_name('chromium-mac-snowleopard', '10.6.3', 'chromium-mac-snowleopard')
>-
>-        self.assert_name(None, '10.7', 'chromium-mac-lion')
>-        self.assert_name(None, '10.7.3', 'chromium-mac-lion')
>-        self.assert_name(None, '10.8', 'chromium-mac-future')
>-        self.assert_name('chromium-mac', '10.7.3', 'chromium-mac-lion')
>-        self.assert_name('chromium-mac-future', '10.4.3', 'chromium-mac-future')
>-        self.assert_name('chromium-mac-future', '10.5.3', 'chromium-mac-future')
>-        self.assert_name('chromium-mac-future', '10.6.3', 'chromium-mac-future')
>-        self.assert_name('chromium-mac-future', '10.7.3', 'chromium-mac-future')
>-
>-        self.assertRaises(AssertionError, self.assert_name, None, '10.4.1', 'should-raise-assertion-so-this-value-does-not-matter')
>+        self.assert_name('chromium-mac', 'leopard', 'chromium-mac-leopard')
>+        self.assert_name('chromium-mac-leopard', 'leopard', 'chromium-mac-leopard')
>+        self.assert_name('chromium-mac-leopard', 'snowleopard', 'chromium-mac-leopard')
>+
>+        self.assert_name('chromium-mac', 'snowleopard', 'chromium-mac-snowleopard')
>+        self.assert_name('chromium-mac-snowleopard', 'leopard', 'chromium-mac-snowleopard')
>+        self.assert_name('chromium-mac-snowleopard', 'snowleopard', 'chromium-mac-snowleopard')
>+
>+        self.assert_name('chromium-mac', 'lion', 'chromium-mac-lion')
>+        self.assert_name('chromium-mac-lion', 'snowleopard', 'chromium-mac-lion')
>+        self.assert_name('chromium-mac-lion', 'lion', 'chromium-mac-lion')
>+
>+        self.assert_name('chromium-mac', 'future', 'chromium-mac-future')
>+        self.assert_name('chromium-mac-future', 'leopard', 'chromium-mac-future')
>+        self.assert_name('chromium-mac-future', 'future', 'chromium-mac-future')
>+
>+        self.assertRaises(AssertionError, self.assert_name, 'chromium-mac', 'tiger', 'should-raise-assertion-so-this-value-does-not-matter')
> 
>     def test_baseline_path(self):
>         port = self.make_port(port_name='chromium-mac-leopard')
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_unittest.py
>index 4ae7ed3049504151a99b9006623882447fc0299b..8b62ac8396dd0cd79ed2c3b11981f824ba42e389 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_unittest.py
>@@ -34,7 +34,7 @@ import unittest
> from webkitpy.common.system import logtesting
> from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2
> from webkitpy.common.system.filesystem_mock import MockFileSystem
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> from webkitpy.thirdparty.mock import Mock
> from webkitpy.tool.mocktool import MockOptions
> 
>@@ -158,7 +158,7 @@ class ChromiumPortTest(port_testcase.PortTestCase):
> 
>     def test_all_test_configurations(self):
>         """Validate the complete set of configurations this port knows about."""
>-        port = chromium.ChromiumPort(MockHost())
>+        port = chromium.ChromiumPort(MockSystemHost(), 'chromiumport')
>         self.assertEquals(set(port.all_test_configurations()), set([
>             TestConfiguration('leopard', 'x86', 'debug', 'cpu'),
>             TestConfiguration('leopard', 'x86', 'debug', 'gpu'),
>@@ -221,7 +221,7 @@ class ChromiumPortTest(port_testcase.PortTestCase):
>     class TestMacPort(chromium_mac.ChromiumMacPort):
>         def __init__(self, options=None):
>             options = options or MockOptions()
>-            chromium_mac.ChromiumMacPort.__init__(self, MockHost(), options=options)
>+            chromium_mac.ChromiumMacPort.__init__(self, MockSystemHost(), 'chromium-mac-leopard', options=options)
> 
>         def default_configuration(self):
>             self.default_configuration_called = True
>@@ -230,7 +230,7 @@ class ChromiumPortTest(port_testcase.PortTestCase):
>     class TestLinuxPort(chromium_linux.ChromiumLinuxPort):
>         def __init__(self, options=None):
>             options = options or MockOptions()
>-            chromium_linux.ChromiumLinuxPort.__init__(self, MockHost(), options=options)
>+            chromium_linux.ChromiumLinuxPort.__init__(self, MockSystemHost(), 'chromium-linux-x86', options=options)
> 
>         def default_configuration(self):
>             self.default_configuration_called = True
>@@ -239,7 +239,7 @@ class ChromiumPortTest(port_testcase.PortTestCase):
>     class TestWinPort(chromium_win.ChromiumWinPort):
>         def __init__(self, options=None):
>             options = options or MockOptions()
>-            chromium_win.ChromiumWinPort.__init__(self, MockHost(), options=options)
>+            chromium_win.ChromiumWinPort.__init__(self, MockSystemHost(), 'chromium-win-win7', options=options)
> 
>         def default_configuration(self):
>             self.default_configuration_called = True
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_win.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_win.py
>index c7e14859921cbb4186643b17278820986183c3f8..6a05e7d91439cdca8aaf26c88f6c201d3b8c1729 100755
>--- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_win.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_win.py
>@@ -34,30 +34,27 @@ import logging
> import sys
> 
> import chromium
>+import win
> 
> 
> _log = logging.getLogger(__name__)
> 
> 
>-def os_version(windows_version=None):
>-    if not windows_version:
>-        if hasattr(sys, 'getwindowsversion'):
>-            windows_version = tuple(sys.getwindowsversion()[:2])
>-        else:
>-            # Make up something for testing.
>-            windows_version = (5, 1)
>-
>+def os_version(host, windows_version=None):
>+    windows_version = windows_version or win._windows_version_tuple(host)
>     version_strings = {
>         (6, 1): 'win7',
>         (6, 0): 'vista',
>         (5, 1): 'xp',
>     }
>-    return version_strings[windows_version]
>+    return version_strings[windows_version[:2]]
> 
> 
> class ChromiumWinPort(chromium.ChromiumPort):
>+    port_name = 'chromium-win'
>+
>     # FIXME: Figure out how to unify this with base.TestConfiguration.all_systems()?
>-    SUPPORTED_VERSIONS = ('xp', 'vista', 'win7')
>+    SUPPORTED_VERSIONS = ('xp', 'vista', '7sp0')
> 
>     # FIXME: Do we need mac-snowleopard here, like the base win port?
>     FALLBACK_PATHS = {
>@@ -84,18 +81,22 @@ class ChromiumWinPort(chromium.ChromiumPort):
>         ],
>     }
> 
>-    def __init__(self, host, port_name=None, windows_version=None, **kwargs):
>-        # We're a little generic here because this code is reused by the
>-        # 'google-chrome' port as well as the 'mock-' and 'dryrun-' ports.
>-        port_name = port_name or 'chromium-win'
>-        chromium.ChromiumPort.__init__(self, host, port_name=port_name, **kwargs)
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>         if port_name.endswith('-win'):
>-            self._version = os_version(windows_version)
>-            self._name = port_name + '-' + self._version
>-        else:
>-            self._version = port_name[port_name.index('-win-') + len('-win-'):]
>-            assert self._version in self.SUPPORTED_VERSIONS, "%s is not in %s" % (self._version, self.SUPPORTED_VERSIONS)
>+            os_version = host.platform.os_version
>+            assert os_version in cls.SUPPORTED_VERSIONS, "%s is not a supported version (needs to be one of %s" % (os_version, cls.SUPPORTED_VERSIONS)
>+            if os_version == '7sp0':
>+                return port_name + '-win7'
>+            return port_name + '-' + os_version
>+        return port_name
>+
>+    def __init__(self, host, port_name, **kwargs):
>+        chromium.ChromiumPort.__init__(self, host, port_name=port_name, **kwargs)
> 
>+        # We're a little generic here because this code is reused by the
>+        # 'google-chrome' port as well as the 'mock-' and 'dryrun-' ports.
>+        self._version = port_name[port_name.index('-win-') + len('-win-'):]
> 
>     def setup_environ_for_server(self, server_name=None):
>         env = chromium.ChromiumPort.setup_environ_for_server(self, server_name)
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py
>index 716ef901eb02f432194aac5762f7c6aecdd5cdcd..50511e5686ccda1ba0be5ce5fb873de01b911545 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/chromium_win_unittest.py
>@@ -31,7 +31,7 @@ import sys
> import unittest
> 
> from webkitpy.common.system import outputcapture
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> from webkitpy.common.system.executive_mock import MockExecutive
> from webkitpy.common.system.filesystem_mock import MockFileSystem
> 
>@@ -45,6 +45,7 @@ class ChromiumWinTest(port_testcase.PortTestCase):
>             self.register_cygwin = True
>             self.results_directory = '/'
> 
>+    port_name = 'chromium-win-xp'
>     port_maker = chromium_win.ChromiumWinPort
> 
>     def test_uses_apache(self):
>@@ -72,54 +73,45 @@ class ChromiumWinTest(port_testcase.PortTestCase):
>         output = outputcapture.OutputCapture()
>         output.assert_outputs(self, port.setup_environ_for_server, expected_stderr=expected_stderr)
> 
>-    def assert_name(self, port_name, windows_version, expected):
>-        port = chromium_win.ChromiumWinPort(MockHost(), port_name=port_name, windows_version=windows_version)
>+    def assert_name(self, port_name, os_version, expected):
>+        port = self.make_port(port_name=port_name, os_version=os_version)
>         self.assertEquals(expected, port.name())
> 
>     def test_versions(self):
>-        port = chromium_win.ChromiumWinPort(MockHost())
>-        self.assertTrue(port.name() in ('chromium-win-xp', 'chromium-win-vista', 'chromium-win-win7'))
>-
>-        self.assert_name(None, (5, 1), 'chromium-win-xp')
>-        self.assert_name('chromium-win', (5, 1), 'chromium-win-xp')
>-        self.assert_name('chromium-win-xp', (5, 1), 'chromium-win-xp')
>-        self.assert_name('chromium-win-xp', (6, 0), 'chromium-win-xp')
>-        self.assert_name('chromium-win-xp', (6, 1), 'chromium-win-xp')
>-
>-        self.assert_name(None, (6, 0), 'chromium-win-vista')
>-        self.assert_name('chromium-win', (6, 0), 'chromium-win-vista')
>-        self.assert_name('chromium-win-vista', (5, 1), 'chromium-win-vista')
>-        self.assert_name('chromium-win-vista', (6, 0), 'chromium-win-vista')
>-        self.assert_name('chromium-win-vista', (6, 1), 'chromium-win-vista')
>-
>-        self.assert_name(None, (6, 1), 'chromium-win-win7')
>-        self.assert_name('chromium-win', (6, 1), 'chromium-win-win7')
>-        self.assert_name('chromium-win-win7', (5, 1), 'chromium-win-win7')
>-        self.assert_name('chromium-win-win7', (6, 0), 'chromium-win-win7')
>-        self.assert_name('chromium-win-win7', (6, 1), 'chromium-win-win7')
>-
>-        self.assertRaises(KeyError, self.assert_name, None, (4, 0), 'chromium-win-xp')
>-        self.assertRaises(KeyError, self.assert_name, None, (5, 0), 'chromium-win-xp')
>-        self.assertRaises(KeyError, self.assert_name, None, (5, 2), 'chromium-win-xp')
>-        self.assertRaises(KeyError, self.assert_name, None, (7, 1), 'chromium-win-xp')
>+        self.assert_name('chromium-win', 'xp', 'chromium-win-xp')
>+        self.assert_name('chromium-win-xp', 'xp', 'chromium-win-xp')
>+        self.assert_name('chromium-win-xp', 'vista', 'chromium-win-xp')
>+        self.assert_name('chromium-win-xp', '7sp0', 'chromium-win-xp')
>+
>+        self.assert_name('chromium-win', 'vista', 'chromium-win-vista')
>+        self.assert_name('chromium-win-vista', 'xp', 'chromium-win-vista')
>+        self.assert_name('chromium-win-vista', 'vista', 'chromium-win-vista')
>+        self.assert_name('chromium-win-vista', '7sp0', 'chromium-win-vista')
>+
>+        self.assert_name('chromium-win', '7sp0', 'chromium-win-win7')
>+        self.assert_name('chromium-win-win7', 'xp', 'chromium-win-win7')
>+        self.assert_name('chromium-win-win7', 'vista', 'chromium-win-win7')
>+        self.assert_name('chromium-win-win7', '7sp0', 'chromium-win-win7')
>+
>+        self.assertRaises(AssertionError, self.assert_name, 'chromium-win', 'w2k', 'does-not-matter')
> 
>     def test_baseline_path(self):
>-        port = chromium_win.ChromiumWinPort(MockHost(), port_name='chromium-win-xp')
>+        port = self.make_port(port_name='chromium-win-xp')
>         self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-win-xp'))
> 
>-        port = chromium_win.ChromiumWinPort(MockHost(), port_name='chromium-win-vista')
>+        port = self.make_port(port_name='chromium-win-vista')
>         self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-win-vista'))
> 
>-        port = chromium_win.ChromiumWinPort(MockHost(), port_name='chromium-win-win7')
>+        port = self.make_port(port_name='chromium-win-win7')
>         self.assertEquals(port.baseline_path(), port._webkit_baseline_path('chromium-win'))
> 
>     def test_build_path(self):
>-        host = MockHost()
>+        host = MockSystemHost()
>         host.filesystem = MockFileSystem(files={
>             '/mock-checkout/Source/WebKit/chromium/build/Release/DumpRenderTree.exe': 'exe',
>         })
> 
>-        port = chromium_win.ChromiumWinPort(host)
>+        port = chromium_win.ChromiumWinPort(host, self.port_name)
>         self.assertEquals(
>             '/mock-checkout/Source/WebKit/chromium/build/Release/DumpRenderTree.exe',
>             port._path_to_driver('Release'))
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/driver_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/driver_unittest.py
>index ad8359668c1dc0d47ced17325fee82de6885dcec..5e847eee869da031a70288bb6d5c80fe4f271f69 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/driver_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/driver_unittest.py
>@@ -30,17 +30,17 @@ import sys
> import unittest
> 
> from webkitpy.common.system.path import abspath_to_uri
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> 
> from webkitpy.layout_tests.port import Port, Driver, DriverOutput
> 
> 
> class DriverTest(unittest.TestCase):
>     def make_port(self):
>-        return Port(MockHost())
>+        return Port(MockSystemHost(), 'dummy')
> 
>     def _assert_wrapper(self, wrapper_string, expected_wrapper):
>-        wrapper = Driver(Port(MockHost()), None, pixel_tests=False)._command_wrapper(wrapper_string)
>+        wrapper = Driver(Port(MockSystemHost(), 'dummy'), None, pixel_tests=False)._command_wrapper(wrapper_string)
>         self.assertEqual(wrapper, expected_wrapper)
> 
>     def test_command_wrapper(self):
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/dryrun.py b/Tools/Scripts/webkitpy/layout_tests/port/dryrun.py
>index aaafb094cf6877f0aea300e23e75ea1573292c0b..1e2cc19a9dbe80242254de70987b79d4d4e091d4 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/dryrun.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/dryrun.py
>@@ -58,15 +58,15 @@ from webkitpy.layout_tests.port import Driver, DriverOutput, factory
> # all of the methods are passed to the __delegate, not to the base class.
> class DryRunPort(object):
>     """DryRun implementation of the Port interface."""
>+    port_name = 'dryrun'
> 
>-    def __init__(self, host, **kwargs):
>-        pfx = 'dryrun-'
>-        if 'port_name' in kwargs:
>-            if kwargs['port_name'].startswith(pfx):
>-                kwargs['port_name'] = kwargs['port_name'][len(pfx):]
>-            else:
>-                kwargs['port_name'] = None
>-        self.__delegate = factory.PortFactory(host).get(**kwargs)
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        return port_name
>+
>+    def __init__(self, host, port_name, **kwargs):
>+        prefix = 'dryrun-'
>+        self.__delegate = factory.PortFactory(host).get(port_name=port_name.replace(prefix, ''), **kwargs)
> 
>     def __getattr__(self, name):
>         return getattr(self.__delegate, name)
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/efl.py b/Tools/Scripts/webkitpy/layout_tests/port/efl.py
>index 3ac71d571478f3883a1d0ddcd670d7be31a5e9d8..a4b70a378961eb91b1a1e3f41b859e642f17986a 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/efl.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/efl.py
>@@ -38,11 +38,7 @@ _log = logging.getLogger(__name__)
> 
> 
> class EflPort(WebKitPort):
>-    port_name = "efl"
>-
>-    def __init__(self, host, **kwargs):
>-        WebKitPort.__init__(self, host, **kwargs)
>-        self._version = self.port_name
>+    port_name = 'efl'
> 
>     def _port_flag_for_scripts(self):
>         return "--efl"
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/factory.py b/Tools/Scripts/webkitpy/layout_tests/port/factory.py
>index f87a447b0c4715a5a3bb7f98ba0c3d921b079c3b..af40ca74ba857657aefaf505a190e57d15a47c84 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/factory.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/factory.py
>@@ -30,7 +30,6 @@
> """Factory method to retrieve the appropriate port implementation."""
> 
> import re
>-import sys
> 
> from webkitpy.layout_tests.port import builders
> 
>@@ -45,38 +44,34 @@ class PortFactory(object):
>     def __init__(self, host):
>         self._host = host
> 
>-    def _port_name_from_arguments_and_options(self, port_name, options, platform):
>-        if port_name == 'chromium-gpu':
>-            if platform in ('cygwin', 'win32'):
>-                return 'chromium-gpu-win'
>-            if platform.startswith('linux'):
>-                return 'chromium-gpu-linux'
>-            if platform == 'darwin':
>-                return 'chromium-gpu-mac'
>-
>+    def _port_name_from_arguments_and_options(self, port_name, options):
>+        os_name = self._host.platform.os_name
>         if port_name:
>+            if port_name == 'chromium-gpu':
>+                return {
>+                'linux': 'chromium-gpu-linux',
>+                'mac': 'chromium-gpu-mac',
>+                'win': 'chromium-gpu-win',
>+                }[os_name]
>             return port_name
>-
>-        if platform in ('win32', 'cygwin'):
>-            if options and hasattr(options, 'chromium') and options.chromium:
>-                return 'chromium-win'
>-            return 'win'
>-        if platform.startswith('linux'):
>-            return 'chromium-linux'
>-        if platform == 'darwin':
>-            if options and hasattr(options, 'chromium') and options.chromium:
>-                return 'chromium-cg-mac'
>-                # FIXME: Add a way to select the chromium-mac port.
>-            return 'mac'
>-
>-        raise NotImplementedError('unknown port; platform = "%s"' % platform)
>-
>-    def get(self, port_name=None, options=None, platform=None, **kwargs):
>+        if options and hasattr(options, 'chromium') and options.chromium:
>+            return {
>+                'linux': 'chromium-linux',
>+                'mac': 'chromium-cg-mac',  # FIXME: change this back to chromium-mac soon.
>+                'win': 'chromium-win',
>+                }[os_name]
>+        return {
>+            'linux': 'chromium-linux',
>+            'mac': 'mac',
>+            'win': 'win',
>+            }[os_name]
>+
>+    def get(self, port_name=None, options=None, **kwargs):
>         """Returns an object implementing the Port interface. If
>         port_name is None, this routine attempts to guess at the most
>         appropriate port on this platform."""
>-        platform = platform or sys.platform
>-        port_to_use = self._port_name_from_arguments_and_options(port_name, options, platform)
>+        port_to_use = self._port_name_from_arguments_and_options(port_name, options)
>+        port_name = port_name or port_to_use
>         if port_to_use.startswith('test'):
>             import test
>             maker = test.TestPort
>@@ -126,11 +121,9 @@ class PortFactory(object):
>             maker = chromium_win.ChromiumWinPort
>         elif port_to_use == 'google-chrome-linux32':
>             import google_chrome
>-            port_name = 'chromium-linux-x86'
>             maker = google_chrome.GoogleChromeLinux32Port
>         elif port_to_use == 'google-chrome-linux64':
>             import google_chrome
>-            port_name = 'chromium-linux-x86_64'
>             maker = google_chrome.GoogleChromeLinux64Port
>         elif port_to_use.startswith('google-chrome-win'):
>             import google_chrome
>@@ -144,7 +137,8 @@ class PortFactory(object):
>         else:
>             raise NotImplementedError('unsupported port: %s' % port_to_use)
> 
>-        return maker(self._host, port_name=port_name, options=options, **kwargs)
>+        port_name = maker.determine_port_name(self._host, options, port_name)
>+        return maker(self._host, port_name, options=options, **kwargs)
> 
>     def all_port_names(self):
>         """Return a list of all valid, fully-specified, "real" port names.
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/factory_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/factory_unittest.py
>index 16874e0c6a6cf911b3738be61d6528e69d4c671a..249294302406065fc1edc2390a880fe06ba0f9f9 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/factory_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/factory_unittest.py
>@@ -26,7 +26,6 @@
> # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> 
>-import sys
> import unittest
> 
> from webkitpy.tool.mocktool import MockOptions
>@@ -49,59 +48,39 @@ import win
> class FactoryTest(unittest.TestCase):
>     """Test factory creates proper port object for the target.
> 
>-    Target is specified by port_name, sys.platform and options.
>+    Target is specified by port_name, os_name, os_version, and options.
> 
>     """
>     # FIXME: The ports themselves should expose what options they require,
>     # instead of passing generic "options".
> 
>     def setUp(self):
>-        self.real_sys_platform = sys.platform
>         self.webkit_options = MockOptions(pixel_tests=False)
>         self.chromium_options = MockOptions(pixel_tests=False, chromium=True)
>         self.factory = factory.PortFactory(MockSystemHost())
> 
>-    def tearDown(self):
>-        sys.platform = self.real_sys_platform
>-
>-    def assert_port(self, port_name, expected_port, port_obj=None, platform=None):
>-        """Helper assert for port_name.
>-
>-        Args:
>-          port_name: port name to get port object.
>-          expected_port: class of expected port object.
>-          port_obj: optional port object
>-        """
>-        port_obj = port_obj or self.factory.get(port_name=port_name, platform=platform)
>+    def assert_port(self, port_name, expected_port, port_obj=None, os_name=None, os_version=None, options=None):
>+        if os_name:
>+            self.factory._host.platform.os_name = os_name
>+        if os_version:
>+            self.factory._host.platform.os_version = os_version
>+        port_obj = port_obj or self.factory.get(port_name=port_name, options=options)
>         self.assertTrue(isinstance(port_obj, expected_port))
> 
>-    def assert_platform_port(self, platform, options, expected_port):
>-        """Helper assert for platform and options.
>-
>-        Args:
>-          platform: sys.platform.
>-          options: options to get port object.
>-          expected_port: class of expected port object.
>-
>-        """
>-        # FIXME: Hacking sys.platform like this is WRONG.
>-        orig_platform = sys.platform
>-        sys.platform = platform
>-        # FIXME: We need a better way to mock this.
>+    def assert_platform_port(self, os_name, os_version, options, expected_port):
>+        self.factory._host.platform.os_name = os_name
>+        self.factory._host.platform.os_version = os_version
>         self.assertTrue(isinstance(self.factory.get(options=options), expected_port))
>-        sys.platform = orig_platform
> 
>     def test_mac(self):
>-        self.assert_port("mac", mac.MacPort)
>-        self.assert_platform_port("darwin", None, mac.MacPort)
>-        self.assert_platform_port("darwin", self.webkit_options, mac.MacPort)
>+        self.assert_port('mac-leopard', mac.MacPort)
>+        self.assert_platform_port('mac', 'leopard', None, mac.MacPort)
>+        self.assert_platform_port('mac', 'leopard', self.webkit_options, mac.MacPort)
> 
>     def test_win(self):
>-        self.assert_port("win", win.WinPort)
>-        self.assert_platform_port("win32", None, win.WinPort)
>-        self.assert_platform_port("win32", self.webkit_options, win.WinPort)
>-        self.assert_platform_port("cygwin", None, win.WinPort)
>-        self.assert_platform_port("cygwin", self.webkit_options, win.WinPort)
>+        self.assert_port('win-xp', win.WinPort)
>+        self.assert_platform_port('win', 'xp', None, win.WinPort)
>+        self.assert_platform_port('win', 'xp', self.webkit_options, win.WinPort)
> 
>     def test_google_chrome(self):
>         self.assert_port("google-chrome-linux32", google_chrome.GoogleChromeLinux32Port)
>@@ -116,52 +95,43 @@ class FactoryTest(unittest.TestCase):
>         self.assert_port("qt", qt.QtPort)
> 
>     def test_chromium_gpu(self):
>-        self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuMacPort, platform='darwin')
>-        self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuWinPort, platform='win32')
>-        self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuWinPort, platform='cygwin')
>-        self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuLinuxPort, platform='linux2')
>-        self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuLinuxPort, platform='linux3')
>+        self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuMacPort, os_name='mac', os_version='leopard')
>+        self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuWinPort, os_name='win', os_version='xp')
>+        self.assert_port('chromium-gpu', chromium_gpu.ChromiumGpuLinuxPort, os_name='linux', os_version='lucid')
> 
>     def test_chromium_gpu_linux(self):
>-        self.assert_port("chromium-gpu-linux", chromium_gpu.ChromiumGpuLinuxPort)
>+        self.assert_port("chromium-gpu-linux-x86_64", chromium_gpu.ChromiumGpuLinuxPort)
> 
>     def test_chromium_gpu_mac(self):
>         self.assert_port("chromium-gpu-cg-mac", chromium_gpu.ChromiumGpuCgMacPort)
>-        self.assert_port("chromium-gpu-mac", chromium_gpu.ChromiumGpuMacPort)
>+        self.assert_port("chromium-gpu-mac-leopard", chromium_gpu.ChromiumGpuMacPort)
>+        self.assert_port("chromium-gpu-mac-snowleopard", chromium_gpu.ChromiumGpuMacPort)
> 
>     def test_chromium_gpu_win(self):
>-        self.assert_port("chromium-gpu-win", chromium_gpu.ChromiumGpuWinPort)
>+        self.assert_port('chromium-gpu-win-xp', chromium_gpu.ChromiumGpuWinPort)
> 
>     def test_chromium_mac(self):
>-        self.assert_port("chromium-mac", chromium_mac.ChromiumMacPort)
>-        self.assert_port("chromium-cg-mac", chromium_mac.ChromiumMacPort)
>-        self.assert_platform_port("darwin", self.chromium_options,
>-                                  chromium_mac.ChromiumMacPort)
>+        self.assert_port("chromium-mac-leopard", chromium_mac.ChromiumMacPort)
>+        self.assert_port("chromium-cg-mac-leopard", chromium_mac.ChromiumMacPort)
>+        self.assert_platform_port('mac', 'leopard', self.chromium_options, chromium_mac.ChromiumMacPort)
> 
>     def test_chromium_linux(self):
>-        self.assert_port("chromium-linux", chromium_linux.ChromiumLinuxPort)
>-        self.assert_platform_port("linux2", self.chromium_options,
>-                                  chromium_linux.ChromiumLinuxPort)
>-        self.assert_platform_port("linux3", self.chromium_options,
>-                                  chromium_linux.ChromiumLinuxPort)
>+        self.assert_port("chromium-linux-x86", chromium_linux.ChromiumLinuxPort)
>+        self.assert_platform_port("linux", 'lucid', None, chromium_linux.ChromiumLinuxPort)
>+        self.assert_platform_port("linux", 'lucid', self.chromium_options, chromium_linux.ChromiumLinuxPort)
> 
>     def test_chromium_win(self):
>-        self.assert_port("chromium-win", chromium_win.ChromiumWinPort)
>-        self.assert_platform_port("win32", self.chromium_options,
>-                                  chromium_win.ChromiumWinPort)
>-        self.assert_platform_port("cygwin", self.chromium_options,
>-                                  chromium_win.ChromiumWinPort)
>+        self.assert_port("chromium-win-xp", chromium_win.ChromiumWinPort)
>+        self.assert_platform_port('win', 'xp', self.chromium_options, chromium_win.ChromiumWinPort)
> 
>-    def test_unknown_specified(self):
>+    def test_unknown_port_name(self):
>         # Test what happens when you specify an unknown port.
>         self.assertRaises(NotImplementedError, self.factory.get, port_name='unknown')
> 
>-    def test_unknown_default(self):
>+    def test_unknown_os_name(self):
>         # Test what happens when you're running on an unknown platform.
>-        orig_platform = sys.platform
>-        sys.platform = 'unknown'
>-        self.assertRaises(NotImplementedError, self.factory.get)
>-        sys.platform = orig_platform
>+        self.factory._host.platform.os_name = 'unknown'
>+        self.assertRaises(KeyError, self.factory.get)
> 
> 
> if __name__ == '__main__':
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/google_chrome.py b/Tools/Scripts/webkitpy/layout_tests/port/google_chrome.py
>index 1d778312684f9a6261b52a5b31c31be467740ecf..77346aa1123e2435087505712ccddcdb5e7b07ea 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/google_chrome.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/google_chrome.py
>@@ -47,6 +47,10 @@ def _test_expectations_overrides(port, super):
> 
> 
> class GoogleChromeLinux32Port(chromium_linux.ChromiumLinuxPort):
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        return 'chromium-linux-x86'
>+
>     def baseline_search_path(self):
>         paths = chromium_linux.ChromiumLinuxPort.baseline_search_path(self)
>         paths.insert(0, self._webkit_baseline_path('google-chrome-linux32'))
>@@ -60,6 +64,10 @@ class GoogleChromeLinux32Port(chromium_linux.ChromiumLinuxPort):
> 
> 
> class GoogleChromeLinux64Port(chromium_linux.ChromiumLinuxPort):
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        return 'chromium-linux-x86_64'
>+
>     def baseline_search_path(self):
>         paths = chromium_linux.ChromiumLinuxPort.baseline_search_path(self)
>         paths.insert(0, self._webkit_baseline_path('google-chrome-linux64'))
>@@ -73,6 +81,10 @@ class GoogleChromeLinux64Port(chromium_linux.ChromiumLinuxPort):
> 
> 
> class GoogleChromeMacPort(chromium_mac.ChromiumMacPort):
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        return 'chromium-mac-leopard'
>+
>     def baseline_search_path(self):
>         paths = chromium_mac.ChromiumMacPort.baseline_search_path(self)
>         paths.insert(0, self._webkit_baseline_path('google-chrome-mac'))
>@@ -83,6 +95,10 @@ class GoogleChromeMacPort(chromium_mac.ChromiumMacPort):
> 
> 
> class GoogleChromeWinPort(chromium_win.ChromiumWinPort):
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        return 'chromium-win-xp'
>+
>     def baseline_search_path(self):
>         paths = chromium_win.ChromiumWinPort.baseline_search_path(self)
>         paths.insert(0, self._webkit_baseline_path('google-chrome-win'))
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/google_chrome_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/google_chrome_unittest.py
>index b2013e2a7be5415f2e2f19ffda4a944cdebd90ef..129d587559795ec75b96c4bf30a2850efedb710e 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/google_chrome_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/google_chrome_unittest.py
>@@ -26,7 +26,8 @@
> 
> import unittest
> 
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
>+from webkitpy.layout_tests.port.factory import PortFactory
> 
> 
> class GetGoogleChromePortTest(unittest.TestCase):
>@@ -41,7 +42,7 @@ class GetGoogleChromePortTest(unittest.TestCase):
>         self._verify_baseline_path('google-chrome-win', 'google-chrome-win-vista')
> 
>     def _verify_baseline_path(self, expected_path, port_name):
>-        port = MockHost().port_factory.get(port_name=port_name)
>+        port = PortFactory(MockSystemHost()).get(port_name=port_name)
>         path = port.baseline_search_path()[0]
>         self.assertEqual(expected_path, port._filesystem.basename(path))
> 
>@@ -51,10 +52,10 @@ class GetGoogleChromePortTest(unittest.TestCase):
>         # be able to control the contents better.
>         # FIXME: What is the Tree() abstraction?
> 
>-        host = MockHost()
>-        chromium_port = host.port_factory.get("chromium-cg-mac")
>+        host = MockSystemHost()
>+        chromium_port = PortFactory(host).get("chromium-cg-mac")
>         chromium_base = chromium_port.path_from_chromium_base()
>-        port = host.port_factory.get(port_name=port_name, options=None)
>+        port = PortFactory(host).get(port_name=port_name, options=None)
> 
>         expected_chromium_overrides = '// chromium overrides\n'
>         expected_chrome_overrides = '// chrome overrides\n'
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/gtk.py b/Tools/Scripts/webkitpy/layout_tests/port/gtk.py
>index d05dda9855a543265d429d638dbea2f262c9d7b2..4d66765d0455e703865821b13287aeb2f881814e 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/gtk.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/gtk.py
>@@ -76,10 +76,6 @@ class GtkDriver(WebKitDriver):
> class GtkPort(WebKitPort):
>     port_name = "gtk"
> 
>-    def __init__(self, host, **kwargs):
>-        WebKitPort.__init__(self, host, **kwargs)
>-        self._version = self.port_name
>-
>     def _port_flag_for_scripts(self):
>         return "--gtk"
> 
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/mac.py b/Tools/Scripts/webkitpy/layout_tests/port/mac.py
>index 93855b8759aca9cefd75456db18bf88c7e24c9fe..4764293a04fb27c23efc0d1c009b5b4bfdfd9893 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/mac.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/mac.py
>@@ -37,26 +37,6 @@ from webkitpy.layout_tests.port.leakdetector import LeakDetector
> _log = logging.getLogger(__name__)
> 
> 
>-def os_version(os_version_string=None, supported_versions=None):
>-    if not os_version_string:
>-        if hasattr(platform, 'mac_ver') and platform.mac_ver()[0]:
>-            os_version_string = platform.mac_ver()[0]
>-        else:
>-            # Make up something for testing.
>-            os_version_string = "10.5.6"
>-    release_version = int(os_version_string.split('.')[1])
>-    version_strings = {
>-        5: 'leopard',
>-        6: 'snowleopard',
>-        7: 'lion',
>-    }
>-    assert release_version >= min(version_strings.keys())
>-    version_string = version_strings.get(release_version, 'future')
>-    if supported_versions:
>-        assert version_string in supported_versions
>-    return version_string
>-
>-
> class MacPort(ApplePort):
>     port_name = "mac"
> 
>@@ -64,18 +44,19 @@ class MacPort(ApplePort):
>     # and the order of fallback between them.  Matches ORWT.
>     VERSION_FALLBACK_ORDER = ["mac-leopard", "mac-snowleopard", "mac-lion", "mac"]
> 
>-    def _detect_version(self, os_version_string):
>-        # FIXME: MacPort and WinPort implement _detect_version differently.
>-        # WinPort uses os_version_string as a replacement for self.version.
>-        # Thus just returns os_version_string from this function if not None.
>-        # Mac (incorrectly) uses os_version_string as a way to unit-test
>-        # the os_version parsing logic.  We should split the os_version parsing tests
>-        # into separate unittests so that they do not need to construct
>-        # MacPort objects just to test our version parsing.
>-        return os_version(os_version_string)
>-
>-    def __init__(self, host, **kwargs):
>-        ApplePort.__init__(self, host, **kwargs)
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        if port_name.endswith('-wk2'):
>+            # FIXME: This may be wrong, since options is a global property, and the port_name is specific to this object?
>+            if options and not hasattr(options, 'webkit_test_runner'):
>+                options.webkit_test_runner = True
>+            port_name = port_name.replace('-wk2', '')
>+        if port_name.endswith('mac'):
>+            return port_name + '-' + host.platform.os_version
>+        return port_name
>+
>+    def __init__(self, host, port_name, **kwargs):
>+        ApplePort.__init__(self, host, port_name, **kwargs)
>         self._leak_detector = LeakDetector(self)
>         if self.get_option("leaks"):
>             # DumpRenderTree slows down noticably if we run more than about 1000 tests in a batch
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py
>index 2acea97cd588ddec4ec0fda4561420c78a523717..66bb4614d7f04c54c3f4f0b75a60e2210e0c5c83 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/mac_unittest.py
>@@ -32,11 +32,11 @@ from webkitpy.common.system.filesystem_mock import MockFileSystem
> from webkitpy.common.system.outputcapture import OutputCapture
> from webkitpy.tool.mocktool import MockOptions
> from webkitpy.common.system.executive_mock import MockExecutive
>-from webkitpy.common.host_mock import MockHost
> 
> 
> class MacTest(port_testcase.PortTestCase):
>     port_maker = MacPort
>+    port_name = 'mac-leopard'
> 
>     def assert_skipped_file_search_paths(self, port_name, expected_paths):
>         port = self.make_port(port_name=port_name)
>@@ -73,13 +73,13 @@ java/
>         port = self.make_port()
>         self.assertEqual(port._tests_from_skipped_file_contents(self.example_skipped_file), self.example_skipped_tests)
> 
>-    def assert_name(self, port_name, os_version_string, expected):
>-        port = self.make_port(port_name=port_name, os_version_string=os_version_string)
>+    def assert_name(self, port_name, os_version, expected):
>+        port = self.make_port(port_name=port_name, os_version=os_version)
>         self.assertEquals(expected, port.name())
> 
>     def test_tests_for_other_platforms(self):
>         platforms = ['mac', 'chromium-linux', 'mac-snowleopard']
>-        port = MacPort(MockHost(), port_name='mac-snowleopard')
>+        port = self.make_port(port_name='mac-snowleopard')
>         platform_dir_paths = map(port._webkit_baseline_path, platforms)
>         # Replace our empty mock file system with one which has our expected platform directories.
>         port._filesystem = MockFileSystem(dirs=platform_dir_paths)
>@@ -90,59 +90,52 @@ java/
>         self.assertFalse('platform/mac-snowleopard' in dirs_to_skip)
> 
>     def test_version(self):
>-        port = MacPort(MockHost())
>+        port = self.make_port()
>         self.assertTrue(port.version())
> 
>     def test_versions(self):
>-        self.assert_name(None, '10.5.3', 'mac-leopard')
>-        self.assert_name('mac', '10.5.3', 'mac-leopard')
>-        self.assert_name('mac-leopard', '10.4.8', 'mac-leopard')
>-        self.assert_name('mac-leopard', '10.5.3', 'mac-leopard')
>-        self.assert_name('mac-leopard', '10.6.3', 'mac-leopard')
>+        self.assert_name('mac', 'leopard', 'mac-leopard')
>+        self.assert_name('mac-leopard', 'tiger', 'mac-leopard')
>+        self.assert_name('mac-leopard', 'leopard', 'mac-leopard')
>+        self.assert_name('mac-leopard', 'snowleopard', 'mac-leopard')
> 
>-        self.assert_name(None, '10.6.3', 'mac-snowleopard')
>-        self.assert_name('mac', '10.6.3', 'mac-snowleopard')
>-        self.assert_name('mac-snowleopard', '10.4.3', 'mac-snowleopard')
>-        self.assert_name('mac-snowleopard', '10.5.3', 'mac-snowleopard')
>-        self.assert_name('mac-snowleopard', '10.6.3', 'mac-snowleopard')
>+        self.assert_name('mac', 'snowleopard', 'mac-snowleopard')
>+        self.assert_name('mac-snowleopard', 'tiger', 'mac-snowleopard')
>+        self.assert_name('mac-snowleopard', 'leopard', 'mac-snowleopard')
>+        self.assert_name('mac-snowleopard', 'snowleopard', 'mac-snowleopard')
> 
>-        self.assert_name(None, '10.7', 'mac-lion')
>-        self.assert_name(None, '10.7.3', 'mac-lion')
>-        self.assert_name('mac', '10.7.3', 'mac-lion')
>+        self.assert_name('mac', 'lion', 'mac-lion')
> 
>-        self.assert_name(None, '10.9', 'mac-future')
>-        self.assert_name('mac', '10.9', 'mac-future')
>-        self.assert_name('mac-future', '10.9', 'mac-future')
>+        self.assert_name('mac', 'future', 'mac-future')
>+        self.assert_name('mac-future', 'leopard', 'mac-future')
>+        self.assert_name('mac-future', 'future', 'mac-future')
> 
>-        self.assertRaises(AssertionError, self.assert_name, None, '10.3.1', 'should-raise-assertion-so-this-value-does-not-matter')
>+        self.assertRaises(AssertionError, self.assert_name, 'mac', 'tiger', 'should-raise-assertion-so-this-value-does-not-matter')
> 
>     def test_is_version_methods(self):
>-        leopard_port = self.make_port(port_name='mac-leopard', os_version_string='10.5.3')
>+        leopard_port = self.make_port(port_name='mac-leopard')
>         self.assertTrue(leopard_port.is_leopard())
>         self.assertFalse(leopard_port.is_snowleopard())
>         self.assertFalse(leopard_port.is_lion())
> 
>-        snowleopard_port = self.make_port(port_name='mac-snowleopard', os_version_string='10.6.3')
>+        snowleopard_port = self.make_port(port_name='mac-snowleopard')
>         self.assertFalse(snowleopard_port.is_leopard())
>         self.assertTrue(snowleopard_port.is_snowleopard())
>         self.assertFalse(snowleopard_port.is_lion())
> 
>-        lion_port = self.make_port(port_name='mac-lion', os_version_string='10.7.2')
>+        lion_port = self.make_port(port_name='mac-lion')
>         self.assertFalse(lion_port.is_leopard())
>         self.assertFalse(lion_port.is_snowleopard())
>         self.assertTrue(lion_port.is_lion())
> 
>     def test_setup_environ_for_server(self):
>-        port = MacPort(MockHost(), options=MockOptions(leaks=True, guard_malloc=True))
>+        port = self.make_port(options=MockOptions(leaks=True, guard_malloc=True))
>         env = port.setup_environ_for_server(port.driver_name())
>         self.assertEquals(env['MallocStackLogging'], '1')
>         self.assertEquals(env['DYLD_INSERT_LIBRARIES'], '/usr/lib/libgmalloc.dylib')
> 
>     def _assert_search_path(self, search_paths, version, use_webkit2=False):
>-        # FIXME: Port constructors should not "parse" the port name, but
>-        # rather be passed components (directly or via setters).  Once
>-        # we fix that, this method will need a re-write.
>-        port = MacPort(MockHost(), port_name='mac-%s' % version, options=MockOptions(webkit_test_runner=use_webkit2))
>+        port = self.make_port(port_name='mac', os_version=version, options=MockOptions(webkit_test_runner=use_webkit2))
>         absolute_search_paths = map(port._webkit_baseline_path, search_paths)
>         self.assertEquals(port.baseline_search_path(), absolute_search_paths)
> 
>@@ -157,7 +150,7 @@ java/
>         self._assert_search_path(['mac-wk2', 'mac-lion', 'mac'], 'lion', use_webkit2=True)
> 
>     def test_show_results_html_file(self):
>-        port = MacPort(MockHost())
>+        port = self.make_port()
>         # Delay setting a should_log executive to avoid logging from MacPort.__init__.
>         port._executive = MockExecutive(should_log=True)
>         expected_stderr = "MOCK run_command: ['Tools/Scripts/run-safari', '--release', '-NSOpen', 'test.html'], cwd=/mock-checkout\n"
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/mock_drt.py b/Tools/Scripts/webkitpy/layout_tests/port/mock_drt.py
>index d5359dec7950ca6147b31fc46c4bb841f543c5fa..5e02439e49cb31fc6f421bb0c910c971f6a3b6f4 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/mock_drt.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/mock_drt.py
>@@ -50,14 +50,13 @@ _log = logging.getLogger(__name__)
> 
> class MockDRTPort(object):
>     """MockPort implementation of the Port interface."""
>+    port_name = 'mock'
> 
>-    def __init__(self, host, **kwargs):
>+    def __init__(self, host, port_name, **kwargs):
>         prefix = 'mock-'
>-        if 'port_name' in kwargs:
>-            kwargs['port_name'] = kwargs['port_name'][len(prefix):]
>-        self._host = host
>-        self.__delegate = PortFactory(host).get(**kwargs)
>+        self.__delegate = PortFactory(host).get(port_name=port_name.replace(prefix, ''), **kwargs)
>         self.__real_name = prefix + self.__delegate.name()
>+        self._host = host
> 
>     def real_name(self):
>         return self.__real_name
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py
>index 2425d58de5e6d3e2d66a3ae19fbcacb877210b2c..aaad9dcd670636f55acb0fc4bb84471380877bcf 100755
>--- a/Tools/Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/mock_drt_unittest.py
>@@ -33,31 +33,30 @@ import sys
> import unittest
> 
> from webkitpy.common import newstringio
>-
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> from webkitpy.layout_tests.port import mock_drt
>+from webkitpy.layout_tests.port.factory import PortFactory
> from webkitpy.layout_tests.port import port_testcase
>-from webkitpy.layout_tests.port import test
>-
>-from webkitpy.common.host_mock import MockHost
>-
>+from webkitpy.layout_tests.port.test import add_unit_tests_to_mock_filesystem
> from webkitpy.tool import mocktool
> mock_options = mocktool.MockOptions(configuration='Release')
> 
> 
> class MockDRTPortTest(port_testcase.PortTestCase):
>     def make_port(self, options=mock_options):
>-        host = MockHost()
>+        host = MockSystemHost()
>+        add_unit_tests_to_mock_filesystem(host.filesystem)
>         if sys.platform == 'win32':
>             # We use this because the 'win' port doesn't work yet.
>-            return mock_drt.MockDRTPort(host, port_name='mock-chromium-win', options=options)
>-        return mock_drt.MockDRTPort(host, options=options)
>+            return mock_drt.MockDRTPort(host, 'mock-chromium-win', options=options)
>+        return mock_drt.MockDRTPort(host, 'mock-mac', options=options)
> 
>     def test_default_worker_model(self):
>         # only overridding the default test; we don't care about this one.
>         pass
> 
>     def test_port_name_in_constructor(self):
>-        self.assertTrue(mock_drt.MockDRTPort(MockHost(), port_name='mock-test'))
>+        self.assertTrue(mock_drt.MockDRTPort(MockSystemHost(), port_name='mock-test'))
> 
>     def test_check_sys_deps(self):
>         pass
>@@ -140,8 +139,9 @@ class MockDRTTest(unittest.TestCase):
> 
>     def assertTest(self, test_name, pixel_tests, expected_checksum=None, drt_output=None, host=None):
>         port_name = 'test'
>-        host = host or MockHost()
>-        port = host.port_factory.get(port_name)
>+        host = host or MockSystemHost()
>+        add_unit_tests_to_mock_filesystem(host.filesystem)
>+        port = PortFactory(host).get(port_name)
>         drt_input, drt_output = self.make_input_output(port, test_name,
>             pixel_tests, expected_checksum, drt_output)
> 
>@@ -162,7 +162,7 @@ class MockDRTTest(unittest.TestCase):
>         self.assertEqual(stderr.getvalue(), '')
> 
>     def test_main(self):
>-        host = MockHost()
>+        host = MockSystemHost()
>         stdin = newstringio.StringIO()
>         stdout = newstringio.StringIO()
>         stderr = newstringio.StringIO()
>@@ -235,7 +235,7 @@ class MockChromiumDRTTest(MockDRTTest):
>                     '#EOF\n']
> 
>     def test_pixeltest__fails(self):
>-        host = MockHost()
>+        host = MockSystemHost()
>         self.assertTest('failures/expected/checksum.html', pixel_tests=True,
>             expected_checksum='wrong-checksum',
>             drt_output=['#URL:file:///test.checkout/LayoutTests/failures/expected/checksum.html\n',
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py b/Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py
>index a4d93ff25b449c492f858983760499291ccaf21b..389f07ef5eefe56b2f0f39696a1c8ddf3c8f1799 100755
>--- a/Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/port_testcase.py
>@@ -46,7 +46,7 @@ from webkitpy.layout_tests.servers import http_server_base
> from webkitpy.common.system.filesystem_mock import MockFileSystem
> from webkitpy.tool.mocktool import MockOptions
> from webkitpy.common.system.executive_mock import MockExecutive
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> 
> 
> class PortTestCase(unittest.TestCase):
>@@ -54,13 +54,22 @@ class PortTestCase(unittest.TestCase):
>     HTTP_PORTS = (8000, 8080, 8443)
>     WEBSOCKET_PORTS = (8880,)
> 
>-    # Subclasses override this to point to their Port subclass.
>+    # Subclasses override these to point to their Port subclass.
>     port_maker = None
>+    port_name = None
>+
>+    def make_port(self, host=None, options=None, port_name=None, os_name=None, os_version=None, executive=None, **kwargs):
>+        host = host or MockSystemHost()
>+        if executive:
>+            host.executive = executive
>+        if os_name:
>+            host.platform.os_name = os_name
>+        if os_version:
>+            host.platform.os_version = os_version
> 
>-    def make_port(self, host=None, options=None, **kwargs):
>-        host = host or MockHost()
>         options = options or MockOptions(configuration='Release')
>-        return self.port_maker(host, options=options, **kwargs)
>+        port_name = self.port_maker.determine_port_name(host, options, port_name or self.port_name)
>+        return self.port_maker(host, port_name, options=options, **kwargs)
> 
>     def test_default_worker_model(self):
>         port = self.make_port()
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/qt.py b/Tools/Scripts/webkitpy/layout_tests/port/qt.py
>index 5f3b9d732d9104dbfab4a35f107dd44ce13b3c60..35e41821d562bb7ad0e9fc1be15ba4d7ee008b7f 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/qt.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/qt.py
>@@ -49,32 +49,20 @@ class QtPort(WebKitPort):
>     def _port_flag_for_scripts(self):
>         return "--qt"
> 
>-    def _operating_system_for_platform(self, platform):
>-        if platform.startswith('linux'):
>-            return "linux"
>-        elif platform in ('win32', 'cygwin'):
>-            return "win"
>-        elif platform == 'darwin':
>-            return "mac"
>-        return None
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        if port_name and port_name != cls.port_name:
>+            return port_name
>+        return port_name + '-' + host.platform.os_name
> 
>     # sys_platform exists only for unit testing.
>-    def __init__(self, host, port_name=None, sys_platform=None, **kwargs):
>-        port_name = port_name or self.port_name
>-        WebKitPort.__init__(self, host, port_name=None, **kwargs)
>-        self._operating_system = self._operating_system_for_platform(sys_platform or sys.platform)
>-        self._version = self.operating_system()
>+    def __init__(self, host, port_name, **kwargs):
>+        WebKitPort.__init__(self, host, port_name, **kwargs)
> 
>         # FIXME: This will allow WebKitPort.baseline_search_path and WebKitPort._skipped_file_search_paths
>         # to do the right thing, but doesn't include support for qt-4.8 or qt-arm (seen in LayoutTests/platform) yet.
>-
>-        if port_name != self.port_name:
>-            self._name = port_name
>-        else:
>-            name_components = [self.port_name]
>-            if self.operating_system():
>-                name_components.append(self.operating_system())
>-            self._name = "-".join(name_components)
>+        self._operating_system = port_name.replace('qt-', '')
>+        self._version = self.operating_system()
> 
>     def _generate_all_test_configurations(self):
>         configurations = []
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/qt_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/qt_unittest.py
>index f46a440cde851fd64b5134e4ec3cf2f0b4cee105..00fcab6cc74c74bf7d62d000c15b0371cf989e65 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/qt_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/qt_unittest.py
>@@ -28,25 +28,22 @@
> 
> import unittest
> 
>-from webkitpy.common.system.executive_mock import MockExecutive2
>+from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2
> from webkitpy.common.system.outputcapture import OutputCapture
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> from webkitpy.layout_tests.port.qt import QtPort
> from webkitpy.layout_tests.port import port_testcase
> from webkitpy.tool.mocktool import MockOptions
>-from webkitpy.common.system.executive_mock import MockExecutive
>-from webkitpy.common.host_mock import MockHost
> 
> 
> class QtPortTest(port_testcase.PortTestCase):
>+    port_name = 'qt-mac'
>     port_maker = QtPort
> 
>-    def _assert_search_path(self, search_paths, sys_platform, use_webkit2=False, qt_version='4.8'):
>-        # FIXME: Port constructors should not "parse" the port name, but
>-        # rather be passed components (directly or via setters).  Once
>-        # we fix that, this method will need a re-write.
>-        host = MockHost()
>+    def _assert_search_path(self, search_paths, port_name, use_webkit2=False, qt_version='4.8'):
>+        host = MockSystemHost()
>         host.executive = MockExecutive2(self._qt_version(qt_version))
>-        port = QtPort(host, sys_platform=sys_platform, options=MockOptions(webkit_test_runner=use_webkit2, platform='qt'))
>+        port = QtPort(host, port_name, options=MockOptions(webkit_test_runner=use_webkit2, platform='qt'))
>         absolute_search_paths = map(port._webkit_baseline_path, search_paths)
>         self.assertEquals(port.baseline_search_path(), absolute_search_paths)
> 
>@@ -57,21 +54,18 @@ class QtPortTest(port_testcase.PortTestCase):
>             return 'QMake version 2.01a\nUsing Qt version 5.0.0 in /usr/local/Trolltech/Qt-5.0.0/lib'
> 
>     def test_baseline_search_path(self):
>-        self._assert_search_path(['qt-mac', 'qt-4.8', 'qt'], 'darwin', qt_version='4.8')
>-        self._assert_search_path(['qt-win', 'qt-4.8', 'qt'], 'win32', qt_version='4.8')
>-        self._assert_search_path(['qt-win', 'qt-4.8', 'qt'], 'cygwin', qt_version='4.8')
>-        self._assert_search_path(['qt-linux', 'qt-4.8', 'qt'], 'linux2', qt_version='4.8')
>-        self._assert_search_path(['qt-linux', 'qt-4.8', 'qt'], 'linux3', qt_version='4.8')
>+        self._assert_search_path(['qt-mac', 'qt-4.8', 'qt'], 'qt-mac', qt_version='4.8')
>+        self._assert_search_path(['qt-win', 'qt-4.8', 'qt'], 'qt-win', qt_version='4.8')
>+        self._assert_search_path(['qt-linux', 'qt-4.8', 'qt'], 'qt-linux', qt_version='4.8')
> 
>-        self._assert_search_path(['qt-mac', 'qt-4.8', 'qt'], 'darwin')
>-        self._assert_search_path(['qt-win', 'qt-4.8', 'qt'], 'win32')
>-        self._assert_search_path(['qt-win', 'qt-4.8', 'qt'], 'cygwin')
>-        self._assert_search_path(['qt-linux', 'qt-4.8', 'qt'], 'linux2')
>-        self._assert_search_path(['qt-linux', 'qt-4.8', 'qt'], 'linux3')
>+        self._assert_search_path(['qt-mac', 'qt-4.8', 'qt'], 'qt-mac')
>+        self._assert_search_path(['qt-win', 'qt-4.8', 'qt'], 'qt-win')
>+        self._assert_search_path(['qt-win', 'qt-4.8', 'qt'], 'qt-win')
>+        self._assert_search_path(['qt-linux', 'qt-4.8', 'qt'], 'qt-linux')
> 
>-        self._assert_search_path(['qt-wk2', 'qt-mac', 'qt-5.0', 'qt'], 'darwin', use_webkit2=True, qt_version='5.0')
>-        self._assert_search_path(['qt-wk2', 'qt-win', 'qt-5.0', 'qt'], 'cygwin', use_webkit2=True, qt_version='5.0')
>-        self._assert_search_path(['qt-wk2', 'qt-linux', 'qt-5.0', 'qt'], 'linux2', use_webkit2=True, qt_version='5.0')
>+        self._assert_search_path(['qt-wk2', 'qt-mac', 'qt-5.0', 'qt'], 'qt-mac', use_webkit2=True, qt_version='5.0')
>+        self._assert_search_path(['qt-wk2', 'qt-win', 'qt-5.0', 'qt'], 'qt-win', use_webkit2=True, qt_version='5.0')
>+        self._assert_search_path(['qt-wk2', 'qt-linux', 'qt-5.0', 'qt'], 'qt-linux', use_webkit2=True, qt_version='5.0')
> 
>     def test_show_results_html_file(self):
>         port = self.make_port()
>@@ -85,7 +79,6 @@ class QtPortTest(port_testcase.PortTestCase):
>         self.assertEquals(env['QTWEBKIT_PLUGIN_PATH'], 'MOCK output of child process/lib/plugins')
> 
>     def test_operating_system(self):
>-        self.assertEqual('linux', self.make_port(sys_platform='linux').operating_system())
>-        self.assertEqual('mac', self.make_port(sys_platform='darwin').operating_system())
>-        self.assertEqual('win', self.make_port(sys_platform='cygwin').operating_system())
>-        self.assertEqual('win', self.make_port(sys_platform='win32').operating_system())
>+        self.assertEqual('linux', self.make_port(port_name='qt', os_name='linux').operating_system())
>+        self.assertEqual('mac', self.make_port(port_name='qt', os_name='mac').operating_system())
>+        self.assertEqual('win', self.make_port(port_name='qt', os_name='win').operating_system())
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/test.py b/Tools/Scripts/webkitpy/layout_tests/port/test.py
>index a3cc463f855b9a5377bdde416eb4392e22f2ca37..6bb206b044e7a03c0d87ded5a1934c2d1cc284cd 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/test.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/test.py
>@@ -300,6 +300,8 @@ WONTFIX SKIP : failures/expected/exception.html = CRASH
> 
> 
> class TestPort(Port):
>+    port_name = 'test'
>+
>     """Test implementation of the Port interface."""
>     ALL_BASELINE_VARIANTS = (
>         'test-mac-snowleopard', 'test-mac-leopard',
>@@ -307,16 +309,21 @@ class TestPort(Port):
>         'test-linux-x86_64',
>     )
> 
>-    def __init__(self, host, port_name=None, **kwargs):
>-        if not port_name or port_name == 'test':
>-            port_name = 'test-mac-leopard'
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        if port_name == 'test':
>+            return 'test-mac-leopard'
>+        return port_name
> 
>+    def __init__(self, host, port_name=None, **kwargs):
>+        # FIXME: Consider updating all of the callers to pass in a port_name so it can be a
>+        # required parameter like all of the other Port objects.
>+        port_name = port_name or 'test-mac-leopard'
>+        Port.__init__(self, host, port_name, **kwargs)
>         self._tests = unit_test_list()
>         self._expectations_path = LAYOUT_TEST_DIR + '/platform/test/test_expectations.txt'
>         self._results_directory = None
> 
>-        Port.__init__(self, host, port_name=port_name, **kwargs)
>-
>         self._operating_system = 'mac'
>         if port_name.startswith('test-win'):
>             self._operating_system = 'win'
>@@ -333,7 +340,6 @@ class TestPort(Port):
>         }
>         self._version = version_map[port_name]
> 
>-
>     def _path_to_driver(self):
>         # This routine shouldn't normally be called, but it is called by
>         # the mock_drt Driver. We return something, but make sure it's useless.
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/webkit.py b/Tools/Scripts/webkitpy/layout_tests/port/webkit.py
>index eaab9aef6ca31a3e9a7dba1167086e69ab2467a4..1fe04d4470ae548700c253760198c6a2b4b26a40 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/webkit.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/webkit.py
>@@ -50,8 +50,8 @@ _log = logging.getLogger(__name__)
> 
> 
> class WebKitPort(Port):
>-    def __init__(self, host, **kwargs):
>-        Port.__init__(self, host, **kwargs)
>+    def __init__(self, host, port, **kwargs):
>+        Port.__init__(self, host, port, **kwargs)
> 
>         # FIXME: Disable pixel tests until they are run by default on build.webkit.org.
>         self.set_option_default("pixel_tests", False)
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/webkit_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/webkit_unittest.py
>index 78b8e751e8886a482507f158eabbb472e4f5d2e9..6742f18aee67f7610936dd163c9fb40846513457 100755
>--- a/Tools/Scripts/webkitpy/layout_tests/port/webkit_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/webkit_unittest.py
>@@ -28,7 +28,7 @@
> import logging
> import unittest
> 
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> from webkitpy.common.system.executive_mock import MockExecutive
> from webkitpy.common.system.filesystem_mock import MockFileSystem
> from webkitpy.common.system.outputcapture import OutputCapture
>@@ -46,8 +46,8 @@ class TestWebKitPort(WebKitPort):
>                  **kwargs):
>         self.symbols_string = symbols_string  # Passing "" disables all staticly-detectable features.
>         self.feature_list = feature_list  # Passing [] disables all runtime-detectable features.
>-        host = host or MockHost()
>-        WebKitPort.__init__(self, host=host, **kwargs)
>+        host = host or MockSystemHost()
>+        WebKitPort.__init__(self, host, self.port_name, **kwargs)
> 
>     def all_test_configurations(self):
>         return [self.test_configuration()]
>@@ -69,18 +69,19 @@ class WebKitPortUnitTests(unittest.TestCase):
>     def test_default_options(self):
>         # The WebKit ports override new-run-webkit-test default options.
>         options = MockOptions(pixel_tests=None, time_out_ms=None)
>-        port = WebKitPort(MockHost(), options=options)
>+        port = WebKitPort(MockSystemHost(), 'testwebkitport', options=options)
>         self.assertEquals(port._options.pixel_tests, False)
>         self.assertEquals(port._options.time_out_ms, 35000)
> 
>         # Note that we don't override options if specified by the user.
>         options = MockOptions(pixel_tests=True, time_out_ms=6000)
>-        port = WebKitPort(MockHost(), options=options)
>+        port = WebKitPort(MockSystemHost(), 'testwebkitport', options=options)
>         self.assertEquals(port._options.pixel_tests, True)
>         self.assertEquals(port._options.time_out_ms, 6000)
> 
> 
> class WebKitPortTest(port_testcase.PortTestCase):
>+    port_name = 'testwebkitport'
>     port_maker = TestWebKitPort
> 
>     def test_check_build(self):
>@@ -125,7 +126,7 @@ class WebKitPortTest(port_testcase.PortTestCase):
>         self.assertEqual(result_directories, expected_directories)
> 
>     def test_runtime_feature_list(self):
>-        port = WebKitPort(MockHost())
>+        port = WebKitPort(MockSystemHost(), 'testwebkitport')
>         port._executive.run_command = lambda command, cwd=None, error_handler=None: "Nonsense"
>         # runtime_features_list returns None when its results are meaningless (it couldn't run DRT or parse the output, etc.)
>         self.assertEquals(port._runtime_feature_list(), None)
>@@ -139,7 +140,7 @@ class WebKitPortTest(port_testcase.PortTestCase):
>         self.assertEqual(result_directories, expected_directories)
> 
>     def test_skipped_layout_tests(self):
>-        self.assertEqual(TestWebKitPort(None, None).skipped_layout_tests(), set(['media']))
>+        self.assertEqual(TestWebKitPort().skipped_layout_tests(), set(['media']))
> 
>     def test_skipped_file_search_paths(self):
>         port = TestWebKitPort()
>@@ -156,7 +157,7 @@ class WebKitPortTest(port_testcase.PortTestCase):
> 
>     def test_test_expectations(self):
>         # Check that we read the expectations file
>-        host = MockHost()
>+        host = MockSystemHost()
>         host.filesystem.write_text_file('/mock-checkout/LayoutTests/platform/testwebkitport/test_expectations.txt',
>             'BUG_TESTEXPECTATIONS SKIP : fast/html/article-element.html = FAIL\n')
>         port = TestWebKitPort(host=host)
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/win.py b/Tools/Scripts/webkitpy/layout_tests/port/win.py
>index ed75a79deb96aa480020db530684ea3db39aebad..f7c8cc3a05b39265827526a97c196ead5f5d342e 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/win.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/win.py
>@@ -38,6 +38,7 @@ from webkitpy.layout_tests.port.apple import ApplePort
> _log = logging.getLogger(__name__)
> 
> 
>+
> class WinPort(ApplePort):
>     port_name = "win"
> 
>@@ -45,35 +46,19 @@ class WinPort(ApplePort):
>     # and the order of fallback between them.  Matches ORWT.
>     VERSION_FALLBACK_ORDER = ["win-xp", "win-vista", "win-7sp0", "win"]
> 
>-    def _version_string_from_windows_version_tuple(self, windows_version_tuple):
>-        if windows_version_tuple[:3] == (6, 1, 7600):
>-            return '7sp0'
>-        if windows_version_tuple[:2] == (6, 0):
>-            return 'vista'
>-        if windows_version_tuple[:2] == (5, 1):
>-            return 'xp'
>-        return None
>-
>-    def _detect_version(self, os_version_string=None, run_on_non_windows_platforms=None):
>-        # FIXME: os_version_string is for unit testing, but may eventually be provided by factory.py instead.
>-        if os_version_string is not None:
>-            return os_version_string
>-
>-        # No sense in trying to detect our windows version on non-windows platforms, unless we're unittesting.
>-        if sys.platform != 'cygwin' and not run_on_non_windows_platforms:
>-            return None
>-
>-        # Note, this intentionally returns None to mean that it can't detect what the current version is.
>-        # Callers can then decide what version they want to pretend to be.
>-        try:
>-            ver_output = self._executive.run_command(['cmd', '/c', 'ver'])
>-        except (ScriptError, OSError), e:
>-            ver_output = ""
>-            _log.error("Failed to detect Windows version, assuming latest.\n%s" % e)
>-        match_object = re.search(r'(?P<major>\d)\.(?P<minor>\d)\.(?P<build>\d+)', ver_output)
>-        if match_object:
>-            version_tuple = tuple(map(int, match_object.groups()))
>-            return self._version_string_from_windows_version_tuple(version_tuple)
>+    @classmethod
>+    def determine_port_name(cls, host, options, port_name):
>+        if port_name.endswith('-wk2'):
>+            # FIXME: This may be wrong, since options is a global property, and the port_name is specific to this object?
>+            if options and not hasattr(options, 'webkit_test_runner'):
>+                options.webkit_test_runner = True
>+            port_name = port_name.replace('-wk2', '')
>+        if port_name.endswith('win'):
>+            if host.platform.os_name != 'win':
>+                return 'win'
>+            return port_name + '-' + host.platform.os_version
>+        return port_name
>+
> 
>     def compare_text(self, expected_text, actual_text):
>         # Sanity was restored in WK2, so we don't need this hack there.
>diff --git a/Tools/Scripts/webkitpy/layout_tests/port/win_unittest.py b/Tools/Scripts/webkitpy/layout_tests/port/win_unittest.py
>index 972415998f47b5e6939bcdeba6f14fb8467c69d3..54814b317f63e028fde41e70e50ad0689fb34366 100644
>--- a/Tools/Scripts/webkitpy/layout_tests/port/win_unittest.py
>+++ b/Tools/Scripts/webkitpy/layout_tests/port/win_unittest.py
>@@ -26,24 +26,22 @@
> # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
> # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
> 
>-import StringIO
> import sys
> import unittest
> 
> from webkitpy.common.system.executive import ScriptError
> from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2
>-from webkitpy.common.system.filesystem_mock import MockFileSystem
>-from webkitpy.common.host_mock import MockHost
>+from webkitpy.common.system.systemhost_mock import MockSystemHost
> from webkitpy.common.system.outputcapture import OutputCapture
> from webkitpy.layout_tests.port import port_testcase
>+# from webkitpy.layout_tests.port.win import os_version
> from webkitpy.layout_tests.port.win import WinPort
> from webkitpy.tool.mocktool import MockOptions
> 
> 
>-class WinPortTest(port_testcase.PortTestCase):
>-    port_maker = WinPort
>-
>-    def test_show_results_html_file(self):
>+# FIXME: move this to platforminfo_unittest.py
>+class WinOsVersionTest(unittest.TestCase):
>+    def disabled_test_show_results_html_file(self):
>         port = self.make_port()
>         port._executive = MockExecutive(should_log=True)
>         capture = OutputCapture()
>@@ -55,43 +53,64 @@ class WinPortTest(port_testcase.PortTestCase):
>         self.assertTrue(stderr.startswith("MOCK run_command: ['Tools/Scripts/run-safari', '--release', '"))
>         self.assertTrue(stderr.endswith("test.html'], cwd=/mock-checkout\n"))
> 
>-    def test_detect_version(self):
>-        port = self.make_port()
>+    def disabled_test_os_version(self):
>+        orig_getwindowsversion = None
>+        try:
>+            if hasattr(sys, 'getwindowsversion'):
>+                orig_getwindowsversion = getattr(sys, 'getwindowsversion')
> 
>-        def mock_run_command(cmd):
>-            self.assertEquals(cmd, ['cmd', '/c', 'ver'])
>-            return "6.1.7600"
>+            host = MockSystemHost()
> 
>-        port._executive = MockExecutive2(run_command_fn=mock_run_command)
>-        self.assertEquals(port._detect_version(run_on_non_windows_platforms=True), '7sp0')
>+            def mock_run_command(cmd):
>+                self.assertEquals(cmd, ['cmd', '/c', 'ver'])
>+                return "6.1.7600"
> 
>-        def mock_run_command(cmd):
>-            raise ScriptError('Failure')
>+            host.executive = MockExecutive2(run_command_fn=mock_run_command)
>+            self.assertEquals(os_version(host), '7sp0')
>+
>+            def mock_run_command(cmd):
>+                raise ScriptError('Failure')
>+
>+            host.executive = MockExecutive2(run_command_fn=mock_run_command)
>+            self.assertRaises(ScriptError, os_version, host, None)
>+        finally:
>+            if hasattr(sys, 'getwindowsversion'):
>+                sys.getwindowsversion = orig_getwindowsversion
>+
>+
>+class WinPortTest(port_testcase.PortTestCase):
>+    port_name = 'win-future'
>+    port_maker = WinPort
> 
>-        port._executive = MockExecutive2(run_command_fn=mock_run_command)
>-        # Failures log to the python error log, but we have no easy way to capture/test that.
>-        self.assertEquals(port._detect_version(run_on_non_windows_platforms=True), None)
>+    def test_show_results_html_file(self):
>+        port = self.make_port(executive=MockExecutive(should_log=True))
>+        capture = OutputCapture()
>+        capture.capture_output()
>+        port.show_results_html_file('test.html')
>+        _, stderr, _ = capture.restore_output()
>+        # We can't know for sure what path will be produced by cygpath, but we can assert about
>+        # everything else.
>+        self.assertTrue(stderr.startswith("MOCK run_command: ['Tools/Scripts/run-safari', '--release', '"))
>+        self.assertTrue(stderr.endswith("test.html'], cwd=/mock-checkout\n"))
> 
>-    def _assert_search_path(self, expected_search_paths, version, use_webkit2=False):
>-        port = WinPort(os_version_string=version,
>-            options=MockOptions(webkit_test_runner=use_webkit2),
>-            host=MockHost())
>+    def _assert_search_path(self, expected_search_paths, port_name, use_webkit2=False):
>+        port = self.make_port(port_name=port_name, options=MockOptions(webkit_test_runner=use_webkit2))
>         absolute_search_paths = map(port._webkit_baseline_path, expected_search_paths)
>         self.assertEquals(port.baseline_search_path(), absolute_search_paths)
> 
>     def test_baseline_search_path(self):
>-        self._assert_search_path(['win-xp', 'win-vista', 'win-7sp0', 'win', 'mac-lion', 'mac'], 'xp')
>-        self._assert_search_path(['win-vista', 'win-7sp0', 'win', 'mac-lion', 'mac'], 'vista')
>-        self._assert_search_path(['win-7sp0', 'win', 'mac-lion', 'mac'], '7sp0')
>-        self._assert_search_path(['win', 'mac-lion', 'mac'], 'bogus')
>+        self._assert_search_path(['win-xp', 'win-vista', 'win-7sp0', 'win', 'mac-lion', 'mac'], 'win-xp')
>+        self._assert_search_path(['win-vista', 'win-7sp0', 'win', 'mac-lion', 'mac'], 'win-vista')
>+        self._assert_search_path(['win-7sp0', 'win', 'mac-lion', 'mac'], 'win-7sp0')
>+        self._assert_search_path(['win', 'mac-lion', 'mac'], 'win-future')
> 
>-        self._assert_search_path(['win-wk2', 'win-xp', 'win-vista', 'win-7sp0', 'win', 'mac-wk2', 'mac-lion', 'mac'], 'xp', use_webkit2=True)
>-        self._assert_search_path(['win-wk2', 'win-vista', 'win-7sp0', 'win', 'mac-wk2', 'mac-lion', 'mac'], 'vista', use_webkit2=True)
>-        self._assert_search_path(['win-wk2', 'win-7sp0', 'win', 'mac-wk2', 'mac-lion', 'mac'], '7sp0', use_webkit2=True)
>-        self._assert_search_path(['win-wk2', 'win', 'mac-wk2', 'mac-lion', 'mac'], 'bogus', use_webkit2=True)
>+        self._assert_search_path(['win-wk2', 'win-xp', 'win-vista', 'win-7sp0', 'win', 'mac-wk2', 'mac-lion', 'mac'], 'win-xp', use_webkit2=True)
>+        self._assert_search_path(['win-wk2', 'win-vista', 'win-7sp0', 'win', 'mac-wk2', 'mac-lion', 'mac'], 'win-vista', use_webkit2=True)
>+        self._assert_search_path(['win-wk2', 'win-7sp0', 'win', 'mac-wk2', 'mac-lion', 'mac'], 'win-7sp0', use_webkit2=True)
>+        self._assert_search_path(['win-wk2', 'win', 'mac-wk2', 'mac-lion', 'mac'], 'win-future', use_webkit2=True)
> 
>     def _assert_version(self, port_name, expected_version):
>-        port = WinPort(port_name=port_name, host=MockHost())
>+        port = self.make_port(port_name=port_name)
>         self.assertEquals(port.version(), expected_version)
> 
>     def test_versions(self):
>diff --git a/Tools/Scripts/webkitpy/tool/servers/rebaselineserver.py b/Tools/Scripts/webkitpy/tool/servers/rebaselineserver.py
>index 39c5b9e551da1ef0ea90681c494c95559ac8a35a..15bcd6f559431b5e616ed74650428f9e64eb116a 100644
>--- a/Tools/Scripts/webkitpy/tool/servers/rebaselineserver.py
>+++ b/Tools/Scripts/webkitpy/tool/servers/rebaselineserver.py
>@@ -165,7 +165,7 @@ def get_test_baselines(test_file, test_config):
>     # FIXME: This seems like a hack. This only seems used to access the Port.expected_baselines logic.
>     class AllPlatformsPort(WebKitPort):
>         def __init__(self, host):
>-            WebKitPort.__init__(self, host)
>+            WebKitPort.__init__(self, host, 'mac')
>             self._platforms_by_directory = dict([(self._webkit_baseline_path(p), p) for p in test_config.platforms])
> 
>         def baseline_search_path(self):
>diff --git a/Tools/Scripts/webkitpy/tool/servers/rebaselineserver_unittest.py b/Tools/Scripts/webkitpy/tool/servers/rebaselineserver_unittest.py
>index b02d1d35795063d1059b324febcb27e35ad79243..0b9bc43afd4be49488436ee12a2fd47c4244de6a 100644
>--- a/Tools/Scripts/webkitpy/tool/servers/rebaselineserver_unittest.py
>+++ b/Tools/Scripts/webkitpy/tool/servers/rebaselineserver_unittest.py
>@@ -311,7 +311,7 @@ def get_test_config(test_files=[], result_files=[]):
>         port_name = "mac"
> 
>     return TestConfig(
>-        TestMacPort(host),
>+        TestMacPort(host, 'mac'),
>         layout_tests_directory,
>         results_directory,
>         ('mac', 'mac-leopard', 'win', 'linux'),

Actions: View | Formatted Diff | Diff

Attachments on bug 75764: 121529