Change rebaseline-test-internal to take port name option.

third_party/WebKit/Tools/Scripts/webkitpy/tool/commands/rebaseline_unittest.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import json
 import optparse
 import unittest
 
 from webkitpy.common.net.buildbot import Build
 from webkitpy.common.net.layout_test_results import LayoutTestResults
 from webkitpy.common.system.executive_mock import MockExecutive
 from webkitpy.common.system.output_capture import OutputCapture
 from webkitpy.layout_tests.builder_list import BuilderList
 from webkitpy.layout_tests.port.factory_mock import MockPortFactory
 from webkitpy.tool.commands.rebaseline import (
@@ skipping 93 matching lines @@
     command_constructor = CopyExistingBaselinesInternal
 
     def setUp(self):
         super(TestCopyExistingBaselinesInternal, self).setUp()
 
     def options(self, **kwargs):
         options_dict = {
             'results_directory': None,
             'suffixes': 'txt',
             'verbose': False,
+            'port_name': None,
         }
         options_dict.update(kwargs)
         return optparse.Values(options_dict)
 
     def baseline_path(self, path_from_layout_test_dir):
         port = self.tool.port_factory.get()
         return self.tool.filesystem.join(port.layout_tests_dir(), path_from_layout_test_dir)
 
     # The tests in this class all depend on the fall-back path graph
     # that is set up in |TestPort.FALLBACK_PATHS|.
 
     def test_copy_baseline_mac_newer_to_older_version(self):
         # The test-mac-mac10.11 baseline is copied over to the test-mac-mac10.10
         # baseline directory because test-mac-mac10.10 is the "immediate
         # predecessor" in the fall-back graph.
         self._write(
             self.baseline_path('platform/test-mac-mac10.11/failures/expected/image-expected.txt'),
             'original test-mac-mac10.11 result')
         self.assertFalse(self.tool.filesystem.exists(
             self.baseline_path('platform/test-mac-mac10.10/failures/expected/image-expected.txt')))
 
-        self.command.execute(self.options(builder='MOCK Mac10.11', test='failures/expected/image.html'), [], self.tool)
+        self.command.execute(self.options(port_name='test-mac-mac10.11', test='failures/expected/image.html'), [], self.tool)
 
         self.assertEqual(
             self._read(self.baseline_path('platform/test-mac-mac10.11/failures/expected/image-expected.txt')),
             'original test-mac-mac10.11 result')
         self.assertEqual(
             self._read(self.baseline_path('platform/test-mac-mac10.10/failures/expected/image-expected.txt')),
             'original test-mac-mac10.11 result')
 
-    def test_copy_baseline_win10_to_linux_trusty_and_win7(self):
+    def test_copy_baseline_to_multiple_immediate_predecessors(self):
         # The test-win-win10 baseline is copied over to the test-linux-trusty
         # and test-win-win7 baseline paths, since both of these are "immediate
         # predecessors".
         self._write(
             self.baseline_path('platform/test-win-win10/failures/expected/image-expected.txt'),
             'original test-win-win10 result')
         self.assertFalse(self.tool.filesystem.exists(
             self.baseline_path('platform/test-linux-trusty/failures/expected/image-expected.txt')))
 
-        self.command.execute(self.options(builder='MOCK Win10', test='failures/expected/image.html'), [], self.tool)
+        self.command.execute(self.options(port_name='test-win-win10', test='failures/expected/image.html'), [], self.tool)
 
         self.assertEqual(
             self._read(self.baseline_path('platform/test-win-win10/failures/expected/image-expected.txt')),
             'original test-win-win10 result')
         self.assertEqual(
             self._read(self.baseline_path('platform/test-linux-trusty/failures/expected/image-expected.txt')),
             'original test-win-win10 result')
         self.assertEqual(
             self._read(self.baseline_path('platform/test-linux-trusty/failures/expected/image-expected.txt')),
             'original test-win-win10 result')
 
     def test_no_copy_existing_baseline(self):
         # If a baseline exists already for an "immediate prdecessor" baseline
         # directory, (e.g. test-linux-trusty), then no "immediate successor"
         # baselines (e.g. test-win-win10) are copied over.
         self._write(
             self.baseline_path('platform/test-win-win10/failures/expected/image-expected.txt'),
             'original test-win-win10 result')
         self._write(
             self.baseline_path('platform/test-linux-trusty/failures/expected/image-expected.txt'),
             'original test-linux-trusty result')
 
-        self.command.execute(self.options(builder='MOCK Win10', test='failures/expected/image.html'), [], self.tool)
+        self.command.execute(self.options(port_name='test-win-win10', test='failures/expected/image.html'), [], self.tool)
 
         self.assertEqual(
             self._read(self.baseline_path('platform/test-win-win10/failures/expected/image-expected.txt')),
             'original test-win-win10 result')
         self.assertEqual(
             self._read(self.baseline_path('platform/test-linux-trusty/failures/expected/image-expected.txt')),
             'original test-linux-trusty result')
 
     def test_no_copy_skipped_test(self):
         # If a test is skipped on some platform, no baselines are copied over
         # to that directory. In this example, the test is skipped on linux,
         # so the test-win-win10 baseline is not copied over.
         port = self.tool.port_factory.get('test-win-win10')
         self._write(
             self.baseline_path('platform/test-win-win10/failures/expected/image-expected.txt'),
             'original test-win-win10 result')
         self._write(
             port.path_to_generic_test_expectations_file(),
             ('[ Win ] failures/expected/image.html [ Failure ]\n'
              '[ Linux ] failures/expected/image.html [ Skip ]\n'))
 
-        self.command.execute(self.options(builder='MOCK Win10', test='failures/expected/image.html'), [], self.tool)
+        self.command.execute(self.options(port_name='test-win-win10', test='failures/expected/image.html'), [], self.tool)
 
         self.assertFalse(
             self.tool.filesystem.exists(self.baseline_path('platform/test-linux-trusty/failures/expected/image-expected.txt')))
 
     def test_port_for_primary_baseline(self):
         self.assertEqual(self.command._port_for_primary_baseline('test-linux-trusty').name(), 'test-linux-trusty')
         self.assertEqual(self.command._port_for_primary_baseline('test-mac-mac10.11').name(), 'test-mac-mac10.11')
 
     def test_port_for_primary_baseline_not_found(self):
         with self.assertRaises(Exception):
             self.command._port_for_primary_baseline('test-foo-foo4.7')
 
 
 class TestRebaselineTest(BaseTestCase):
     command_constructor = RebaselineTest  # AKA webkit-patch rebaseline-test-internal
 
     def setUp(self):
         super(TestRebaselineTest, self).setUp()
 
     @staticmethod
     def options(**kwargs):
         return optparse.Values(dict({
             'builder': 'MOCK Mac10.11',
+            'port_name': None,
             'test': 'userscripts/another-test.html',
             'suffixes': 'txt',
             'results_directory': None,
             'build_number': None
         }, **kwargs))
 
     def test_baseline_directory(self):
         command = self.command
         self.assertMultiLineEqual(command._baseline_directory('MOCK Mac10.11'),
                                   '/test.checkout/LayoutTests/platform/test-mac-mac10.11')
@@ skipping 20 matching lines @@
                               [self.WEB_PREFIX + '/userscripts/another-test-actual.png',
                                self.WEB_PREFIX + '/userscripts/another-test-actual.wav',
                                self.WEB_PREFIX + '/userscripts/another-test-actual.txt'])
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations,
             ('Bug(B) [ Mac Linux Win7 Debug ] fast/dom/Window/window-postmessage-clone-really-deep-array.html [ Pass ]\n'
              'Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ]\n'))
 
     def test_rebaseline_test(self):
