Changeset 251808 in webkit


Ignore:
Timestamp:
Oct 30, 2019 2:56:56 PM (5 years ago)
Author:
Jonathan Bedard
Message:

Python 3: Add support in webkitpy.port
​https://bugs.webkit.org/show_bug.cgi?id=203489

Reviewed by Dewei Zhu.

  • Scripts/test-webkitpy-python3: Add webkitpy.port.
  • Scripts/webkitpy/common/newstringio.py: Removed.
  • Scripts/webkitpy/common/newstringio_unittest.py: Removed.
  • Scripts/webkitpy/common/system/executive_mock.py:

(MockProcess.init): Ensure that stdout and stderr are byte arrays.

  • Scripts/webkitpy/common/version.py:

(Version.hash): Add hash function for Version objects.

  • Scripts/webkitpy/port/base.py:

(Port.default_baseline_search_path): Convert list to map.
(Port.diff_text): Decode for the native string type.
(Port.skipped_perf_tests): Convert filter to list.
(Port._run_script): No need to decode strings in Python 3, even if decode_output is set.
(Port.diff_text.to_raw_bytes): Deleted.

  • Scripts/webkitpy/port/base_unittest.py:

(cmp): Add cmp function for Python 3 comparisons.
(PortTest.test_diff_text): Do not escape spaces.
(PortTest.test_parse_reftest_list): Write to test file explicitly.

  • Scripts/webkitpy/port/builders_unittest.py: Use full import path.
  • Scripts/webkitpy/port/config_standalone.py: script_dir was refering to Tools,

not Tools/Scripts.

  • Scripts/webkitpy/port/config_unittest.py: Use full import path.
  • Scripts/webkitpy/port/darwin.py:

(DarwinPort.show_results_html_file): Use os.devnull directly.

  • Scripts/webkitpy/port/driver_unittest.py:

(DriverTest.test_read_base64_block): Explicitly compare against byte array.
(DriverTest.test_setup_environ_base_vars): Convert iterators to lists.

  • Scripts/webkitpy/port/factory.py:

(PortFactory.get.in): Imports need to use the full import path.

  • Scripts/webkitpy/port/gtk.py:

(GtkPort.default_baseline_search_path): Convert map to list.

  • Scripts/webkitpy/port/leakdetector.py:

(LeakDetector._parse_leaks_output): Search byte array with byte array.

  • Scripts/webkitpy/port/leakdetector_valgrind.py:

(ValgrindError.str): Split byte array with byte array.
(ValgrindError.error_hash): Correct regex.
(LeakDetectorValgrind._parse_leaks_output): Convert bytes to string.
(LeakDetectorValgrind.parse_and_print_leaks_detail): Standardize Python 2 and 3 sorting order.

  • Scripts/webkitpy/port/leakdetector_valgrind_unittest.py: Make unit tests Python 3 compatible.
  • Scripts/webkitpy/port/linux_get_crash_log.py:

(GDBCrashLogGenerator._get_trace_from_systemd): Modernize exception handling.
(GDBCrashLogGenerator.generate_crash_log): No need to decode strings in Python 3.

  • Scripts/webkitpy/port/mac.py:

(MacPort.start_helper): is_ready will be a byte array.
(MacPort.stop_helper): stdin will be a byte array.

  • Scripts/webkitpy/port/mock_drt_unittest.py:

(MockDRTTest.assertTest): Use unicode compatible StringIO objects.
(MockDRTTest.test_main): Ditto.

  • Scripts/webkitpy/port/port_testcase.py:

(bind_mock_apple_additions.MockAppleAdditions.version_name_mapping): Use items instead of iteritems.
(PortTestCase.test_expectations_ordering): Convert iterator to list.
(PortTestCase.test_test_expectations): Ditto.

  • Scripts/webkitpy/port/win.py:

(WinPort.init):
(WinPort.default_baseline_search_path): Convert map to list.
(WinPort.test_search_path): Ditto.
(WinPort.setup_crash_log_saving): Use items instead of iteritems.
(WinPort.restore_crash_log_saving): Ditto.
(WinPort.prevent_error_dialogs): Ditto.
(WinPort.allow_error_dialogs): Ditto.
(WinCairoPort.default_baseline_search_path): Convert map to list.
(WinCairoPort._port_specific_expectations_files): Ditto.
(FTWPort.default_baseline_search_path): Ditto.
(FTWPort._port_specific_expectations_files): Ditto.

  • Scripts/webkitpy/port/win_unittest.py: Ditto.

(WinPortTest._assert_search_path): Ditto.

  • Scripts/webkitpy/port/wpe.py:

(WPEPort.default_baseline_search_path): Convert map to list.
(WPEPort._port_specific_expectations_files): Ditto.

