[run_web_tests] Remove unused pixel_tests parameter in Driver

Bug: 703899

Change-Id: I3b19b91c5e74401e7ba576112d68f0adc9893aca
Reviewed-on: https://chromium-review.googlesource.com/c/1277286Reviewed-by: Robert Ma <robertma@chromium.org>
Commit-Queue: Xianzhu Wang <wangxianzhu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#599249}

third_party/blink/tools/blinkpy/web_tests/port/android.py

@@ -473,7 +473,7 @@ class AndroidPort(base.Port):
         super(AndroidPort, self).start_http_server(additional_dirs, number_of_drivers)
 
     def create_driver(self, worker_number, no_timeout=False):
-        return ChromiumAndroidDriver(self, worker_number, pixel_tests=self.get_option('pixel_tests'),
+        return ChromiumAndroidDriver(self, worker_number,
                                      driver_details=self._driver_details,
                                      android_devices=self._devices,
                                      # Force no timeout to avoid test driver timeouts before NRWT.
@@ -481,7 +481,7 @@ class AndroidPort(base.Port):
 
     def driver_cmd_line(self):
         # Override to return the actual test driver's command line.
-        return self.create_driver(0)._android_driver_cmd_line(self.get_option('pixel_tests'), [])
+        return self.create_driver(0)._android_driver_cmd_line([])
 
     def clobber_old_port_specific_results(self):
         if not self.get_option('disable_breakpad'):
@@ -643,8 +643,8 @@ http://crbug.com/165250 discusses making these pre-built binaries externally ava
 
 class ChromiumAndroidDriver(driver.Driver):
 
-    def __init__(self, port, worker_number, pixel_tests, driver_details, android_devices, no_timeout=False):
-        super(ChromiumAndroidDriver, self).__init__(port, worker_number, pixel_tests, no_timeout)
+    def __init__(self, port, worker_number, driver_details, android_devices, no_timeout=False):
+        super(ChromiumAndroidDriver, self).__init__(port, worker_number, no_timeout)
         self._write_stdin_process = None
         self._read_stdout_process = None
         self._read_stderr_process = None
@@ -802,13 +802,13 @@ class ChromiumAndroidDriver(driver.Driver):
         return super(ChromiumAndroidDriver, self)._get_crash_log(
             stdout, stderr, newer_than)
 
-    def cmd_line(self, pixel_tests, per_test_args):
+    def cmd_line(self, per_test_args):
         # The returned command line is used to start _server_process. In our case, it's an interactive 'adb shell'.
         # The command line passed to the driver process is returned by _driver_cmd_line() instead.
         return [self._device.adb.GetAdbPath(), '-s', self._device.serial, 'shell']
 
-    def _android_driver_cmd_line(self, pixel_tests, per_test_args):
-        return driver.Driver.cmd_line(self, pixel_tests, per_test_args)
+    def _android_driver_cmd_line(self, per_test_args):
+        return driver.Driver.cmd_line(self, per_test_args)
 
     @staticmethod
     def _loop_with_timeout(condition, timeout_secs):
@@ -818,10 +818,10 @@ class ChromiumAndroidDriver(driver.Driver):
                 return True
         return False
 
-    def start(self, pixel_tests, per_test_args, deadline):
+    def start(self, per_test_args, deadline):
         # We override the default start() so that we can call _android_driver_cmd_line()
         # instead of cmd_line().
-        new_cmd_line = self._android_driver_cmd_line(pixel_tests, per_test_args)
+        new_cmd_line = self._android_driver_cmd_line(per_test_args)
 
         # Since _android_driver_cmd_line() is different than cmd_line() we need to provide
         # our own mechanism for detecting when the process should be stopped.
@@ -831,15 +831,15 @@ class ChromiumAndroidDriver(driver.Driver):
             self.stop()
         self._current_android_cmd_line = new_cmd_line
 
-        super(ChromiumAndroidDriver, self).start(pixel_tests, per_test_args, deadline)
+        super(ChromiumAndroidDriver, self).start(per_test_args, deadline)
 
-    def _start(self, pixel_tests, per_test_args):
+    def _start(self, per_test_args):
         if not self._android_devices.is_device_prepared(self._device.serial):
             raise driver.DeviceFailure('%s is not prepared in _start()' % self._device.serial)
 
         for retries in range(3):
             try:
-                if self._start_once(pixel_tests, per_test_args):
+                if self._start_once(per_test_args):
                     return
             except ScriptError as error:
                 self._abort('ScriptError("%s") in _start()' % error)
@@ -849,8 +849,8 @@ class ChromiumAndroidDriver(driver.Driver):
             time.sleep(2)
         self._abort('Failed to start the content_shell application multiple times. Giving up.')
 
-    def _start_once(self, pixel_tests, per_test_args):
-        super(ChromiumAndroidDriver, self)._start(pixel_tests, per_test_args, wait_for_ready=False)
+    def _start_once(self, per_test_args):
+        super(ChromiumAndroidDriver, self)._start(per_test_args, wait_for_ready=False)
 
         self._device.adb.Logcat(clear=True)
 
@@ -909,7 +909,7 @@ class ChromiumAndroidDriver(driver.Driver):
             '--android-stdin-port=%s' % forwarder.Forwarder.DevicePortForHostPort(stdin_port),
             '--android-stdout-port=%s' % forwarder.Forwarder.DevicePortForHostPort(stdout_port),
         ]
-        cmd_line_contents = self._android_driver_cmd_line(pixel_tests, per_test_args + stream_port_args)
+        cmd_line_contents = self._android_driver_cmd_line(per_test_args + stream_port_args)
         self._device.WriteFile(
             self._driver_details.command_line_file(),
             ' '.join(cmd_line_contents))

third_party/blink/tools/blinkpy/web_tests/port/android_unittest.py

@@ -153,7 +153,6 @@ class ChromiumAndroidDriverTest(unittest.TestCase):
         self._driver = android.ChromiumAndroidDriver(
             self._port,
             worker_number=0,
-            pixel_tests=True,
             driver_details=android.ContentShellDriverDetails(),
             android_devices=self._port._devices)  # pylint: disable=protected-access
 
@@ -166,7 +165,7 @@ class ChromiumAndroidDriverTest(unittest.TestCase):
 
     # The cmd_line() method in the Android port is used for starting a shell, not the test runner.
     def test_cmd_line(self):
-        self.assertEquals(['adb', '-s', '123456789ABCDEF0', 'shell'], self._driver.cmd_line(False, []))
+        self.assertEquals(['adb', '-s', '123456789ABCDEF0', 'shell'], self._driver.cmd_line([]))
 
     # Test that the Chromium Android port can interpret Android's shell output.
     def test_read_prompt(self):
@@ -201,13 +200,13 @@ class ChromiumAndroidDriverTwoDriversTest(unittest.TestCase):
 
     def test_two_drivers(self):
         port = android.AndroidPort(MockSystemHost(executive=MockExecutive()), 'android')
-        driver0 = android.ChromiumAndroidDriver(port, worker_number=0, pixel_tests=True,
+        driver0 = android.ChromiumAndroidDriver(port, worker_number=0,
                                                 driver_details=android.ContentShellDriverDetails(), android_devices=port._devices)
-        driver1 = android.ChromiumAndroidDriver(port, worker_number=1, pixel_tests=True,
+        driver1 = android.ChromiumAndroidDriver(port, worker_number=1,
                                                 driver_details=android.ContentShellDriverDetails(), android_devices=port._devices)
 
-        self.assertEqual(['adb', '-s', '123456789ABCDEF0', 'shell'], driver0.cmd_line(True, []))
-        self.assertEqual(['adb', '-s', '123456789ABCDEF1', 'shell'], driver1.cmd_line(True, ['anything']))
+        self.assertEqual(['adb', '-s', '123456789ABCDEF0', 'shell'], driver0.cmd_line([]))
+        self.assertEqual(['adb', '-s', '123456789ABCDEF1', 'shell'], driver1.cmd_line(['anything']))
 
 
 class ChromiumAndroidTwoPortsTest(unittest.TestCase):
@@ -263,7 +262,6 @@ class ChromiumAndroidDriverTombstoneTest(unittest.TestCase):
         self._driver = android.ChromiumAndroidDriver(
             self._port,
             worker_number=0,
-            pixel_tests=True,
             driver_details=android.ContentShellDriverDetails(),
             android_devices=self._port._devices)  # pylint: disable=protected-access
 

third_party/blink/tools/blinkpy/web_tests/port/base.py

@@ -908,7 +908,7 @@ class Port(object):
 
     def driver_cmd_line(self):
         """Prints the DRT (DumpRenderTree) command that will be used."""
-        return self.create_driver(0).cmd_line(self.get_option('pixel_tests'), [])
+        return self.create_driver(0).cmd_line([])
 
     def update_baseline(self, baseline_path, data):
         """Updates the baseline for a test.
@@ -1167,7 +1167,7 @@ class Port(object):
         """Returns a newly created Driver subclass for starting/stopping the
         test driver.
         """
-        return self._driver_class()(self, worker_number, pixel_tests=self.get_option('pixel_tests'), no_timeout=no_timeout)
+        return self._driver_class()(self, worker_number, no_timeout=no_timeout)
 
     def requires_http_server(self):
         # Does the port require an HTTP server for running tests? This could
@@ -1721,7 +1721,8 @@ class Port(object):
 
         This provides the *default* value for whether a test should run as
         pixel test. When reference files exist (checked by layout_test_runner
-        before calling this method), the test always runs as pixel test.
+        before calling this method), the test always runs as pixel test
+        regardless of this function.
         """
         if not self._options.pixel_tests:
             return False

third_party/blink/tools/blinkpy/web_tests/port/browser_test_driver.py

@@ -32,11 +32,11 @@ from blinkpy.web_tests.port.driver import Driver
 class BrowserTestDriver(Driver):
     """Object for running print preview test(s) using browser_tests."""
 
-    def __init__(self, port, worker_number, pixel_tests, no_timeout=False):
+    def __init__(self, port, worker_number, no_timeout=False):
         """Invokes the constructor of Driver."""
-        super(BrowserTestDriver, self).__init__(port, worker_number, pixel_tests, no_timeout)
+        super(BrowserTestDriver, self).__init__(port, worker_number, no_timeout)
 
-    def start(self, pixel_tests, per_test_args, deadline):
+    def start(self, per_test_args, deadline):
         """Same as Driver.start() however, it has an extra step. It waits for
         a path to a file to be used for stdin to be printed by the browser test.
         If a path is found by the deadline test test will open the file and
@@ -45,9 +45,9 @@ class BrowserTestDriver(Driver):
         """
         # FIXME(ivandavid): Need to handle case where the layout test doesn't
         # get a file name.
-        new_cmd_line = self.cmd_line(pixel_tests, per_test_args)
+        new_cmd_line = self.cmd_line(per_test_args)
         if not self._server_process or new_cmd_line != self._current_cmd_line:
-            self._start(pixel_tests, per_test_args)
+            self._start(per_test_args)
             self._run_post_start_tasks()
             self._open_stdin_path(deadline)
 
@@ -73,7 +73,7 @@ class BrowserTestDriver(Driver):
             return (block.stdin_path, True)
         return (None, False)
 
-    def cmd_line(self, pixel_tests, per_test_args):
+    def cmd_line(self, per_test_args):
         """Command line arguments to run the browser test."""
         cmd = self._command_wrapper(self._port.get_option('wrapper'))
         cmd.append(self._port._path_to_driver())

third_party/blink/tools/blinkpy/web_tests/port/browser_test_driver_unittest.py

@@ -38,7 +38,7 @@ class BrowserTestDriverTest(unittest.TestCase):
 
     def test_read_stdin_path(self):
         port = TestPort(MockHost())
-        driver = BrowserTestDriver(port, 0, pixel_tests=True)
+        driver = BrowserTestDriver(port, 0)
         driver._server_process = MockServerProcess(lines=[
             'StdinPath: /foo/bar', '#EOF'])
         content_block = driver._read_block(0)

third_party/blink/tools/blinkpy/web_tests/port/driver.py

@@ -91,7 +91,7 @@ class DeviceFailure(Exception):
 class Driver(object):
     """object for running test(s) using content_shell or other driver."""
 
-    def __init__(self, port, worker_number, pixel_tests, no_timeout=False):
+    def __init__(self, port, worker_number, no_timeout=False):
         """Initialize a Driver to subsequently run tests.
 
         Typically this routine will spawn content_shell in a config
@@ -156,7 +156,7 @@ class Driver(object):
         """
         start_time = time.time()
         stdin_deadline = start_time + int(driver_input.timeout) / 2000.0
-        self.start(driver_input.should_run_pixel_test, driver_input.args, stdin_deadline)
+        self.start(driver_input.args, stdin_deadline)
         test_begin_time = time.time()
         self.error_from_test = str()
         self.err_seen_eof = False
@@ -305,10 +305,10 @@ class Driver(object):
             return True
         return False
 
-    def start(self, pixel_tests, per_test_args, deadline):
-        new_cmd_line = self.cmd_line(pixel_tests, per_test_args)
+    def start(self, per_test_args, deadline):
+        new_cmd_line = self.cmd_line(per_test_args)
         if not self._server_process or new_cmd_line != self._current_cmd_line:
-            self._start(pixel_tests, per_test_args)
+            self._start(per_test_args)
             self._run_post_start_tasks()
 
     def _setup_environ_for_driver(self, environment):
@@ -316,7 +316,7 @@ class Driver(object):
             environment = self._profiler.adjusted_environment(environment)
         return environment
 
-    def _start(self, pixel_tests, per_test_args, wait_for_ready=True):
+    def _start(self, per_test_args, wait_for_ready=True):
         self.stop()
         self._driver_tempdir = self._port.host.filesystem.mkdtemp(prefix='%s-' % self._port.driver_name())
         server_name = self._port.driver_name()
@@ -326,7 +326,7 @@ class Driver(object):
         self._crashed_pid = None
         self._leaked = False
         self._leak_log = None
-        cmd_line = self.cmd_line(pixel_tests, per_test_args)
+        cmd_line = self.cmd_line(per_test_args)
         self._server_process = self._port.server_process_constructor(
             self._port, server_name, cmd_line, environment, more_logging=self._port.get_option('driver_logging'))
         self._server_process.start()
@@ -380,7 +380,7 @@ class Driver(object):
     def _base_cmd_line(self):
         return [self._port._path_to_driver()]  # pylint: disable=protected-access
 
-    def cmd_line(self, pixel_tests, per_test_args):
+    def cmd_line(self, per_test_args):
         cmd = self._command_wrapper(self._port.get_option('wrapper'))
         cmd += self._base_cmd_line()
         if self._no_timeout:

third_party/blink/tools/blinkpy/web_tests/port/driver_unittest.py

@@ -41,7 +41,7 @@ class DriverTest(unittest.TestCase):
         return Port(MockSystemHost(), 'test', optparse.Values({'configuration': 'Release'}))
 
     def _assert_wrapper(self, wrapper_string, expected_wrapper):
-        wrapper = Driver(self.make_port(), None, pixel_tests=False)._command_wrapper(wrapper_string)
+        wrapper = Driver(self.make_port(), None)._command_wrapper(wrapper_string)
         self.assertEqual(wrapper, expected_wrapper)
 
     def test_command_wrapper(self):
@@ -55,7 +55,7 @@ class DriverTest(unittest.TestCase):
 
     def test_test_to_uri(self):
         port = self.make_port()
-        driver = Driver(port, None, pixel_tests=False)
+        driver = Driver(port, None)
         self.assertEqual(driver.test_to_uri('foo/bar.html'), 'file://%s/foo/bar.html' % port.layout_tests_dir())
         self.assertEqual(driver.test_to_uri('http/tests/foo.html'), 'http://127.0.0.1:8000/foo.html')
         self.assertEqual(driver.test_to_uri('http/tests/https/bar.html'), 'https://127.0.0.1:8443/https/bar.html')
@@ -67,7 +67,7 @@ class DriverTest(unittest.TestCase):
 
     def test_uri_to_test(self):
         port = self.make_port()
-        driver = Driver(port, None, pixel_tests=False)
+        driver = Driver(port, None)
         self.assertEqual(driver.uri_to_test('file://%s/foo/bar.html' % port.layout_tests_dir()), 'foo/bar.html')
         self.assertEqual(driver.uri_to_test('http://127.0.0.1:8000/foo.html'), 'http/tests/foo.html')
         self.assertEqual(driver.uri_to_test('https://127.0.0.1:8443/https/bar.html'), 'http/tests/https/bar.html')
@@ -78,7 +78,7 @@ class DriverTest(unittest.TestCase):
 
     def test_read_block(self):
         port = self.make_port()
-        driver = Driver(port, 0, pixel_tests=False)
+        driver = Driver(port, 0)
         driver._server_process = MockServerProcess(lines=[
             'ActualHash: foobar',
             'Content-Type: my_type',
@@ -94,7 +94,7 @@ class DriverTest(unittest.TestCase):
 
     def test_read_binary_block(self):
         port = self.make_port()
-        driver = Driver(port, 0, pixel_tests=True)
+        driver = Driver(port, 0)
         driver._server_process = MockServerProcess(lines=[
             'ActualHash: actual',
             'ExpectedHash: expected',
@@ -112,7 +112,7 @@ class DriverTest(unittest.TestCase):
 
     def test_read_base64_block(self):
         port = self.make_port()
-        driver = Driver(port, 0, pixel_tests=True)
+        driver = Driver(port, 0)
         driver._server_process = MockServerProcess(lines=[
             'ActualHash: actual',
             'ExpectedHash: expected',
@@ -130,15 +130,15 @@ class DriverTest(unittest.TestCase):
 
     def test_no_timeout(self):
         port = self.make_port()
-        driver = Driver(port, 0, pixel_tests=True, no_timeout=True)
-        cmd_line = driver.cmd_line(True, [])
+        driver = Driver(port, 0, no_timeout=True)
+        cmd_line = driver.cmd_line([])
         self.assertEqual(cmd_line[0], '/mock-checkout/out/Release/content_shell')
         self.assertEqual(cmd_line[-1], '-')
         self.assertIn('--no-timeout', cmd_line)
 
     def test_check_for_driver_crash(self):
         port = self.make_port()
-        driver = Driver(port, 0, pixel_tests=True)
+        driver = Driver(port, 0)
 
         class FakeServerProcess(object):
 
@@ -219,15 +219,15 @@ class DriverTest(unittest.TestCase):
 
     def test_creating_a_port_does_not_write_to_the_filesystem(self):
         port = self.make_port()
-        Driver(port, 0, pixel_tests=True)
+        Driver(port, 0)
         self.assertEqual(port.host.filesystem.written_files, {})
         self.assertIsNone(port.host.filesystem.last_tmpdir)
 
     def test_stop_cleans_up_properly(self):
         port = self.make_port()
         port.server_process_constructor = MockServerProcess
-        driver = Driver(port, 0, pixel_tests=True)
-        driver.start(True, [], None)
+        driver = Driver(port, 0)
+        driver.start([], None)
         last_tmpdir = port.host.filesystem.last_tmpdir
         self.assertIsNotNone(last_tmpdir)
         driver.stop()
@@ -236,15 +236,15 @@ class DriverTest(unittest.TestCase):
     def test_two_starts_cleans_up_properly(self):
         port = self.make_port()
         port.server_process_constructor = MockServerProcess
-        driver = Driver(port, 0, pixel_tests=True)
-        driver.start(True, [], None)
+        driver = Driver(port, 0)
+        driver.start([], None)
         last_tmpdir = port.host.filesystem.last_tmpdir
-        driver._start(True, [])
+        driver._start([])
         self.assertFalse(port.host.filesystem.isdir(last_tmpdir))
 
     def test_start_actually_starts(self):
         port = self.make_port()
         port.server_process_constructor = MockServerProcess
-        driver = Driver(port, 0, pixel_tests=True)
-        driver.start(True, [], None)
+        driver = Driver(port, 0)
+        driver.start([], None)
         self.assertTrue(driver._server_process.started)

third_party/blink/tools/blinkpy/web_tests/port/fuchsia.py

@@ -268,9 +268,9 @@ class FuchsiaPort(base.Port):
 
 
 class ChromiumFuchsiaDriver(driver.Driver):
-    def __init__(self, port, worker_number, pixel_tests, no_timeout=False):
+    def __init__(self, port, worker_number, no_timeout=False):
         super(ChromiumFuchsiaDriver, self).__init__(
-            port, worker_number, pixel_tests, no_timeout)
+            port, worker_number, no_timeout)
 
     def _base_cmd_line(self):
         return ['run', 'content_shell']

third_party/blink/tools/blinkpy/web_tests/port/mock_drt.py

@@ -79,9 +79,9 @@ class MockDRTPort(object):
     def _driver_class(self, delegate):
         return self._mocked_driver_maker
 
-    def _mocked_driver_maker(self, port, worker_number, pixel_tests, no_timeout=False):
+    def _mocked_driver_maker(self, port, worker_number, no_timeout=False):
         path_to_this_file = self.host.filesystem.abspath(__file__.replace('.pyc', '.py'))
-        driver = self.__delegate_driver_class()(self, worker_number, pixel_tests, no_timeout)
+        driver = self.__delegate_driver_class()(self, worker_number, no_timeout)
         driver.cmd_line = self._overriding_cmd_line(driver.cmd_line,
                                                     self.__delegate._path_to_driver(),
                                                     sys.executable,
@@ -91,8 +91,8 @@ class MockDRTPort(object):
 
     @staticmethod
     def _overriding_cmd_line(original_cmd_line, driver_path, python_exe, this_file, port_name):
-        def new_cmd_line(pixel_tests, per_test_args):
-            cmd_line = original_cmd_line(pixel_tests, per_test_args)
+        def new_cmd_line(per_test_args):
+            cmd_line = original_cmd_line(per_test_args)
             index = cmd_line.index(driver_path)
             cmd_line[index:index + 1] = [python_exe, this_file, '--platform', port_name]
             return cmd_line

third_party/blink/tools/blinkpy/web_tests/port/test.py

@@ -560,9 +560,8 @@ class TestDriver(Driver):
         self.started = False
         self.pid = 0
 
-    def cmd_line(self, pixel_tests, per_test_args):
-        pixel_tests_flag = '-p' if pixel_tests else ''
-        return [self._port._path_to_driver()] + [pixel_tests_flag] + \
+    def cmd_line(self, per_test_args):
+        return [self._port._path_to_driver()] + \
             self._port.get_option('additional_driver_flag', []) + per_test_args
 
     def run_test(self, driver_input, stop_when_done):