-        self.command._rebaseline_test('MOCK Trusty', 'userscripts/another-test.html', 'txt', self.WEB_PREFIX)
+        self.command._rebaseline_test('test-linux-trusty', 'userscripts/another-test.html', 'txt', self.WEB_PREFIX)
         self.assertItemsEqual(self.tool.web.urls_fetched, [self.WEB_PREFIX + '/userscripts/another-test-actual.txt'])
 
     def test_rebaseline_test_with_results_directory(self):
         self._write('userscripts/another-test.html', 'test data')
         self._write(
             self.mac_expectations_path,
             ('Bug(x) [ Mac ] userscripts/another-test.html [ Failure ]\n'
              'bug(z) [ Linux ] userscripts/another-test.html [ Failure ]\n'))
         self.command._rebaseline_test_and_update_expectations(self.options(results_directory='/tmp'))
         self.assertItemsEqual(self.tool.web.urls_fetched, ['file:///tmp/userscripts/another-test-actual.txt'])
@@ skipping 14 matching lines @@
             port.host.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-win-win10/failures/expected/image-expected.txt'),
             'original win10 result')
 
         oc = OutputCapture()
         try:
             options = optparse.Values({
                 'optimize': True,
                 'builder': 'MOCK Win10',
+                'port_name': None,
                 'suffixes': 'txt',
                 'verbose': True,
                 'test': 'failures/expected/image.html',
                 'results_directory': None,
                 'build_number': None
             })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
             out, _, _ = oc.restore_output()
 
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
                 'platform/test-win-win10/failures/expected/image-expected.txt')),
             'MOCK Web result, convert 404 to None=True')
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
             port.layout_tests_dir(), 'platform/test-win-win7/failures/expected/image-expected.txt')))
         self.assertMultiLineEqual(
-            out, '{"remove-lines": [{"test": "failures/expected/image.html", "builder": "MOCK Win10"}]}\n')
+            out, '{"remove-lines": [{"test": "failures/expected/image.html", "port_name": "test-win-win10"}]}\n')
 
 
 class TestAbstractParallelRebaselineCommand(BaseTestCase):
     command_constructor = AbstractParallelRebaselineCommand
 
     def test_builders_to_fetch_from(self):
         builders_to_fetch = self.command._builders_to_fetch_from(
             ['MOCK Win10', 'MOCK Win7 (dbg)(1)', 'MOCK Win7 (dbg)(2)', 'MOCK Win7'])
         self.assertEqual(builders_to_fetch, {'MOCK Win7', 'MOCK Win10'})
 
