Changeset 107271 in webkit


Ignore:
Timestamp:
Feb 9, 2012 12:11:06 PM (12 years ago)
Author:
eric@webkit.org
Message:

Rename ports.WebKitPort to DeprecatedPort and make it stop being all class methods
​https://bugs.webkit.org/show_bug.cgi?id=78263

Reviewed by Adam Barth.

  • Scripts/webkitpy/common/config/ports.py:

(DeprecatedPort):
(DeprecatedPort.name):
(DeprecatedPort.flag):
(DeprecatedPort.script_path):
(DeprecatedPort.script_shell_command):
(DeprecatedPort.port):
(DeprecatedPort.makeArgs):
(DeprecatedPort.update_webkit_command):
(DeprecatedPort.check_webkit_style_command):
(DeprecatedPort.prepare_changelog_command):
(DeprecatedPort.build_webkit_command):
(DeprecatedPort.run_javascriptcore_tests_command):
(DeprecatedPort.run_webkit_unit_tests_command):
(DeprecatedPort.run_webkit_tests_command):
(DeprecatedPort.run_python_unittests_command):
(DeprecatedPort.run_perl_unittests_command):
(DeprecatedPort.layout_tests_results_path):
(MacPort):
(WinPort):
(GtkPort):
(GtkPort.build_webkit_command):
(GtkPort.run_webkit_tests_command):
(QtPort):
(QtPort.build_webkit_command):
(EflPort):
(EflPort.build_webkit_command):
(ChromiumPort):
(ChromiumPort.update_webkit_command):
(ChromiumPort.build_webkit_command):
(ChromiumPort.run_webkit_tests_command):
(ChromiumPort.run_javascriptcore_tests_command):
(ChromiumXVFBPort):
(ChromiumXVFBPort.run_webkit_tests_command):

  • Scripts/webkitpy/common/config/ports_unittest.py:

(DeprecatedPortTest):
(DeprecatedPortTest.test_mac_port):
(DeprecatedPortTest.test_gtk_port):
(DeprecatedPortTest.test_qt_port):
(DeprecatedPortTest.test_chromium_port):
(DeprecatedPortTest.test_chromium_xvfb_port):

  • Scripts/webkitpy/tool/commands/earlywarningsystem.py:

(AbstractEarlyWarningSystem.init):

  • Scripts/webkitpy/tool/commands/sheriffbot.py:
  • Scripts/webkitpy/tool/main.py:

(WebKitPatch):
(WebKitPatch.handle_global_options):

  • Scripts/webkitpy/tool/steps/abstractstep.py:
  • Scripts/webkitpy/tool/steps/steps_unittest.py:

(StepsTest.test_runtests_args):