Location:
trunk/Tools
Files:
2 deleted
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r251793 r251808  
     12019-10-30  Jonathan Bedard  <jbedard@apple.com>
     2
     3        Python 3: Add support in webkitpy.port
     4        https://bugs.webkit.org/show_bug.cgi?id=203489
     5
     6        Reviewed by Dewei Zhu.
     7
     8        * Scripts/test-webkitpy-python3: Add webkitpy.port.
     9        * Scripts/webkitpy/common/newstringio.py: Removed.
     10        * Scripts/webkitpy/common/newstringio_unittest.py: Removed.
     11        * Scripts/webkitpy/common/system/executive_mock.py:
     12        (MockProcess.__init__): Ensure that stdout and stderr are byte arrays.
     13        * Scripts/webkitpy/common/version.py:
     14        (Version.__hash__): Add hash function for Version objects.
     15        * Scripts/webkitpy/port/base.py:
     16        (Port.default_baseline_search_path): Convert list to map.
     17        (Port.diff_text): Decode for the native string type.
     18        (Port.skipped_perf_tests): Convert filter to list.
     19        (Port._run_script): No need to decode strings in Python 3, even if decode_output is set.
     20        (Port.diff_text.to_raw_bytes): Deleted.
     21        * Scripts/webkitpy/port/base_unittest.py:
     22        (cmp): Add cmp function for Python 3 comparisons.
     23        (PortTest.test_diff_text): Do not escape spaces.
     24        (PortTest.test_parse_reftest_list): Write to test file explicitly.
     25        * Scripts/webkitpy/port/builders_unittest.py: Use full import path.
     26        * Scripts/webkitpy/port/config_standalone.py: script_dir was refering to Tools,
     27        not Tools/Scripts.
     28        * Scripts/webkitpy/port/config_unittest.py: Use full import path.
     29        * Scripts/webkitpy/port/darwin.py:
     30        (DarwinPort.show_results_html_file): Use os.devnull directly.
     31        * Scripts/webkitpy/port/driver_unittest.py:
     32        (DriverTest.test_read_base64_block): Explicitly compare against byte array.
     33        (DriverTest.test_setup_environ_base_vars): Convert iterators to lists.
     34        * Scripts/webkitpy/port/factory.py:
     35        (PortFactory.get.in): Imports need to use the full import path.
     36        * Scripts/webkitpy/port/gtk.py:
     37        (GtkPort.default_baseline_search_path): Convert map to list.
     38        * Scripts/webkitpy/port/leakdetector.py:
     39        (LeakDetector._parse_leaks_output): Search byte array with byte array.
     40        * Scripts/webkitpy/port/leakdetector_valgrind.py:
     41        (ValgrindError.__str__): Split byte array with byte array.
     42        (ValgrindError.error_hash): Correct regex.
     43        (LeakDetectorValgrind._parse_leaks_output): Convert bytes to string.
     44        (LeakDetectorValgrind.parse_and_print_leaks_detail): Standardize Python 2 and 3 sorting order.
     45        * Scripts/webkitpy/port/leakdetector_valgrind_unittest.py: Make unit tests Python 3 compatible.
     46        * Scripts/webkitpy/port/linux_get_crash_log.py:
     47        (GDBCrashLogGenerator._get_trace_from_systemd): Modernize exception handling.
     48        (GDBCrashLogGenerator.generate_crash_log): No need to decode strings in Python 3.
     49        * Scripts/webkitpy/port/mac.py:
     50        (MacPort.start_helper): is_ready will be a byte array.
     51        (MacPort.stop_helper): stdin will be a byte array.
     52        * Scripts/webkitpy/port/mock_drt_unittest.py:
     53        (MockDRTTest.assertTest): Use unicode compatible StringIO objects.
     54        (MockDRTTest.test_main): Ditto.
     55        * Scripts/webkitpy/port/port_testcase.py:
     56        (bind_mock_apple_additions.MockAppleAdditions.version_name_mapping): Use items instead of iteritems.
     57        (PortTestCase.test_expectations_ordering): Convert iterator to list.
     58        (PortTestCase.test_test_expectations): Ditto.
     59        * Scripts/webkitpy/port/win.py:
     60        (WinPort.__init__):
     61        (WinPort.default_baseline_search_path): Convert map to list.
     62        (WinPort.test_search_path): Ditto.
     63        (WinPort.setup_crash_log_saving): Use items instead of iteritems.
     64        (WinPort.restore_crash_log_saving): Ditto.
     65        (WinPort.prevent_error_dialogs): Ditto.
     66        (WinPort.allow_error_dialogs): Ditto.
     67        (WinCairoPort.default_baseline_search_path): Convert map to list.
     68        (WinCairoPort._port_specific_expectations_files): Ditto.
     69        (FTWPort.default_baseline_search_path): Ditto.
     70        (FTWPort._port_specific_expectations_files): Ditto.
     71        * Scripts/webkitpy/port/win_unittest.py: Ditto.
     72        (WinPortTest._assert_search_path): Ditto.
     73        * Scripts/webkitpy/port/wpe.py:
     74        (WPEPort.default_baseline_search_path): Convert map to list.
     75        (WPEPort._port_specific_expectations_files): Ditto.
     76
    1772019-10-30  Jonathan Bedard  <jbedard@apple.com>
    278

  • trunk/Tools/Scripts/test-webkitpy-python3

    r251613 r251808  
    4141  'webkitpy.common.net',
    4242  'webkitpy.common.watchlist',
     43  'webkitpy.port',
    4344  'webkitpy.results',
    4445  'webkitpy.xcode',

  • trunk/Tools/Scripts/webkitpy/common/system/executive_mock.py

    r250375 r251808  
    3030import os
    3131
    32 from webkitpy.common.unicode_compatibility import BytesIO, unicode
     32from webkitpy.common.unicode_compatibility import BytesIO, encode_if_necessary, unicode
    3333from webkitpy.common.system.executive import ScriptError
    3434
    … …  
    3939    def __init__(self, stdout='MOCK STDOUT\n', stderr=''):
    4040        self.pid = 42
    41         self.stdout = BytesIO(stdout)
    42         self.stderr = BytesIO(stderr)
     41        self.stdout = BytesIO(encode_if_necessary(stdout))
     42        self.stderr = BytesIO(encode_if_necessary(stderr))
    4343        self.stdin = BytesIO()
    4444        self.returncode = 0

  • trunk/Tools/Scripts/webkitpy/common/version.py

    r250375 r251808  
    117117        return result
    118118
     119    def __hash__(self):
     120        return hash(str(self))
     121
    119122    def __cmp__(self, other):
    120123        if other is None:

  • trunk/Tools/Scripts/webkitpy/port/base.py

    r251020 r251808  
    5252from webkitpy.common.wavediff import WaveDiff
    5353from webkitpy.common.webkit_finder import WebKitFinder
     54from webkitpy.common.unicode_compatibility import encode_for, encode_if_necessary, decode_for
    5455from webkitpy.layout_tests.models.test_configuration import TestConfiguration
    5556from webkitpy.port import config as port_config
    … …  
    223224        if self.name() != self.port_name:
    224225            search_paths.append(self.port_name)
    225         return map(self._webkit_baseline_path, search_paths)
     226        return list(map(self._webkit_baseline_path, search_paths))
    226227
    227228    @memoized
    … …  
    341342        """Returns a string containing the diff of the two text strings
    342343        in 'unified diff' format."""
    343 
    344         # The filenames show up in the diff output, make sure they're
    345         # raw bytes and not unicode, so that they don't trigger join()
    346         # trying to decode the input.
    347         def to_raw_bytes(string_value):
    348             if isinstance(string_value, unicode):
    349                 return string_value.encode('utf-8')
    350             return string_value
    351         expected_filename = to_raw_bytes(expected_filename)
    352         actual_filename = to_raw_bytes(actual_filename)
     344        expected_filename = decode_for(encode_if_necessary(expected_filename), str)
     345        actual_filename = decode_for(encode_if_necessary(actual_filename), str)
    353346        diff = difflib.unified_diff(expected_text.splitlines(True),
    354347                                    actual_text.splitlines(True),
    … …  
    359352            result += line
    360353            if not line.endswith('\n'):
    361                 result += '\n\ No newline at end of file\n'
     354                result += '\n No newline at end of file\n'
    362355        return result
    363356
    … …  
    765758                _log.error("Syntax error at line %d in %s: %s" % (line_number + 1, filename, line))
    766759            else:
    767                 platform_names = filter(lambda token: token, match.group('platforms').lower().split(' ')) if match.group('platforms') else []
     760                platform_names = list(filter(lambda token: token, match.group('platforms').lower().split(' '))) if match.group('platforms') else []
    768761                test_name = match.group('test')
    769762                if test_name and (not platform_names or self.port_name in platform_names or self._name in platform_names):
    … …  
    14931486            run_script_command.extend(args)
    14941487        output = self._executive.run_command(run_script_command, cwd=self.webkit_base(), decode_output=decode_output, env=env)
    1495         _log.debug('Output of %s:\n%s' % (run_script_command, output.encode('utf-8') if decode_output else output))
     1488        _log.debug('Output of %s:\n%s' % (run_script_command, encode_for(output, str) if decode_output else output))
    14961489        return output
    14971490

  • trunk/Tools/Scripts/webkitpy/port/base_unittest.py

    r241318 r251808  
    4242
    4343
     44def cmp(a, b):
     45    return (a > b) - (a < b)
     46
    4447class PortTest(unittest.TestCase):
    4548    def make_port(self, executive=None, with_tests=False, port_name=None, **kwargs):
    … …  
    106109        t1 = "A\n\nB"
    107110        t2 = "A\n\nB\n\n\n"
    108         t3 = "--- exp.txt\n+++ act.txt\n@@ -1,3 +1,5 @@\n A\n \n-B\n\ No newline at end of file\n+B\n+\n+\n"
     111        t3 = "--- exp.txt\n+++ act.txt\n@@ -1,3 +1,5 @@\n A\n \n-B\n No newline at end of file\n+B\n+\n+\n"
    109112        self.assertEqual(t3, port.diff_text(t1, t2, 'exp.txt', 'act.txt'))
    110113
    … …  
    289292    def test_parse_reftest_list(self):
    290293        port = self.make_port(with_tests=True)
    291         port.host.filesystem.files['bar/reftest.list'] = "\n".join(["== test.html test-ref.html",
    292         "",
    293         "# some comment",
    294         "!= test-2.html test-notref.html # more comments",
    295         "== test-3.html test-ref.html",
    296         "== test-3.html test-ref2.html",
    297         "!= test-3.html test-notref.html"])
     294        port.host.filesystem.write_text_file(
     295            'bar/reftest.list',
     296            "\n".join([
     297                "== test.html test-ref.html",
     298                "",
     299                "# some comment",
     300                "!= test-2.html test-notref.html # more comments",
     301                "== test-3.html test-ref.html",
     302                "== test-3.html test-ref2.html",
     303                "!= test-3.html test-notref.html",
     304            ]),
     305        )
    298306
    299307        reftest_list = Port._parse_reftest_list(port.host.filesystem, 'bar')

  • trunk/Tools/Scripts/webkitpy/port/builders_unittest.py

    r174136 r251808  
    2727# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828
    29 import builders
    3029import unittest
     30import webkitpy.port.builders as builders
    3131
    3232

  • trunk/Tools/Scripts/webkitpy/port/config_standalone.py

    r225698 r251808  
    4040this_dir = os.path.abspath(sys.path[0])
    4141up = os.path.dirname
    42 script_dir = up(up(up(this_dir)))
     42script_dir = up(up(this_dir))
    4343if script_dir not in sys.path:
    4444    sys.path.append(script_dir)

  • trunk/Tools/Scripts/webkitpy/port/config_unittest.py

    r246159 r251808  
    3838from webkitpy.common.webkit_finder import WebKitFinder
    3939
    40 import config
     40import webkitpy.port.config as config
    4141
    4242

  • trunk/Tools/Scripts/webkitpy/port/darwin.py

    r249151 r251808  
    8686        # launching the browser.
    8787        self._executive.popen([self.path_to_script('run-safari')] + self._arguments_for_configuration() + ['--no-saved-state', '-NSOpen', results_filename],
    88             cwd=self.webkit_base(), stdout=file(os.devnull), stderr=file(os.devnull))
     88            cwd=self.webkit_base(), stdout=os.devnull, stderr=os.devnull)
    8989
    9090    @memoized

  • trunk/Tools/Scripts/webkitpy/port/driver_unittest.py

    r247682 r251808  
    203203        self.assertEqual(content_block.encoding, 'base64')
    204204        self.assertEqual(content_block.content, 'MTIzNDU2NzgK')
    205         self.assertEqual(content_block.decoded_content, '12345678\n')
     205        self.assertEqual(content_block.decoded_content, b'12345678\n')
    206206
    207207    def test_no_timeout(self):
    … …  
    369369                          'WAYLAND_SOCKET': 'wayland-socket-0',
    370370                          'GDK_BACKEND': 'x11'}
    371         environment_user = dict(environ_keep_yes.items() + environ_keep_no.items())
     371        environment_user = dict(list(environ_keep_yes.items()) + list(environ_keep_no.items()))
    372372        with patch('os.environ', environment_user):
    373373            port = self.make_port()

  • trunk/Tools/Scripts/webkitpy/port/factory.py

    r250121 r251808  
    137137        for port_class in self.PORT_CLASSES:
    138138            module_name, class_name = port_class.rsplit('.', 1)
    139             module = __import__(module_name, globals(), locals(), [], -1)
    140             cls = module.__dict__[class_name]
    141             classes.append(cls)
     139            module = __import__('webkitpy.port.{}'.format(module_name), globals(), locals(), [], 0)
     140            cls = module.__dict__.get('port').__dict__.get(module_name).__dict__.get(class_name)
     141            if cls:
     142                classes.append(cls)
    142143        if config.apple_additions() and hasattr(config.apple_additions(), 'ports'):
    143144            classes += config.apple_additions().ports()

  • trunk/Tools/Scripts/webkitpy/port/gtk.py

    r251661 r251808  
    212212
    213213    def default_baseline_search_path(self, **kwargs):
    214         return map(self._webkit_baseline_path, self._search_paths())
     214        return list(map(self._webkit_baseline_path, self._search_paths()))
    215215
    216216    def _port_specific_expectations_files(self, **kwargs):

  • trunk/Tools/Scripts/webkitpy/port/leakdetector.py

    r243559 r251808  
    3232
    3333from webkitpy.common.system.executive import ScriptError
     34from webkitpy.common.unicode_compatibility import encode_if_necessary
    3435
    3536_log = logging.getLogger(__name__)
    … …  
    7980        if not leaks_output:
    8081            return 0, 0, 0
    81         _, count, bytes = re.search(r'Process (?P<pid>\d+): (?P<count>\d+) leaks? for (?P<bytes>\d+) total', leaks_output).groups()
    82         excluded_match = re.search(r'(?P<excluded>\d+) leaks? excluded', leaks_output)
     82        leaks_output = encode_if_necessary(leaks_output)
     83        _, count, bytes = re.search(b'Process (?P<pid>\\d+): (?P<count>\\d+) leaks? for (?P<bytes>\\d+) total', leaks_output).groups()
     84        excluded_match = re.search(b'(?P<excluded>\\d+) leaks? excluded', leaks_output)
    8385        excluded = excluded_match.group('excluded') if excluded_match else 0
    8486        return int(count), int(excluded), int(bytes)

  • trunk/Tools/Scripts/webkitpy/port/leakdetector_valgrind.py

    r225733 r251808  
    3535from xml.dom.minidom import parseString
    3636from xml.parsers.expat import ExpatError
     37
     38from webkitpy.common.unicode_compatibility import encode_if_necessary, decode_for
    3739
    3840_log = logging.getLogger(__name__)
    … …  
    128130                buf += (frame[FUNCTION_NAME] or frame[INSTRUCTION_POINTER]) + "\n"
    129131
    130             input = buf.encode('latin-1').split("\n")
     132            input = buf.encode('latin-1').split(b"\n")
    131133            demangled_names = [self._executive.run_command(['c++filt', '-n', name]) for name in input if name]
    132134
    … …  
    173175        for frame in range(len(supplines)):
    174176            # Replace the always-changing anonymous namespace prefix with "*".
    175             m = re.match("( +fun:)_ZN.*_GLOBAL__N_.*\.cc_" +
    176                          "[0-9a-fA-F]{8}_[0-9a-fA-F]{8}(.*)",
    177                          supplines[frame])
     177            m = re.match(r"( +fun:)_ZN.*_GLOBAL__N_.*\.cc_" +
     178                          "[0-9a-fA-F]{8}_[0-9a-fA-F]{8}(.*)",
     179                          supplines[frame])
    178180            if m:
    179181                supplines[frame] = "*".join(m.groups())
    … …  
    197199        # By printing out this hash we can find duplicate reports between tests and
    198200        # different shards running on multiple buildbots
    199         return int(hashlib.md5(self.unique_string()).hexdigest()[:16], 16)
     201        return int(hashlib.md5(encode_if_necessary(self.unique_string())).hexdigest()[:16], 16)
    200202
    201203    def __hash__(self):
    … …  
    223225        except ExpatError as e:
    224226            parse_failed = True
    225             _log.error("could not parse %s: %s" % (leaks_output, e))
     227            _log.error("could not parse %s: %s" % (decode_for(leaks_output, str), e))
    226228            return
    227229
    … …  
    284286        _log.info("Suppressions used:")
    285287        _log.info("  count name")
    286         for (name, count) in sorted(self._suppressions.items(), key=lambda (k, v): (v, k)):
     288        for (name, count) in sorted(self._suppressions.items(), key=lambda pair: (pair[1], pair[0])):
    287289            _log.info("%7d %s" % (count, name))
    288290        _log.info("-----------------------------------------------------")
    … …  
    290292        if self._errors:
    291293            _log.info("Valgrind detected %s leaks:" % len(self._errors))
    292             for leak in self._errors:
     294            # Force the same order in Python 2 and Python 3
     295            for leak in sorted(self._errors, key=lambda error: error.unique_string()):
    293296                _log.info(leak)

  • trunk/Tools/Scripts/webkitpy/port/leakdetector_valgrind_unittest.py

    r174136 r251808  
    3030from webkitpy.common.system.filesystem_mock import MockFileSystem
    3131from webkitpy.common.system.outputcapture import OutputCapture
     32from webkitpy.common.unicode_compatibility import decode_for
    3233from webkitpy.port.leakdetector_valgrind import LeakDetectorValgrind
    3334
    … …  
    620621Valgrind detected 2 leaks:
    621622Leak_DefinitelyLost
    622 8 bytes in 1 blocks are definitely lost in loss record 421 of 7,972
    623   operator new(unsigned long) (/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    624   std::_Function_base::_Base_manager<WebCore::PolicyChecker::checkNavigationPolicy(WebCore::ResourceRequest const&, WebCore::DocumentLoader*, WTF::PassRefPtr<WebCore::FormState>, void (*)(void*, WebCore::ResourceRequest const&, WTF::PassRefPtr<WebCore::FormState>, bool), void*)::{lambda(WebCore::PolicyAction)#1}>::_M_manager(std::_Any_data&, std::_Function_base::_Base_manager<WebCore::PolicyChecker::checkNavigationPolicy(WebCore::ResourceRequest const&, WebCore::DocumentLoader*, WTF::PassRefPtr<WebCore::FormState>, void (*)(void*, WebCore::ResourceRequest const&, WTF::PassRefPtr<WebCore::FormState>, bool), void*)::{lambda(WebCore::PolicyAction)#1}> const&, std::_Manager_operation) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
    625   webkit_web_policy_decision_new (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
    626   WebKit::FrameLoaderClient::dispatchDecidePolicyForNavigationAction(WebCore::NavigationAction const&, WebCore::ResourceRequest const&, WTF::PassRefPtr<WebCore::FormState>, std::function<void (WebCore::PolicyAction)>) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
    627   WebCore::PolicyChecker::checkNavigationPolicy(WebCore::ResourceRequest const&, WebCore::DocumentLoader*, WTF::PassRefPtr<WebCore::FormState>, void (*)(void*, WebCore::ResourceRequest const&, WTF::PassRefPtr<WebCore::FormState>, bool), void*) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
    628   WebCore::FrameLoader::loadWithDocumentLoader(WebCore::DocumentLoader*, WebCore::FrameLoadType, WTF::PassRefPtr<WebCore::FormState>) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
    629   WebCore::FrameLoader::load(WebCore::DocumentLoader*) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
    630   WebCore::FrameLoader::load(WebCore::FrameLoadRequest const&) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
    631   webkit_web_frame_load_uri (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
    632   runTest(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) (/home/user/WebKit/WebKitBuild/Release/Programs/DumpRenderTree)
    633   runTestingServerLoop() (/home/user/WebKit/WebKitBuild/Release/Programs/DumpRenderTree)
    634   main (/home/user/WebKit/WebKitBuild/Release/Programs/DumpRenderTree)
    635 Suppression (error hash=#0449D3ED253FE1F9#):
    636 
    637 {
    638    <insert_a_suppression_name_here>
    639    Memcheck:Leak
    640    fun:_Znw*
    641    fun:_ZNSt14_Function_base13_Base_managerIZN7WebCore13PolicyChecker21checkNavigationPolicyERKNS1_15ResourceRequestEPNS1_14DocumentLoaderEN3WTF10PassRefPtrINS1_9FormStateEEEPFvPvS5_SB_bESC_EUlNS1_12PolicyActionEE_E10_M_managerERSt9_Any_dataRKSI_St18_Manager_operation
    642    fun:webkit_web_policy_decision_new
    643    fun:_ZN6WebKit17FrameLoaderClient39dispatchDecidePolicyForNavigationActionERKN7WebCore16NavigationActionERKNS1_15ResourceRequestEN3WTF10PassRefPtrINS1_9FormStateEEESt8functionIFvNS1_12PolicyActionEEE
    644    fun:_ZN7WebCore13PolicyChecker21checkNavigationPolicyERKNS_15ResourceRequestEPNS_14DocumentLoaderEN3WTF10PassRefPtrINS_9FormStateEEEPFvPvS3_S9_bESA_
    645    fun:_ZN7WebCore11FrameLoader22loadWithDocumentLoaderEPNS_14DocumentLoaderENS_13FrameLoadTypeEN3WTF10PassRefPtrINS_9FormStateEEE
    646    fun:_ZN7WebCore11FrameLoader4loadEPNS_14DocumentLoaderE
    647    fun:_ZN7WebCore11FrameLoader4loadERKNS_16FrameLoadRequestE
    648    fun:webkit_web_frame_load_uri
    649    fun:_ZL7runTestRKSs
    650    fun:_ZL20runTestingServerLoopv
    651    fun:main
    652 }
    653 
    654 
    655 Leak_DefinitelyLost
    6566238 bytes in 1 blocks are definitely lost in loss record 422 of 7,972
    657624  operator new(unsigned long) (/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    … …  
    693660   fun:g_main_loop_run
    694661   fun:gtk_main
     662   fun:_ZL7runTestRKSs
     663   fun:_ZL20runTestingServerLoopv
     664   fun:main
     665}
     666
     667
     668Leak_DefinitelyLost
     6698 bytes in 1 blocks are definitely lost in loss record 421 of 7,972
     670  operator new(unsigned long) (/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
     671  std::_Function_base::_Base_manager<WebCore::PolicyChecker::checkNavigationPolicy(WebCore::ResourceRequest const&, WebCore::DocumentLoader*, WTF::PassRefPtr<WebCore::FormState>, void (*)(void*, WebCore::ResourceRequest const&, WTF::PassRefPtr<WebCore::FormState>, bool), void*)::{lambda(WebCore::PolicyAction)#1}>::_M_manager(std::_Any_data&, std::_Function_base::_Base_manager<WebCore::PolicyChecker::checkNavigationPolicy(WebCore::ResourceRequest const&, WebCore::DocumentLoader*, WTF::PassRefPtr<WebCore::FormState>, void (*)(void*, WebCore::ResourceRequest const&, WTF::PassRefPtr<WebCore::FormState>, bool), void*)::{lambda(WebCore::PolicyAction)#1}> const&, std::_Manager_operation) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
     672  webkit_web_policy_decision_new (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
     673  WebKit::FrameLoaderClient::dispatchDecidePolicyForNavigationAction(WebCore::NavigationAction const&, WebCore::ResourceRequest const&, WTF::PassRefPtr<WebCore::FormState>, std::function<void (WebCore::PolicyAction)>) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
     674  WebCore::PolicyChecker::checkNavigationPolicy(WebCore::ResourceRequest const&, WebCore::DocumentLoader*, WTF::PassRefPtr<WebCore::FormState>, void (*)(void*, WebCore::ResourceRequest const&, WTF::PassRefPtr<WebCore::FormState>, bool), void*) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
     675  WebCore::FrameLoader::loadWithDocumentLoader(WebCore::DocumentLoader*, WebCore::FrameLoadType, WTF::PassRefPtr<WebCore::FormState>) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
     676  WebCore::FrameLoader::load(WebCore::DocumentLoader*) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
     677  WebCore::FrameLoader::load(WebCore::FrameLoadRequest const&) (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
     678  webkit_web_frame_load_uri (/home/user/WebKit/WebKitBuild/Release/.libs/libwebkitgtk-3.0.so.0.19.3)
     679  runTest(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) (/home/user/WebKit/WebKitBuild/Release/Programs/DumpRenderTree)
     680  runTestingServerLoop() (/home/user/WebKit/WebKitBuild/Release/Programs/DumpRenderTree)
     681  main (/home/user/WebKit/WebKitBuild/Release/Programs/DumpRenderTree)
     682Suppression (error hash=#0449D3ED253FE1F9#):
     683
     684{
     685   <insert_a_suppression_name_here>
     686   Memcheck:Leak
     687   fun:_Znw*
     688   fun:_ZNSt14_Function_base13_Base_managerIZN7WebCore13PolicyChecker21checkNavigationPolicyERKNS1_15ResourceRequestEPNS1_14DocumentLoaderEN3WTF10PassRefPtrINS1_9FormStateEEEPFvPvS5_SB_bESC_EUlNS1_12PolicyActionEE_E10_M_managerERSt9_Any_dataRKSI_St18_Manager_operation
     689   fun:webkit_web_policy_decision_new
     690   fun:_ZN6WebKit17FrameLoaderClient39dispatchDecidePolicyForNavigationActionERKN7WebCore16NavigationActionERKNS1_15ResourceRequestEN3WTF10PassRefPtrINS1_9FormStateEEESt8functionIFvNS1_12PolicyActionEEE
     691   fun:_ZN7WebCore13PolicyChecker21checkNavigationPolicyERKNS_15ResourceRequestEPNS_14DocumentLoaderEN3WTF10PassRefPtrINS_9FormStateEEEPFvPvS3_S9_bESA_
     692   fun:_ZN7WebCore11FrameLoader22loadWithDocumentLoaderEPNS_14DocumentLoaderENS_13FrameLoadTypeEN3WTF10PassRefPtrINS_9FormStateEEE
     693   fun:_ZN7WebCore11FrameLoader4loadEPNS_14DocumentLoaderE
     694   fun:_ZN7WebCore11FrameLoader4loadERKNS_16FrameLoadRequestE
     695   fun:webkit_web_frame_load_uri
    695696   fun:_ZL7runTestRKSs
    696697   fun:_ZL20runTestingServerLoopv
    … …  
    808809def mock_run_cppfilt_command(args):
    809810    if args[0] == 'c++filt':
    810         return valgrind_output_cppfilt_map[args[2]]
     811        return valgrind_output_cppfilt_map[decode_for(args[2], str)]
    811812    return ""
    812813

  • trunk/Tools/Scripts/webkitpy/port/linux_get_crash_log.py

    r233411 r251808  
    3737
    3838from webkitpy.common.system.executive import ScriptError
     39from webkitpy.common.unicode_compatibility import decode_if_necessary
    3940
    4041
    … …  
    7677                info = self._executive.run_command(coredumpctl + ['info', "--since=" + time.strftime("%a %Y-%m-%d %H:%M:%S %Z", time.localtime(self.newer_than))],
    7778                    return_stderr=True)
    78             except ScriptError, OSError:
     79            except (ScriptError, OSError):
    7980                continue
    8081
    … …  
    130131            crash_log, errors = self._get_trace_from_systemd(coredumpctl, pid_representation)
    131132
    132         stderr_lines = errors + str(stderr or '<empty>').decode('utf8', 'ignore').splitlines()
     133        stderr_lines = errors + decode_if_necessary(str(stderr or '<empty>'), errors='ignore').splitlines()
    133134        errors_str = '\n'.join(('STDERR: ' + stderr_line) for stderr_line in stderr_lines)
    134135        cppfilt_proc = self._executive.popen(

  • trunk/Tools/Scripts/webkitpy/port/mac.py

    r251020 r251808  
    223223            stdin=self._executive.PIPE, stdout=self._executive.PIPE, stderr=None)
    224224        is_ready = self._helper.stdout.readline()
    225         if not is_ready.startswith('ready'):
     225        if not is_ready.startswith(b'ready'):
    226226            _log.error("LayoutTestHelper could not start")
    227227            return False
    … …  
    243243            _log.debug("Stopping LayoutTestHelper")
    244244            try:
    245                 self._helper.stdin.write("x\n")
     245                self._helper.stdin.write(b"x\n")
    246246                self._helper.stdin.close()
    247247                self._helper.wait()

  • trunk/Tools/Scripts/webkitpy/port/mock_drt_unittest.py

    r246326 r251808  
    3232import unittest
    3333
    34 from webkitpy.common import newstringio
    3534from webkitpy.common.system.systemhost_mock import MockSystemHost
     35from webkitpy.common.unicode_compatibility import StringIO
    3636from webkitpy.port import mock_drt
    3737from webkitpy.port import port_testcase
    … …  
    147147
    148148        args = ['--platform', port_name] + self.extra_args(pixel_tests)
    149         stdin = newstringio.StringIO(drt_input)
    150         stdout = newstringio.StringIO()
    151         stderr = newstringio.StringIO()
     149        stdin = StringIO(drt_input)
     150        stdout = StringIO()
     151        stderr = StringIO()
    152152        options, args = mock_drt.parse_options(args)
    153153
    … …  
    157157        self.assertEqual(res, 0)
    158158
    159         # We use the StringIO.buflist here instead of getvalue() because
    160         # the StringIO might be a mix of unicode/ascii and 8-bit strings.
    161         self.assertEqual(stdout.buflist, drt_output)
     159        self.assertEqual(stdout.getvalue(), ''.join(drt_output))
    162160        self.assertEqual(stderr.getvalue(), '#EOF\n')
    163161
    … …  
    165163        host = MockSystemHost()
    166164        test.add_unit_tests_to_mock_filesystem(host.filesystem)
    167         stdin = newstringio.StringIO()
    168         stdout = newstringio.StringIO()
    169         stderr = newstringio.StringIO()
     165        stdin = StringIO()
     166        stdout = StringIO()
     167        stderr = StringIO()
    170168        res = mock_drt.main(['--platform', 'test'] + self.extra_args(False),
    171169                            host, stdin, stdout, stderr)

  • trunk/Tools/Scripts/webkitpy/port/port_testcase.py

    r250330 r251808  
    9090            for platform in result.mapping[PUBLIC_TABLE]:
    9191                result.mapping[INTERNAL_TABLE][platform] = {}
    92                 for name, version in result.mapping[PUBLIC_TABLE][platform].iteritems():
     92                for name, version in result.mapping[PUBLIC_TABLE][platform].items():
    9393                    result.mapping[INTERNAL_TABLE][platform]['add-' + name] = version
    9494            return result
    … …  
    470470            port._filesystem.write_text_file(path, '')
    471471        ordered_dict = port.expectations_dict()
    472         self.assertEqual(port.path_to_generic_test_expectations_file(), ordered_dict.keys()[0])
    473         self.assertEqual(port.path_to_test_expectations_file(), ordered_dict.keys()[port.test_expectations_file_position()])
     472        self.assertEqual(port.path_to_generic_test_expectations_file(), list(ordered_dict.keys())[0])
     473        self.assertEqual(port.path_to_test_expectations_file(), list(ordered_dict.keys())[port.test_expectations_file_position()])
    474474
    475475        options = MockOptions(additional_expectations=['/tmp/foo', '/tmp/bar'])
    … …  
    480480        port._filesystem.write_text_file('/tmp/bar', 'bar')
    481481        ordered_dict = port.expectations_dict()
    482         self.assertEqual(ordered_dict.keys()[-2:], options.additional_expectations)  # pylint: disable=E1101
    483         self.assertEqual(ordered_dict.values()[-2:], ['foo', 'bar'])
     482        self.assertEqual(list(ordered_dict.keys())[-2:], options.additional_expectations)  # pylint: disable=E1101
     483        self.assertEqual(list(ordered_dict.values())[-2:], ['foo', 'bar'])
    484484
    485485    def test_path_to_test_expectations_file(self):
    … …  
    532532            'BUG_TESTEXPECTATIONS SKIP : fast/html/article-element.html = FAIL\n')
    533533        port = TestWebKitPort(host=host)
    534         self.assertEqual(''.join(port.expectations_dict().values()), 'BUG_TESTEXPECTATIONS SKIP : fast/html/article-element.html = FAIL\n')
     534        self.assertEqual(''.join(list(port.expectations_dict().values())), 'BUG_TESTEXPECTATIONS SKIP : fast/html/article-element.html = FAIL\n')
    535535
    536536    def test_build_driver(self):

  • trunk/Tools/Scripts/webkitpy/port/win.py

    r251661 r251808  
    9292    def __init__(self, host, port_name, **kwargs):
    9393        ApplePort.__init__(self, host, port_name, **kwargs)
    94         if port_name.split('-') > 1:
     94        if len(port_name.split('-')) > 1:
    9595            self._os_version = VersionNameMap.map(host.platform).from_name(port_name.split('-')[1])[1]
    9696        else:
    … …  
    128128        # FIXME: Perhaps we should get this list from MacPort?
    129129        fallback_names.append('mac')
    130         result = map(self._webkit_baseline_path, fallback_names)
     130        result = list(map(self._webkit_baseline_path, fallback_names))
    131131        if apple_additions() and getattr(apple_additions(), "layout_tests_path", None):
    132132            result.insert(0, self._filesystem.join(apple_additions().layout_tests_path(), self.port_name))
    … …  
    206206    def test_search_path(self, **kwargs):
    207207        test_fallback_names = [path for path in self.baseline_search_path() if not path.startswith(self._webkit_baseline_path('mac'))]
    208         return map(self._webkit_baseline_path, test_fallback_names)
     208        return list(map(self._webkit_baseline_path, test_fallback_names))
    209209
    210210    def _ntsd_location(self):
    … …  
    341341        debugger_options = '"{0}" -p %ld -e %ld -g -noio -lines -cf "{1}"'.format(cygpath(ntsd_path), cygpath(command_file))
    342342        registry_settings = {'Debugger': [debugger_options, self._REG_SZ], 'Auto': ["1", self._REG_SZ]}
    343         for key, value in registry_settings.iteritems():
     343        for key, value in registry_settings.items():
    344344            for arch in ["--wow32", "--wow64"]:
    345345                self.previous_debugger_values[(arch, self._HKLM, key)] = self.read_registry_value(self.POST_MORTEM_DEBUGGER_KEY, arch, self._HKLM, key)
    … …  
    349349
    350350    def restore_crash_log_saving(self):
    351         for key, value in self.previous_debugger_values.iteritems():
     351        for key, value in self.previous_debugger_values.items():
    352352            self.write_registry_value(self.POST_MORTEM_DEBUGGER_KEY, key[0], key[1], key[2], value[1], value[0])
    353         for key, value in self.previous_wow64_debugger_values.iteritems():
     353        for key, value in self.previous_wow64_debugger_values.items():
    354354            self.write_registry_value(self.WOW64_POST_MORTEM_DEBUGGER_KEY, key[0], key[1], key[2], value[1], value[0])
    355355
    356356    def prevent_error_dialogs(self):
    357357        registry_settings = {'DontShowUI': [1, self._REG_DWORD], 'Disabled': [1, self._REG_DWORD]}
    358         for key, value in registry_settings.iteritems():
     358        for key, value in registry_settings.items():
    359359            for root in [self._HKLM, self._HKCU]:
    360360                for arch in ["--wow32", "--wow64"]:
    … …  
    365365
    366366    def allow_error_dialogs(self):
    367         for key, value in self.previous_error_reporting_values.iteritems():
     367        for key, value in self.previous_error_reporting_values.items():
    368368            self.write_registry_value(self.WINDOWS_ERROR_REPORTING_KEY, key[0], key[1], key[2], value[1], value[0])
    369         for key, value in self.previous_wow64_error_reporting_values.iteritems():
     369        for key, value in self.previous_wow64_error_reporting_values.items():
    370370            self.write_registry_value(self.WOW64_WINDOWS_ERROR_REPORTING_KEY, key[0], key[1], key[2], value[1], value[0])
    371371
    … …  
    464464
    465465    def default_baseline_search_path(self, **kwargs):
    466         return map(self._webkit_baseline_path, self._search_paths())
     466        return list(map(self._webkit_baseline_path, self._search_paths()))
    467467
    468468    def _port_specific_expectations_files(self, **kwargs):
    469         return map(lambda x: self._filesystem.join(self._webkit_baseline_path(x), 'TestExpectations'), reversed(self._search_paths()))
     469        return list(map(lambda x: self._filesystem.join(self._webkit_baseline_path(x), 'TestExpectations'), reversed(self._search_paths())))
    470470
    471471    def _search_paths(self):
    … …  
    508508
    509509    def default_baseline_search_path(self, **kwargs):
    510         return map(self._webkit_baseline_path, self._search_paths())
     510        return list(map(self._webkit_baseline_path, self._search_paths()))
    511511
    512512    def _port_specific_expectations_files(self, **kwargs):
    513         return map(lambda x: self._filesystem.join(self._webkit_baseline_path(x), 'TestExpectations'), reversed(self._search_paths()))
     513        return list(map(lambda x: self._filesystem.join(self._webkit_baseline_path(x), 'TestExpectations'), reversed(self._search_paths())))
    514514
    515515    def _search_paths(self):

  • trunk/Tools/Scripts/webkitpy/port/win_unittest.py

    r245733 r251808  
    5757    def _assert_search_path(self, expected_search_paths, version, use_webkit2=False):
    5858        port = self.make_port(port_name='win', os_version=version, options=MockOptions(webkit_test_runner=use_webkit2))
    59         absolute_search_paths = map(port._webkit_baseline_path, expected_search_paths)
     59        absolute_search_paths = list(map(port._webkit_baseline_path, expected_search_paths))
    6060        self.assertEqual(port.baseline_search_path(), absolute_search_paths)
    6161

  • trunk/Tools/Scripts/webkitpy/port/wpe.py

    r251661 r251808  
    108108
    109109    def default_baseline_search_path(self, **kwargs):
    110         return map(self._webkit_baseline_path, self._search_paths())
     110        return list(map(self._webkit_baseline_path, self._search_paths()))
    111111
    112112    def _port_specific_expectations_files(self, **kwargs):
    113         return map(lambda x: self._filesystem.join(self._webkit_baseline_path(x), 'TestExpectations'), reversed(self._search_paths()))
     113        return list(map(lambda x: self._filesystem.join(self._webkit_baseline_path(x), 'TestExpectations'), reversed(self._search_paths())))
    114114
    115115    def test_expectations_file_position(self):
Note: See TracChangeset for help on using the changeset viewer.