@@ skipping 76 matching lines @@
         self._setup_mock_build_data()
 
         self._write('userscripts/first-test.html', 'Dummy test contents')
         test_baseline_set = TestBaselineSet(self.tool)
         test_baseline_set.add('userscripts/first-test.html', Build('MOCK Win7'))
         self.command.rebaseline(self.options(), test_baseline_set)
 
         self.assertEqual(
             self.tool.executive.calls,
             [
-                [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                  '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
-                [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                  '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
-                [['python', 'echo', 'optimize-baselines', '--suffixes', 'txt,png',
-                  'userscripts/first-test.html', '--verbose']]
+                [[
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+                ]],
+                [[
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+                    '--builder', 'MOCK Win7',
+                ]],
+                [[
+                    'python', 'echo', 'optimize-baselines',
+                    '--verbose',
+                    '--suffixes', 'txt,png',
+                    'userscripts/first-test.html',
+                ]]
             ])
 
     def test_rebaseline_debug(self):
         self._setup_mock_build_data()
         self._write('userscripts/first-test.html', 'Dummy test contents')
         test_baseline_set = TestBaselineSet(self.tool)
         test_baseline_set.add('userscripts/first-test.html', Build('MOCK Win7 (dbg)'))
 
         self.command.rebaseline(self.options(), test_baseline_set)
 
         self.assertEqual(
             self.tool.executive.calls,
             [
-                [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                  '--builder', 'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']],
-                [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder',
-                  'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']],
-                [['python', 'echo', 'optimize-baselines', '--suffixes', 'txt,png',
-                  'userscripts/first-test.html', '--verbose']]
+                [[
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+                ]],
+                [[
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+                    '--builder', 'MOCK Win7 (dbg)',
+                ]],
+                [[
+                    'python', 'echo', 'optimize-baselines',
+                    '--verbose',
+                    '--suffixes', 'txt,png',
+                    'userscripts/first-test.html',
+                ]]
             ])
 
     def test_no_optimize(self):
         self._setup_mock_build_data()
         self._write('userscripts/first-test.html', 'Dummy test contents')
         test_baseline_set = TestBaselineSet(self.tool)
         test_baseline_set.add('userscripts/first-test.html', Build('MOCK Win7'))
         self.command.rebaseline(self.options(optimize=False), test_baseline_set)
 
         self.assertEqual(
             self.tool.executive.calls,
             [
-                [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                  '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
-                [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                  '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']]
+                [[
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+
+                ]],
+                [[
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+                    '--builder', 'MOCK Win7',
+                ]]
             ])
 
     def test_results_directory(self):
         self._setup_mock_build_data()
         self._write('userscripts/first-test.html', 'Dummy test contents')
         test_baseline_set = TestBaselineSet(self.tool)
         test_baseline_set.add('userscripts/first-test.html', Build('MOCK Win7'))
         self.command.rebaseline(self.options(optimize=False, results_directory='/tmp'), test_baseline_set)
 
         self.assertEqual(
             self.tool.executive.calls,
             [
-                [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                  '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
-                [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                  '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose', '--results-directory', '/tmp']]
+                [[
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+                ]],
+                [[
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+                    '--builder', 'MOCK Win7',
+                    '--results-directory', '/tmp']]
             ])
 
     def test_unstaged_baselines(self):
         git = self.tool.git()
         git.unstaged_changes = lambda: {
             'third_party/WebKit/LayoutTests/x/foo-expected.txt': 'M',
             'third_party/WebKit/LayoutTests/x/foo-expected.something': '?',
             'third_party/WebKit/LayoutTests/x/foo-expected.png': '?',
             'third_party/WebKit/LayoutTests/x/foo.html': 'M',
             'docs/something.md': '?',
         }
         self.assertEqual(
             self.command.unstaged_baselines(),
             [
                 '/mock-checkout/third_party/WebKit/LayoutTests/x/foo-expected.png',
                 '/mock-checkout/third_party/WebKit/LayoutTests/x/foo-expected.txt',
             ])
 
 
 class TestRebaselineUpdatesExpectationsFiles(BaseTestCase):
     """Tests for the logic related to updating the test expectations file."""
     command_constructor = Rebaseline
 
     def setUp(self):
         super(TestRebaselineUpdatesExpectationsFiles, self).setUp()
         self.tool.executive = MockExecutive()
 
         def mock_run_command(*args, **kwargs):  # pylint: disable=unused-argument