Location:
trunk/Tools
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r107255 r107271  
     12012-02-09  Eric Seidel  <eric@webkit.org>
     2
     3        Rename ports.WebKitPort to DeprecatedPort and make it stop being all class methods
     4        https://bugs.webkit.org/show_bug.cgi?id=78263
     5
     6        Reviewed by Adam Barth.
     7
     8        * Scripts/webkitpy/common/config/ports.py:
     9        (DeprecatedPort):
     10        (DeprecatedPort.name):
     11        (DeprecatedPort.flag):
     12        (DeprecatedPort.script_path):
     13        (DeprecatedPort.script_shell_command):
     14        (DeprecatedPort.port):
     15        (DeprecatedPort.makeArgs):
     16        (DeprecatedPort.update_webkit_command):
     17        (DeprecatedPort.check_webkit_style_command):
     18        (DeprecatedPort.prepare_changelog_command):
     19        (DeprecatedPort.build_webkit_command):
     20        (DeprecatedPort.run_javascriptcore_tests_command):
     21        (DeprecatedPort.run_webkit_unit_tests_command):
     22        (DeprecatedPort.run_webkit_tests_command):
     23        (DeprecatedPort.run_python_unittests_command):
     24        (DeprecatedPort.run_perl_unittests_command):
     25        (DeprecatedPort.layout_tests_results_path):
     26        (MacPort):
     27        (WinPort):
     28        (GtkPort):
     29        (GtkPort.build_webkit_command):
     30        (GtkPort.run_webkit_tests_command):
     31        (QtPort):
     32        (QtPort.build_webkit_command):
     33        (EflPort):
     34        (EflPort.build_webkit_command):
     35        (ChromiumPort):
     36        (ChromiumPort.update_webkit_command):
     37        (ChromiumPort.build_webkit_command):
     38        (ChromiumPort.run_webkit_tests_command):
     39        (ChromiumPort.run_javascriptcore_tests_command):
     40        (ChromiumXVFBPort):
     41        (ChromiumXVFBPort.run_webkit_tests_command):
     42        * Scripts/webkitpy/common/config/ports_unittest.py:
     43        (DeprecatedPortTest):
     44        (DeprecatedPortTest.test_mac_port):
     45        (DeprecatedPortTest.test_gtk_port):
     46        (DeprecatedPortTest.test_qt_port):
     47        (DeprecatedPortTest.test_chromium_port):
     48        (DeprecatedPortTest.test_chromium_xvfb_port):
     49        * Scripts/webkitpy/tool/commands/earlywarningsystem.py:
     50        (AbstractEarlyWarningSystem.__init__):
     51        * Scripts/webkitpy/tool/commands/sheriffbot.py:
     52        * Scripts/webkitpy/tool/main.py:
     53        (WebKitPatch):
     54        (WebKitPatch.handle_global_options):
     55        * Scripts/webkitpy/tool/steps/abstractstep.py:
     56        * Scripts/webkitpy/tool/steps/steps_unittest.py:
     57        (StepsTest.test_runtests_args):
     58
    1592012-02-09  Jochen Eisinger  <jochen@chromium.org>
    260

  • trunk/Tools/Scripts/webkitpy/common/config/ports.py

    r106518 r107271  
    3636
    3737
    38 class WebKitPort(object):
     38class DeprecatedPort(object):
    3939    results_directory = "/tmp/layout-test-results"
    4040
     41    # FIXME: This is only used by BotInfo.
     42    def name(self):
     43        return self.__class__
     44
     45    def flag(self):
     46        if self.port_flag_name:
     47            return "--port=%s" % self.port_flag_name
     48        return None
     49
    4150    # We might need to pass scm into this function for scm.checkout_root
    42     @classmethod
    43     def script_path(cls, script_name):
     51    def script_path(self, script_name):
    4452        return os.path.join("Tools", "Scripts", script_name)
    4553
    46     @classmethod
    47     def script_shell_command(cls, script_name):
    48         script_path = cls.script_path(script_name)
     54    def script_shell_command(self, script_name):
     55        script_path = self.script_path(script_name)
    4956        return Executive.shell_command_for_script(script_path)
    5057
    … …  
    6572        }
    6673        # Do we really need MacPort as the ultimate default?
    67         return ports.get(port_name, default_port.get(platform.system(), MacPort))
     74        return ports.get(port_name, default_port.get(platform.system(), MacPort))()
    6875
    69     @staticmethod
    70     def makeArgs():
     76    def makeArgs(self):
     77        # FIXME: This shouldn't use a static Executive().
    7178        args = '--makeargs="-j%s"' % Executive().cpu_count()
    7279        if os.environ.has_key('MAKEFLAGS'):
    … …  
    7481        return args
    7582
    76     @classmethod
    77     def name(cls):
    78         raise NotImplementedError("subclasses must implement")
     83    def update_webkit_command(self, non_interactive=False):
     84        return self.script_shell_command("update-webkit")
    7985
    80     @classmethod
    81     def flag(cls):
    82         raise NotImplementedError("subclasses must implement")
     86    def check_webkit_style_command(self):
     87        return self.script_shell_command("check-webkit-style")
    8388
    84     @classmethod
    85     def update_webkit_command(cls, non_interactive=False):
    86         return cls.script_shell_command("update-webkit")
     89    def prepare_changelog_command(self):
     90        return self.script_shell_command("prepare-ChangeLog")
    8791
    88     @classmethod
    89     def check_webkit_style_command(cls):
    90         return cls.script_shell_command("check-webkit-style")
    91 
    92     @classmethod
    93     def prepare_changelog_command(cls):
    94         return cls.script_shell_command("prepare-ChangeLog")
    95 
    96     @classmethod
    97     def build_webkit_command(cls, build_style=None):
    98         command = cls.script_shell_command("build-webkit")
     92    def build_webkit_command(self, build_style=None):
     93        command = self.script_shell_command("build-webkit")
    9994        if build_style == "debug":
    10095            command.append("--debug")
    … …  
    10398        return command
    10499
    105     @classmethod
    106     def run_javascriptcore_tests_command(cls):
    107         return cls.script_shell_command("run-javascriptcore-tests")
     100    def run_javascriptcore_tests_command(self):
     101        return self.script_shell_command("run-javascriptcore-tests")
    108102
    109     @classmethod
    110     def run_webkit_unit_tests_command(cls):
     103    def run_webkit_unit_tests_command(self):
    111104        return None
    112105
    113     @classmethod
    114     def run_webkit_tests_command(cls):
    115         return cls.script_shell_command("run-webkit-tests")
     106    def run_webkit_tests_command(self):
     107        return self.script_shell_command("run-webkit-tests")
    116108
    117     @classmethod
    118     def run_python_unittests_command(cls):
    119         return cls.script_shell_command("test-webkitpy")
     109    def run_python_unittests_command(self):
     110        return self.script_shell_command("test-webkitpy")
    120111
    121     @classmethod
    122     def run_perl_unittests_command(cls):
    123         return cls.script_shell_command("test-webkitperl")
     112    def run_perl_unittests_command(self):
     113        return self.script_shell_command("test-webkitperl")
    124114
    125     @classmethod
    126     def layout_tests_results_path(cls):
    127         return os.path.join(cls.results_directory, "full_results.json")
     115    def layout_tests_results_path(self):
     116        return os.path.join(self.results_directory, "full_results.json")
    128117
    129118
    130 class MacPort(WebKitPort):
    131 
    132     @classmethod
    133     def name(cls):
    134         return "Mac"
    135 
    136     @classmethod
    137     def flag(cls):
    138         return "--port=mac"
    139 
    140     @classmethod
    141     def _system_version(cls):
    142         version_string = platform.mac_ver()[0]  # e.g. "10.5.6"
    143         version_tuple = version_string.split('.')
    144         return map(int, version_tuple)
    145 
    146     @classmethod
    147     def is_leopard(cls):
    148         return tuple(cls._system_version()[:2]) == (10, 5)
     119class MacPort(DeprecatedPort):
     120    port_flag_name = "mac"
    149121
    150122
    151 class WinPort(WebKitPort):
    152 
    153     @classmethod
    154     def name(cls):
    155         return "Win"
    156 
    157     @classmethod
    158     def flag(cls):
    159         # FIXME: This is lame.  We should autogenerate this from a codename or something.
    160         return "--port=win"
     123class WinPort(DeprecatedPort):
     124    port_flag_name = "win"
    161125
    162126
    163 class GtkPort(WebKitPort):
     127class GtkPort(DeprecatedPort):
     128    port_flag_name = "gtk"
    164129
    165     @classmethod
    166     def name(cls):
    167         return "Gtk"
    168 
    169     @classmethod
    170     def flag(cls):
    171         return "--port=gtk"
    172 
    173     @classmethod
    174     def build_webkit_command(cls, build_style=None):
    175         command = WebKitPort.build_webkit_command(build_style=build_style)
     130    def build_webkit_command(self, build_style=None):
     131        command = super(GtkPort, self).build_webkit_command(build_style=build_style)
    176132        command.append("--gtk")
    177133        command.append("--update-gtk")
    178         command.append(WebKitPort.makeArgs())
     134        command.append(super(GtkPort, self).makeArgs())
    179135        return command
    180136
    181     @classmethod
    182     def run_webkit_tests_command(cls):
    183         command = WebKitPort.run_webkit_tests_command()
     137    def run_webkit_tests_command(self):
     138        command = super(GtkPort, self).run_webkit_tests_command()
    184139        command.append("--gtk")
    185140        return command
    186141
    187142
    188 class QtPort(WebKitPort):
     143class QtPort(DeprecatedPort):
     144    port_flag_name = "qt"
    189145
    190     @classmethod
    191     def name(cls):
    192         return "Qt"
    193 
    194     @classmethod
    195     def flag(cls):
    196         return "--port=qt"
    197 
    198     @classmethod
    199     def build_webkit_command(cls, build_style=None):
    200         command = WebKitPort.build_webkit_command(build_style=build_style)
     146    def build_webkit_command(self, build_style=None):
     147        command = super(QtPort, self).build_webkit_command(build_style=build_style)
    201148        command.append("--qt")
    202         command.append(WebKitPort.makeArgs())
     149        command.append(super(QtPort, self).makeArgs())
    203150        return command
    204151
    205152
    206 class EflPort(WebKitPort):
     153class EflPort(DeprecatedPort):
     154    port_flag_name = "efl"
    207155
    208     @classmethod
    209     def name(cls):
    210         return "Efl"
    211 
    212     @classmethod
    213     def flag(cls):
    214         return "--port=efl"
    215 
    216     @classmethod
    217     def build_webkit_command(cls, build_style=None):
    218         command = WebKitPort.build_webkit_command(build_style=build_style)
     156    def build_webkit_command(self, build_style=None):
     157        command = super(EflPort, self).build_webkit_command(build_style=build_style)
    219158        command.append("--efl")
    220         command.append(WebKitPort.makeArgs())
     159        command.append(super(EflPort, self).makeArgs())
    221160        return command
    222161
    223162
    224 class ChromiumPort(WebKitPort):
     163class ChromiumPort(DeprecatedPort):
     164    port_flag_name = "chromium"
    225165
    226     @classmethod
    227     def name(cls):
    228         return "Chromium"
    229 
    230     @classmethod
    231     def flag(cls):
    232         return "--port=chromium"
    233 
    234     @classmethod
    235     def update_webkit_command(cls, non_interactive=False):
    236         command = WebKitPort.update_webkit_command(non_interactive=non_interactive)
     166    def update_webkit_command(self, non_interactive=False):
     167        command = super(ChromiumPort, self).update_webkit_command(non_interactive=non_interactive)
    237168        command.append("--chromium")
    238169        if non_interactive:
    … …  
    240171        return command
    241172
    242     @classmethod
    243     def build_webkit_command(cls, build_style=None):
    244         command = WebKitPort.build_webkit_command(build_style=build_style)
     173    def build_webkit_command(self, build_style=None):
     174        command = super(ChromiumPort, self).build_webkit_command(build_style=build_style)
    245175        command.append("--chromium")
    246176        command.append("--update-chromium")
    247177        return command
    248178
    249     @classmethod
    250     def run_webkit_tests_command(cls):
    251         command = cls.script_shell_command("new-run-webkit-tests")
     179    def run_webkit_tests_command(self):
     180        # Note: This could be run-webkit-tests now.
     181        command = self.script_shell_command("new-run-webkit-tests")
    252182        command.append("--chromium")
    253183        command.append("--skip-failing-tests")
    254184        return command
    255185
    256     @classmethod
    257     def run_javascriptcore_tests_command(cls):
     186    def run_javascriptcore_tests_command(self):
    258187        return None
    259188
    260189
    261190class ChromiumXVFBPort(ChromiumPort):
     191    port_flag_name = "chromium-xvfb"
    262192
    263     @classmethod
    264     def flag(cls):
    265         return "--port=chromium-xvfb"
    266 
    267     @classmethod
    268     def run_webkit_tests_command(cls):
    269         return ["xvfb-run"] + ChromiumPort.run_webkit_tests_command()
     193    def run_webkit_tests_command(self):
     194        return ["xvfb-run"] + super(ChromiumXVFBPort, self).run_webkit_tests_command()

  • trunk/Tools/Scripts/webkitpy/common/config/ports_unittest.py

    r106518 r107271  
    3333
    3434
    35 class WebKitPortTest(unittest.TestCase):
     35class DeprecatedPortTest(unittest.TestCase):
    3636    def test_mac_port(self):
    37         self.assertEquals(MacPort.name(), "Mac")
    38         self.assertEquals(MacPort.flag(), "--port=mac")
    39         self.assertEquals(MacPort.run_webkit_tests_command(), WebKitPort.script_shell_command("run-webkit-tests"))
    40         self.assertEquals(MacPort.build_webkit_command(), WebKitPort.script_shell_command("build-webkit"))
    41         self.assertEquals(MacPort.build_webkit_command(build_style="debug"), WebKitPort.script_shell_command("build-webkit") + ["--debug"])
    42         self.assertEquals(MacPort.build_webkit_command(build_style="release"), WebKitPort.script_shell_command("build-webkit") + ["--release"])
    43 
    44         class TestIsLeopard(MacPort):
    45             @classmethod
    46             def _system_version(cls):
    47                 return [10, 5]
    48         self.assertTrue(TestIsLeopard.is_leopard())
     37        self.assertEquals(MacPort().flag(), "--port=mac")
     38        self.assertEquals(MacPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("run-webkit-tests"))
     39        self.assertEquals(MacPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit"))
     40        self.assertEquals(MacPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug"])
     41        self.assertEquals(MacPort().build_webkit_command(build_style="release"), DeprecatedPort().script_shell_command("build-webkit") + ["--release"])
    4942
    5043    def test_gtk_port(self):
    51         self.assertEquals(GtkPort.name(), "Gtk")
    52         self.assertEquals(GtkPort.flag(), "--port=gtk")
    53         self.assertEquals(GtkPort.run_webkit_tests_command(), WebKitPort.script_shell_command("run-webkit-tests") + ["--gtk"])
    54         self.assertEquals(GtkPort.build_webkit_command(), WebKitPort.script_shell_command("build-webkit") + ["--gtk", "--update-gtk", WebKitPort.makeArgs()])
    55         self.assertEquals(GtkPort.build_webkit_command(build_style="debug"), WebKitPort.script_shell_command("build-webkit") + ["--debug", "--gtk", "--update-gtk", WebKitPort.makeArgs()])
     44        self.assertEquals(GtkPort().flag(), "--port=gtk")
     45        self.assertEquals(GtkPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("run-webkit-tests") + ["--gtk"])
     46        self.assertEquals(GtkPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--gtk", "--update-gtk", DeprecatedPort().makeArgs()])
     47        self.assertEquals(GtkPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--gtk", "--update-gtk", DeprecatedPort().makeArgs()])
    5648
    5749    def test_qt_port(self):
    58         self.assertEquals(QtPort.name(), "Qt")
    59         self.assertEquals(QtPort.flag(), "--port=qt")
    60         self.assertEquals(QtPort.run_webkit_tests_command(), WebKitPort.script_shell_command("run-webkit-tests"))
    61         self.assertEquals(QtPort.build_webkit_command(), WebKitPort.script_shell_command("build-webkit") + ["--qt", WebKitPort.makeArgs()])
    62         self.assertEquals(QtPort.build_webkit_command(build_style="debug"), WebKitPort.script_shell_command("build-webkit") + ["--debug", "--qt", WebKitPort.makeArgs()])
     50        self.assertEquals(QtPort().flag(), "--port=qt")
     51        self.assertEquals(QtPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("run-webkit-tests"))
     52        self.assertEquals(QtPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--qt", DeprecatedPort().makeArgs()])
     53        self.assertEquals(QtPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--qt", DeprecatedPort().makeArgs()])
    6354
    6455    def test_chromium_port(self):
    65         self.assertEquals(ChromiumPort.name(), "Chromium")
    66         self.assertEquals(ChromiumPort.flag(), "--port=chromium")
    67         self.assertEquals(ChromiumPort.run_webkit_tests_command(), WebKitPort.script_shell_command("new-run-webkit-tests") + ["--chromium", "--skip-failing-tests"])
    68         self.assertEquals(ChromiumPort.build_webkit_command(), WebKitPort.script_shell_command("build-webkit") + ["--chromium", "--update-chromium"])
    69         self.assertEquals(ChromiumPort.build_webkit_command(build_style="debug"), WebKitPort.script_shell_command("build-webkit") + ["--debug", "--chromium", "--update-chromium"])
    70         self.assertEquals(ChromiumPort.update_webkit_command(), WebKitPort.script_shell_command("update-webkit") + ["--chromium"])
     56        self.assertEquals(ChromiumPort().flag(), "--port=chromium")
     57        self.assertEquals(ChromiumPort().run_webkit_tests_command(), DeprecatedPort().script_shell_command("new-run-webkit-tests") + ["--chromium", "--skip-failing-tests"])
     58        self.assertEquals(ChromiumPort().build_webkit_command(), DeprecatedPort().script_shell_command("build-webkit") + ["--chromium", "--update-chromium"])
     59        self.assertEquals(ChromiumPort().build_webkit_command(build_style="debug"), DeprecatedPort().script_shell_command("build-webkit") + ["--debug", "--chromium", "--update-chromium"])
     60        self.assertEquals(ChromiumPort().update_webkit_command(), DeprecatedPort().script_shell_command("update-webkit") + ["--chromium"])
    7161
    7262    def test_chromium_xvfb_port(self):
    73         self.assertEquals(ChromiumXVFBPort.run_webkit_tests_command(), ['xvfb-run'] + WebKitPort.script_shell_command('new-run-webkit-tests') + ['--chromium', '--skip-failing-tests'])
     63        self.assertEquals(ChromiumXVFBPort().run_webkit_tests_command(), ['xvfb-run'] + DeprecatedPort().script_shell_command('new-run-webkit-tests') + ['--chromium', '--skip-failing-tests'])
     64
    7465
    7566if __name__ == '__main__':

  • trunk/Tools/Scripts/webkitpy/tool/commands/earlywarningsystem.py

    r106509 r107271  
    2828
    2929from webkitpy.common.config.committers import CommitterList
    30 from webkitpy.common.config.ports import WebKitPort
     30from webkitpy.common.config.ports import DeprecatedPort
    3131from webkitpy.common.system.deprecated_logging import error, log
    3232from webkitpy.common.system.executive import ScriptError
    … …  
    4545    def __init__(self):
    4646        AbstractReviewQueue.__init__(self)
    47         self.port = WebKitPort.port(self.port_name)
     47        self.port = DeprecatedPort.port(self.port_name)
    4848
    4949    def should_proceed_with_work_item(self, patch):

  • trunk/Tools/Scripts/webkitpy/tool/commands/sheriffbot.py

    r90636 r107271  
    3030
    3131from webkitpy.common.system.deprecated_logging import log
    32 from webkitpy.common.config.ports import WebKitPort
    3332from webkitpy.tool.bot.sheriff import Sheriff
    3433from webkitpy.tool.bot.sheriffircbot import SheriffIRCBot

  • trunk/Tools/Scripts/webkitpy/tool/main.py

    r104998 r107271  
    3434import threading
    3535
    36 from webkitpy.common.config.ports import WebKitPort
     36from webkitpy.common.config.ports import DeprecatedPort
    3737from webkitpy.common.host import Host
    3838from webkitpy.common.net.irc import ircproxy
    … …  
    6262        self._deprecated_port = None
    6363
     64    # FIXME: Rename this deprecated_port()
    6465    def port(self):
    6566        return self._deprecated_port
    … …  
    99100            self.irc_password = options.irc_password
    100101        # If options.port is None, we'll get the default port for this platform.
    101         self._deprecated_port = WebKitPort.port(options.port)
     102        self._deprecated_port = DeprecatedPort.port(options.port)
    102103
    103104    def should_execute_command(self, command):

  • trunk/Tools/Scripts/webkitpy/tool/steps/abstractstep.py

    r106721 r107271  
    3030
    3131from webkitpy.common.system.executive import ScriptError
    32 from webkitpy.common.config.ports import WebKitPort
    3332from webkitpy.tool.steps.options import Options
    3433

  • trunk/Tools/Scripts/webkitpy/tool/steps/steps_unittest.py

    r106518 r107271  
    3030
    3131from webkitpy.common.system.outputcapture import OutputCapture
    32 from webkitpy.common.config.ports import WebKitPort
     32from webkitpy.common.config.ports import DeprecatedPort
    3333from webkitpy.tool.mocktool import MockOptions, MockTool
    3434
    … …  
    101101        step = steps.RunTests(MockTool(log_executive=True), mock_options)
    102102        # FIXME: We shouldn't use a real port-object here, but there is too much to mock at the moment.
    103         mock_port = WebKitPort()
    104         mock_port.name = lambda: "Mac"
     103        mock_port = DeprecatedPort()
    105104        tool = MockTool(log_executive=True)
    106105        tool.port = lambda: mock_port
Note: See TracChangeset for help on using the changeset viewer.