-            return '{"add": [], "remove-lines": [{"test": "userscripts/first-test.html", "builder": "MOCK Mac10.11"}]}\n'
+            return '{"add": [], "remove-lines": [{"test": "userscripts/first-test.html", "port_name": "test-mac-mac10.11"}]}\n'
         self.tool.executive.run_command = mock_run_command
 
     @staticmethod
     def options():
         return optparse.Values({
             'optimize': False,
             'verbose': True,
             'results_directory': None
         })
 
@@ skipping 103 matching lines @@
             'optimize': False,
             'builders': None,
             'suffixes': 'txt,png',
             'verbose': True
         })
         self.command.execute(options, ['userscripts/first-test.html'], self.tool)
 
         self.assertEqual(
             self.tool.executive.calls,
             [
-                [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                  '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
-                [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                  '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']]
+                [[
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+                ]],
+                [[
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--verbose',
+                    '--test', 'userscripts/first-test.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-win-win7',
+                    '--builder', 'MOCK Win7',
+                ]]
             ])
 
     def test_rebaseline_directory(self):
         self.command._builders_to_pull_from = lambda: ['MOCK Win7']
 
         self._write('userscripts/first-test.html', 'test data')
         self._write('userscripts/second-test.html', 'test data')
 
         self._setup_mock_build_data()
         options = optparse.Values({
             'results_directory': False,
             'optimize': False,
             'builders': None,
             'suffixes': 'txt,png',
             'verbose': True
         })
         self.command.execute(options, ['userscripts'], self.tool)
 
         self.assertEqual(
             self.tool.executive.calls,
             [
                 [
-                    ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                     '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose'],
-                    ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                     '--builder', 'MOCK Win7', '--test', 'userscripts/second-test.html', '--verbose']
+                    [
+                        'python', 'echo', 'copy-existing-baselines-internal',
+                        '--verbose',
+                        '--test', 'userscripts/first-test.html',
+                        '--suffixes', 'txt,png',
+                        '--port-name', 'test-win-win7',
+                    ],
+                    [
+                        'python', 'echo', 'copy-existing-baselines-internal',
+                        '--verbose',
+                        '--test', 'userscripts/second-test.html',
+                        '--suffixes', 'txt,png',
+                        '--port-name', 'test-win-win7',
+                    ]
                 ],
                 [
-                    ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                     '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose'],
-                    ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                     '--builder', 'MOCK Win7', '--test', 'userscripts/second-test.html', '--verbose']
+                    [
+                        'python', 'echo', 'rebaseline-test-internal',
+                        '--verbose',
+                        '--test', 'userscripts/first-test.html',
+                        '--suffixes', 'txt,png',
+                        '--port-name', 'test-win-win7',
+                        '--builder', 'MOCK Win7',
+                    ],
+                    [
+                        'python', 'echo', 'rebaseline-test-internal',
+                        '--verbose',
+                        '--test', 'userscripts/second-test.html',
+                        '--suffixes', 'txt,png',
+                        '--port-name', 'test-win-win7',
+                        '--builder', 'MOCK Win7',
+                    ]
                 ]
             ])
 
 
 class TestRebaselineExpectations(BaseTestCase):
     command_constructor = RebaselineExpectations
 
     def setUp(self):
         super(TestRebaselineExpectations, self).setUp()
 
@@ skipping 38 matching lines @@
         self.command._tests_to_rebaseline = lambda port: {
             'userscripts/another-test.html',
             'userscripts/images.svg',
             'userscripts/not-actually-failing.html',
         }
 
         self.command.execute(self.options(), [], self.tool)
 
         self.assertEqual(self.tool.executive.calls, [
             [
-                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.10', '--test', 'userscripts/another-test.html'],
-                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.11', '--test', 'userscripts/another-test.html'],
-                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                 '--builder', 'MOCK Mac10.10', '--test', 'userscripts/images.svg'],
-                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                 '--builder', 'MOCK Mac10.11', '--test', 'userscripts/images.svg'],
+                [
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--test', 'userscripts/another-test.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.10',
+                ],
+                [
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--test', 'userscripts/another-test.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.11',
+                ],
+                [
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--test', 'userscripts/images.svg',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-mac-mac10.10',
+                ],
+                [
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--test', 'userscripts/images.svg',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-mac-mac10.11',
+                ],
             ],
             [
-                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.10', '--test', 'userscripts/another-test.html'],
-                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.11', '--test', 'userscripts/another-test.html'],
-                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                 '--builder', 'MOCK Mac10.10', '--test', 'userscripts/images.svg'],
-                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                 '--builder', 'MOCK Mac10.11', '--test', 'userscripts/images.svg'],
+                [
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--test', 'userscripts/another-test.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.10',
+                    '--builder', 'MOCK Mac10.10',
+                ],
+                [
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--test', 'userscripts/another-test.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.11',
+                    '--builder', 'MOCK Mac10.11',
+                ],
+                [
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--test', 'userscripts/images.svg',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-mac-mac10.10',
+                    '--builder', 'MOCK Mac10.10',
+                ],
+                [
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--test', 'userscripts/images.svg',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-mac-mac10.11',
+                    '--builder', 'MOCK Mac10.11',
+                ],
             ],
         ])
 
     def test_rebaseline_expectations_reftests(self):
         self._zero_out_test_expectations()
 
         self.tool.executive = MockExecutive()
 
         for builder in ['MOCK Mac10.10', 'MOCK Mac10.11']:
             self.tool.buildbot.set_results(Build(builder), LayoutTestResults({
@@ skipping 21 matching lines @@
         self.command._tests_to_rebaseline = lambda port: {
             'userscripts/reftest-text.html': set(['txt']),
             'userscripts/reftest-image.html': set(['png']),
             'userscripts/reftest-image-text.html': set(['png', 'txt']),
         }
 
         self.command.execute(self.options(), [], self.tool)
 
         self.assertEqual(self.tool.executive.calls, [
             [
-                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.10', '--test', 'userscripts/reftest-text.html'],
-                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.11', '--test', 'userscripts/reftest-text.html'],
+                [
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--test', 'userscripts/reftest-text.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.10',
+                ],
+                [
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--test', 'userscripts/reftest-text.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.11',
+                ],
             ],
             [
-                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.10', '--test', 'userscripts/reftest-text.html'],
-                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.11', '--test', 'userscripts/reftest-text.html'],
+                [
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--test', 'userscripts/reftest-text.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.10',
+                    '--builder', 'MOCK Mac10.10',
+                ],
+                [
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--test', 'userscripts/reftest-text.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.11',
+                    '--builder', 'MOCK Mac10.11',
+                ],
             ],
         ])
 
     def test_rebaseline_expectations_noop(self):
         self._zero_out_test_expectations()
         self.command.execute(self.options(), [], self.tool)
         self.assertEqual(self.tool.filesystem.written_files, {})
 
     def disabled_test_overrides_are_included_correctly(self):
         # TODO(qyearsley): Fix or remove this test method.
@@ skipping 92 matching lines @@
         self.command._tests_to_rebaseline = lambda port: {
             'fast/dom/missing-text.html': set(['txt', 'png']),
             'fast/dom/missing-text-and-image.html': set(['txt', 'png']),
             'fast/dom/missing-image.html': set(['txt', 'png']),
         }
 
         self.command.execute(self.options(), [], self.tool)
 
         self.assertEqual(self.tool.executive.calls, [
             [
-                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/missing-text.html'],
-                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
-                 '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/missing-text-and-image.html'],
-                ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'png',
-                 '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/missing-image.html'],
+                [
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--test', 'fast/dom/missing-text.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.10',
+                ],
+                [
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--test', 'fast/dom/missing-text-and-image.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-mac-mac10.10',
+                ],
+                [
+                    'python', 'echo', 'copy-existing-baselines-internal',
+                    '--test', 'fast/dom/missing-image.html',
+                    '--suffixes', 'png',
+                    '--port-name', 'test-mac-mac10.10',
+                ],
             ],
             [
-                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt',
-                 '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/missing-text.html'],
-                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
-                 '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/missing-text-and-image.html'],
-                ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'png',
-                 '--builder', 'MOCK Mac10.10', '--test', 'fast/dom/missing-image.html'],
+                [
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--test', 'fast/dom/missing-text.html',
+                    '--suffixes', 'txt',
+                    '--port-name', 'test-mac-mac10.10',
+                    '--builder', 'MOCK Mac10.10',
+                ],
+                [
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--test', 'fast/dom/missing-text-and-image.html',
+                    '--suffixes', 'txt,png',
+                    '--port-name', 'test-mac-mac10.10',
+                    '--builder', 'MOCK Mac10.10',
+                ],
+                [
+                    'python', 'echo', 'rebaseline-test-internal',
+                    '--test', 'fast/dom/missing-image.html',
+                    '--suffixes', 'png',
+                    '--port-name', 'test-mac-mac10.10',
+                    '--builder', 'MOCK Mac10.10',
+                ],
             ]
         ])
 
 
 class MockLineRemovingExecutive(MockExecutive):
 
     def run_in_parallel(self, commands):
         assert len(commands)
 
         num_previous_calls = len(self.calls)
         command_outputs = []
         for cmd_line, cwd in commands:
             out = self.run_command(cmd_line, cwd=cwd)
             if 'rebaseline-test-internal' in cmd_line:
-                out = '{"remove-lines": [{"test": "%s", "builder": "%s"}]}\n' % (cmd_line[8], cmd_line[6])
+                test = cmd_line[cmd_line.index('--test') + 1]
+                port_name = cmd_line[cmd_line.index('--port-name') + 1]
+                out = json.dumps({'remove-lines': [{'test': test, 'port_name': port_name}]})
             command_outputs.append([0, out, ''])
 
         new_calls = self.calls[num_previous_calls:]
         self.calls = self.calls[:num_previous_calls]
         self.calls.append(new_calls)
         return command_outputs
 
 
 class TestBaselineSetTest(unittest.TestCase):
 
@@ skipping 31 matching lines @@
 
     def test_str_basic(self):
         test_baseline_set = TestBaselineSet(host=self.host)
         test_baseline_set.add('a/x.html', Build('MOCK Mac10.12'))
         test_baseline_set.add('a/x.html', Build('MOCK Win10'))
         self.assertEqual(
             str(test_baseline_set),
             ('<TestBaselineSet with:\n'
              '  a/x.html: Build(builder_name=\'MOCK Mac10.12\', build_number=None)\n'
              '  a/x.html: Build(builder_name=\'MOCK Win10\', build_number=None)>'))