Reland "Roll WPT Tooling."

This is a reland of bb3fab20f9

Key additions since the original CL (in PS3 and onward):
- added //third_party/wpt_tools/wpt/tools/third_party/websockets, which
is required by webdriver tests.
- updated //chrome/test/chromedriver/test/run_webdriver_tests.py to
import localpaths.py so it can use vendored-in deps (like websockets).
- several updates to .vpython3 to add more wheels and bump up some
versions.

Original change's description:
> Roll WPT Tooling.
>
> This is a significant change because we pull in the breaking py3-only
> changes from upstream.
>
> In addition to the changes made by //third_party/wpt_tools/checkout.sh,
> this CL also includes several fixups to pass CQ (eg: some more py3
> updates, and manually adding a webdriver bidi PR).
>
> Cq-Include-Trybots: luci.chromium.try:linux-wpt-identity-fyi-rel,linux-wpt-input-fyi-rel
> Change-Id: I6380ec6bb46fa6fe8e0db66ebe1f82122b5c3c87
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2764543
> Reviewed-by: Stephen McGruer <smcgruer@chromium.org>
> Reviewed-by: Rakib Hasan <rmhasan@google.com>
> Commit-Queue: Luke Z <lpz@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#863882}

Change-Id: I44674cdb767ade155a04fb5920bb339d066dce42
Cq-Include-Trybots: luci.chromium.try:linux-wpt-identity-fyi-rel
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2775239
Reviewed-by: Rakib Hasan <rmhasan@google.com>
Reviewed-by: Stephen McGruer <smcgruer@chromium.org>
Reviewed-by: Dirk Pranke <dpranke@google.com>
Reviewed-by: Shengfa Lin <shengfa@google.com>
Commit-Queue: Luke Z <lpz@chromium.org>
Cr-Commit-Position: refs/heads/master@{#866232}

.vpython3

@@ -138,15 +138,39 @@ wheel: <
 
 # Used by:
 #   chrome/test/chromedriver/test/run_webdriver_tests.py
+wheel: <
+  name: "infra/python/wheels/iniconfig-py3"
+  version: "version:1.1.1"
+>
+
+wheel: <
+  name: "infra/python/wheels/packaging-py2_py3"
+  version: "version:16.8"
+>
+
+wheel: <
+  name: "infra/python/wheels/pyparsing-py2_py3"
+  version: "version:2.2.0"
+>
+
+wheel: <
+  name: "infra/python/wheels/toml-py3"
+  version: "version:0.10.1"
+>
 
 wheel <
-  name: "infra/python/wheels/pytest-py2_py3"
-  version: "version:4.1.1"
+  name: "infra/python/wheels/pytest-py3"
+  version: "version:6.2.2"
+>
+
+wheel <
+  name: "infra/python/wheels/pytest-asyncio-py3"
+  version: "version:0.14.0"
 >
 
 wheel <
   name: "infra/python/wheels/attrs-py2_py3"
-  version: "version:18.2.0"
+  version: "version:20.3.0"
 >
 
 wheel <
@@ -160,8 +184,8 @@ wheel <
 >
 
 wheel <
-  name: "infra/python/wheels/pluggy-py2_py3"
-  version: "version:0.8.1"
+  name: "infra/python/wheels/pluggy-py3"
+  version: "version:0.13.1"
 >
 
 wheel <

chrome/test/chromedriver/test/run_webdriver_tests.py

@@ -40,7 +40,14 @@ from blinkpy.w3c.common import CHROMIUM_WPT_DIR
 from blinkpy.web_tests.models.test_expectations import TestExpectations
 from blinkpy.web_tests.models.typ_types import ResultType
 
-WD_CLIENT_PATH = 'third_party/wpt_tools/wpt/tools/webdriver'
+WPT_TOOLS_PATH = 'third_party/wpt_tools/wpt/tools'
+WPT_TOOLS_ABSPATH = os.path.join(SRC_DIR, WPT_TOOLS_PATH)
+sys.path.insert(0, WPT_TOOLS_ABSPATH)
+# Importing localpaths allows us to use vendored-in dependencies from the
+# wpt_tools/wpt/tools/third_party directory.
+import localpaths  # noqa: F401
+
+WD_CLIENT_PATH = os.path.join(WPT_TOOLS_PATH, 'webdriver')
 WEBDRIVER_CLIENT_ABS_PATH = os.path.join(SRC_DIR, WD_CLIENT_PATH)
 
 

testing/scripts/run_android_wpt.py

@@ -119,9 +119,6 @@ class WPTAndroidAdapter(wpt_common.BaseWptScriptAdapter):
     # Here we add all of the arguments required to run WPT tests on Android.
     rest_args.extend([self.options.wpt_path])
 
-    # TODO(crbug.com/1166741): We should be running WPT under Python 3.
-    rest_args.extend(["--py3"])
-
     # vpython has packages needed by wpt, so force it to skip the setup
     rest_args.extend(["--venv=" + SRC_DIR, "--skip-venv-setup"])
 

testing/scripts/run_wpt_tests.py

@@ -73,8 +73,6 @@ class WPTTestAdapter(wpt_common.BaseWptScriptAdapter):
             WPT_BINARY,
             "--venv=" + SRC_DIR,
             "--skip-venv-setup",
-            # TODO(crbug.com/1166741): We should be running WPT under Python 3.
-            "--py3",
             "run",
             "chrome"
         ] + self.options.test_list + [

third_party/blink/web_tests/external/wpt/webdriver/tests/bidi/new_session/connect.py

@@ -0,0 +1,36 @@
+import pytest
+import asyncio
+import websockets
+import webdriver
+
+# classic session to enable bidi capability manually
+# Intended to be the first test in this file
+@pytest.mark.asyncio
+@pytest.mark.capabilities({"webSocketUrl": True})
+async def test_websocket_url_connect(session):
+    assert not isinstance(session, webdriver.BidiSession)
+    websocket_url = session.capabilities["webSocketUrl"]
+    async with websockets.connect(websocket_url) as websocket:
+        await websocket.send("Hello world!")
+
+# test bidi_session send
+# using bidi_session is the recommended way to test bidi
+@pytest.mark.asyncio
+async def test_bidi_session_send(bidi_session):
+    await bidi_session.websocket_transport.send("test_bidi_session: send")
+
+# bidi session following a bidi session with a different capabilities
+# to test session recreation
+@pytest.mark.asyncio
+@pytest.mark.capabilities({"acceptInsecureCerts": True})
+async def test_bidi_session_with_different_capability(bidi_session):
+    await bidi_session.websocket_transport.send("test_bidi_session: different capability")
+
+# classic session following a bidi session to test session
+# recreation
+# Intended to be the last test in this file to make sure
+# classic session is not impacted by bidi tests
+@pytest.mark.asyncio
+def test_classic_after_bidi_session(session):
+    assert not isinstance(session, webdriver.BidiSession)
+

third_party/blink/web_tests/external/wpt/webdriver/tests/new_session/websocket_url.py

@@ -0,0 +1,8 @@
+from tests.support.asserts import assert_success
+
+def test_websocket_url(new_session, add_browser_capabilities):
+    response, _ = new_session({"capabilities": {
+        "alwaysMatch": add_browser_capabilities({"webSocketUrl": True})}})
+    value = assert_success(response)
+    assert value["capabilities"]["webSocketUrl"].startswith("ws://")
+

third_party/blink/web_tests/external/wpt/webdriver/tests/support/fixtures.py

@@ -2,6 +2,7 @@ import copy
 import json
 import os
 
+import asyncio
 import pytest
 import webdriver
 
@@ -39,6 +40,17 @@ def pytest_generate_tests(metafunc):
             metafunc.parametrize("capabilities", marker.args, ids=None)
 
 
+# Ensure that the event loop is restarted once per session rather than the default  of once per test
+# if we don't do this, tests will try to reuse a closed event loop and fail with an error that the "future
+# belongs to a different loop"
+@pytest.fixture(scope="session")
+def event_loop():
+    """Change event_loop fixture to session level."""
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+
 @pytest.fixture
 def add_event_listeners(session):
     """Register listeners for tracked events on element."""
@@ -111,8 +123,23 @@ def configuration():
     }
 
 
+async def reset_current_session_if_necessary(caps, request_bidi):
+    global _current_session
+
+    # If there is a session with different capabilities active or the current session
+    # is of different type than the one we would like to create, end it now.
+    if _current_session is not None:
+        is_bidi = isinstance(_current_session, webdriver.BidiSession)
+        if is_bidi != request_bidi or not _current_session.match(caps):
+            if is_bidi:
+                await _current_session.end()
+            else:
+                _current_session.end()
+            _current_session = None
+
+
 @pytest.fixture(scope="function")
-def session(capabilities, configuration, request):
+async def session(capabilities, configuration, request):
     """Create and start a session for a test that does not itself test session creation.
 
     By default the session will stay open after each test, but we always try to start a
@@ -127,11 +154,7 @@ def session(capabilities, configuration, request):
     deep_update(caps, capabilities)
     caps = {"alwaysMatch": caps}
 
-    # If there is a session with different capabilities active, end it now
-    if _current_session is not None and (
-            caps != _current_session.requested_capabilities):
-        _current_session.end()
-        _current_session = None
+    await reset_current_session_if_necessary(caps, False)
 
     if _current_session is None:
         _current_session = webdriver.Session(
@@ -140,6 +163,46 @@ def session(capabilities, configuration, request):
             capabilities=caps)
     try:
         _current_session.start()
+
+    except webdriver.error.SessionNotCreatedException:
+        if not _current_session.session_id:
+            raise
+
+    # Enforce a fixed default window size and position
+    _current_session.window.size = defaults.WINDOW_SIZE
+    _current_session.window.position = defaults.WINDOW_POSITION
+
+    yield _current_session
+
+    cleanup_session(_current_session)
+
+
+@pytest.fixture(scope="function")
+async def bidi_session(capabilities, configuration, request):
+    """Create and start a bidi session for a test that does not itself test
+    bidi session creation.
+    By default the session will stay open after each test, but we always try to start a
+    new one and assume that if that fails there is already a valid session. This makes it
+    possible to recover from some errors that might leave the session in a bad state, but
+    does not demand that we start a new session per test."""
+    global _current_session
+
+    # Update configuration capabilities with custom ones from the
+    # capabilities fixture, which can be set by tests
+    caps = copy.deepcopy(configuration["capabilities"])
+    deep_update(caps, capabilities)
+    caps = {"alwaysMatch": caps}
+
+    await reset_current_session_if_necessary(caps, True)
+
+    if _current_session is None:
+        _current_session = webdriver.BidiSession(
+            configuration["host"],
+            configuration["port"],
+            capabilities=caps)
+    try:
+        await _current_session.start()
+
     except webdriver.error.SessionNotCreatedException:
         if not _current_session.session_id:
             raise

third_party/wpt_tools/PRESUBMIT.py

@@ -20,7 +20,8 @@ def _TestWPTLint(input_api, output_api):
     name='web_tests/external/PRESUBMIT_test.py',
     cmd=[abspath_to_test],
     kwargs={},
-    message=output_api.PresubmitError
+    message=output_api.PresubmitError,
+    python3=True
   )
   if input_api.verbose:
     print('Running ' + abspath_to_test)
@@ -45,7 +46,7 @@ def _TestWPTManifest(input_api, output_api):
         blink_path, 'web_tests', 'external', 'wpt')
     try:
       input_api.subprocess.check_output(
-          ['python', wpt_exec_path, 'manifest', '--no-download',
+          ['python3', wpt_exec_path, 'manifest', '--no-download',
            '--path', f.name, '--tests-root', external_wpt])
     except input_api.subprocess.CalledProcessError as exc:
       return [output_api.PresubmitError('wpt manifest failed:', long_text=exc.output)]

third_party/wpt_tools/README.chromium

@@ -1,7 +1,7 @@
 Name: web-platform-tests - Test Suites for Web Platform specifications
 Short Name: wpt
 URL: https://github.com/web-platform-tests/wpt/
-Version: 3eb2cdae07a8842112e804a59dbd0f9800c64e73
+Version: f6a1fd063fd77ea5865c82682458ae4fb7d04bb3
 License: LICENSES FOR W3C TEST SUITES (https://www.w3.org/Consortium/Legal/2008/03-bsd-license.html)
 License File: NOT_SHIPPED
 Security Critical: no
@@ -12,7 +12,3 @@ Description: This includes code for the manifest tool, lint tool, and wptserve.
     for more details on maintenance.
 Local Modifications:
 - Removed all files except for those listed in wpt/WPTIncludeList.
-- Cherry-picked df9dc69c2340d79fbd56ee2adfa85ac8d4af0b93 temporarily to fix a
-  lint error blocking the importer.
-- Cherry-picked 9b5f845370d7c6fe83b51ceef3f91e42aa85bbc2 temporatily to resolve
-  https://crbug.com/1182579

third_party/wpt_tools/WPTIncludeList

@@ -174,7 +174,45 @@
 ./tools/third_party/webencodings/webencodings/mklabels.py
 ./tools/third_party/webencodings/webencodings/tests.py
 ./tools/third_party/webencodings/webencodings/x_user_defined.py
+./tools/third_party/websockets/README.rst
+./tools/third_party/websockets/LICENSE
+./tools/third_party/websockets/setup.py
+./tools/third_party/websockets/tox.ini
+./tools/third_party/websockets/performance/mem_server.py
+./tools/third_party/websockets/performance/mem_client.py
+./tools/third_party/websockets/Makefile
+./tools/third_party/websockets/MANIFEST.in
+./tools/third_party/websockets/setup.cfg
+./tools/third_party/websockets/.gitignore
+./tools/third_party/websockets/src/websockets/version.py
+./tools/third_party/websockets/src/websockets/uri.py
+./tools/third_party/websockets/src/websockets/protocol.py
+./tools/third_party/websockets/src/websockets/framing.py
+./tools/third_party/websockets/src/websockets/__init__.py
+./tools/third_party/websockets/src/websockets/headers.py
+./tools/third_party/websockets/src/websockets/speedups.pyi
+./tools/third_party/websockets/src/websockets/server.py
+./tools/third_party/websockets/src/websockets/typing.py
+./tools/third_party/websockets/src/websockets/client.py
+./tools/third_party/websockets/src/websockets/handshake.py
+./tools/third_party/websockets/src/websockets/extensions/base.py
+./tools/third_party/websockets/src/websockets/extensions/__init__.py
+./tools/third_party/websockets/src/websockets/extensions/permessage_deflate.py
+./tools/third_party/websockets/src/websockets/py.typed
+./tools/third_party/websockets/src/websockets/__main__.py
+./tools/third_party/websockets/src/websockets/speedups.c
+./tools/third_party/websockets/src/websockets/exceptions.py
+./tools/third_party/websockets/src/websockets/utils.py
+./tools/third_party/websockets/src/websockets/auth.py
+./tools/third_party/websockets/src/websockets/http.py
+./tools/third_party/websockets/.appveyor.yml
+./tools/third_party/websockets/compliance/README.rst
+./tools/third_party/websockets/compliance/fuzzingclient.json
+./tools/third_party/websockets/compliance/test_client.py
+./tools/third_party/websockets/compliance/fuzzingserver.json
+./tools/third_party/websockets/compliance/test_server.py
 ./tools/webdriver/webdriver/__init__.py
+./tools/webdriver/webdriver/bidi.py
 ./tools/webdriver/webdriver/client.py
 ./tools/webdriver/webdriver/error.py
 ./tools/webdriver/webdriver/protocol.py

third_party/wpt_tools/checkout.sh

@@ -9,7 +9,7 @@ cd $DIR
 
 TARGET_DIR=$DIR/wpt
 REMOTE_REPO="https://github.com/web-platform-tests/wpt.git"
-WPT_HEAD=3eb2cdae07a8842112e804a59dbd0f9800c64e73
+WPT_HEAD=f6a1fd063fd77ea5865c82682458ae4fb7d04bb3
 
 function clone {
   # Remove existing repo if already exists.

third_party/wpt_tools/wpt/docs/commands.json

@@ -3,7 +3,6 @@
     "path": "frontend.py",
     "script": "build",
     "help": "Build documentation",
-    "py3only": true,
     "virtualenv": true,
     "requirements": [
       "./requirements.txt"

third_party/wpt_tools/wpt/tools/certs/cacert.key

@@ -1,30 +1,30 @@
 -----BEGIN ENCRYPTED PRIVATE KEY-----
-MIIFHDBOBgkqhkiG9w0BBQ0wQTApBgkqhkiG9w0BBQwwHAQI666o+tmBgXYCAggA
-MAwGCCqGSIb3DQIJBQAwFAYIKoZIhvcNAwcECILZgh0KpE9MBIIEyCgMCCFkSlDm
-wPDpQ0rFCyQyAcdP5HMnLM/W+2z5TYDqdhtLd+XqD2lGqr4lCd33CoDubRxZoU/t
-VQ0TuDQcfhCz8HG6nXMpai2NDrc5Ot29fVFdMFkk8na17RhMKUc6Gan/TDi+E4i8
-e2YakJ5JgaBUFBf/jyqJfLsYJezNFhn5+nCsz+KbZBoht2B+W/rq/FAUzwPGJ+Yc
-8J2gVcuRUctXwS47yI8aklXhIhwmL89Ioad3rpypeDX3tu5TeG2nv/d1uV3/FngC
-/18b4eJz6dpqdTVN5Uoa3NjHjY8a8mcBvWKBL6mWy2dTVl9W8wdgtVkvc0PsF3Pu
-oJy5oeWhP6dSqAvDHTDXa38rt3H9IRmTsIXd0VVOIhFjg8tDQTBR/CyJKp4JO8Oy
-y/RGZsdqcO03ujolWOlDY4Pi8e7JpHK+1kyhGOTimi/9JuWtiSp40gKDzylL1oaw
-hr1UaPHl/kA/gJgpDBKT+PXQt2Gm9qje9+B/U6zj31bVd0r1S0qMlXz81t/K+BcH
-u/5NaZsDXyE8rufyxAHPBKPxXMZONG7y6EbF868EHUrCAKlElfHtTnvP/k68V3eH
-GnVzsId8eirzutrRdugPXS7Pg1Uj1CL6Ga8ia9MfEIbSx/g2FQ9SMnurXVeWv1qM
-uMNZbRZUkkJD8T/VqB7ezrI553iTqZFGr6fQ0dyXBS0m1phPSkmPcqE42sYCIZcy
-KZGYeWS1LkFRoTxoAwRS8cf14NjmoG+Aby4iyB3QiMDOmsylZDF0vsYeUbUIkxyz
-GnSn2LaVpT3ZeuziLnNn3JaeIy946jEgZETvCDruurV5AoAb9pXG2Xuysevx/AuV
-Owzz82PqG308kq6xhcGNK+v9FRbagHaGZ5EG+iVUTjN348NjJIriDVdrH06fBqe+
-UFD9fAnN/Kj4dIJKUCun4UZiz2jHeNnAmkLwOZn/eTK1LbUrmT0J+3eupaF7zzxo
-CednARzHvAiEVAX8Wd5DauIjczesjdrO9ys7dTMeZeyV5t/s8W66TB6tVDIQwTIp
-3skdhbw22zI2lcrDhZbbYhwO9R6d4liENUZ/W5ISLDXn+w8kqqh1qXoE8vR0lxpy
-Oz27kg5DBqyUflx99HwLj8epMNpGzepMAeFXTd+gLFKk7gWtU/5mJItTEfBu8Iih
-FT3/eesClxxzBm2Mk1viv/iKspTH92+mKEz2ng6jONWxHXkfuxNWe4wX+KmO7s7P
-plzxnbr2TlNTewbuYqyKMwe9KOiXosdfxUkJq6D8R0bf+A69M/dggO7BVdxNfF71
-+xdfqjWjll/58lQ15KdlycfVlYj6iDvK1ChrK4UH2myGbmhThIItezPm8Oo4i3I6
-iPk8ns/BqfFH2raE7cw7G3Ug6cEJrc8OG4c1mfBuHPAeDrCWNu7tEqwKrGGJVA3b
-1GiBo72z5XVOiP7lku708ZEfrzh2UGuSvx0gbpW3aMDNnVq2O6euIquZugeewckq
-2Ox9C1vADIA8ugRdHbSVRQE33YiU1QS3MvQ9TYW/Zv7Buuhrdk2S1WLRpkWw+qR6
-62EFFAw6wjpK/vciGucrV8GyybdxPFqZPMtQkghaOPUO84Qsx2rZXAR+4/gZuHGm
-v2L3tYSDEmQ+6kEynWtX/w==
+MIIFHDBOBgkqhkiG9w0BBQ0wQTApBgkqhkiG9w0BBQwwHAQIy+AmMEgUCbACAggA
+MAwGCCqGSIb3DQIJBQAwFAYIKoZIhvcNAwcECJTlAsVqhvE6BIIEyG++PNkc48P8
+oprMaYzGL0QsYQb7xLR/JYhWB2GVUZGTTYORqiUIgKUQkayG1cxO2Jyhqb+qZfdI
+gAt9x7uS6A2omVXCm0ZW1vl4NGOyNdHvTmCnf9EkCzqWYYUW0nxxdV6DsVtsOb1/
+gDJxo3n8CYue/5zGuOprQJRUZAHrvx2huKMzg3wxSzYOaRfYVy5N9dKbgroyd/Vy
+05H+k9HY9+YwhRhXSTyqMRNj3ftbizdoPFyWihVABUvan6ExScuXNbfVu/qwxG86
+WRAFr6qu1EBhe5OLttHDYnhr14HjSTkTp289wKAn9fOMzvUh0NEMTx5PgF3u0AK6
+edhtDrJwjgrRc6ENJw3mM6VGa/FxR0eRyp38+/MteYyfz5eVnyPnJw22uiBd8i2j
+6dzDS+zZMA3vmp2NdB3rbgleQ5sdNEqJz4GC/yqTtwGDwH+OrbMpl2BAn1ckz9R9
+2b+DYsstBtLDx+R6JOy/sOFGcZla5T5TYOVJWD5i4vnW216rK6Pi+mbXa9WzGfGH
+UmghkDDh7iLYIBT3+YgEHqAeb+RKfeq7X3r6PBOAhavLp/4w2ZffywnyfxOxKQwE
+nb0bU8OPkPe3by3sbfS9H17729dTMMAJ3NGVjst2rEGYbDU/OZuBZzW3fwFnwKV2
+N3BTe3nPpZ/SXip7I6Hf+b6TNGeyVZUvBzw7spGGlXbbK76EdWY3dcs2OMH6JxUW
+Ib/bkNqclqSeXYFigzDozAuBJ2cM0TXxhnvLLuLLgL4+kH/d0tdCLJLNSqDy4Q+N
+GOFWZGtaowGuhpblGsAC/Z2wdPJ+fVQxGbHfGOttyoxCdfNfSclk7KuJFVQCGn1H
+aBvZfr1bf+o+mxuDmaDKFyb3fGQ55AgAdno5NxEInSofuopAefNxwfGzhTYmnAdF
+JY6WvXisz57EW9SjEvGHJMRREYw9a8tPKCOXa9CgPFsVdhPA+cFaBI3qDoY9E6rv
+cYdhXKatnORDHTQXPJz241cJK1yz6VDqAzExQlXli+dSqLl04X/3hAjIAMtDeeCc
+7F3U9XLkMIAiU3GKHIA0mq8wkTucOd7EVV+TS+i4e9MBIRueNyEd4u6m04G7Y4kf
+pkGowONXy1CETy4RoRNJi+nGC7TwCLzbEg6Sb9xs9q2lLh/cAiqdArPk9vLNe9Gh
+YSlcwN4WSPtQTN4hjiBhWe7O9Ux6f2llptyQhCzpb58h7IOQgTUcHOENoxUnVQwS
+RYsj+29aAYcLI+5NJzMwYXNR3Fdb3sDUn16f/NsfZUpxFzmu7zSrt7SJJfFasMN3
+EjwuSoEtVdwT7+IOO8A9gRuh5JRjuFYx252Mc0HY/R3qlTwrBNXyUUyFUO8t6TYN
+gxpJEKFEcsgUe+O345PrwzX+lbs9Vqvz52XO+aKsVDmbjTzWV3MnSPZcBnw1GTtq
+uKGJYDOCDhV7R8IElf87xQz6z6qNYDfAjlcxfeJK5V6U07Qwi4pxvoychK/4hQ7q
+X8mHWDMdyTGqED191NcI0EMHu6cjm5JSs7gXQibYrRaUGXcgk50o+LE6hIyd4VC1
+vmkKK48mcfi4GFFtmfiWX4vDK8Qzs2/PZNZURc3zgXxu4CtopFnL5SX+ZOAMSWUo
+DV8CBNpQbBi6sYo4aHNB3g==
 -----END ENCRYPTED PRIVATE KEY-----

third_party/wpt_tools/wpt/tools/certs/cacert.pem

@@ -1,176 +1,176 @@
 -----BEGIN CERTIFICATE-----
-MIJAhzCCP2+gAwIBAgIDBlVFMA0GCSqGSIb3DQEBCwUAMB0xGzAZBgNVBAMMEndl
-Yi1wbGF0Zm9ybS10ZXN0czAeFw0yMTAxMTIxNjEzMjhaFw0yMjAxMTIxNjEzMjha
+MIJAhzCCP2+gAwIBAgIDDuxtMA0GCSqGSIb3DQEBCwUAMB0xGzAZBgNVBAMMEndl
+Yi1wbGF0Zm9ybS10ZXN0czAeFw0yMTAzMTIwMDI3MzNaFw0yMjAzMTIwMDI3MzNa
 MB0xGzAZBgNVBAMMEndlYi1wbGF0Zm9ybS10ZXN0czCCASIwDQYJKoZIhvcNAQEB
-BQADggEPADCCAQoCggEBAKlAc+52QkFGs3xjT0OiT3t7HajqFqelNp5toVZfL/SF
-cXqvhldvWzlKs3XW4+OKnGQP1nB7qmZZ8GjSY02Nho36Vq+YdzmHIHYPZcAlfmNO
-6iY/nca7C9MEIVJvxQsG/C5ZUTkKJ93iDehGay5YF8wiIb+k6cmaV5cDs+oBwmwu
-X3hxsDjOklUYCVY4Wvd4fU/zR/LdI3QZTAlNa4eLu7v/8z0vo8vG7T8VS09mc6eh
-BjB0x1L7XE6n+4v3gGE8RbxeaIpZbv8vVWK1LLLQ01gCOiNFjuuD3VcBqnZTbV9/
-v4MqHrPFfZm1MxesB/kybMTve4Y6PjT1U3zgJsrV0UcCAwEAAaOCPc4wgj3KMAwG
-A1UdEwQFMAMBAf8wHQYDVR0OBBYEFNxtjWLdVJjIYBfC01Gzv3NbXJC5MEcGA1Ud
-IwRAMD6AFNxtjWLdVJjIYBfC01Gzv3NbXJC5oSGkHzAdMRswGQYDVQQDDBJ3ZWIt
-cGxhdGZvcm0tdGVzdHOCAwZVRTALBgNVHQ8EBAMCAgQwgh+bBgNVHR4Egh+SMIIf
-jqCCH4owE4IRd2ViLXBsYXRmb3JtLnRlc3QwF4IVb3A4LndlYi1wbGF0Zm9ybS50
-ZXN0MBeCFW9wNy53ZWItcGxhdGZvcm0udGVzdDAXghVvcDkud2ViLXBsYXRmb3Jt
-LnRlc3QwF4IVb3A0LndlYi1wbGF0Zm9ybS50ZXN0MBeCFW5vdC13ZWItcGxhdGZv
-cm0udGVzdDAXghVvcDYud2ViLXBsYXRmb3JtLnRlc3QwF4IVb3AzLndlYi1wbGF0
-Zm9ybS50ZXN0MBeCFW9wMi53ZWItcGxhdGZvcm0udGVzdDAXghVvcDEud2ViLXBs
-YXRmb3JtLnRlc3QwF4IVd3d3LndlYi1wbGF0Zm9ybS50ZXN0MBeCFW9wNS53ZWIt
-cGxhdGZvcm0udGVzdDAYghZvcDg4LndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wOTgu
-d2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A4NS53ZWItcGxhdGZvcm0udGVzdDAYghZv
-cDg5LndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wNjYud2ViLXBsYXRmb3JtLnRlc3Qw
-GIIWb3A3Mi53ZWItcGxhdGZvcm0udGVzdDAYghZvcDI0LndlYi1wbGF0Zm9ybS50
-ZXN0MBiCFm9wNDEud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A3OS53ZWItcGxhdGZv
-cm0udGVzdDAYghZvcDkxLndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wNTkud2ViLXBs
-YXRmb3JtLnRlc3QwGIIWb3AzOS53ZWItcGxhdGZvcm0udGVzdDAYghZvcDYwLndl
-Yi1wbGF0Zm9ybS50ZXN0MBiCFm9wNTgud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3Ay
-OC53ZWItcGxhdGZvcm0udGVzdDAYghZ3d3cxLndlYi1wbGF0Zm9ybS50ZXN0MBiC
-Fm9wMTQud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A2OS53ZWItcGxhdGZvcm0udGVz
-dDAYghZvcDQwLndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wNzQud2ViLXBsYXRmb3Jt
-LnRlc3QwGIIWb3AzMS53ZWItcGxhdGZvcm0udGVzdDAYghZvcDE4LndlYi1wbGF0
-Zm9ybS50ZXN0MBiCFm9wNzMud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A3Ny53ZWIt
-cGxhdGZvcm0udGVzdDAYghZvcDEyLndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wNTQu
-d2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A2My53ZWItcGxhdGZvcm0udGVzdDAYghZv
-cDcxLndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wOTUud2ViLXBsYXRmb3JtLnRlc3Qw
-GIIWb3AxNi53ZWItcGxhdGZvcm0udGVzdDAYghZvcDM2LndlYi1wbGF0Zm9ybS50
-ZXN0MBiCFm9wMjcud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3AyOS53ZWItcGxhdGZv
-cm0udGVzdDAYghZvcDk0LndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wNDQud2ViLXBs
-YXRmb3JtLnRlc3QwGIIWb3AzMy53ZWItcGxhdGZvcm0udGVzdDAYghZvcDg0Lndl
-Yi1wbGF0Zm9ybS50ZXN0MBiCFm9wMzIud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A2
-MS53ZWItcGxhdGZvcm0udGVzdDAYghZvcDcwLndlYi1wbGF0Zm9ybS50ZXN0MBiC
-Fnd3dzIud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A0My53ZWItcGxhdGZvcm0udGVz
-dDAYghZvcDc4LndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wMjYud2ViLXBsYXRmb3Jt
-LnRlc3QwGIIWb3A3Ni53ZWItcGxhdGZvcm0udGVzdDAYghZvcDUyLndlYi1wbGF0
-Zm9ybS50ZXN0MBiCFm9wOTkud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A4Ni53ZWIt
-cGxhdGZvcm0udGVzdDAYghZvcDQ2LndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wMTcu
-d2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A5MC53ZWItcGxhdGZvcm0udGVzdDAYghZv
-cDkzLndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wMTAud2ViLXBsYXRmb3JtLnRlc3Qw
-GIIWb3A1NS53ZWItcGxhdGZvcm0udGVzdDAYghZvcDQ3LndlYi1wbGF0Zm9ybS50
-ZXN0MBiCFm9wNTEud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A0NS53ZWItcGxhdGZv
-cm0udGVzdDAYghZvcDgwLndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wNjgud2ViLXBs
-YXRmb3JtLnRlc3QwGIIWb3A0OS53ZWItcGxhdGZvcm0udGVzdDAYghZvcDU3Lndl
-Yi1wbGF0Zm9ybS50ZXN0MBiCFm9wMzUud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A2
-Ny53ZWItcGxhdGZvcm0udGVzdDAYghZvcDkyLndlYi1wbGF0Zm9ybS50ZXN0MBiC
-Fm9wMTUud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3AxMy53ZWItcGxhdGZvcm0udGVz
-dDAYghZvcDc1LndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wNjQud2ViLXBsYXRmb3Jt
-LnRlc3QwGIIWb3A5Ny53ZWItcGxhdGZvcm0udGVzdDAYghZvcDM3LndlYi1wbGF0
-Zm9ybS50ZXN0MBiCFm9wNTYud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A2Mi53ZWIt
-cGxhdGZvcm0udGVzdDAYghZvcDgyLndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wMjUu
-d2ViLXBsYXRmb3JtLnRlc3QwGIIWb3AxMS53ZWItcGxhdGZvcm0udGVzdDAYghZv
-cDUwLndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wMzgud2ViLXBsYXRmb3JtLnRlc3Qw
-GIIWb3A4My53ZWItcGxhdGZvcm0udGVzdDAYghZvcDgxLndlYi1wbGF0Zm9ybS50
-ZXN0MBiCFm9wMjAud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3AyMS53ZWItcGxhdGZv
-cm0udGVzdDAYghZvcDIzLndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wNDIud2ViLXBs
-YXRmb3JtLnRlc3QwGIIWb3AyMi53ZWItcGxhdGZvcm0udGVzdDAYghZvcDY1Lndl
-Yi1wbGF0Zm9ybS50ZXN0MBiCFm9wOTYud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3A4
-Ny53ZWItcGxhdGZvcm0udGVzdDAYghZvcDE5LndlYi1wbGF0Zm9ybS50ZXN0MBiC
-Fm9wNTMud2ViLXBsYXRmb3JtLnRlc3QwGIIWb3AzMC53ZWItcGxhdGZvcm0udGVz
-dDAYghZvcDQ4LndlYi1wbGF0Zm9ybS50ZXN0MBiCFm9wMzQud2ViLXBsYXRmb3Jt
-LnRlc3QwG4IZb3A2Lm5vdC13ZWItcGxhdGZvcm0udGVzdDAbghlvcDMubm90LXdl
-Yi1wbGF0Zm9ybS50ZXN0MBuCGW9wMi5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwG4IZ
-b3A1Lm5vdC13ZWItcGxhdGZvcm0udGVzdDAbghl3d3cubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MBuCGXd3dy53d3cud2ViLXBsYXRmb3JtLnRlc3QwG4IZb3A3Lm5vdC13
-ZWItcGxhdGZvcm0udGVzdDAbghlvcDQubm90LXdlYi1wbGF0Zm9ybS50ZXN0MBuC
-GW9wOC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwG4IZb3A5Lm5vdC13ZWItcGxhdGZv
-cm0udGVzdDAbghlvcDEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMzYubm90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 LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNTMubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wNTAubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMjQubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wMzEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-OTUubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wODMubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGnd3dzIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNzMubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMTkubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wMjEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wODEubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wNzAubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-Nzgubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNDAubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wMjUubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNjUubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGnd3dy53d3cyLndlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wODAubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNTIubm90LXdlYi1w
+MByCGm9wMzcubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNDEubm90LXdlYi1w
 bGF0Zm9ybS50ZXN0MByCGm9wNjgubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-NDUubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNzEubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wNzIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wOTAubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wODkubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wNDkubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNzcubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wNzkubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-ODIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGnd3dy53d3cxLndlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wMTIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMzkubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNDQubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGnd3dzEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNTgubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wMTQubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-MzAubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNjIubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wNjEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wOTIubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMjkubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wOTgubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNjQubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wMjYubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-MjIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wOTQubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wMzgubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMzMubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMjMubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wNTcubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNTQubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wODUubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-NDYubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wOTcubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wMzIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNjAubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wOTYubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wNTEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNDEubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wMzUubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-OTkubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNDIubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wNjcubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMzcubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNDgubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wNTUubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNTYubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wODQubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-MzQubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNjkubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wMTEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wOTMubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGnd3dzEud3d3LndlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wODYubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMTMubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wMjAubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-NzYubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMjcubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wMTcubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNzUubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMTUubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wNDcubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMTgubm90LXdlYi1w
+ODcubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGnd3dzEud3d3LndlYi1wbGF0Zm9y
+bS50ZXN0MByCGm9wNzAubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wODMubm90
+LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wOTEubm90LXdlYi1wbGF0Zm9ybS50ZXN0
+MByCGm9wODEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wOTkubm90LXdlYi1w
+bGF0Zm9ybS50ZXN0MByCGm9wNDgubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
+NjQubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNzYubm90LXdlYi1wbGF0Zm9y
+bS50ZXN0MByCGnd3dy53d3cyLndlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMjQubm90
+LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNzgubm90LXdlYi1wbGF0Zm9ybS50ZXN0
+MByCGnd3dy53d3cxLndlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNzEubm90LXdlYi1w
+bGF0Zm9ybS50ZXN0MByCGm9wMTUubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
+NzIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNjUubm90LXdlYi1wbGF0Zm9y
+bS50ZXN0MByCGm9wOTgubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNDkubm90
+LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNTAubm90LXdlYi1wbGF0Zm9ybS50ZXN0
+MByCGnd3dzEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNDcubm90LXdlYi1w
+bGF0Zm9ybS50ZXN0MByCGm9wODIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
+MTIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMjcubm90LXdlYi1wbGF0Zm9y
+bS50ZXN0MByCGm9wODkubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wODYubm90
+LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNTIubm90LXdlYi1wbGF0Zm9ybS50ZXN0
+MByCGm9wMjAubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMjMubm90LXdlYi1w
 bGF0Zm9ybS50ZXN0MByCGm9wNjMubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-Mjgubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNDMubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wNjYubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGnd3dzIud3d3
-LndlYi1wbGF0Zm9ybS50ZXN0MByCGm9wOTEubm90LXdlYi1wbGF0Zm9ybS50ZXN0
-MByCGm9wNzQubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wNTkubm90LXdlYi1w
-bGF0Zm9ybS50ZXN0MByCGm9wODgubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9w
-ODcubm90LXdlYi1wbGF0Zm9ybS50ZXN0MByCGm9wMTAubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0MByCGm9wMTYubm90LXdlYi1wbGF0Zm9ybS50ZXN0MB2CG3d3dzEud3d3
-Mi53ZWItcGxhdGZvcm0udGVzdDAdght3d3cyLnd3dzIud2ViLXBsYXRmb3JtLnRl
-c3QwHYIbd3d3Mi53d3cxLndlYi1wbGF0Zm9ybS50ZXN0MB2CG3d3dzEud3d3MS53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 ZWItcGxhdGZvcm0udGVzdDAfgh13d3cud3d3Lm5vdC13ZWItcGxhdGZvcm0udGVz
-dDAggh54bi0tbHZlLTZsYWQud2ViLXBsYXRmb3JtLnRlc3QwIIIed3d3MS53d3cu
+dDAggh53d3cxLnd3dy5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwIIIed3d3Lnd3dzEu
 bm90LXdlYi1wbGF0Zm9ybS50ZXN0MCCCHnd3dy53d3cyLm5vdC13ZWItcGxhdGZv
-cm0udGVzdDAggh53d3cyLnd3dy5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwIIIed3d3
-Lnd3dzEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MCGCH3d3dzIud3d3Mi5ub3Qtd2Vi
-LXBsYXRmb3JtLnRlc3QwIYIfd3d3Mi53d3cxLm5vdC13ZWItcGxhdGZvcm0udGVz
-dDAhgh93d3cxLnd3dzEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MCGCH3d3dzEud3d3
+cm0udGVzdDAggh53d3cyLnd3dy5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwIIIeeG4t
+LWx2ZS02bGFkLndlYi1wbGF0Zm9ybS50ZXN0MCGCH3d3dzIud3d3MS5ub3Qtd2Vi
+LXBsYXRmb3JtLnRlc3QwIYIfd3d3MS53d3cxLm5vdC13ZWItcGxhdGZvcm0udGVz
+dDAhgh93d3cyLnd3dzIubm90LXdlYi1wbGF0Zm9ybS50ZXN0MCGCH3d3dzEud3d3
 Mi5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwJIIieG4tLWx2ZS02bGFkLnd3dy53ZWIt
-cGxhdGZvcm0udGVzdDAkgiJ4bi0tbHZlLTZsYWQubm90LXdlYi1wbGF0Zm9ybS50
-ZXN0MCSCInd3dy54bi0tbHZlLTZsYWQud2ViLXBsYXRmb3JtLnRlc3QwJYIjd3d3
-Mi54bi0tbHZlLTZsYWQud2ViLXBsYXRmb3JtLnRlc3QwJYIjeG4tLWx2ZS02bGFk
-Lnd3dzIud2ViLXBsYXRmb3JtLnRlc3QwJYIjeG4tLWx2ZS02bGFkLnd3dzEud2Vi
+cGxhdGZvcm0udGVzdDAkgiJ3d3cueG4tLWx2ZS02bGFkLndlYi1wbGF0Zm9ybS50
+ZXN0MCSCInhuLS1sdmUtNmxhZC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwJYIjeG4t
+LWx2ZS02bGFkLnd3dzEud2ViLXBsYXRmb3JtLnRlc3QwJYIjeG4tLWx2ZS02bGFk
+Lnd3dzIud2ViLXBsYXRmb3JtLnRlc3QwJYIjd3d3Mi54bi0tbHZlLTZsYWQud2Vi
 LXBsYXRmb3JtLnRlc3QwJYIjd3d3MS54bi0tbHZlLTZsYWQud2ViLXBsYXRmb3Jt
 LnRlc3QwKIImeG4tLWx2ZS02bGFkLnd3dy5ub3Qtd2ViLXBsYXRmb3JtLnRlc3Qw
-KIImd3d3LnhuLS1sdmUtNmxhZC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwKYIneG4t
-LWx2ZS02bGFkLnd3dzEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MCmCJ3d3dzIueG4t
-LWx2ZS02bGFkLm5vdC13ZWItcGxhdGZvcm0udGVzdDApgid3d3cxLnhuLS1sdmUt
-NmxhZC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwKYIneG4tLWx2ZS02bGFkLnd3dzIu
+KIImd3d3LnhuLS1sdmUtNmxhZC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwKYInd3d3
+MS54bi0tbHZlLTZsYWQubm90LXdlYi1wbGF0Zm9ybS50ZXN0MCmCJ3huLS1sdmUt
+NmxhZC53d3cxLm5vdC13ZWItcGxhdGZvcm0udGVzdDApgid4bi0tbHZlLTZsYWQu
+d3d3Mi5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwKYInd3d3Mi54bi0tbHZlLTZsYWQu
 bm90LXdlYi1wbGF0Zm9ybS50ZXN0MCuCKXhuLS1uOGo2ZHM1M2x3d2tycWh2Mjhh
 LndlYi1wbGF0Zm9ybS50ZXN0MC2CK3huLS1sdmUtNmxhZC54bi0tbHZlLTZsYWQu
-d2ViLXBsYXRmb3JtLnRlc3QwL4Itd3d3LnhuLS1uOGo2ZHM1M2x3d2tycWh2Mjhh
+d2ViLXBsYXRmb3JtLnRlc3QwL4IteG4tLW44ajZkczUzbHd3a3JxaHYyOGEud3d3
 LndlYi1wbGF0Zm9ybS50ZXN0MC+CLXhuLS1uOGo2ZHM1M2x3d2tycWh2MjhhLm5v
-dC13ZWItcGxhdGZvcm0udGVzdDAvgi14bi0tbjhqNmRzNTNsd3drcnFodjI4YS53
-d3cud2ViLXBsYXRmb3JtLnRlc3QwMIIud3d3MS54bi0tbjhqNmRzNTNsd3drcnFo
-djI4YS53ZWItcGxhdGZvcm0udGVzdDAwgi54bi0tbjhqNmRzNTNsd3drcnFodjI4
-YS53d3cyLndlYi1wbGF0Zm9ybS50ZXN0MDCCLnhuLS1uOGo2ZHM1M2x3d2tycWh2
-MjhhLnd3dzEud2ViLXBsYXRmb3JtLnRlc3QwMIIud3d3Mi54bi0tbjhqNmRzNTNs
-d3drcnFodjI4YS53ZWItcGxhdGZvcm0udGVzdDAxgi94bi0tbHZlLTZsYWQueG4t
+dC13ZWItcGxhdGZvcm0udGVzdDAvgi13d3cueG4tLW44ajZkczUzbHd3a3JxaHYy
+OGEud2ViLXBsYXRmb3JtLnRlc3QwMIIud3d3Mi54bi0tbjhqNmRzNTNsd3drcnFo
+djI4YS53ZWItcGxhdGZvcm0udGVzdDAwgi53d3cxLnhuLS1uOGo2ZHM1M2x3d2ty
+cWh2MjhhLndlYi1wbGF0Zm9ybS50ZXN0MDCCLnhuLS1uOGo2ZHM1M2x3d2tycWh2
+MjhhLnd3dzEud2ViLXBsYXRmb3JtLnRlc3QwMIIueG4tLW44ajZkczUzbHd3a3Jx
+aHYyOGEud3d3Mi53ZWItcGxhdGZvcm0udGVzdDAxgi94bi0tbHZlLTZsYWQueG4t
 LWx2ZS02bGFkLm5vdC13ZWItcGxhdGZvcm0udGVzdDAzgjF3d3cueG4tLW44ajZk
 czUzbHd3a3JxaHYyOGEubm90LXdlYi1wbGF0Zm9ybS50ZXN0MDOCMXhuLS1uOGo2
 ZHM1M2x3d2tycWh2MjhhLnd3dy5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwNIIyeG4t
-LW44ajZkczUzbHd3a3JxaHYyOGEud3d3Mi5ub3Qtd2ViLXBsYXRmb3JtLnRlc3Qw
-NIIyd3d3MS54bi0tbjhqNmRzNTNsd3drcnFodjI4YS5ub3Qtd2ViLXBsYXRmb3Jt
-LnRlc3QwNIIyd3d3Mi54bi0tbjhqNmRzNTNsd3drcnFodjI4YS5ub3Qtd2ViLXBs
-YXRmb3JtLnRlc3QwNIIyeG4tLW44ajZkczUzbHd3a3JxaHYyOGEud3d3MS5ub3Qt
+LW44ajZkczUzbHd3a3JxaHYyOGEud3d3MS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3Qw
+NIIyd3d3Mi54bi0tbjhqNmRzNTNsd3drcnFodjI4YS5ub3Qtd2ViLXBsYXRmb3Jt
+LnRlc3QwNIIyd3d3MS54bi0tbjhqNmRzNTNsd3drcnFodjI4YS5ub3Qtd2ViLXBs
+YXRmb3JtLnRlc3QwNIIyeG4tLW44ajZkczUzbHd3a3JxaHYyOGEud3d3Mi5ub3Qt
 d2ViLXBsYXRmb3JtLnRlc3QwOII2eG4tLW44ajZkczUzbHd3a3JxaHYyOGEueG4t
 LWx2ZS02bGFkLndlYi1wbGF0Zm9ybS50ZXN0MDiCNnhuLS1sdmUtNmxhZC54bi0t
 bjhqNmRzNTNsd3drcnFodjI4YS53ZWItcGxhdGZvcm0udGVzdDA8gjp4bi0tbjhq
@@ -180,156 +180,156 @@ d2ViLXBsYXRmb3JtLnRlc3QwQ4JBeG4tLW44ajZkczUzbHd3a3JxaHYyOGEueG4t
 LW44ajZkczUzbHd3a3JxaHYyOGEud2ViLXBsYXRmb3JtLnRlc3QwR4JFeG4tLW44
 ajZkczUzbHd3a3JxaHYyOGEueG4tLW44ajZkczUzbHd3a3JxaHYyOGEubm90LXdl
 Yi1wbGF0Zm9ybS50ZXN0MBMGA1UdJQQMMAoGCCsGAQUFBwMBMIIdjwYDVR0RBIId
-hjCCHYKCEXdlYi1wbGF0Zm9ybS50ZXN0ghVvcDgud2ViLXBsYXRmb3JtLnRlc3SC
-FW9wNy53ZWItcGxhdGZvcm0udGVzdIIVb3A5LndlYi1wbGF0Zm9ybS50ZXN0ghVv
-cDQud2ViLXBsYXRmb3JtLnRlc3SCFW5vdC13ZWItcGxhdGZvcm0udGVzdIIVb3A2
-LndlYi1wbGF0Zm9ybS50ZXN0ghVvcDMud2ViLXBsYXRmb3JtLnRlc3SCFW9wMi53
-ZWItcGxhdGZvcm0udGVzdIIVb3AxLndlYi1wbGF0Zm9ybS50ZXN0ghV3d3cud2Vi
-LXBsYXRmb3JtLnRlc3SCFW9wNS53ZWItcGxhdGZvcm0udGVzdIIWb3A4OC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A5OC53ZWItcGxhdGZvcm0udGVzdIIWb3A4NS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A4OS53ZWItcGxhdGZvcm0udGVzdIIWb3A2Ni53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A3Mi53ZWItcGxhdGZvcm0udGVzdIIWb3AyNC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A0MS53ZWItcGxhdGZvcm0udGVzdIIWb3A3OS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A5MS53ZWItcGxhdGZvcm0udGVzdIIWb3A1OS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AzOS53ZWItcGxhdGZvcm0udGVzdIIWb3A2MC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A1OC53ZWItcGxhdGZvcm0udGVzdIIWb3AyOC53ZWIt
-cGxhdGZvcm0udGVzdIIWd3d3MS53ZWItcGxhdGZvcm0udGVzdIIWb3AxNC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A2OS53ZWItcGxhdGZvcm0udGVzdIIWb3A0MC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A3NC53ZWItcGxhdGZvcm0udGVzdIIWb3AzMS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AxOC53ZWItcGxhdGZvcm0udGVzdIIWb3A3My53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A3Ny53ZWItcGxhdGZvcm0udGVzdIIWb3AxMi53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A1NC53ZWItcGxhdGZvcm0udGVzdIIWb3A2My53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A3MS53ZWItcGxhdGZvcm0udGVzdIIWb3A5NS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AxNi53ZWItcGxhdGZvcm0udGVzdIIWb3AzNi53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AyNy53ZWItcGxhdGZvcm0udGVzdIIWb3AyOS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A5NC53ZWItcGxhdGZvcm0udGVzdIIWb3A0NC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AzMy53ZWItcGxhdGZvcm0udGVzdIIWb3A4NC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AzMi53ZWItcGxhdGZvcm0udGVzdIIWb3A2MS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A3MC53ZWItcGxhdGZvcm0udGVzdIIWd3d3Mi53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A0My53ZWItcGxhdGZvcm0udGVzdIIWb3A3OC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AyNi53ZWItcGxhdGZvcm0udGVzdIIWb3A3Ni53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A1Mi53ZWItcGxhdGZvcm0udGVzdIIWb3A5OS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A4Ni53ZWItcGxhdGZvcm0udGVzdIIWb3A0Ni53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AxNy53ZWItcGxhdGZvcm0udGVzdIIWb3A5MC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A5My53ZWItcGxhdGZvcm0udGVzdIIWb3AxMC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A1NS53ZWItcGxhdGZvcm0udGVzdIIWb3A0Ny53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A1MS53ZWItcGxhdGZvcm0udGVzdIIWb3A0NS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A4MC53ZWItcGxhdGZvcm0udGVzdIIWb3A2OC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A0OS53ZWItcGxhdGZvcm0udGVzdIIWb3A1Ny53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AzNS53ZWItcGxhdGZvcm0udGVzdIIWb3A2Ny53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A5Mi53ZWItcGxhdGZvcm0udGVzdIIWb3AxNS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AxMy53ZWItcGxhdGZvcm0udGVzdIIWb3A3NS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A2NC53ZWItcGxhdGZvcm0udGVzdIIWb3A5Ny53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AzNy53ZWItcGxhdGZvcm0udGVzdIIWb3A1Ni53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A2Mi53ZWItcGxhdGZvcm0udGVzdIIWb3A4Mi53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AyNS53ZWItcGxhdGZvcm0udGVzdIIWb3AxMS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A1MC53ZWItcGxhdGZvcm0udGVzdIIWb3AzOC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A4My53ZWItcGxhdGZvcm0udGVzdIIWb3A4MS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AyMC53ZWItcGxhdGZvcm0udGVzdIIWb3AyMS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AyMy53ZWItcGxhdGZvcm0udGVzdIIWb3A0Mi53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AyMi53ZWItcGxhdGZvcm0udGVzdIIWb3A2NS53ZWIt
-cGxhdGZvcm0udGVzdIIWb3A5Ni53ZWItcGxhdGZvcm0udGVzdIIWb3A4Ny53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AxOS53ZWItcGxhdGZvcm0udGVzdIIWb3A1My53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AzMC53ZWItcGxhdGZvcm0udGVzdIIWb3A0OC53ZWIt
-cGxhdGZvcm0udGVzdIIWb3AzNC53ZWItcGxhdGZvcm0udGVzdIIZb3A2Lm5vdC13
-ZWItcGxhdGZvcm0udGVzdIIZb3AzLm5vdC13ZWItcGxhdGZvcm0udGVzdIIZb3Ay
-Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIZb3A1Lm5vdC13ZWItcGxhdGZvcm0udGVz
-dIIZd3d3Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIZd3d3Lnd3dy53ZWItcGxhdGZv
-cm0udGVzdIIZb3A3Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIZb3A0Lm5vdC13ZWIt
-cGxhdGZvcm0udGVzdIIZb3A4Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIZb3A5Lm5v
-dC13ZWItcGxhdGZvcm0udGVzdIIZb3AxLm5vdC13ZWItcGxhdGZvcm0udGVzdIIa
-b3AzNi5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wNTMubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0ghpvcDUwLm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3AyNC5ub3Qtd2Vi
-LXBsYXRmb3JtLnRlc3SCGm9wMzEubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDk1
-Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A4My5ub3Qtd2ViLXBsYXRmb3JtLnRl
-c3SCGnd3dzIubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDczLm5vdC13ZWItcGxh
-dGZvcm0udGVzdIIab3AxOS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wMjEubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDgxLm5vdC13ZWItcGxhdGZvcm0udGVzdIIa
-b3A3MC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wNzgubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0ghpvcDQwLm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3AyNS5ub3Qtd2Vi
-LXBsYXRmb3JtLnRlc3SCGm9wNjUubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghp3d3cu
-d3d3Mi53ZWItcGxhdGZvcm0udGVzdIIab3A4MC5ub3Qtd2ViLXBsYXRmb3JtLnRl
-c3SCGm9wNTIubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDY4Lm5vdC13ZWItcGxh
-dGZvcm0udGVzdIIab3A0NS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wNzEubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDcyLm5vdC13ZWItcGxhdGZvcm0udGVzdIIa
-b3A5MC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wODkubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0ghpvcDQ5Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A3Ny5ub3Qtd2Vi
-LXBsYXRmb3JtLnRlc3SCGm9wNzkubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDgy
-Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIad3d3Lnd3dzEud2ViLXBsYXRmb3JtLnRl
-c3SCGm9wMTIubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDM5Lm5vdC13ZWItcGxh
-dGZvcm0udGVzdIIab3A0NC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGnd3dzEubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDU4Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIa
-b3AxNC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wMzAubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0ghpvcDYyLm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A2MS5ub3Qtd2Vi
-LXBsYXRmb3JtLnRlc3SCGm9wOTIubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDI5
-Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A5OC5ub3Qtd2ViLXBsYXRmb3JtLnRl
-c3SCGm9wNjQubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDI2Lm5vdC13ZWItcGxh
-dGZvcm0udGVzdIIab3AyMi5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wOTQubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDM4Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIa
-b3AzMy5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wMjMubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0ghpvcDU3Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A1NC5ub3Qtd2Vi
-LXBsYXRmb3JtLnRlc3SCGm9wODUubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDQ2
-Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A5Ny5ub3Qtd2ViLXBsYXRmb3JtLnRl
-c3SCGm9wMzIubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDYwLm5vdC13ZWItcGxh
-dGZvcm0udGVzdIIab3A5Ni5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wNTEubm90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 LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDQxLm5vdC13ZWItcGxhdGZvcm0udGVzdIIa
-b3AzNS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wOTkubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0ghpvcDQyLm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A2Ny5ub3Qtd2Vi
-LXBsYXRmb3JtLnRlc3SCGm9wMzcubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDQ4
-Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A1NS5ub3Qtd2ViLXBsYXRmb3JtLnRl
-c3SCGm9wNTYubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDg0Lm5vdC13ZWItcGxh
-dGZvcm0udGVzdIIab3AzNC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wNjkubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDExLm5vdC13ZWItcGxhdGZvcm0udGVzdIIa
-b3A5My5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGnd3dzEud3d3LndlYi1wbGF0Zm9y
-bS50ZXN0ghpvcDg2Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3AxMy5ub3Qtd2Vi
-LXBsYXRmb3JtLnRlc3SCGm9wMjAubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDc2
-Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3AyNy5ub3Qtd2ViLXBsYXRmb3JtLnRl
-c3SCGm9wMTcubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDc1Lm5vdC13ZWItcGxh
-dGZvcm0udGVzdIIab3AxNS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wNDcubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDE4Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIa
-b3A2My5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wMjgubm90LXdlYi1wbGF0Zm9y
-bS50ZXN0ghpvcDQzLm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A2Ni5ub3Qtd2Vi
-LXBsYXRmb3JtLnRlc3SCGnd3dzIud3d3LndlYi1wbGF0Zm9ybS50ZXN0ghpvcDkx
-Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIab3A3NC5ub3Qtd2ViLXBsYXRmb3JtLnRl
-c3SCGm9wNTkubm90LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDg4Lm5vdC13ZWItcGxh
-dGZvcm0udGVzdIIab3A4Ny5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCGm9wMTAubm90
-LXdlYi1wbGF0Zm9ybS50ZXN0ghpvcDE2Lm5vdC13ZWItcGxhdGZvcm0udGVzdIIb
-d3d3MS53d3cyLndlYi1wbGF0Zm9ybS50ZXN0ght3d3cyLnd3dzIud2ViLXBsYXRm
-b3JtLnRlc3SCG3d3dzIud3d3MS53ZWItcGxhdGZvcm0udGVzdIIbd3d3MS53d3cx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 LndlYi1wbGF0Zm9ybS50ZXN0gh13d3cud3d3Lm5vdC13ZWItcGxhdGZvcm0udGVz
-dIIeeG4tLWx2ZS02bGFkLndlYi1wbGF0Zm9ybS50ZXN0gh53d3cxLnd3dy5ub3Qt
+dIIed3d3MS53d3cubm90LXdlYi1wbGF0Zm9ybS50ZXN0gh53d3cud3d3MS5ub3Qt
 d2ViLXBsYXRmb3JtLnRlc3SCHnd3dy53d3cyLm5vdC13ZWItcGxhdGZvcm0udGVz
-dIIed3d3Mi53d3cubm90LXdlYi1wbGF0Zm9ybS50ZXN0gh53d3cud3d3MS5ub3Qt
-d2ViLXBsYXRmb3JtLnRlc3SCH3d3dzIud3d3Mi5ub3Qtd2ViLXBsYXRmb3JtLnRl
-c3SCH3d3dzIud3d3MS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCH3d3dzEud3d3MS5u
+dIIed3d3Mi53d3cubm90LXdlYi1wbGF0Zm9ybS50ZXN0gh54bi0tbHZlLTZsYWQu
+d2ViLXBsYXRmb3JtLnRlc3SCH3d3dzIud3d3MS5ub3Qtd2ViLXBsYXRmb3JtLnRl
+c3SCH3d3dzEud3d3MS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCH3d3dzIud3d3Mi5u
 b3Qtd2ViLXBsYXRmb3JtLnRlc3SCH3d3dzEud3d3Mi5ub3Qtd2ViLXBsYXRmb3Jt
-LnRlc3SCInhuLS1sdmUtNmxhZC53d3cud2ViLXBsYXRmb3JtLnRlc3SCInhuLS1s
-dmUtNmxhZC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCInd3dy54bi0tbHZlLTZsYWQu
-d2ViLXBsYXRmb3JtLnRlc3SCI3d3dzIueG4tLWx2ZS02bGFkLndlYi1wbGF0Zm9y
-bS50ZXN0giN4bi0tbHZlLTZsYWQud3d3Mi53ZWItcGxhdGZvcm0udGVzdIIjeG4t
-LWx2ZS02bGFkLnd3dzEud2ViLXBsYXRmb3JtLnRlc3SCI3d3dzEueG4tLWx2ZS02
+LnRlc3SCInhuLS1sdmUtNmxhZC53d3cud2ViLXBsYXRmb3JtLnRlc3SCInd3dy54
+bi0tbHZlLTZsYWQud2ViLXBsYXRmb3JtLnRlc3SCInhuLS1sdmUtNmxhZC5ub3Qt
+d2ViLXBsYXRmb3JtLnRlc3SCI3huLS1sdmUtNmxhZC53d3cxLndlYi1wbGF0Zm9y
+bS50ZXN0giN4bi0tbHZlLTZsYWQud3d3Mi53ZWItcGxhdGZvcm0udGVzdIIjd3d3
+Mi54bi0tbHZlLTZsYWQud2ViLXBsYXRmb3JtLnRlc3SCI3d3dzEueG4tLWx2ZS02
 bGFkLndlYi1wbGF0Zm9ybS50ZXN0giZ4bi0tbHZlLTZsYWQud3d3Lm5vdC13ZWIt
 cGxhdGZvcm0udGVzdIImd3d3LnhuLS1sdmUtNmxhZC5ub3Qtd2ViLXBsYXRmb3Jt
-LnRlc3SCJ3huLS1sdmUtNmxhZC53d3cxLm5vdC13ZWItcGxhdGZvcm0udGVzdIIn
-d3d3Mi54bi0tbHZlLTZsYWQubm90LXdlYi1wbGF0Zm9ybS50ZXN0gid3d3cxLnhu
-LS1sdmUtNmxhZC5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCJ3huLS1sdmUtNmxhZC53
-d3cyLm5vdC13ZWItcGxhdGZvcm0udGVzdIIpeG4tLW44ajZkczUzbHd3a3JxaHYy
+LnRlc3SCJ3d3dzEueG4tLWx2ZS02bGFkLm5vdC13ZWItcGxhdGZvcm0udGVzdIIn
+eG4tLWx2ZS02bGFkLnd3dzEubm90LXdlYi1wbGF0Zm9ybS50ZXN0gid4bi0tbHZl
+LTZsYWQud3d3Mi5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCJ3d3dzIueG4tLWx2ZS02
+bGFkLm5vdC13ZWItcGxhdGZvcm0udGVzdIIpeG4tLW44ajZkczUzbHd3a3JxaHYy
 OGEud2ViLXBsYXRmb3JtLnRlc3SCK3huLS1sdmUtNmxhZC54bi0tbHZlLTZsYWQu
-d2ViLXBsYXRmb3JtLnRlc3SCLXd3dy54bi0tbjhqNmRzNTNsd3drcnFodjI4YS53
+d2ViLXBsYXRmb3JtLnRlc3SCLXhuLS1uOGo2ZHM1M2x3d2tycWh2MjhhLnd3dy53
 ZWItcGxhdGZvcm0udGVzdIIteG4tLW44ajZkczUzbHd3a3JxaHYyOGEubm90LXdl
-Yi1wbGF0Zm9ybS50ZXN0gi14bi0tbjhqNmRzNTNsd3drcnFodjI4YS53d3cud2Vi
-LXBsYXRmb3JtLnRlc3SCLnd3dzEueG4tLW44ajZkczUzbHd3a3JxaHYyOGEud2Vi
-LXBsYXRmb3JtLnRlc3SCLnhuLS1uOGo2ZHM1M2x3d2tycWh2MjhhLnd3dzIud2Vi
-LXBsYXRmb3JtLnRlc3SCLnhuLS1uOGo2ZHM1M2x3d2tycWh2MjhhLnd3dzEud2Vi
+Yi1wbGF0Zm9ybS50ZXN0gi13d3cueG4tLW44ajZkczUzbHd3a3JxaHYyOGEud2Vi
 LXBsYXRmb3JtLnRlc3SCLnd3dzIueG4tLW44ajZkczUzbHd3a3JxaHYyOGEud2Vi
+LXBsYXRmb3JtLnRlc3SCLnd3dzEueG4tLW44ajZkczUzbHd3a3JxaHYyOGEud2Vi
+LXBsYXRmb3JtLnRlc3SCLnhuLS1uOGo2ZHM1M2x3d2tycWh2MjhhLnd3dzEud2Vi
+LXBsYXRmb3JtLnRlc3SCLnhuLS1uOGo2ZHM1M2x3d2tycWh2MjhhLnd3dzIud2Vi
 LXBsYXRmb3JtLnRlc3SCL3huLS1sdmUtNmxhZC54bi0tbHZlLTZsYWQubm90LXdl
 Yi1wbGF0Zm9ybS50ZXN0gjF3d3cueG4tLW44ajZkczUzbHd3a3JxaHYyOGEubm90
 LXdlYi1wbGF0Zm9ybS50ZXN0gjF4bi0tbjhqNmRzNTNsd3drcnFodjI4YS53d3cu
 bm90LXdlYi1wbGF0Zm9ybS50ZXN0gjJ4bi0tbjhqNmRzNTNsd3drcnFodjI4YS53
-d3cyLm5vdC13ZWItcGxhdGZvcm0udGVzdIIyd3d3MS54bi0tbjhqNmRzNTNsd3dr
-cnFodjI4YS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCMnd3dzIueG4tLW44ajZkczUz
+d3cxLm5vdC13ZWItcGxhdGZvcm0udGVzdIIyd3d3Mi54bi0tbjhqNmRzNTNsd3dr
+cnFodjI4YS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCMnd3dzEueG4tLW44ajZkczUz
 bHd3a3JxaHYyOGEubm90LXdlYi1wbGF0Zm9ybS50ZXN0gjJ4bi0tbjhqNmRzNTNs
-d3drcnFodjI4YS53d3cxLm5vdC13ZWItcGxhdGZvcm0udGVzdII2eG4tLW44ajZk
+d3drcnFodjI4YS53d3cyLm5vdC13ZWItcGxhdGZvcm0udGVzdII2eG4tLW44ajZk
 czUzbHd3a3JxaHYyOGEueG4tLWx2ZS02bGFkLndlYi1wbGF0Zm9ybS50ZXN0gjZ4
 bi0tbHZlLTZsYWQueG4tLW44ajZkczUzbHd3a3JxaHYyOGEud2ViLXBsYXRmb3Jt
 LnRlc3SCOnhuLS1uOGo2ZHM1M2x3d2tycWh2MjhhLnhuLS1sdmUtNmxhZC5ub3Qt
@@ -337,11 +337,11 @@ d2ViLXBsYXRmb3JtLnRlc3SCOnhuLS1sdmUtNmxhZC54bi0tbjhqNmRzNTNsd3dr
 cnFodjI4YS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3SCQXhuLS1uOGo2ZHM1M2x3d2ty
 cWh2MjhhLnhuLS1uOGo2ZHM1M2x3d2tycWh2MjhhLndlYi1wbGF0Zm9ybS50ZXN0
 gkV4bi0tbjhqNmRzNTNsd3drcnFodjI4YS54bi0tbjhqNmRzNTNsd3drcnFodjI4
-YS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwDQYJKoZIhvcNAQELBQADggEBAHOGp2Ji
-xKvvqNucL2gpFBIpsT8abmKBLBm4LsSBGEFPy12fDztkWBVTEN/WiyHRL93PPnn2
-YFn3/jSuAgq0LkSx8VB/Xn2CZgY9+WzL4++GN6I6kYAuuvG4/P6iwwDCwX7y2coD
-D75E4WVVTjEsKG2vRiVWzccmg/BTmvXQJU8DSPhzPQtU/D8qHUIe/McHmEW9sxpG
-ktJSXqAe0VnvwPXhJ/scOiyJaXvC8mRjM50nUGny0n9Nywltm3oxOAVAZIahZa7g
-KMnRywojNqlkccXeHCjH1wXOhzuyQX+MvvBqq968ttIV/hbUXh+D/Su9M0qQclbA
-09vdXeld+rSxP8s=
+YS5ub3Qtd2ViLXBsYXRmb3JtLnRlc3QwDQYJKoZIhvcNAQELBQADggEBADVc8bl1
+d4P2NmDg9XR7Lf97e9v4JIQMfvBpKk9kiyRrMGKHpWlGetSipBL4MAR0yvrHUs7+
+61Bbzu0L5Tzd/gyD7ZG8nYHZCThjrWFMdxdltwO2FNmb3xs8lAS8pCOXEcXwY8bv
+y/ODP24UZvkBsizQ/cm4uOD70cdPZq+gKf103nUtPNIkq+NhbpzoNfzV/XYIG4Mb
+TxAngSBX9/swqkYkgojpSJX+BPr0lZ9iNh/JNCUnwX/HRDYdt0br+ytEf2U0RQ97
+ZUlyC264H2+g8Gnv4BRbfvktaS4PpVSE29tAHBL0cowmx7jXuie3n2O35SDxQkgz
+P57oA3Ezv83wshY=
 -----END CERTIFICATE-----

third_party/wpt_tools/wpt/tools/certs/web-platform.test.key

@@ -1,28 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDcwhdziEv2WAkv
-K/wpecn5LRAprbWRjaotacXvktoxS0aK2ff34wiV7GrBucxxU81i3LCucnd82dGT
-4vHfzTKKab5/+vut1FNoG5BKmGYZCpOo6MZOWAJJ4zXYQBAEeKurSjglzOXWmjSp
-AEzM9TqUG66lpoSK58zv7gneDbjDnJhbKYZQurNOm3PLMd0ep3/yxqwqVia1nOn+
-xa4ZoFrWwguWDKx09yhBKEVDHXtAGfZp9EWATquEsqFSoeLqyQDvfe5Hefi4dPmY
-32OiJG4ArSKegxyRekQZ8E4x3mnlt3prC6nZFexLG60UOix/AN3RifpHDey8Zq/L
-pGsy+NT7AgMBAAECggEBAJrkOA4hAKNs66zEYN49DKCfpKqJrk7dJh1NDMtmr19M
-4McF3r1394sx4Unh8ndFhGMsU29i80GPl0P7RRhxYlfJkBc94574zjjKtjgQq/o/
-+JDYGmPXzmtHV31Ona51eIXrwm+LT2x+sBowErLwEVTgA29I4dCQibOCwjuiRxQ/
-mn2A4Q60OllIRCwSE3/uA9+mUpeMp5jgJd+oN3uT58Tme/SRNXxOKgCie8WRUnue
-X/cghKYSNmAyDSkbJ0KY4oavb5YRKXNpAt2hNW9JsN0qd3+j6JZ21odhydDbtqSq
-mxjPTUFQNFeLVvDTaRYw+zK+I/noZIrlQsS6JPNfXkECgYEA+m3L9jLe2lz0SJmG
-NnFuY8rwwYVJm4TLhjYDmdmYbGcYCPo9CHHKhR6ZXrmNzxcXvwaZk8ZTspAZ2Bzw
-1AM52mhGZejR7yV5FECh+UKrx/Aud+jm0WhPtwYjixz8IhmGG81orYueux50HUcO
-Q/K5Nqo1esBBC+X5Ya2rb3jShGECgYEA4atRn6P5DCj4ug3SSlUNIS3dJxbe3QhB
-lTkCtXUQC+p+VIUI0mVk6NgN4drgViKOlhzMKYDMtiVY2XLXQNVPEJ4ngMSC1uzr
-tGefMuL/WRpsysxwjN0b+0fDVeXtM16CtXOpqnoYi3XX/R6aIqZ3zVi/ttwEOy6G
-TdgnZNcJVtsCgYAW70tIpuwF75FnvLev8L99YC6gaoaNOaIyDmxSAL2W3/IxkEla
-pqE3g8/j/vZfyuuf0QjrobQ0nEHhqvTbVdhMilQ4LRRc5H+sPScYXuTAkNyQmsHY
-18bFKkjDCsqEjPXdQfiePDUzSdy0ebdyvZ38xaXUMhtC7bLjITacJOKSwQKBgGlJ
-1kZmab8rqoicBD5cGkkdre4b9JUp0fd+Zu4klP0KRjDG9Qu89OzSSP/UcBCgBOiy
-vOqsRlbBbAfgVd/Q5he5wnKIvQbr+Tjtk9BZKov3EUU5R1Xhn7mIjPGZ2ia6dL+W
-HFYGq0b+D2zwhzeddY3gV2pIkszN8ymErTSWQ6w7AoGBAIECBMwE3YL0TGWPdU9A
-RV3a5G9slunqhVGQCwvBfWwj6tIplhtOLAp4y400DHbw4Jwi5Z+hDQu9PzMGhhwu
-qZLMJZJ4BAUaVHoEcuo1sab25UH6a0pdGf7BgCmjKjPAHtvzMyfwfKpju7ZObpqx
-Yet1DMpvmPlX1kZsEh072zBs
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC0NvriO1g8i0L7
+kEIwIDMFeyOvfiHxY8SnFioFfxtIiaVde1lC4DZm8+nC5z4uJa/IFghDpsPh0Mx3
+X8fZ/MK/W8i28hVf8tecB1NGevxZGBeVxDDZt7rMAsPCkRxw03BH2udMIY+8v68K
+ErT0G7ryzO8R3UN57RZsA3vtDfkvjaLgAbedjb4A/ETqBk/e+s36587iBPvqxaAm
+wFWyqzacRI/agK6EoOkEps8AeJlhHiVzLevF/MQxAxmS9ZQ4aGBrMmhSZEfGSfsk
+4bTwFucFrlFmwaNayWBlhrC677pqFZpWJYw5JBY+J+eYE8RiOCQfacD/XkQIktUy
+Djrq7GQrAgMBAAECggEBAIwW5SXx3eCKnRIzDNCeZysOkyn7keU0mg0M1LObIBle
+LrchiLzM0F1tpDzHR3XWA/Q09E2qmEC08Ayn3xJcQwNAFSHpw6Xnf6WhqCF0vy9+
+4+6fKR5FjabDS2u3I/Ws1250AzMSL8sY8reQ3SuZVtUha4Jmjup7298xQid/okJM
+uOemXHg/jBhwoYW8pWG331ezGTOxQExIVE3FTtlwSk5wkDbf7+klT4adwpEDRwpW
+JbI/xdq+r7SxGRKA5DNWETePQNQSKEzRXeZ+eh/ipWoNG6mXrppLs0EeaF55XB1b
+e1UvNFOCozsiTY2s8DBEg9hlqL+k7nLeaUGUtui5/EECgYEA2ST2jpNJfXcI9oPl
+yjg88cbBpaMGp3w1ygQzfnVQ2h05drM6frLqg/1MlpHW5XWxadeNn3PzlnBb6JVo
+v522Y/IRcSNLC8enfUTy/Oltem7RTggL4hMMi2yZordJ5AMvWqYCw22SNSMt3m9Z
+K4UnbkFpIDYJtetfPeNSkKm1e6ECgYEA1HZUfWwdJUc1mgOBSIzZ9v/SPRdIjz9E
+p3JqNIaJaXO/bE91Y1C0L26hX7gNmEtBjsHvQskOUSrDNkyCMGANRepyH3FfrF6V
+kuKUK3bSUkUNowL0ztzsk7QE/dRIg8gpLHQzHj9JTdz5qRSoDjJm2ph2rigRmJ9V
+2d59O04RrEsCgYEAxTA13n+OSytfrk1UzXCIl57Al6QWFN5NEmkCQiJTC99iIZLc
+2dWr9bR+anWByto4BD/E0jo/yCu8qteTSf70dIqMoEtGiSoDxVRpvJZV3srns47H
+C8P0rmAunH8J0M+7nvwGomXMUgjiTI6dUVIX3p3z01Z/Nv7JfLAEeG5E6kECgYBm
+iXk7Uss6K4TOALULW5byIwLHIw6Mu78ZhRmGogt9TjRrRGnl9ZQQdDcDqCM/hcps
+6GHdfIUhXR77fK80Q5cEUCKl1CSVXsyXKCzUUTMuK09qhcm6cFro6e+ixSn+F8Lv
+RmFJTsfFAUmodWSp/V8wTnawlHvxiax4Sm1sCsBywwKBgCL3fpUb8bMddwm7dgIT
+DWBVdjTbEvvZhJ4Ec0sSTxv3AwUoD70evuphotIucruLPhG0NWrPIQgZfjTKaZ24
+MBjMSWSfu+FH3J+UYaaFQKWp7fu65ioaNIrb/AhlCP68yl30m0vLGrDiZk66XAUx
+JPGxuQ/gxnR2RogWiLK9tQ+k
 -----END PRIVATE KEY-----

third_party/wpt_tools/wpt/tools/gitignore/gitignore.py

@@ -1,7 +1,7 @@
 import re
 import os
 import itertools
-from six import ensure_binary, itervalues, iteritems
+from six import ensure_binary
 from collections import defaultdict
 
 MYPY = False
@@ -194,13 +194,13 @@ class PathFilter(object):
                 rule = cast(Tuple[bool, Pattern[bytes]], rule)
             if not dir_only:
                 rules_iter = itertools.chain(
-                    itertools.chain(*(iteritems(item) for item in itervalues(self.literals_dir))),
-                    itertools.chain(*(iteritems(item) for item in itervalues(self.literals_file))),
+                    itertools.chain(*(item.items() for item in self.literals_dir.values())),
+                    itertools.chain(*(item.items() for item in self.literals_file.values())),
                     self.patterns_dir,
                     self.patterns_file)  # type: Iterable[Tuple[Any, List[Tuple[bool, Pattern[bytes]]]]]
             else:
                 rules_iter = itertools.chain(
-                    itertools.chain(*(iteritems(item) for item in itervalues(self.literals_dir))),
+                    itertools.chain(*(item.items() for item in self.literals_dir.values())),
                     self.patterns_dir)
 
             for rules in rules_iter:

third_party/wpt_tools/wpt/tools/lint/lint.py

@@ -14,6 +14,7 @@ import sys
 import tempfile
 
 from collections import defaultdict
+from urllib.parse import urlsplit, urljoin
 
 from . import fnmatch
 from . import rules
@@ -24,9 +25,7 @@ from ..wpt import testfiles
 from ..manifest.vcs import walk
 
 from ..manifest.sourcefile import SourceFile, js_meta_re, python_meta_re, space_chars, get_any_variants
-from six import binary_type, ensure_binary, ensure_text, iteritems, itervalues, with_metaclass
-from six.moves import range
-from six.moves.urllib.parse import urlsplit, urljoin
+from six import ensure_binary, ensure_text
 
 MYPY = False
 if MYPY:
@@ -325,7 +324,7 @@ def check_css_globally_unique(repo_root, paths):
 
     errors = []
 
-    for name, colliding in iteritems(test_files):
+    for name, colliding in test_files.items():
         if len(colliding) > 1:
             if not _all_files_equal([os.path.join(repo_root, x) for x in colliding]):
                 # Only compute by_spec if there are prima-facie collisions because of cost
@@ -342,7 +341,7 @@ def check_css_globally_unique(repo_root, paths):
                             continue
                         by_spec[spec].add(path)
 
-                for spec, spec_paths in iteritems(by_spec):
+                for spec, spec_paths in by_spec.items():
                     if not _all_files_equal([os.path.join(repo_root, x) for x in spec_paths]):
                         for x in spec_paths:
                             context1 = (name, spec, ", ".join(sorted(spec_paths)))
@@ -351,7 +350,7 @@ def check_css_globally_unique(repo_root, paths):
 
     for rule_class, d in [(rules.CSSCollidingRefName, ref_files),
                           (rules.CSSCollidingSupportName, support_files)]:
-        for name, colliding in iteritems(d):
+        for name, colliding in d.items():
             if len(colliding) > 1:
                 if not _all_files_equal([os.path.join(repo_root, x) for x in colliding]):
                     context2 = (name, ", ".join(sorted(colliding)))
@@ -451,7 +450,7 @@ def filter_ignorelist_errors(data, errors):
         # which explains how to fix it correctly and shouldn't be skipped.
         if error_type in data and error_type != "IGNORED PATH":
             wl_files = data[error_type]
-            for file_match, allowed_lines in iteritems(wl_files):
+            for file_match, allowed_lines in wl_files.items():
                 if None in allowed_lines or line in allowed_lines:
                     if fnmatch.fnmatchcase(normpath, file_match):
                         skipped[i] = True
@@ -668,7 +667,7 @@ def check_parsed(repo_root, path, f):
 
     return errors
 
-class ASTCheck(with_metaclass(abc.ABCMeta)):
+class ASTCheck(metaclass=abc.ABCMeta):
     @abc.abstractproperty
     def rule(self):
         # type: () -> Type[rules.Rule]
@@ -741,7 +740,7 @@ def check_script_metadata(repo_root, path, f):
     done = False
     errors = []
     for idx, line in enumerate(f):
-        assert isinstance(line, binary_type), line
+        assert isinstance(line, bytes), line
 
         m = meta_re.match(line)
         if m:
@@ -975,7 +974,7 @@ def create_parser():
 
 def main(**kwargs_str):
     # type: (**Any) -> int
-    kwargs = {ensure_text(key): value for key, value in iteritems(kwargs_str)}
+    kwargs = {ensure_text(key): value for key, value in kwargs_str.items()}
 
     assert logger is not None
     if kwargs.get("json") and kwargs.get("markdown"):
@@ -1103,7 +1102,7 @@ def lint(repo_root, paths, output_format, ignore_glob=None, github_checks_output
     if error_count and github_checks_outputter:
         github_checks_outputter.output("```")
 
-    return sum(itervalues(error_count))
+    return sum(error_count.values())
 
 
 path_lints = [check_file_type, check_path_length, check_worker_collision, check_ahem_copy,

third_party/wpt_tools/wpt/tools/lint/rules.py

@@ -5,8 +5,6 @@ import inspect
 import os
 import re
 
-import six
-
 MYPY = False
 if MYPY:
     # MYPY is set to True when run under Mypy.
@@ -19,7 +17,7 @@ def collapse(text):
     return inspect.cleandoc(str(text)).replace("\n", " ")
 
 
-class Rule(six.with_metaclass(abc.ABCMeta)):
+class Rule(metaclass=abc.ABCMeta):
     @abc.abstractproperty
     def name(self):
         # type: () -> Text
@@ -367,7 +365,7 @@ class TentativeDirectoryName(Rule):
     to_fix = "rename directory to be called 'tentative'"
 
 
-class Regexp(six.with_metaclass(abc.ABCMeta)):
+class Regexp(metaclass=abc.ABCMeta):
     @abc.abstractproperty
     def pattern(self):
         # type: () -> bytes

third_party/wpt_tools/wpt/tools/localpaths.py

@@ -18,6 +18,7 @@ sys.path.insert(0, os.path.join(here, "third_party", "pluggy", "src"))
 sys.path.insert(0, os.path.join(here, "third_party", "py"))
 sys.path.insert(0, os.path.join(here, "third_party", "pytest"))
 sys.path.insert(0, os.path.join(here, "third_party", "pytest", "src"))
+sys.path.insert(0, os.path.join(here, "third_party", "pytest-asyncio"))
 sys.path.insert(0, os.path.join(here, "third_party", "six"))
 sys.path.insert(0, os.path.join(here, "third_party", "webencodings"))
 sys.path.insert(0, os.path.join(here, "third_party", "h2"))
@@ -25,6 +26,8 @@ sys.path.insert(0, os.path.join(here, "third_party", "hpack"))
 sys.path.insert(0, os.path.join(here, "third_party", "hyperframe"))
 sys.path.insert(0, os.path.join(here, "third_party", "certifi"))
 sys.path.insert(0, os.path.join(here, "third_party", "hyper"))
+sys.path.insert(0, os.path.join(here, "third_party", "websockets", "src"))
+sys.path.insert(0, os.path.join(here, "third_party", "iniconfig", "src"))
 if sys.version_info < (3, 8):
     sys.path.insert(0, os.path.join(here, "third_party", "importlib_metadata"))
 sys.path.insert(0, os.path.join(here, "webdriver"))

third_party/wpt_tools/wpt/tools/manifest/XMLParser.py

@@ -6,8 +6,6 @@ from collections import OrderedDict
 from xml.parsers import expat
 import xml.etree.ElementTree as etree  # noqa: N813
 
-from six import text_type
-
 MYPY = False
 if MYPY:
     # MYPY is set to True when run under Mypy.
@@ -83,7 +81,7 @@ class XMLParser(object):
 
     def _start(self, tag, attrib_in):
         # type: (Text, List[str]) -> etree.Element
-        assert isinstance(tag, text_type)
+        assert isinstance(tag, str)
         self._fed_data = None
         tag = _fixname(tag)
         attrib = OrderedDict()  # type: Dict[Union[bytes, Text], Union[bytes, Text]]

third_party/wpt_tools/wpt/tools/manifest/download.py

@@ -7,8 +7,7 @@ import json
 import io
 import os
 from datetime import datetime, timedelta
-
-from six.moves.urllib.request import urlopen
+from urllib.request import urlopen
 
 try:
     import zstandard

third_party/wpt_tools/wpt/tools/manifest/item.py

@@ -1,7 +1,6 @@
 import os.path
 from inspect import isabstract
-from six import iteritems, with_metaclass
-from six.moves.urllib.parse import urljoin, urlparse, parse_qs
+from urllib.parse import urljoin, urlparse, parse_qs
 from abc import ABCMeta, abstractproperty
 
 from .utils import to_os_path
@@ -42,7 +41,7 @@ class ManifestItemMeta(ABCMeta):
         return rv  # type: ignore
 
 
-class ManifestItem(with_metaclass(ManifestItemMeta)):
+class ManifestItem(metaclass=ManifestItemMeta):
     __slots__ = ("_tests_root", "path")
 
     def __init__(self, tests_root, path):
@@ -289,7 +288,7 @@ class RefTest(URLManifestItem):
         if self.dpi is not None:
             extras["dpi"] = self.dpi
         if self.fuzzy:
-            extras["fuzzy"] = list(iteritems(self.fuzzy))
+            extras["fuzzy"] = list(self.fuzzy.items())
         return rv
 
     @classmethod

third_party/wpt_tools/wpt/tools/manifest/jsonlib.py

@@ -1,8 +1,6 @@
 import re
 import json
 
-from six import PY3
-
 
 MYPY = False
 if MYPY:
@@ -49,11 +47,9 @@ _ujson_dump_local_kwargs = {
     'ensure_ascii': False,
     'escape_forward_slashes': False,
     'indent': 1,
+    'reject_bytes': True,
 }  # type: Dict[str, Any]
 
-if PY3:
-    _ujson_dump_local_kwargs['reject_bytes'] = True
-
 
 _json_dump_local_kwargs = {
     'ensure_ascii': False,
@@ -99,10 +95,9 @@ else:
 _ujson_dump_dist_kwargs = {
     'sort_keys': True,
     'indent': 1,
+    'reject_bytes': True,
 }  # type: Dict[str, Any]
 
-if PY3:
-    _ujson_dump_dist_kwargs['reject_bytes'] = True
 
 _json_dump_dist_kwargs = {
     'sort_keys': True,

third_party/wpt_tools/wpt/tools/manifest/manifest.py

@@ -1,17 +1,10 @@
 import io
-import itertools
 import os
 import sys
 from atomicwrites import atomic_write
 from copy import deepcopy
 from multiprocessing import Pool, cpu_count
-from six import (
-    PY3,
-    ensure_text,
-    iteritems,
-    itervalues,
-    string_types,
-)
+from six import ensure_text
 
 from . import jsonlib
 from . import vcs
@@ -93,7 +86,7 @@ class ManifestData(ManifestDataType):
         """Dictionary subclass containing a TypeData instance for each test type,
         keyed by type name"""
         self.initialized = False  # type: bool
-        for key, value in iteritems(item_classes):
+        for key, value in item_classes.items():
             self[key] = TypeData(manifest, value)
         self.initialized = True
         self.json_obj = None  # type: None
@@ -109,7 +102,7 @@ class ManifestData(ManifestDataType):
         """Get a list of all paths containing test items
         without actually constructing all the items"""
         rv = set()  # type: Set[Text]
-        for item_data in itervalues(self):
+        for item_data in self.values():
             for item in item_data:
                 rv.add(os.path.sep.join(item))
         return rv
@@ -117,7 +110,7 @@ class ManifestData(ManifestDataType):
     def type_by_path(self):
         # type: () -> Dict[Tuple[Text, ...], Text]
         rv = {}
-        for item_type, item_data in iteritems(self):
+        for item_type, item_data in self.items():
             for item in item_data:
                 rv[item] = item_type
         return rv
@@ -159,7 +152,7 @@ class Manifest(object):
         tpath_len = len(tpath)
 
         for type_tests in self._data.values():
-            for path, tests in iteritems(type_tests):
+            for path, tests in type_tests.items():
                 if path[:tpath_len] == tpath:
                     for test in tests:
                         yield test
@@ -253,10 +246,8 @@ class Manifest(object):
                                           to_update,
                                           chunksize=chunksize
                                           )  # type: Iterator[Tuple[Tuple[Text, ...], Text, Set[ManifestItem], Text]]
-        elif PY3:
-            results = map(compute_manifest_items, to_update)
         else:
-            results = itertools.imap(compute_manifest_items, to_update)
+            results = map(compute_manifest_items, to_update)
 
         for result in results:
             rel_path_parts, new_type, manifest_items, file_hash = result
@@ -271,7 +262,7 @@ class Manifest(object):
         if remaining_manifest_paths:
             changed = True
             for rel_path_parts in remaining_manifest_paths:
-                for test_data in itervalues(data):
+                for test_data in data.values():
                     if rel_path_parts in test_data:
                         del test_data[rel_path_parts]
 
@@ -291,7 +282,7 @@ class Manifest(object):
         """
         out_items = {
             test_type: type_paths.to_json()
-            for test_type, type_paths in iteritems(self._data) if type_paths
+            for test_type, type_paths in self._data.items() if type_paths
         }
 
         if caller_owns_obj:
@@ -325,7 +316,7 @@ class Manifest(object):
         if not hasattr(obj, "items"):
             raise ManifestError
 
-        for test_type, type_paths in iteritems(obj["items"]):
+        for test_type, type_paths in obj["items"].items():
             if test_type not in item_classes:
                 raise ManifestError
 
@@ -358,12 +349,12 @@ def _load(logger,  # type: Logger
           allow_cached=True  # type: bool
           ):
     # type: (...) -> Optional[Manifest]
-    manifest_path = (manifest if isinstance(manifest, string_types)
+    manifest_path = (manifest if isinstance(manifest, str)
                      else manifest.name)
     if allow_cached and manifest_path in __load_cache:
         return __load_cache[manifest_path]
 
-    if isinstance(manifest, string_types):
+    if isinstance(manifest, str):
         if os.path.exists(manifest):
             logger.debug("Opening manifest at %s" % manifest)
         else:

third_party/wpt_tools/wpt/tools/manifest/sourcefile.py

@@ -3,8 +3,7 @@ import re
 import os
 from collections import deque
 from io import BytesIO
-from six import binary_type, iteritems, text_type
-from six.moves.urllib.parse import urljoin
+from urllib.parse import urljoin
 from fnmatch import fnmatch
 
 MYPY = False
@@ -74,7 +73,7 @@ def read_script_metadata(f, regexp):
                value.
     """
     for line in f:
-        assert isinstance(line, binary_type), line
+        assert isinstance(line, bytes), line
         m = regexp.match(line)
         if not m:
             break
@@ -85,9 +84,13 @@ def read_script_metadata(f, regexp):
 _any_variants = {
     "window": {"suffix": ".any.html"},
     "serviceworker": {"force_https": True},
+    "serviceworker-module": {"force_https": True},
     "sharedworker": {},
+    "sharedworker-module": {},
     "dedicatedworker": {"suffix": ".any.worker.html"},
+    "dedicatedworker-module": {"suffix": ".any.worker-module.html"},
     "worker": {"longhand": {"dedicatedworker", "sharedworker", "serviceworker"}},
+    "worker-module": {},
     "jsshell": {"suffix": ".any.js"},
 }  # type: Dict[Text, Dict[Text, Any]]
 
@@ -97,7 +100,7 @@ def get_any_variants(item):
     """
     Returns a set of variants (strings) defined by the given keyword.
     """
-    assert isinstance(item, text_type), item
+    assert isinstance(item, str), item
 
     variant = _any_variants.get(item, None)
     if variant is None:
@@ -119,7 +122,7 @@ def parse_variants(value):
     """
     Returns a set of variants (strings) defined by a comma-separated value.
     """
-    assert isinstance(value, text_type), value
+    assert isinstance(value, str), value
 
     if value == "":
         return get_default_any_variants()
@@ -138,7 +141,7 @@ def global_suffixes(value):
     variant is intended to run in a JS shell, for the variants defined by the
     given comma-separated value.
     """
-    assert isinstance(value, text_type), value
+    assert isinstance(value, str), value
 
     rv = set()
 
@@ -243,7 +246,7 @@ class SourceFile(object):
 
         if "__cached_properties__" in rv:
             cached_properties = rv["__cached_properties__"]
-            rv = {key:value for key, value in iteritems(rv) if key not in cached_properties}
+            rv = {key:value for key, value in rv.items() if key not in cached_properties}
             del rv["__cached_properties__"]
         return rv
 
@@ -304,7 +307,7 @@ class SourceFile(object):
                 content = f.read()
 
             data = b"".join((b"blob ", b"%d" % len(content), b"\0", content))
-            self._hash = text_type(hashlib.sha1(data).hexdigest())
+            self._hash = str(hashlib.sha1(data).hexdigest())
 
         return self._hash
 

third_party/wpt_tools/wpt/tools/manifest/testpaths.py

@@ -3,8 +3,6 @@ import json
 import os
 from collections import defaultdict
 
-from six import iteritems
-
 from .manifest import load_and_update, Manifest
 from .log import get_logger
 
@@ -102,7 +100,7 @@ def write_output(path_id_map, as_json):
     if as_json:
         print(json.dumps(path_id_map))
     else:
-        for path, test_ids in sorted(iteritems(path_id_map)):
+        for path, test_ids in sorted(path_id_map.items()):
             print(path)
             for test_id in sorted(test_ids):
                 print("  " + test_id)

third_party/wpt_tools/wpt/tools/manifest/typedata.py

@@ -1,5 +1,4 @@
-from six import itervalues, iteritems
-from six.moves.collections_abc import MutableMapping
+from collections.abc import MutableMapping
 
 
 MYPY = False
@@ -181,7 +180,7 @@ class TypeData(TypeDataType):
             if isinstance(v, set):
                 count += 1
             else:
-                stack.extend(itervalues(v))
+                stack.extend(v.values())
 
         stack = [self._json_data]
         while stack:
@@ -189,7 +188,7 @@ class TypeData(TypeDataType):
             if isinstance(v, list):
                 count += 1
             else:
-                stack.extend(itervalues(v))
+                stack.extend(v.values())
 
         return count
 
@@ -270,7 +269,7 @@ class TypeData(TypeDataType):
         stack = [(self._data, json_rv, tuple())]  # type: List[Tuple[Dict[Text, Any], Dict[Text, Any], Tuple[Text, ...]]]
         while stack:
             data_node, json_node, par_full_key = stack.pop()
-            for k, v in iteritems(data_node):
+            for k, v in data_node.items():
                 full_key = par_full_key + (k,)
                 if isinstance(v, set):
                     assert k not in json_node

third_party/wpt_tools/wpt/tools/manifest/vcs.py

@@ -2,9 +2,7 @@ import abc
 import os
 import stat
 from collections import deque
-
-from six import with_metaclass, PY2
-from six.moves.collections_abc import MutableMapping
+from collections.abc import MutableMapping
 
 from . import jsonlib
 from .utils import git
@@ -19,10 +17,7 @@ if MYPY:
     # MYPY is set to True when run under Mypy.
     from typing import Dict, Optional, List, Set, Text, Iterable, Any, Tuple, Iterator
     from .manifest import Manifest  # cyclic import under MYPY guard
-    if PY2:
-        stat_result = Any
-    else:
-        stat_result = os.stat_result
+    stat_result = os.stat_result
 
     GitIgnoreCacheType = MutableMapping[bytes, bool]
 else:
@@ -132,7 +127,7 @@ class FileSystem(object):
                 cache.dump()
 
 
-class CacheFile(with_metaclass(abc.ABCMeta)):
+class CacheFile(metaclass=abc.ABCMeta):
     def __init__(self, cache_root, tests_root, rebuild=False):
         # type: (Text, Text, bool) -> None
         self.tests_root = tests_root

third_party/wpt_tools/wpt/tools/quic/commands.json

@@ -3,7 +3,6 @@
     "path": "serve.py",
     "script": "run",
     "parser": "get_parser",
-    "py3only": true,
     "help": "Start the QUIC server for WebTransport",
     "virtualenv": true,
     "requirements": [

third_party/wpt_tools/wpt/tools/serve/serve.py

@@ -4,6 +4,7 @@ from __future__ import print_function
 
 import abc
 import argparse
+import importlib
 import json
 import logging
 import multiprocessing
@@ -16,13 +17,12 @@ import sys
 import threading
 import time
 import traceback
-from six.moves import urllib
+import urllib
 import uuid
 from collections import defaultdict, OrderedDict
 from itertools import chain, product
 
 from localpaths import repo_root
-from six.moves import reload_module
 
 from manifest.sourcefile import read_script_metadata, js_meta_re, parse_variants
 from wptserve import server as wptserve, handlers
@@ -227,6 +227,22 @@ fetch_tests_from_worker(new Worker("%(path)s%(query)s"));
 """
 
 
+class WorkerModulesHandler(HtmlWrapperHandler):
+    global_type = "dedicatedworker-module"
+    path_replace = [(".any.worker-module.html", ".any.js", ".any.worker-module.js"),
+                    (".worker.html", ".worker.js")]
+    wrapper = """<!doctype html>
+<meta charset=utf-8>
+%(meta)s
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id=log></div>
+<script>
+fetch_tests_from_worker(new Worker("%(path)s%(query)s", { type: "module" }));
+</script>
+"""
+
+
 class WindowHandler(HtmlWrapperHandler):
     path_replace = [(".window.html", ".window.js")]
     wrapper = """<!doctype html>
@@ -275,6 +291,21 @@ fetch_tests_from_worker(new SharedWorker("%(path)s%(query)s"));
 """
 
 
+class SharedWorkerModulesHandler(HtmlWrapperHandler):
+    global_type = "sharedworker-module"
+    path_replace = [(".any.sharedworker-module.html", ".any.js", ".any.worker-module.js")]
+    wrapper = """<!doctype html>
+<meta charset=utf-8>
+%(meta)s
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id=log></div>
+<script>
+fetch_tests_from_worker(new SharedWorker("%(path)s%(query)s", { type: "module" }));
+</script>
+"""
+
+
 class ServiceWorkersHandler(HtmlWrapperHandler):
     global_type = "serviceworker"
     path_replace = [(".any.serviceworker.html", ".any.js", ".any.worker.js")]
@@ -296,8 +327,54 @@ class ServiceWorkersHandler(HtmlWrapperHandler):
 """
 
 
-class AnyWorkerHandler(WrapperHandler):
+class ServiceWorkerModulesHandler(HtmlWrapperHandler):
+    global_type = "serviceworker-module"
+    path_replace = [(".any.serviceworker-module.html",
+                     ".any.js", ".any.worker-module.js")]
+    wrapper = """<!doctype html>
+<meta charset=utf-8>
+%(meta)s
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<div id=log></div>
+<script>
+(async function() {
+  const scope = 'does/not/exist';
+  let reg = await navigator.serviceWorker.getRegistration(scope);
+  if (reg) await reg.unregister();
+  reg = await navigator.serviceWorker.register(
+    "%(path)s%(query)s",
+    { scope, type: 'module' },
+  );
+  fetch_tests_from_worker(reg.installing);
+})();
+</script>
+"""
+
+
+class BaseWorkerHandler(WrapperHandler):
     headers = [('Content-Type', 'text/javascript')]
+
+    def _meta_replacement(self, key, value):
+        return None
+
+    @abc.abstractmethod
+    def _create_script_import(self, attribute):
+        # Take attribute (a string URL to a JS script) and return JS source to import the script
+        # into the worker.
+        pass
+
+    def _script_replacement(self, key, value):
+        if key == "script":
+            attribute = value.replace("\\", "\\\\").replace('"', '\\"')
+            return self._create_script_import(attribute)
+        if key == "title":
+            value = value.replace("\\", "\\\\").replace('"', '\\"')
+            return 'self.META_TITLE = "%s";' % value
+        return None
+
+
+class ClassicWorkerHandler(BaseWorkerHandler):
     path_replace = [(".any.worker.js", ".any.js")]
     wrapper = """%(meta)s
 self.GLOBAL = {
@@ -310,17 +387,25 @@ importScripts("%(path)s");
 done();
 """
 
-    def _meta_replacement(self, key, value):
-        return None
+    def _create_script_import(self, attribute):
+        return 'importScripts("%s")' % attribute
 
-    def _script_replacement(self, key, value):
-        if key == "script":
-            attribute = value.replace("\\", "\\\\").replace('"', '\\"')
-            return 'importScripts("%s")' % attribute
-        if key == "title":
-            value = value.replace("\\", "\\\\").replace('"', '\\"')
-            return 'self.META_TITLE = "%s";' % value
-        return None
+
+class ModuleWorkerHandler(BaseWorkerHandler):
+    path_replace = [(".any.worker-module.js", ".any.js")]
+    wrapper = """%(meta)s
+self.GLOBAL = {
+  isWindow: function() { return false; },
+  isWorker: function() { return true; },
+};
+import "/resources/testharness.js";
+%(script)s
+import "%(path)s";
+done();
+"""
+
+    def _create_script_import(self, attribute):
+        return 'import "%s";' % attribute
 
 
 rewrites = [("GET", "/resources/WebIDLParser.js", "/resources/webidl2/lib/webidl2.js")]
@@ -368,11 +453,15 @@ class RoutesBuilder(object):
 
         routes = [
             ("GET", "*.worker.html", WorkersHandler),
+            ("GET", "*.worker-module.html", WorkerModulesHandler),
             ("GET", "*.window.html", WindowHandler),
             ("GET", "*.any.html", AnyHtmlHandler),
             ("GET", "*.any.sharedworker.html", SharedWorkersHandler),
+            ("GET", "*.any.sharedworker-module.html", SharedWorkerModulesHandler),
             ("GET", "*.any.serviceworker.html", ServiceWorkersHandler),
-            ("GET", "*.any.worker.js", AnyWorkerHandler),
+            ("GET", "*.any.serviceworker-module.html", ServiceWorkerModulesHandler),
+            ("GET", "*.any.worker.js", ClassicWorkerHandler),
+            ("GET", "*.any.worker-module.js", ModuleWorkerHandler),
             ("GET", "*.asis", handlers.AsIsHandler),
             ("GET", "/.well-known/origin-policy", handlers.PythonScriptHandler),
             ("*", "*.py", handlers.PythonScriptHandler),
@@ -697,7 +786,7 @@ def release_mozlog_lock():
 def start_ws_server(host, port, paths, routes, bind_address, config, **kwargs):
     # Ensure that when we start this in a new process we have the global lock
     # in the logging module unlocked
-    reload_module(logging)
+    importlib.reload(logging)
     release_mozlog_lock()
     try:
         return WebSocketDaemon(host,
@@ -713,7 +802,7 @@ def start_ws_server(host, port, paths, routes, bind_address, config, **kwargs):
 def start_wss_server(host, port, paths, routes, bind_address, config, **kwargs):
     # Ensure that when we start this in a new process we have the global lock
     # in the logging module unlocked
-    reload_module(logging)
+    importlib.reload(logging)
     release_mozlog_lock()
     try:
         return WebSocketDaemon(host,
@@ -771,7 +860,7 @@ class QuicTransportDaemon(object):
 def start_quic_transport_server(host, port, paths, routes, bind_address, config, **kwargs):
     # Ensure that when we start this in a new process we have the global lock
     # in the logging module unlocked
-    reload_module(logging)
+    importlib.reload(logging)
     release_mozlog_lock()
     try:
         return QuicTransportDaemon(host,

third_party/wpt_tools/wpt/tools/third_party/pywebsocket3/mod_pywebsocket/standalone.py

@@ -403,8 +403,7 @@ def _parse_args_and_config(args):
 def _main(args=None):
     """You can call this function from your own program, but please note that
     this function has some side-effects that might affect your program. For
-    example, util.wrap_popen3_for_win use in this method replaces implementation
-    of os.popen3.
+    example, it changes the current directory.
     """
 
     options, args = _parse_args_and_config(args=args)
@@ -427,7 +426,6 @@ def _main(args=None):
             # full path of third_party/cygwin/bin.
             if 'CYGWIN_PATH' in os.environ:
                 cygwin_path = os.environ['CYGWIN_PATH']
-            util.wrap_popen3_for_win(cygwin_path)
 
             def __check_script(scriptpath):
                 return util.get_script_interp(scriptpath, cygwin_path)

third_party/wpt_tools/wpt/tools/third_party/pywebsocket3/mod_pywebsocket/util.py

@@ -97,25 +97,6 @@ def get_script_interp(script_path, cygwin_path=None):
     return None
 
 
-def wrap_popen3_for_win(cygwin_path):
-    """Wrap popen3 to support #!-script on Windows.
-
-    Args:
-      cygwin_path:  path for cygwin binary if command path is needed to be
-                    translated.  None if no translation required.
-    """
-    __orig_popen3 = os.popen3
-
-    def __wrap_popen3(cmd, mode='t', bufsize=-1):
-        cmdline = cmd.split(' ')
-        interp = get_script_interp(cmdline[0], cygwin_path)
-        if interp:
-            cmd = interp + ' ' + cmd
-        return __orig_popen3(cmd, mode, bufsize)
-
-    os.popen3 = __wrap_popen3
-
-
 def hexify(s):
     return ' '.join(['%02x' % x for x in six.iterbytes(s)])
 

third_party/wpt_tools/wpt/tools/third_party/pywebsocket3/setup.py

@@ -43,7 +43,7 @@ _USE_FAST_MASKING = False
 
 # This is used since python_requires field is not recognized with
 # pip version 9.0.0 and earlier
-if sys.version < '2.7':
+if sys.hexversion < 0x020700f0:
     print('%s requires Python 2.7 or later.' % _PACKAGE_NAME, file=sys.stderr)
     sys.exit(1)
 
@@ -66,9 +66,8 @@ setup(
     packages=[_PACKAGE_NAME, _PACKAGE_NAME + '.handshake'],
     python_requires='>=2.7',
     install_requires=['six'],
-    #TODO(suzukikeita): Update this to new Github URL
-    url='http://code.google.com/p/pywebsocket/',
-    version='3.0.0',
+    url='https://github.com/GoogleChromeLabs/pywebsocket3',
+    version='3.0.1',
 )
 
 # vi:sts=4 sw=4 et

third_party/wpt_tools/wpt/tools/third_party/websockets/.appveyor.yml

@@ -0,0 +1,27 @@
+branches:
+  only:
+    - master
+
+skip_branch_with_pr: true
+
+environment:
+# websockets only works on Python >= 3.6.
+  CIBW_SKIP: cp27-* cp33-* cp34-* cp35-*
+  CIBW_TEST_COMMAND: python -W default -m unittest
+  WEBSOCKETS_TESTS_TIMEOUT_FACTOR: 100
+
+install:
+# Ensure python is Python 3.
+  - set PATH=C:\Python37;%PATH%
+  - cmd: python -m pip install --upgrade cibuildwheel
+# Create file '.cibuildwheel' so that extension build is not optional (c.f. setup.py).
+  - cmd: touch .cibuildwheel
+
+build_script:
+  - cmd: python -m cibuildwheel --output-dir wheelhouse
+# Upload to PyPI on tags
+  - ps: >-
+      if ($env:APPVEYOR_REPO_TAG -eq "true") {
+        Invoke-Expression "python -m pip install twine"
+        Invoke-Expression "python -m twine upload --skip-existing wheelhouse/*.whl"
+      }

third_party/wpt_tools/wpt/tools/third_party/websockets/.gitignore

@@ -0,0 +1,12 @@
+*.pyc
+*.so
+.coverage
+.mypy_cache
+.tox
+build/
+compliance/reports/
+dist/
+docs/_build/
+htmlcov/
+MANIFEST
+websockets.egg-info/

third_party/wpt_tools/wpt/tools/third_party/websockets/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2013-2019 Aymeric Augustin and contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of websockets nor the names of its contributors may
+      be used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

third_party/wpt_tools/wpt/tools/third_party/websockets/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+include src/websockets/py.typed

third_party/wpt_tools/wpt/tools/third_party/websockets/Makefile

@@ -0,0 +1,29 @@
+.PHONY: default style test coverage build clean
+
+export PYTHONASYNCIODEBUG=1
+export PYTHONPATH=src
+
+default: coverage style
+
+style:
+	isort --recursive src tests
+	black src tests
+	flake8 src tests
+	mypy --strict src
+
+test:
+	python -W default -m unittest
+
+coverage:
+	python -m coverage erase
+	python -W default -m coverage run -m unittest
+	python -m coverage html
+	python -m coverage report --show-missing --fail-under=100
+
+build:
+	python setup.py build_ext --inplace
+
+clean:
+	find . -name '*.pyc' -o -name '*.so' -delete
+	find . -name __pycache__ -delete
+	rm -rf .coverage build compliance/reports dist docs/_build htmlcov MANIFEST src/websockets.egg-info

third_party/wpt_tools/wpt/tools/third_party/websockets/README.rst

@@ -0,0 +1,154 @@
+.. image:: logo/horizontal.svg
+   :width: 480px
+   :alt: websockets
+
+|rtd| |pypi-v| |pypi-pyversions| |pypi-l| |pypi-wheel| |circleci| |codecov|
+
+.. |rtd| image:: https://readthedocs.org/projects/websockets/badge/?version=latest
+   :target: https://websockets.readthedocs.io/
+
+.. |pypi-v| image:: https://img.shields.io/pypi/v/websockets.svg
+    :target: https://pypi.python.org/pypi/websockets
+
+.. |pypi-pyversions| image:: https://img.shields.io/pypi/pyversions/websockets.svg
+    :target: https://pypi.python.org/pypi/websockets
+
+.. |pypi-l| image:: https://img.shields.io/pypi/l/websockets.svg
+    :target: https://pypi.python.org/pypi/websockets
+
+.. |pypi-wheel| image:: https://img.shields.io/pypi/wheel/websockets.svg
+    :target: https://pypi.python.org/pypi/websockets
+
+.. |circleci| image:: https://img.shields.io/circleci/project/github/aaugustin/websockets.svg
+   :target: https://circleci.com/gh/aaugustin/websockets
+
+.. |codecov| image:: https://codecov.io/gh/aaugustin/websockets/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/aaugustin/websockets
+
+What is ``websockets``?
+-----------------------
+
+``websockets`` is a library for building WebSocket servers_ and clients_ in
+Python with a focus on correctness and simplicity.
+
+.. _servers: https://github.com/aaugustin/websockets/blob/master/example/server.py
+.. _clients: https://github.com/aaugustin/websockets/blob/master/example/client.py
+
+Built on top of ``asyncio``, Python's standard asynchronous I/O framework, it
+provides an elegant coroutine-based API.
+
+`Documentation is available on Read the Docs. <https://websockets.readthedocs.io/>`_
+
+Here's how a client sends and receives messages:
+
+.. copy-pasted because GitHub doesn't support the include directive
+
+.. code:: python
+
+    #!/usr/bin/env python
+
+    import asyncio
+    import websockets
+
+    async def hello(uri):
+        async with websockets.connect(uri) as websocket:
+            await websocket.send("Hello world!")
+            await websocket.recv()
+
+    asyncio.get_event_loop().run_until_complete(
+        hello('ws://localhost:8765'))
+
+And here's an echo server:
+
+.. code:: python
+
+    #!/usr/bin/env python
+
+    import asyncio
+    import websockets
+
+    async def echo(websocket, path):
+        async for message in websocket:
+            await websocket.send(message)
+
+    asyncio.get_event_loop().run_until_complete(
+        websockets.serve(echo, 'localhost', 8765))
+    asyncio.get_event_loop().run_forever()
+
+Does that look good?
+
+`Get started with the tutorial! <https://websockets.readthedocs.io/en/stable/intro.html>`_
+
+.. raw:: html
+
+    <hr>
+    <img align="left" height="150" width="150" src="https://raw.githubusercontent.com/aaugustin/websockets/master/logo/tidelift.png">
+    <h3 align="center"><i>websockets for enterprise</i></h3>
+    <p align="center"><i>Available as part of the Tidelift Subscription</i></p>
+    <p align="center"><i>The maintainers of websockets and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. <a href="https://tidelift.com/subscription/pkg/pypi-websockets?utm_source=pypi-websockets&utm_medium=referral&utm_campaign=readme">Learn more.</a></i></p>
+    <hr>
+    <p>(If you contribute to <code>websockets</code> and would like to become an official support provider, <a href="https://fractalideas.com/">let me know</a>.)</p>
+
+Why should I use ``websockets``?
+--------------------------------
+
+The development of ``websockets`` is shaped by four principles:
+
+1. **Simplicity**: all you need to understand is ``msg = await ws.recv()`` and
+   ``await ws.send(msg)``; ``websockets`` takes care of managing connections
+   so you can focus on your application.
+
+2. **Robustness**: ``websockets`` is built for production; for example it was
+   the only library to `handle backpressure correctly`_ before the issue
+   became widely known in the Python community.
+
+3. **Quality**: ``websockets`` is heavily tested. Continuous integration fails
+   under 100% branch coverage. Also it passes the industry-standard `Autobahn
+   Testsuite`_.
+
+4. **Performance**: memory use is configurable. An extension written in C
+   accelerates expensive operations. It's pre-compiled for Linux, macOS and
+   Windows and packaged in the wheel format for each system and Python version.
+
+Documentation is a first class concern in the project. Head over to `Read the
+Docs`_ and see for yourself.
+
+.. _Read the Docs: https://websockets.readthedocs.io/
+.. _handle backpressure correctly: https://vorpus.org/blog/some-thoughts-on-asynchronous-api-design-in-a-post-asyncawait-world/#websocket-servers
+.. _Autobahn Testsuite: https://github.com/aaugustin/websockets/blob/master/compliance/README.rst
+
+Why shouldn't I use ``websockets``?
+-----------------------------------
+
+* If you prefer callbacks over coroutines: ``websockets`` was created to
+  provide the best coroutine-based API to manage WebSocket connections in
+  Python. Pick another library for a callback-based API.
+* If you're looking for a mixed HTTP / WebSocket library: ``websockets`` aims
+  at being an excellent implementation of :rfc:`6455`: The WebSocket Protocol
+  and :rfc:`7692`: Compression Extensions for WebSocket. Its support for HTTP
+  is minimal — just enough for a HTTP health check.
+* If you want to use Python 2: ``websockets`` builds upon ``asyncio`` which
+  only works on Python 3. ``websockets`` requires Python ≥ 3.6.1.
+
+What else?
+----------
+
+Bug reports, patches and suggestions are welcome!
+
+To report a security vulnerability, please use the `Tidelift security
+contact`_. Tidelift will coordinate the fix and disclosure.
+
+.. _Tidelift security contact: https://tidelift.com/security
+
+For anything else, please open an issue_ or send a `pull request`_.
+
+.. _issue: https://github.com/aaugustin/websockets/issues/new
+.. _pull request: https://github.com/aaugustin/websockets/compare/
+
+Participants must uphold the `Contributor Covenant code of conduct`_.
+
+.. _Contributor Covenant code of conduct: https://github.com/aaugustin/websockets/blob/master/CODE_OF_CONDUCT.md
+
+``websockets`` is released under the `BSD license`_.
+
+.. _BSD license: https://github.com/aaugustin/websockets/blob/master/LICENSE

third_party/wpt_tools/wpt/tools/third_party/websockets/compliance/README.rst

@@ -0,0 +1,50 @@
+Autobahn Testsuite
+==================
+
+General information and installation instructions are available at
+https://github.com/crossbario/autobahn-testsuite.
+
+To improve performance, you should compile the C extension first::
+
+    $ python setup.py build_ext --inplace
+
+Running the test suite
+----------------------
+
+All commands below must be run from the directory containing this file.
+
+To test the server::
+
+    $ PYTHONPATH=.. python test_server.py
+    $ wstest -m fuzzingclient
+
+To test the client::
+
+    $ wstest -m fuzzingserver
+    $ PYTHONPATH=.. python test_client.py
+
+Run the first command in a shell. Run the second command in another shell.
+It should take about ten minutes to complete — wstest is the bottleneck.
+Then kill the first one with Ctrl-C.
+
+The test client or server shouldn't display any exceptions. The results are
+stored in reports/clients/index.html.
+
+Note that the Autobahn software only supports Python 2, while ``websockets``
+only supports Python 3; you need two different environments.
+
+Conformance notes
+-----------------
+
+Some test cases are more strict than the RFC. Given the implementation of the
+library and the test echo client or server, ``websockets`` gets a "Non-Strict"
+in these cases.
+
+In 3.2, 3.3, 4.1.3, 4.1.4, 4.2.3, 4.2.4, and 5.15 ``websockets`` notices the
+protocol error and closes the connection before it has had a chance to echo
+the previous frame.
+
+In 6.4.3 and 6.4.4, even though it uses an incremental decoder, ``websockets``
+doesn't notice the invalid utf-8 fast enough to get a "Strict" pass. These
+tests are more strict than the RFC.
+

third_party/wpt_tools/wpt/tools/third_party/websockets/compliance/fuzzingclient.json

@@ -0,0 +1,11 @@
+
+{
+   "options": {"failByDrop": false},
+   "outdir": "./reports/servers",
+
+   "servers": [{"agent": "websockets", "url": "ws://localhost:8642", "options": {"version": 18}}],
+
+   "cases": ["*"],
+   "exclude-cases": [],
+   "exclude-agent-cases": {}
+}

third_party/wpt_tools/wpt/tools/third_party/websockets/compliance/fuzzingserver.json

@@ -0,0 +1,12 @@
+
+{
+   "url": "ws://localhost:8642",
+
+   "options": {"failByDrop": false},
+   "outdir": "./reports/clients",
+   "webport": 8080,
+
+   "cases": ["*"],
+   "exclude-cases": [],
+   "exclude-agent-cases": {}
+}

third_party/wpt_tools/wpt/tools/third_party/websockets/compliance/test_client.py

@@ -0,0 +1,49 @@
+import json
+import logging
+import urllib.parse
+
+import asyncio
+import websockets
+
+
+logging.basicConfig(level=logging.WARNING)
+
+# Uncomment this line to make only websockets more verbose.
+# logging.getLogger('websockets').setLevel(logging.DEBUG)
+
+
+SERVER = "ws://127.0.0.1:8642"
+AGENT = "websockets"
+
+
+async def get_case_count(server):
+    uri = f"{server}/getCaseCount"
+    async with websockets.connect(uri) as ws:
+        msg = ws.recv()
+    return json.loads(msg)
+
+
+async def run_case(server, case, agent):
+    uri = f"{server}/runCase?case={case}&agent={agent}"
+    async with websockets.connect(uri, max_size=2 ** 25, max_queue=1) as ws:
+        async for msg in ws:
+            await ws.send(msg)
+
+
+async def update_reports(server, agent):
+    uri = f"{server}/updateReports?agent={agent}"
+    async with websockets.connect(uri):
+        pass
+
+
+async def run_tests(server, agent):
+    cases = await get_case_count(server)
+    for case in range(1, cases + 1):
+        print(f"Running test case {case} out of {cases}", end="\r")
+        await run_case(server, case, agent)
+    print(f"Ran {cases} test cases               ")
+    await update_reports(server, agent)
+
+
+main = run_tests(SERVER, urllib.parse.quote(AGENT))
+asyncio.get_event_loop().run_until_complete(main)

third_party/wpt_tools/wpt/tools/third_party/websockets/compliance/test_server.py

@@ -0,0 +1,27 @@
+import logging
+
+import asyncio
+import websockets
+
+
+logging.basicConfig(level=logging.WARNING)
+
+# Uncomment this line to make only websockets more verbose.
+# logging.getLogger('websockets').setLevel(logging.DEBUG)
+
+
+HOST, PORT = "127.0.0.1", 8642
+
+
+async def echo(ws, path):
+    async for msg in ws:
+        await ws.send(msg)
+
+
+start_server = websockets.serve(echo, HOST, PORT, max_size=2 ** 25, max_queue=1)
+
+try:
+    asyncio.get_event_loop().run_until_complete(start_server)
+    asyncio.get_event_loop().run_forever()
+except KeyboardInterrupt:
+    pass

third_party/wpt_tools/wpt/tools/third_party/websockets/performance/mem_client.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+import asyncio
+import statistics
+import tracemalloc
+
+import websockets
+from websockets.extensions import permessage_deflate
+
+
+CLIENTS = 10
+INTERVAL = 1 / 10  # seconds
+
+MEM_SIZE = []
+
+
+async def mem_client(client):
+    # Space out connections to make them sequential.
+    await asyncio.sleep(client * INTERVAL)
+
+    tracemalloc.start()
+
+    async with websockets.connect(
+        "ws://localhost:8765",
+        extensions=[
+            permessage_deflate.ClientPerMessageDeflateFactory(
+                server_max_window_bits=10,
+                client_max_window_bits=10,
+                compress_settings={"memLevel": 3},
+            )
+        ],
+    ) as ws:
+        await ws.send("hello")
+        await ws.recv()
+
+        await ws.send(b"hello")
+        await ws.recv()
+
+        MEM_SIZE.append(tracemalloc.get_traced_memory()[0])
+        tracemalloc.stop()
+
+        # Hold connection open until the end of the test.
+        await asyncio.sleep(CLIENTS * INTERVAL)
+
+
+asyncio.get_event_loop().run_until_complete(
+    asyncio.gather(*[mem_client(client) for client in range(CLIENTS + 1)])
+)
+
+# First connection incurs non-representative setup costs.
+del MEM_SIZE[0]
+
+print(f"µ = {statistics.mean(MEM_SIZE) / 1024:.1f} KiB")
+print(f"σ = {statistics.stdev(MEM_SIZE) / 1024:.1f} KiB")

third_party/wpt_tools/wpt/tools/third_party/websockets/performance/mem_server.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+import asyncio
+import signal
+import statistics
+import tracemalloc
+
+import websockets
+from websockets.extensions import permessage_deflate
+
+
+CLIENTS = 10
+INTERVAL = 1 / 10  # seconds
+
+MEM_SIZE = []
+
+
+async def handler(ws, path):
+    msg = await ws.recv()
+    await ws.send(msg)
+
+    msg = await ws.recv()
+    await ws.send(msg)
+
+    MEM_SIZE.append(tracemalloc.get_traced_memory()[0])
+    tracemalloc.stop()
+
+    tracemalloc.start()
+
+    # Hold connection open until the end of the test.
+    await asyncio.sleep(CLIENTS * INTERVAL)
+
+
+async def mem_server(stop):
+    async with websockets.serve(
+        handler,
+        "localhost",
+        8765,
+        extensions=[
+            permessage_deflate.ServerPerMessageDeflateFactory(
+                server_max_window_bits=10,
+                client_max_window_bits=10,
+                compress_settings={"memLevel": 3},
+            )
+        ],
+    ):
+        await stop
+
+
+loop = asyncio.get_event_loop()
+
+stop = loop.create_future()
+loop.add_signal_handler(signal.SIGINT, stop.set_result, None)
+
+tracemalloc.start()
+
+loop.run_until_complete(mem_server(stop))
+
+# First connection incurs non-representative setup costs.
+del MEM_SIZE[0]
+
+print(f"µ = {statistics.mean(MEM_SIZE) / 1024:.1f} KiB")
+print(f"σ = {statistics.stdev(MEM_SIZE) / 1024:.1f} KiB")

third_party/wpt_tools/wpt/tools/third_party/websockets/setup.cfg

@@ -0,0 +1,30 @@
+[bdist_wheel]
+python-tag = py36.py37
+
+[metadata]
+license_file = LICENSE
+
+[flake8]
+ignore = E731,F403,F405,W503
+max-line-length = 88
+
+[isort]
+combine_as_imports = True
+force_grid_wrap = 0
+include_trailing_comma = True
+known_standard_library = asyncio
+line_length = 88
+lines_after_imports = 2
+multi_line_output = 3
+
+[coverage:run]
+branch = True
+omit = */__main__.py
+source =
+    websockets
+    tests
+
+[coverage:paths]
+source =
+    src/websockets
+   .tox/*/lib/python*/site-packages/websockets

third_party/wpt_tools/wpt/tools/third_party/websockets/setup.py

@@ -0,0 +1,66 @@
+import pathlib
+import re
+import sys
+
+import setuptools
+
+
+root_dir = pathlib.Path(__file__).parent
+
+description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)"
+
+long_description = (root_dir / 'README.rst').read_text(encoding='utf-8')
+
+# PyPI disables the "raw" directive.
+long_description = re.sub(
+    r"^\.\. raw:: html.*?^(?=\w)",
+    "",
+    long_description,
+    flags=re.DOTALL | re.MULTILINE,
+)
+
+exec((root_dir / 'src' / 'websockets' / 'version.py').read_text(encoding='utf-8'))
+
+if sys.version_info[:3] < (3, 6, 1):
+    raise Exception("websockets requires Python >= 3.6.1.")
+
+packages = ['websockets', 'websockets/extensions']
+
+ext_modules = [
+    setuptools.Extension(
+        'websockets.speedups',
+        sources=['src/websockets/speedups.c'],
+        optional=not (root_dir / '.cibuildwheel').exists(),
+    )
+]
+
+setuptools.setup(
+    name='websockets',
+    version=version,
+    description=description,
+    long_description=long_description,
+    url='https://github.com/aaugustin/websockets',
+    author='Aymeric Augustin',
+    author_email='aymeric.augustin@m4x.org',
+    license='BSD',
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Environment :: Web Environment',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: BSD License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+    ],
+    package_dir = {'': 'src'},
+    package_data = {'websockets': ['py.typed']},
+    packages=packages,
+    ext_modules=ext_modules,
+    include_package_data=True,
+    zip_safe=False,
+    python_requires='>=3.6.1',
+    test_loader='unittest:TestLoader',
+)

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/__init__.py

@@ -0,0 +1,55 @@
+# This relies on each of the submodules having an __all__ variable.
+
+from .auth import *  # noqa
+from .client import *  # noqa
+from .exceptions import *  # noqa
+from .protocol import *  # noqa
+from .server import *  # noqa
+from .typing import *  # noqa
+from .uri import *  # noqa
+from .version import version as __version__  # noqa
+
+
+__all__ = [
+    "AbortHandshake",
+    "basic_auth_protocol_factory",
+    "BasicAuthWebSocketServerProtocol",
+    "connect",
+    "ConnectionClosed",
+    "ConnectionClosedError",
+    "ConnectionClosedOK",
+    "Data",
+    "DuplicateParameter",
+    "ExtensionHeader",
+    "ExtensionParameter",
+    "InvalidHandshake",
+    "InvalidHeader",
+    "InvalidHeaderFormat",
+    "InvalidHeaderValue",
+    "InvalidMessage",
+    "InvalidOrigin",
+    "InvalidParameterName",
+    "InvalidParameterValue",
+    "InvalidState",
+    "InvalidStatusCode",
+    "InvalidUpgrade",
+    "InvalidURI",
+    "NegotiationError",
+    "Origin",
+    "parse_uri",
+    "PayloadTooBig",
+    "ProtocolError",
+    "RedirectHandshake",
+    "SecurityError",
+    "serve",
+    "Subprotocol",
+    "unix_connect",
+    "unix_serve",
+    "WebSocketClientProtocol",
+    "WebSocketCommonProtocol",
+    "WebSocketException",
+    "WebSocketProtocolError",
+    "WebSocketServer",
+    "WebSocketServerProtocol",
+    "WebSocketURI",
+]

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/__main__.py

@@ -0,0 +1,206 @@
+import argparse
+import asyncio
+import os
+import signal
+import sys
+import threading
+from typing import Any, Set
+
+from .client import connect
+from .exceptions import ConnectionClosed, format_close
+
+
+if sys.platform == "win32":
+
+    def win_enable_vt100() -> None:
+        """
+        Enable VT-100 for console output on Windows.
+
+        See also https://bugs.python.org/issue29059.
+
+        """
+        import ctypes
+
+        STD_OUTPUT_HANDLE = ctypes.c_uint(-11)
+        INVALID_HANDLE_VALUE = ctypes.c_uint(-1)
+        ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x004
+
+        handle = ctypes.windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+        if handle == INVALID_HANDLE_VALUE:
+            raise RuntimeError("unable to obtain stdout handle")
+
+        cur_mode = ctypes.c_uint()
+        if ctypes.windll.kernel32.GetConsoleMode(handle, ctypes.byref(cur_mode)) == 0:
+            raise RuntimeError("unable to query current console mode")
+
+        # ctypes ints lack support for the required bit-OR operation.
+        # Temporarily convert to Py int, do the OR and convert back.
+        py_int_mode = int.from_bytes(cur_mode, sys.byteorder)
+        new_mode = ctypes.c_uint(py_int_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+
+        if ctypes.windll.kernel32.SetConsoleMode(handle, new_mode) == 0:
+            raise RuntimeError("unable to set console mode")
+
+
+def exit_from_event_loop_thread(
+    loop: asyncio.AbstractEventLoop, stop: "asyncio.Future[None]"
+) -> None:
+    loop.stop()
+    if not stop.done():
+        # When exiting the thread that runs the event loop, raise
+        # KeyboardInterrupt in the main thread to exit the program.
+        try:
+            ctrl_c = signal.CTRL_C_EVENT  # Windows
+        except AttributeError:
+            ctrl_c = signal.SIGINT  # POSIX
+        os.kill(os.getpid(), ctrl_c)
+
+
+def print_during_input(string: str) -> None:
+    sys.stdout.write(
+        # Save cursor position
+        "\N{ESC}7"
+        # Add a new line
+        "\N{LINE FEED}"
+        # Move cursor up
+        "\N{ESC}[A"
+        # Insert blank line, scroll last line down
+        "\N{ESC}[L"
+        # Print string in the inserted blank line
+        f"{string}\N{LINE FEED}"
+        # Restore cursor position
+        "\N{ESC}8"
+        # Move cursor down
+        "\N{ESC}[B"
+    )
+    sys.stdout.flush()
+
+
+def print_over_input(string: str) -> None:
+    sys.stdout.write(
+        # Move cursor to beginning of line
+        "\N{CARRIAGE RETURN}"
+        # Delete current line
+        "\N{ESC}[K"
+        # Print string
+        f"{string}\N{LINE FEED}"
+    )
+    sys.stdout.flush()
+
+
+async def run_client(
+    uri: str,
+    loop: asyncio.AbstractEventLoop,
+    inputs: "asyncio.Queue[str]",
+    stop: "asyncio.Future[None]",
+) -> None:
+    try:
+        websocket = await connect(uri)
+    except Exception as exc:
+        print_over_input(f"Failed to connect to {uri}: {exc}.")
+        exit_from_event_loop_thread(loop, stop)
+        return
+    else:
+        print_during_input(f"Connected to {uri}.")
+
+    try:
+        while True:
+            incoming: asyncio.Future[Any] = asyncio.ensure_future(websocket.recv())
+            outgoing: asyncio.Future[Any] = asyncio.ensure_future(inputs.get())
+            done: Set[asyncio.Future[Any]]
+            pending: Set[asyncio.Future[Any]]
+            done, pending = await asyncio.wait(
+                [incoming, outgoing, stop], return_when=asyncio.FIRST_COMPLETED
+            )
+
+            # Cancel pending tasks to avoid leaking them.
+            if incoming in pending:
+                incoming.cancel()
+            if outgoing in pending:
+                outgoing.cancel()
+
+            if incoming in done:
+                try:
+                    message = incoming.result()
+                except ConnectionClosed:
+                    break
+                else:
+                    if isinstance(message, str):
+                        print_during_input("< " + message)
+                    else:
+                        print_during_input("< (binary) " + message.hex())
+
+            if outgoing in done:
+                message = outgoing.result()
+                await websocket.send(message)
+
+            if stop in done:
+                break
+
+    finally:
+        await websocket.close()
+        close_status = format_close(websocket.close_code, websocket.close_reason)
+
+        print_over_input(f"Connection closed: {close_status}.")
+
+        exit_from_event_loop_thread(loop, stop)
+
+
+def main() -> None:
+    # If we're on Windows, enable VT100 terminal support.
+    if sys.platform == "win32":
+        try:
+            win_enable_vt100()
+        except RuntimeError as exc:
+            sys.stderr.write(
+                f"Unable to set terminal to VT100 mode. This is only "
+                f"supported since Win10 anniversary update. Expect "
+                f"weird symbols on the terminal.\nError: {exc}\n"
+            )
+            sys.stderr.flush()
+
+    try:
+        import readline  # noqa
+    except ImportError:  # Windows has no `readline` normally
+        pass
+
+    # Parse command line arguments.
+    parser = argparse.ArgumentParser(
+        prog="python -m websockets",
+        description="Interactive WebSocket client.",
+        add_help=False,
+    )
+    parser.add_argument("uri", metavar="<uri>")
+    args = parser.parse_args()
+
+    # Create an event loop that will run in a background thread.
+    loop = asyncio.new_event_loop()
+
+    # Create a queue of user inputs. There's no need to limit its size.
+    inputs: asyncio.Queue[str] = asyncio.Queue(loop=loop)
+
+    # Create a stop condition when receiving SIGINT or SIGTERM.
+    stop: asyncio.Future[None] = loop.create_future()
+
+    # Schedule the task that will manage the connection.
+    asyncio.ensure_future(run_client(args.uri, loop, inputs, stop), loop=loop)
+
+    # Start the event loop in a background thread.
+    thread = threading.Thread(target=loop.run_forever)
+    thread.start()
+
+    # Read from stdin in the main thread in order to receive signals.
+    try:
+        while True:
+            # Since there's no size limit, put_nowait is identical to put.
+            message = input("> ")
+            loop.call_soon_threadsafe(inputs.put_nowait, message)
+    except (KeyboardInterrupt, EOFError):  # ^C, ^D
+        loop.call_soon_threadsafe(stop.set_result, None)
+
+    # Wait for the event loop to terminate.
+    thread.join()
+
+
+if __name__ == "__main__":
+    main()

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/auth.py

@@ -0,0 +1,160 @@
+"""
+:mod:`websockets.auth` provides HTTP Basic Authentication according to
+:rfc:`7235` and :rfc:`7617`.
+
+"""
+
+
+import functools
+import http
+from typing import Any, Awaitable, Callable, Iterable, Optional, Tuple, Type, Union
+
+from .exceptions import InvalidHeader
+from .headers import build_www_authenticate_basic, parse_authorization_basic
+from .http import Headers
+from .server import HTTPResponse, WebSocketServerProtocol
+
+
+__all__ = ["BasicAuthWebSocketServerProtocol", "basic_auth_protocol_factory"]
+
+Credentials = Tuple[str, str]
+
+
+def is_credentials(value: Any) -> bool:
+    try:
+        username, password = value
+    except (TypeError, ValueError):
+        return False
+    else:
+        return isinstance(username, str) and isinstance(password, str)
+
+
+class BasicAuthWebSocketServerProtocol(WebSocketServerProtocol):
+    """
+    WebSocket server protocol that enforces HTTP Basic Auth.
+
+    """
+
+    def __init__(
+        self,
+        *args: Any,
+        realm: str,
+        check_credentials: Callable[[str, str], Awaitable[bool]],
+        **kwargs: Any,
+    ) -> None:
+        self.realm = realm
+        self.check_credentials = check_credentials
+        super().__init__(*args, **kwargs)
+
+    async def process_request(
+        self, path: str, request_headers: Headers
+    ) -> Optional[HTTPResponse]:
+        """
+        Check HTTP Basic Auth and return a HTTP 401 or 403 response if needed.
+
+        If authentication succeeds, the username of the authenticated user is
+        stored in the ``username`` attribute.
+
+        """
+        try:
+            authorization = request_headers["Authorization"]
+        except KeyError:
+            return (
+                http.HTTPStatus.UNAUTHORIZED,
+                [("WWW-Authenticate", build_www_authenticate_basic(self.realm))],
+                b"Missing credentials\n",
+            )
+
+        try:
+            username, password = parse_authorization_basic(authorization)
+        except InvalidHeader:
+            return (
+                http.HTTPStatus.UNAUTHORIZED,
+                [("WWW-Authenticate", build_www_authenticate_basic(self.realm))],
+                b"Unsupported credentials\n",
+            )
+
+        if not await self.check_credentials(username, password):
+            return (
+                http.HTTPStatus.UNAUTHORIZED,
+                [("WWW-Authenticate", build_www_authenticate_basic(self.realm))],
+                b"Invalid credentials\n",
+            )
+
+        self.username = username
+
+        return await super().process_request(path, request_headers)
+
+
+def basic_auth_protocol_factory(
+    realm: str,
+    credentials: Optional[Union[Credentials, Iterable[Credentials]]] = None,
+    check_credentials: Optional[Callable[[str, str], Awaitable[bool]]] = None,
+    create_protocol: Type[
+        BasicAuthWebSocketServerProtocol
+    ] = BasicAuthWebSocketServerProtocol,
+) -> Callable[[Any], BasicAuthWebSocketServerProtocol]:
+    """
+    Protocol factory that enforces HTTP Basic Auth.
+
+    ``basic_auth_protocol_factory`` is designed to integrate with
+    :func:`~websockets.server.serve` like this::
+
+        websockets.serve(
+            ...,
+            create_protocol=websockets.basic_auth_protocol_factory(
+                realm="my dev server",
+                credentials=("hello", "iloveyou"),
+            )
+        )
+
+    ``realm`` indicates the scope of protection. It should contain only ASCII
+    characters because the encoding of non-ASCII characters is undefined.
+    Refer to section 2.2 of :rfc:`7235` for details.
+
+    ``credentials`` defines hard coded authorized credentials. It can be a
+    ``(username, password)`` pair or a list of such pairs.
+
+    ``check_credentials`` defines a coroutine that checks whether credentials
+    are authorized. This coroutine receives ``username`` and ``password``
+    arguments and returns a :class:`bool`.
+
+    One of ``credentials`` or ``check_credentials`` must be provided but not
+    both.
+
+    By default, ``basic_auth_protocol_factory`` creates a factory for building
+    :class:`BasicAuthWebSocketServerProtocol` instances. You can override this
+    with the ``create_protocol`` parameter.
+
+    :param realm: scope of protection
+    :param credentials: hard coded credentials
+    :param check_credentials: coroutine that verifies credentials
+    :raises TypeError: if the credentials argument has the wrong type
+
+    """
+    if (credentials is None) == (check_credentials is None):
+        raise TypeError("provide either credentials or check_credentials")
+
+    if credentials is not None:
+        if is_credentials(credentials):
+
+            async def check_credentials(username: str, password: str) -> bool:
+                return (username, password) == credentials
+
+        elif isinstance(credentials, Iterable):
+            credentials_list = list(credentials)
+            if all(is_credentials(item) for item in credentials_list):
+                credentials_dict = dict(credentials_list)
+
+                async def check_credentials(username: str, password: str) -> bool:
+                    return credentials_dict.get(username) == password
+
+            else:
+                raise TypeError(f"invalid credentials argument: {credentials}")
+
+        else:
+            raise TypeError(f"invalid credentials argument: {credentials}")
+
+    return functools.partial(
+        create_protocol, realm=realm, check_credentials=check_credentials
+    )

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/client.py

@@ -0,0 +1,584 @@
+"""
+:mod:`websockets.client` defines the WebSocket client APIs.
+
+"""
+
+import asyncio
+import collections.abc
+import functools
+import logging
+import warnings
+from types import TracebackType
+from typing import Any, Generator, List, Optional, Sequence, Tuple, Type, cast
+
+from .exceptions import (
+    InvalidHandshake,
+    InvalidHeader,
+    InvalidMessage,
+    InvalidStatusCode,
+    NegotiationError,
+    RedirectHandshake,
+    SecurityError,
+)
+from .extensions.base import ClientExtensionFactory, Extension
+from .extensions.permessage_deflate import ClientPerMessageDeflateFactory
+from .handshake import build_request, check_response
+from .headers import (
+    build_authorization_basic,
+    build_extension,
+    build_subprotocol,
+    parse_extension,
+    parse_subprotocol,
+)
+from .http import USER_AGENT, Headers, HeadersLike, read_response
+from .protocol import WebSocketCommonProtocol
+from .typing import ExtensionHeader, Origin, Subprotocol
+from .uri import WebSocketURI, parse_uri
+
+
+__all__ = ["connect", "unix_connect", "WebSocketClientProtocol"]
+
+logger = logging.getLogger(__name__)
+
+
+class WebSocketClientProtocol(WebSocketCommonProtocol):
+    """
+    :class:`~asyncio.Protocol` subclass implementing a WebSocket client.
+
+    This class inherits most of its methods from
+    :class:`~websockets.protocol.WebSocketCommonProtocol`.
+
+    """
+
+    is_client = True
+    side = "client"
+
+    def __init__(
+        self,
+        *,
+        origin: Optional[Origin] = None,
+        extensions: Optional[Sequence[ClientExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLike] = None,
+        **kwargs: Any,
+    ) -> None:
+        self.origin = origin
+        self.available_extensions = extensions
+        self.available_subprotocols = subprotocols
+        self.extra_headers = extra_headers
+        super().__init__(**kwargs)
+
+    def write_http_request(self, path: str, headers: Headers) -> None:
+        """
+        Write request line and headers to the HTTP request.
+
+        """
+        self.path = path
+        self.request_headers = headers
+
+        logger.debug("%s > GET %s HTTP/1.1", self.side, path)
+        logger.debug("%s > %r", self.side, headers)
+
+        # Since the path and headers only contain ASCII characters,
+        # we can keep this simple.
+        request = f"GET {path} HTTP/1.1\r\n"
+        request += str(headers)
+
+        self.transport.write(request.encode())
+
+    async def read_http_response(self) -> Tuple[int, Headers]:
+        """
+        Read status line and headers from the HTTP response.
+
+        If the response contains a body, it may be read from ``self.reader``
+        after this coroutine returns.
+
+        :raises ~websockets.exceptions.InvalidMessage: if the HTTP message is
+            malformed or isn't an HTTP/1.1 GET response
+
+        """
+        try:
+            status_code, reason, headers = await read_response(self.reader)
+        except Exception as exc:
+            raise InvalidMessage("did not receive a valid HTTP response") from exc
+
+        logger.debug("%s < HTTP/1.1 %d %s", self.side, status_code, reason)
+        logger.debug("%s < %r", self.side, headers)
+
+        self.response_headers = headers
+
+        return status_code, self.response_headers
+
+    @staticmethod
+    def process_extensions(
+        headers: Headers,
+        available_extensions: Optional[Sequence[ClientExtensionFactory]],
+    ) -> List[Extension]:
+        """
+        Handle the Sec-WebSocket-Extensions HTTP response header.
+
+        Check that each extension is supported, as well as its parameters.
+
+        Return the list of accepted extensions.
+
+        Raise :exc:`~websockets.exceptions.InvalidHandshake` to abort the
+        connection.
+
+        :rfc:`6455` leaves the rules up to the specification of each
+        :extension.
+
+        To provide this level of flexibility, for each extension accepted by
+        the server, we check for a match with each extension available in the
+        client configuration. If no match is found, an exception is raised.
+
+        If several variants of the same extension are accepted by the server,
+        it may be configured severel times, which won't make sense in general.
+        Extensions must implement their own requirements. For this purpose,
+        the list of previously accepted extensions is provided.
+
+        Other requirements, for example related to mandatory extensions or the
+        order of extensions, may be implemented by overriding this method.
+
+        """
+        accepted_extensions: List[Extension] = []
+
+        header_values = headers.get_all("Sec-WebSocket-Extensions")
+
+        if header_values:
+
+            if available_extensions is None:
+                raise InvalidHandshake("no extensions supported")
+
+            parsed_header_values: List[ExtensionHeader] = sum(
+                [parse_extension(header_value) for header_value in header_values], []
+            )
+
+            for name, response_params in parsed_header_values:
+
+                for extension_factory in available_extensions:
+
+                    # Skip non-matching extensions based on their name.
+                    if extension_factory.name != name:
+                        continue
+
+                    # Skip non-matching extensions based on their params.
+                    try:
+                        extension = extension_factory.process_response_params(
+                            response_params, accepted_extensions
+                        )
+                    except NegotiationError:
+                        continue
+
+                    # Add matching extension to the final list.
+                    accepted_extensions.append(extension)
+
+                    # Break out of the loop once we have a match.
+                    break
+
+                # If we didn't break from the loop, no extension in our list
+                # matched what the server sent. Fail the connection.
+                else:
+                    raise NegotiationError(
+                        f"Unsupported extension: "
+                        f"name = {name}, params = {response_params}"
+                    )
+
+        return accepted_extensions
+
+    @staticmethod
+    def process_subprotocol(
+        headers: Headers, available_subprotocols: Optional[Sequence[Subprotocol]]
+    ) -> Optional[Subprotocol]:
+        """
+        Handle the Sec-WebSocket-Protocol HTTP response header.
+
+        Check that it contains exactly one supported subprotocol.
+
+        Return the selected subprotocol.
+
+        """
+        subprotocol: Optional[Subprotocol] = None
+
+        header_values = headers.get_all("Sec-WebSocket-Protocol")
+
+        if header_values:
+
+            if available_subprotocols is None:
+                raise InvalidHandshake("no subprotocols supported")
+
+            parsed_header_values: Sequence[Subprotocol] = sum(
+                [parse_subprotocol(header_value) for header_value in header_values], []
+            )
+
+            if len(parsed_header_values) > 1:
+                subprotocols = ", ".join(parsed_header_values)
+                raise InvalidHandshake(f"multiple subprotocols: {subprotocols}")
+
+            subprotocol = parsed_header_values[0]
+
+            if subprotocol not in available_subprotocols:
+                raise NegotiationError(f"unsupported subprotocol: {subprotocol}")
+
+        return subprotocol
+
+    async def handshake(
+        self,
+        wsuri: WebSocketURI,
+        origin: Optional[Origin] = None,
+        available_extensions: Optional[Sequence[ClientExtensionFactory]] = None,
+        available_subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLike] = None,
+    ) -> None:
+        """
+        Perform the client side of the opening handshake.
+
+        :param origin: sets the Origin HTTP header
+        :param available_extensions: list of supported extensions in the order
+            in which they should be used
+        :param available_subprotocols: list of supported subprotocols in order
+            of decreasing preference
+        :param extra_headers: sets additional HTTP request headers; it must be
+            a :class:`~websockets.http.Headers` instance, a
+            :class:`~collections.abc.Mapping`, or an iterable of ``(name,
+            value)`` pairs
+        :raises ~websockets.exceptions.InvalidHandshake: if the handshake
+            fails
+
+        """
+        request_headers = Headers()
+
+        if wsuri.port == (443 if wsuri.secure else 80):  # pragma: no cover
+            request_headers["Host"] = wsuri.host
+        else:
+            request_headers["Host"] = f"{wsuri.host}:{wsuri.port}"
+
+        if wsuri.user_info:
+            request_headers["Authorization"] = build_authorization_basic(
+                *wsuri.user_info
+            )
+
+        if origin is not None:
+            request_headers["Origin"] = origin
+
+        key = build_request(request_headers)
+
+        if available_extensions is not None:
+            extensions_header = build_extension(
+                [
+                    (extension_factory.name, extension_factory.get_request_params())
+                    for extension_factory in available_extensions
+                ]
+            )
+            request_headers["Sec-WebSocket-Extensions"] = extensions_header
+
+        if available_subprotocols is not None:
+            protocol_header = build_subprotocol(available_subprotocols)
+            request_headers["Sec-WebSocket-Protocol"] = protocol_header
+
+        if extra_headers is not None:
+            if isinstance(extra_headers, Headers):
+                extra_headers = extra_headers.raw_items()
+            elif isinstance(extra_headers, collections.abc.Mapping):
+                extra_headers = extra_headers.items()
+            for name, value in extra_headers:
+                request_headers[name] = value
+
+        request_headers.setdefault("User-Agent", USER_AGENT)
+
+        self.write_http_request(wsuri.resource_name, request_headers)
+
+        status_code, response_headers = await self.read_http_response()
+        if status_code in (301, 302, 303, 307, 308):
+            if "Location" not in response_headers:
+                raise InvalidHeader("Location")
+            raise RedirectHandshake(response_headers["Location"])
+        elif status_code != 101:
+            raise InvalidStatusCode(status_code)
+
+        check_response(response_headers, key)
+
+        self.extensions = self.process_extensions(
+            response_headers, available_extensions
+        )
+
+        self.subprotocol = self.process_subprotocol(
+            response_headers, available_subprotocols
+        )
+
+        self.connection_open()
+
+
+class Connect:
+    """
+    Connect to the WebSocket server at the given ``uri``.
+
+    Awaiting :func:`connect` yields a :class:`WebSocketClientProtocol` which
+    can then be used to send and receive messages.
+
+    :func:`connect` can also be used as a asynchronous context manager. In
+    that case, the connection is closed when exiting the context.
+
+    :func:`connect` is a wrapper around the event loop's
+    :meth:`~asyncio.loop.create_connection` method. Unknown keyword arguments
+    are passed to :meth:`~asyncio.loop.create_connection`.
+
+    For example, you can set the ``ssl`` keyword argument to a
+    :class:`~ssl.SSLContext` to enforce some TLS settings. When connecting to
+    a ``wss://`` URI, if this argument isn't provided explicitly,
+    :func:`ssl.create_default_context` is called to create a context.
+
+    You can connect to a different host and port from those found in ``uri``
+    by setting ``host`` and ``port`` keyword arguments. This only changes the
+    destination of the TCP connection. The host name from ``uri`` is still
+    used in the TLS handshake for secure connections and in the ``Host`` HTTP
+    header.
+
+    The ``create_protocol`` parameter allows customizing the
+    :class:`~asyncio.Protocol` that manages the connection. It should be a
+    callable or class accepting the same arguments as
+    :class:`WebSocketClientProtocol` and returning an instance of
+    :class:`WebSocketClientProtocol` or a subclass. It defaults to
+    :class:`WebSocketClientProtocol`.
+
+    The behavior of ``ping_interval``, ``ping_timeout``, ``close_timeout``,
+    ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit`` is
+    described in :class:`~websockets.protocol.WebSocketCommonProtocol`.
+
+    :func:`connect` also accepts the following optional arguments:
+
+    * ``compression`` is a shortcut to configure compression extensions;
+      by default it enables the "permessage-deflate" extension; set it to
+      ``None`` to disable compression
+    * ``origin`` sets the Origin HTTP header
+    * ``extensions`` is a list of supported extensions in order of
+      decreasing preference
+    * ``subprotocols`` is a list of supported subprotocols in order of
+      decreasing preference
+    * ``extra_headers`` sets additional HTTP request headers; it can be a
+      :class:`~websockets.http.Headers` instance, a
+      :class:`~collections.abc.Mapping`, or an iterable of ``(name, value)``
+      pairs
+
+    :raises ~websockets.uri.InvalidURI: if ``uri`` is invalid
+    :raises ~websockets.handshake.InvalidHandshake: if the opening handshake
+        fails
+
+    """
+
+    MAX_REDIRECTS_ALLOWED = 10
+
+    def __init__(
+        self,
+        uri: str,
+        *,
+        path: Optional[str] = None,
+        create_protocol: Optional[Type[WebSocketClientProtocol]] = None,
+        ping_interval: float = 20,
+        ping_timeout: float = 20,
+        close_timeout: Optional[float] = None,
+        max_size: int = 2 ** 20,
+        max_queue: int = 2 ** 5,
+        read_limit: int = 2 ** 16,
+        write_limit: int = 2 ** 16,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        legacy_recv: bool = False,
+        klass: Optional[Type[WebSocketClientProtocol]] = None,
+        timeout: Optional[float] = None,
+        compression: Optional[str] = "deflate",
+        origin: Optional[Origin] = None,
+        extensions: Optional[Sequence[ClientExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLike] = None,
+        **kwargs: Any,
+    ) -> None:
+        # Backwards compatibility: close_timeout used to be called timeout.
+        if timeout is None:
+            timeout = 10
+        else:
+            warnings.warn("rename timeout to close_timeout", DeprecationWarning)
+        # If both are specified, timeout is ignored.
+        if close_timeout is None:
+            close_timeout = timeout
+
+        # Backwards compatibility: create_protocol used to be called klass.
+        if klass is None:
+            klass = WebSocketClientProtocol
+        else:
+            warnings.warn("rename klass to create_protocol", DeprecationWarning)
+        # If both are specified, klass is ignored.
+        if create_protocol is None:
+            create_protocol = klass
+
+        if loop is None:
+            loop = asyncio.get_event_loop()
+
+        wsuri = parse_uri(uri)
+        if wsuri.secure:
+            kwargs.setdefault("ssl", True)
+        elif kwargs.get("ssl") is not None:
+            raise ValueError(
+                "connect() received a ssl argument for a ws:// URI, "
+                "use a wss:// URI to enable TLS"
+            )
+
+        if compression == "deflate":
+            if extensions is None:
+                extensions = []
+            if not any(
+                extension_factory.name == ClientPerMessageDeflateFactory.name
+                for extension_factory in extensions
+            ):
+                extensions = list(extensions) + [
+                    ClientPerMessageDeflateFactory(client_max_window_bits=True)
+                ]
+        elif compression is not None:
+            raise ValueError(f"unsupported compression: {compression}")
+
+        factory = functools.partial(
+            create_protocol,
+            ping_interval=ping_interval,
+            ping_timeout=ping_timeout,
+            close_timeout=close_timeout,
+            max_size=max_size,
+            max_queue=max_queue,
+            read_limit=read_limit,
+            write_limit=write_limit,
+            loop=loop,
+            host=wsuri.host,
+            port=wsuri.port,
+            secure=wsuri.secure,
+            legacy_recv=legacy_recv,
+            origin=origin,
+            extensions=extensions,
+            subprotocols=subprotocols,
+            extra_headers=extra_headers,
+        )
+
+        if path is None:
+            host: Optional[str]
+            port: Optional[int]
+            if kwargs.get("sock") is None:
+                host, port = wsuri.host, wsuri.port
+            else:
+                # If sock is given, host and port shouldn't be specified.
+                host, port = None, None
+            # If host and port are given, override values from the URI.
+            host = kwargs.pop("host", host)
+            port = kwargs.pop("port", port)
+            create_connection = functools.partial(
+                loop.create_connection, factory, host, port, **kwargs
+            )
+        else:
+            create_connection = functools.partial(
+                loop.create_unix_connection, factory, path, **kwargs
+            )
+
+        # This is a coroutine function.
+        self._create_connection = create_connection
+        self._wsuri = wsuri
+
+    def handle_redirect(self, uri: str) -> None:
+        # Update the state of this instance to connect to a new URI.
+        old_wsuri = self._wsuri
+        new_wsuri = parse_uri(uri)
+
+        # Forbid TLS downgrade.
+        if old_wsuri.secure and not new_wsuri.secure:
+            raise SecurityError("redirect from WSS to WS")
+
+        same_origin = (
+            old_wsuri.host == new_wsuri.host and old_wsuri.port == new_wsuri.port
+        )
+
+        # Rewrite the host and port arguments for cross-origin redirects.
+        # This preserves connection overrides with the host and port
+        # arguments if the redirect points to the same host and port.
+        if not same_origin:
+            # Replace the host and port argument passed to the protocol factory.
+            factory = self._create_connection.args[0]
+            factory = functools.partial(
+                factory.func,
+                *factory.args,
+                **dict(factory.keywords, host=new_wsuri.host, port=new_wsuri.port),
+            )
+            # Replace the host and port argument passed to create_connection.
+            self._create_connection = functools.partial(
+                self._create_connection.func,
+                *(factory, new_wsuri.host, new_wsuri.port),
+                **self._create_connection.keywords,
+            )
+
+        # Set the new WebSocket URI. This suffices for same-origin redirects.
+        self._wsuri = new_wsuri
+
+    # async with connect(...)
+
+    async def __aenter__(self) -> WebSocketClientProtocol:
+        return await self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        await self.ws_client.close()
+
+    # await connect(...)
+
+    def __await__(self) -> Generator[Any, None, WebSocketClientProtocol]:
+        # Create a suitable iterator by calling __await__ on a coroutine.
+        return self.__await_impl__().__await__()
+
+    async def __await_impl__(self) -> WebSocketClientProtocol:
+        for redirects in range(self.MAX_REDIRECTS_ALLOWED):
+            transport, protocol = await self._create_connection()
+            # https://github.com/python/typeshed/pull/2756
+            transport = cast(asyncio.Transport, transport)
+            protocol = cast(WebSocketClientProtocol, protocol)
+
+            try:
+                try:
+                    await protocol.handshake(
+                        self._wsuri,
+                        origin=protocol.origin,
+                        available_extensions=protocol.available_extensions,
+                        available_subprotocols=protocol.available_subprotocols,
+                        extra_headers=protocol.extra_headers,
+                    )
+                except Exception:
+                    protocol.fail_connection()
+                    await protocol.wait_closed()
+                    raise
+                else:
+                    self.ws_client = protocol
+                    return protocol
+            except RedirectHandshake as exc:
+                self.handle_redirect(exc.uri)
+        else:
+            raise SecurityError("too many redirects")
+
+    # yield from connect(...)
+
+    __iter__ = __await__
+
+
+connect = Connect
+
+
+def unix_connect(path: str, uri: str = "ws://localhost/", **kwargs: Any) -> Connect:
+    """
+    Similar to :func:`connect`, but for connecting to a Unix socket.
+
+    This function calls the event loop's
+    :meth:`~asyncio.loop.create_unix_connection` method.
+
+    It is only available on Unix.
+
+    It's mainly useful for debugging servers listening on Unix sockets.
+
+    :param path: file system path to the Unix socket
+    :param uri: WebSocket URI
+
+    """
+    return connect(uri=uri, path=path, **kwargs)

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/exceptions.py

@@ -0,0 +1,366 @@
+"""
+:mod:`websockets.exceptions` defines the following exception hierarchy:
+
+* :exc:`WebSocketException`
+    * :exc:`ConnectionClosed`
+        * :exc:`ConnectionClosedError`
+        * :exc:`ConnectionClosedOK`
+    * :exc:`InvalidHandshake`
+        * :exc:`SecurityError`
+        * :exc:`InvalidMessage`
+        * :exc:`InvalidHeader`
+            * :exc:`InvalidHeaderFormat`
+            * :exc:`InvalidHeaderValue`
+            * :exc:`InvalidOrigin`
+            * :exc:`InvalidUpgrade`
+        * :exc:`InvalidStatusCode`
+        * :exc:`NegotiationError`
+            * :exc:`DuplicateParameter`
+            * :exc:`InvalidParameterName`
+            * :exc:`InvalidParameterValue`
+        * :exc:`AbortHandshake`
+        * :exc:`RedirectHandshake`
+    * :exc:`InvalidState`
+    * :exc:`InvalidURI`
+    * :exc:`PayloadTooBig`
+    * :exc:`ProtocolError`
+
+"""
+
+import http
+from typing import Optional
+
+from .http import Headers, HeadersLike
+
+
+__all__ = [
+    "WebSocketException",
+    "ConnectionClosed",
+    "ConnectionClosedError",
+    "ConnectionClosedOK",
+    "InvalidHandshake",
+    "SecurityError",
+    "InvalidMessage",
+    "InvalidHeader",
+    "InvalidHeaderFormat",
+    "InvalidHeaderValue",
+    "InvalidOrigin",
+    "InvalidUpgrade",
+    "InvalidStatusCode",
+    "NegotiationError",
+    "DuplicateParameter",
+    "InvalidParameterName",
+    "InvalidParameterValue",
+    "AbortHandshake",
+    "RedirectHandshake",
+    "InvalidState",
+    "InvalidURI",
+    "PayloadTooBig",
+    "ProtocolError",
+    "WebSocketProtocolError",
+]
+
+
+class WebSocketException(Exception):
+    """
+    Base class for all exceptions defined by :mod:`websockets`.
+
+    """
+
+
+CLOSE_CODES = {
+    1000: "OK",
+    1001: "going away",
+    1002: "protocol error",
+    1003: "unsupported type",
+    # 1004 is reserved
+    1005: "no status code [internal]",
+    1006: "connection closed abnormally [internal]",
+    1007: "invalid data",
+    1008: "policy violation",
+    1009: "message too big",
+    1010: "extension required",
+    1011: "unexpected error",
+    1015: "TLS failure [internal]",
+}
+
+
+def format_close(code: int, reason: str) -> str:
+    """
+    Display a human-readable version of the close code and reason.
+
+    """
+    if 3000 <= code < 4000:
+        explanation = "registered"
+    elif 4000 <= code < 5000:
+        explanation = "private use"
+    else:
+        explanation = CLOSE_CODES.get(code, "unknown")
+    result = f"code = {code} ({explanation}), "
+
+    if reason:
+        result += f"reason = {reason}"
+    else:
+        result += "no reason"
+
+    return result
+
+
+class ConnectionClosed(WebSocketException):
+    """
+    Raised when trying to interact with a closed connection.
+
+    Provides the connection close code and reason in its ``code`` and
+    ``reason`` attributes respectively.
+
+    """
+
+    def __init__(self, code: int, reason: str) -> None:
+        self.code = code
+        self.reason = reason
+        super().__init__(format_close(code, reason))
+
+
+class ConnectionClosedError(ConnectionClosed):
+    """
+    Like :exc:`ConnectionClosed`, when the connection terminated with an error.
+
+    This means the close code is different from 1000 (OK) and 1001 (going away).
+
+    """
+
+    def __init__(self, code: int, reason: str) -> None:
+        assert code != 1000 and code != 1001
+        super().__init__(code, reason)
+
+
+class ConnectionClosedOK(ConnectionClosed):
+    """
+    Like :exc:`ConnectionClosed`, when the connection terminated properly.
+
+    This means the close code is 1000 (OK) or 1001 (going away).
+
+    """
+
+    def __init__(self, code: int, reason: str) -> None:
+        assert code == 1000 or code == 1001
+        super().__init__(code, reason)
+
+
+class InvalidHandshake(WebSocketException):
+    """
+    Raised during the handshake when the WebSocket connection fails.
+
+    """
+
+
+class SecurityError(InvalidHandshake):
+    """
+    Raised when a handshake request or response breaks a security rule.
+
+    Security limits are hard coded.
+
+    """
+
+
+class InvalidMessage(InvalidHandshake):
+    """
+    Raised when a handshake request or response is malformed.
+
+    """
+
+
+class InvalidHeader(InvalidHandshake):
+    """
+    Raised when a HTTP header doesn't have a valid format or value.
+
+    """
+
+    def __init__(self, name: str, value: Optional[str] = None) -> None:
+        self.name = name
+        self.value = value
+        if value is None:
+            message = f"missing {name} header"
+        elif value == "":
+            message = f"empty {name} header"
+        else:
+            message = f"invalid {name} header: {value}"
+        super().__init__(message)
+
+
+class InvalidHeaderFormat(InvalidHeader):
+    """
+    Raised when a HTTP header cannot be parsed.
+
+    The format of the header doesn't match the grammar for that header.
+
+    """
+
+    def __init__(self, name: str, error: str, header: str, pos: int) -> None:
+        self.name = name
+        error = f"{error} at {pos} in {header}"
+        super().__init__(name, error)
+
+
+class InvalidHeaderValue(InvalidHeader):
+    """
+    Raised when a HTTP header has a wrong value.
+
+    The format of the header is correct but a value isn't acceptable.
+
+    """
+
+
+class InvalidOrigin(InvalidHeader):
+    """
+    Raised when the Origin header in a request isn't allowed.
+
+    """
+
+    def __init__(self, origin: Optional[str]) -> None:
+        super().__init__("Origin", origin)
+
+
+class InvalidUpgrade(InvalidHeader):
+    """
+    Raised when the Upgrade or Connection header isn't correct.
+
+    """
+
+
+class InvalidStatusCode(InvalidHandshake):
+    """
+    Raised when a handshake response status code is invalid.
+
+    The integer status code is available in the ``status_code`` attribute.
+
+    """
+
+    def __init__(self, status_code: int) -> None:
+        self.status_code = status_code
+        message = f"server rejected WebSocket connection: HTTP {status_code}"
+        super().__init__(message)
+
+
+class NegotiationError(InvalidHandshake):
+    """
+    Raised when negotiating an extension fails.
+
+    """
+
+
+class DuplicateParameter(NegotiationError):
+    """
+    Raised when a parameter name is repeated in an extension header.
+
+    """
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        message = f"duplicate parameter: {name}"
+        super().__init__(message)
+
+
+class InvalidParameterName(NegotiationError):
+    """
+    Raised when a parameter name in an extension header is invalid.
+
+    """
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        message = f"invalid parameter name: {name}"
+        super().__init__(message)
+
+
+class InvalidParameterValue(NegotiationError):
+    """
+    Raised when a parameter value in an extension header is invalid.
+
+    """
+
+    def __init__(self, name: str, value: Optional[str]) -> None:
+        self.name = name
+        self.value = value
+        if value is None:
+            message = f"missing value for parameter {name}"
+        elif value == "":
+            message = f"empty value for parameter {name}"
+        else:
+            message = f"invalid value for parameter {name}: {value}"
+        super().__init__(message)
+
+
+class AbortHandshake(InvalidHandshake):
+    """
+    Raised to abort the handshake on purpose and return a HTTP response.
+
+    This exception is an implementation detail.
+
+    The public API is :meth:`~server.WebSocketServerProtocol.process_request`.
+
+    """
+
+    def __init__(
+        self, status: http.HTTPStatus, headers: HeadersLike, body: bytes = b""
+    ) -> None:
+        self.status = status
+        self.headers = Headers(headers)
+        self.body = body
+        message = f"HTTP {status}, {len(self.headers)} headers, {len(body)} bytes"
+        super().__init__(message)
+
+
+class RedirectHandshake(InvalidHandshake):
+    """
+    Raised when a handshake gets redirected.
+
+    This exception is an implementation detail.
+
+    """
+
+    def __init__(self, uri: str) -> None:
+        self.uri = uri
+
+    def __str__(self) -> str:
+        return f"redirect to {self.uri}"
+
+
+class InvalidState(WebSocketException, AssertionError):
+    """
+    Raised when an operation is forbidden in the current state.
+
+    This exception is an implementation detail.
+
+    It should never be raised in normal circumstances.
+
+    """
+
+
+class InvalidURI(WebSocketException):
+    """
+    Raised when connecting to an URI that isn't a valid WebSocket URI.
+
+    """
+
+    def __init__(self, uri: str) -> None:
+        self.uri = uri
+        message = "{} isn't a valid URI".format(uri)
+        super().__init__(message)
+
+
+class PayloadTooBig(WebSocketException):
+    """
+    Raised when receiving a frame with a payload exceeding the maximum size.
+
+    """
+
+
+class ProtocolError(WebSocketException):
+    """
+    Raised when the other side breaks the protocol.
+
+    """
+
+
+WebSocketProtocolError = ProtocolError  # for backwards compatibility

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/extensions/base.py

@@ -0,0 +1,119 @@
+"""
+:mod:`websockets.extensions.base` defines abstract classes for implementing
+extensions.
+
+See `section 9 of RFC 6455`_.
+
+.. _section 9 of RFC 6455: http://tools.ietf.org/html/rfc6455#section-9
+
+"""
+
+from typing import List, Optional, Sequence, Tuple
+
+from ..framing import Frame
+from ..typing import ExtensionName, ExtensionParameter
+
+
+__all__ = ["Extension", "ClientExtensionFactory", "ServerExtensionFactory"]
+
+
+class Extension:
+    """
+    Abstract class for extensions.
+
+    """
+
+    @property
+    def name(self) -> ExtensionName:
+        """
+        Extension identifier.
+
+        """
+
+    def decode(self, frame: Frame, *, max_size: Optional[int] = None) -> Frame:
+        """
+        Decode an incoming frame.
+
+        :param frame: incoming frame
+        :param max_size: maximum payload size in bytes
+
+        """
+
+    def encode(self, frame: Frame) -> Frame:
+        """
+        Encode an outgoing frame.
+
+        :param frame: outgoing frame
+
+        """
+
+
+class ClientExtensionFactory:
+    """
+    Abstract class for client-side extension factories.
+
+    """
+
+    @property
+    def name(self) -> ExtensionName:
+        """
+        Extension identifier.
+
+        """
+
+    def get_request_params(self) -> List[ExtensionParameter]:
+        """
+        Build request parameters.
+
+        Return a list of ``(name, value)`` pairs.
+
+        """
+
+    def process_response_params(
+        self,
+        params: Sequence[ExtensionParameter],
+        accepted_extensions: Sequence[Extension],
+    ) -> Extension:
+        """
+        Process response parameters received from the server.
+
+        :param params: list of ``(name, value)`` pairs.
+        :param accepted_extensions: list of previously accepted extensions.
+        :raises ~websockets.exceptions.NegotiationError: if parameters aren't
+            acceptable
+
+        """
+
+
+class ServerExtensionFactory:
+    """
+    Abstract class for server-side extension factories.
+
+    """
+
+    @property
+    def name(self) -> ExtensionName:
+        """
+        Extension identifier.
+
+        """
+
+    def process_request_params(
+        self,
+        params: Sequence[ExtensionParameter],
+        accepted_extensions: Sequence[Extension],
+    ) -> Tuple[List[ExtensionParameter], Extension]:
+        """
+        Process request parameters received from the client.
+
+        To accept the offer, return a 2-uple containing:
+
+        - response parameters: a list of ``(name, value)`` pairs
+        - an extension: an instance of a subclass of :class:`Extension`
+
+        :param params: list of ``(name, value)`` pairs.
+        :param accepted_extensions: list of previously accepted extensions.
+        :raises ~websockets.exceptions.NegotiationError: to reject the offer,
+            if parameters aren't acceptable
+
+        """

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/extensions/permessage_deflate.py

@@ -0,0 +1,588 @@
+"""
+:mod:`websockets.extensions.permessage_deflate` implements the Compression
+Extensions for WebSocket as specified in :rfc:`7692`.
+
+"""
+
+import zlib
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+from ..exceptions import (
+    DuplicateParameter,
+    InvalidParameterName,
+    InvalidParameterValue,
+    NegotiationError,
+    PayloadTooBig,
+)
+from ..framing import CTRL_OPCODES, OP_CONT, Frame
+from ..typing import ExtensionName, ExtensionParameter
+from .base import ClientExtensionFactory, Extension, ServerExtensionFactory
+
+
+__all__ = [
+    "PerMessageDeflate",
+    "ClientPerMessageDeflateFactory",
+    "ServerPerMessageDeflateFactory",
+]
+
+_EMPTY_UNCOMPRESSED_BLOCK = b"\x00\x00\xff\xff"
+
+_MAX_WINDOW_BITS_VALUES = [str(bits) for bits in range(8, 16)]
+
+
+class PerMessageDeflate(Extension):
+    """
+    Per-Message Deflate extension.
+
+    """
+
+    name = ExtensionName("permessage-deflate")
+
+    def __init__(
+        self,
+        remote_no_context_takeover: bool,
+        local_no_context_takeover: bool,
+        remote_max_window_bits: int,
+        local_max_window_bits: int,
+        compress_settings: Optional[Dict[Any, Any]] = None,
+    ) -> None:
+        """
+        Configure the Per-Message Deflate extension.
+
+        """
+        if compress_settings is None:
+            compress_settings = {}
+
+        assert remote_no_context_takeover in [False, True]
+        assert local_no_context_takeover in [False, True]
+        assert 8 <= remote_max_window_bits <= 15
+        assert 8 <= local_max_window_bits <= 15
+        assert "wbits" not in compress_settings
+
+        self.remote_no_context_takeover = remote_no_context_takeover
+        self.local_no_context_takeover = local_no_context_takeover
+        self.remote_max_window_bits = remote_max_window_bits
+        self.local_max_window_bits = local_max_window_bits
+        self.compress_settings = compress_settings
+
+        if not self.remote_no_context_takeover:
+            self.decoder = zlib.decompressobj(wbits=-self.remote_max_window_bits)
+
+        if not self.local_no_context_takeover:
+            self.encoder = zlib.compressobj(
+                wbits=-self.local_max_window_bits, **self.compress_settings
+            )
+
+        # To handle continuation frames properly, we must keep track of
+        # whether that initial frame was encoded.
+        self.decode_cont_data = False
+        # There's no need for self.encode_cont_data because we always encode
+        # outgoing frames, so it would always be True.
+
+    def __repr__(self) -> str:
+        return (
+            f"PerMessageDeflate("
+            f"remote_no_context_takeover={self.remote_no_context_takeover}, "
+            f"local_no_context_takeover={self.local_no_context_takeover}, "
+            f"remote_max_window_bits={self.remote_max_window_bits}, "
+            f"local_max_window_bits={self.local_max_window_bits})"
+        )
+
+    def decode(self, frame: Frame, *, max_size: Optional[int] = None) -> Frame:
+        """
+        Decode an incoming frame.
+
+        """
+        # Skip control frames.
+        if frame.opcode in CTRL_OPCODES:
+            return frame
+
+        # Handle continuation data frames:
+        # - skip if the initial data frame wasn't encoded
+        # - reset "decode continuation data" flag if it's a final frame
+        if frame.opcode == OP_CONT:
+            if not self.decode_cont_data:
+                return frame
+            if frame.fin:
+                self.decode_cont_data = False
+
+        # Handle text and binary data frames:
+        # - skip if the frame isn't encoded
+        # - set "decode continuation data" flag if it's a non-final frame
+        else:
+            if not frame.rsv1:
+                return frame
+            if not frame.fin:  # frame.rsv1 is True at this point
+                self.decode_cont_data = True
+
+            # Re-initialize per-message decoder.
+            if self.remote_no_context_takeover:
+                self.decoder = zlib.decompressobj(wbits=-self.remote_max_window_bits)
+
+        # Uncompress compressed frames. Protect against zip bombs by
+        # preventing zlib from decompressing more than max_length bytes
+        # (except when the limit is disabled with max_size = None).
+        data = frame.data
+        if frame.fin:
+            data += _EMPTY_UNCOMPRESSED_BLOCK
+        max_length = 0 if max_size is None else max_size
+        data = self.decoder.decompress(data, max_length)
+        if self.decoder.unconsumed_tail:
+            raise PayloadTooBig(
+                f"Uncompressed payload length exceeds size limit (? > {max_size} bytes)"
+            )
+
+        # Allow garbage collection of the decoder if it won't be reused.
+        if frame.fin and self.remote_no_context_takeover:
+            del self.decoder
+
+        return frame._replace(data=data, rsv1=False)
+
+    def encode(self, frame: Frame) -> Frame:
+        """
+        Encode an outgoing frame.
+
+        """
+        # Skip control frames.
+        if frame.opcode in CTRL_OPCODES:
+            return frame
+
+        # Since we always encode and never fragment messages, there's no logic
+        # similar to decode() here at this time.
+
+        if frame.opcode != OP_CONT:
+            # Re-initialize per-message decoder.
+            if self.local_no_context_takeover:
+                self.encoder = zlib.compressobj(
+                    wbits=-self.local_max_window_bits, **self.compress_settings
+                )
+
+        # Compress data frames.
+        data = self.encoder.compress(frame.data) + self.encoder.flush(zlib.Z_SYNC_FLUSH)
+        if frame.fin and data.endswith(_EMPTY_UNCOMPRESSED_BLOCK):
+            data = data[:-4]
+
+        # Allow garbage collection of the encoder if it won't be reused.
+        if frame.fin and self.local_no_context_takeover:
+            del self.encoder
+
+        return frame._replace(data=data, rsv1=True)
+
+
+def _build_parameters(
+    server_no_context_takeover: bool,
+    client_no_context_takeover: bool,
+    server_max_window_bits: Optional[int],
+    client_max_window_bits: Optional[Union[int, bool]],
+) -> List[ExtensionParameter]:
+    """
+    Build a list of ``(name, value)`` pairs for some compression parameters.
+
+    """
+    params: List[ExtensionParameter] = []
+    if server_no_context_takeover:
+        params.append(("server_no_context_takeover", None))
+    if client_no_context_takeover:
+        params.append(("client_no_context_takeover", None))
+    if server_max_window_bits:
+        params.append(("server_max_window_bits", str(server_max_window_bits)))
+    if client_max_window_bits is True:  # only in handshake requests
+        params.append(("client_max_window_bits", None))
+    elif client_max_window_bits:
+        params.append(("client_max_window_bits", str(client_max_window_bits)))
+    return params
+
+
+def _extract_parameters(
+    params: Sequence[ExtensionParameter], *, is_server: bool
+) -> Tuple[bool, bool, Optional[int], Optional[Union[int, bool]]]:
+    """
+    Extract compression parameters from a list of ``(name, value)`` pairs.
+
+    If ``is_server`` is ``True``, ``client_max_window_bits`` may be provided
+    without a value. This is only allow in handshake requests.
+
+    """
+    server_no_context_takeover: bool = False
+    client_no_context_takeover: bool = False
+    server_max_window_bits: Optional[int] = None
+    client_max_window_bits: Optional[Union[int, bool]] = None
+
+    for name, value in params:
+
+        if name == "server_no_context_takeover":
+            if server_no_context_takeover:
+                raise DuplicateParameter(name)
+            if value is None:
+                server_no_context_takeover = True
+            else:
+                raise InvalidParameterValue(name, value)
+
+        elif name == "client_no_context_takeover":
+            if client_no_context_takeover:
+                raise DuplicateParameter(name)
+            if value is None:
+                client_no_context_takeover = True
+            else:
+                raise InvalidParameterValue(name, value)
+
+        elif name == "server_max_window_bits":
+            if server_max_window_bits is not None:
+                raise DuplicateParameter(name)
+            if value in _MAX_WINDOW_BITS_VALUES:
+                server_max_window_bits = int(value)
+            else:
+                raise InvalidParameterValue(name, value)
+
+        elif name == "client_max_window_bits":
+            if client_max_window_bits is not None:
+                raise DuplicateParameter(name)
+            if is_server and value is None:  # only in handshake requests
+                client_max_window_bits = True
+            elif value in _MAX_WINDOW_BITS_VALUES:
+                client_max_window_bits = int(value)
+            else:
+                raise InvalidParameterValue(name, value)
+
+        else:
+            raise InvalidParameterName(name)
+
+    return (
+        server_no_context_takeover,
+        client_no_context_takeover,
+        server_max_window_bits,
+        client_max_window_bits,
+    )
+
+
+class ClientPerMessageDeflateFactory(ClientExtensionFactory):
+    """
+    Client-side extension factory for the Per-Message Deflate extension.
+
+    Parameters behave as described in `section 7.1 of RFC 7692`_. Set them to
+    ``True`` to include them in the negotiation offer without a value or to an
+    integer value to include them with this value.
+
+    .. _section 7.1 of RFC 7692: https://tools.ietf.org/html/rfc7692#section-7.1
+
+    :param server_no_context_takeover: defaults to ``False``
+    :param client_no_context_takeover: defaults to ``False``
+    :param server_max_window_bits: optional, defaults to ``None``
+    :param client_max_window_bits: optional, defaults to ``None``
+    :param compress_settings: optional, keyword arguments for
+        :func:`zlib.compressobj`, excluding ``wbits``
+
+    """
+
+    name = ExtensionName("permessage-deflate")
+
+    def __init__(
+        self,
+        server_no_context_takeover: bool = False,
+        client_no_context_takeover: bool = False,
+        server_max_window_bits: Optional[int] = None,
+        client_max_window_bits: Optional[Union[int, bool]] = None,
+        compress_settings: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        Configure the Per-Message Deflate extension factory.
+
+        """
+        if not (server_max_window_bits is None or 8 <= server_max_window_bits <= 15):
+            raise ValueError("server_max_window_bits must be between 8 and 15")
+        if not (
+            client_max_window_bits is None
+            or client_max_window_bits is True
+            or 8 <= client_max_window_bits <= 15
+        ):
+            raise ValueError("client_max_window_bits must be between 8 and 15")
+        if compress_settings is not None and "wbits" in compress_settings:
+            raise ValueError(
+                "compress_settings must not include wbits, "
+                "set client_max_window_bits instead"
+            )
+
+        self.server_no_context_takeover = server_no_context_takeover
+        self.client_no_context_takeover = client_no_context_takeover
+        self.server_max_window_bits = server_max_window_bits
+        self.client_max_window_bits = client_max_window_bits
+        self.compress_settings = compress_settings
+
+    def get_request_params(self) -> List[ExtensionParameter]:
+        """
+        Build request parameters.
+
+        """
+        return _build_parameters(
+            self.server_no_context_takeover,
+            self.client_no_context_takeover,
+            self.server_max_window_bits,
+            self.client_max_window_bits,
+        )
+
+    def process_response_params(
+        self,
+        params: Sequence[ExtensionParameter],
+        accepted_extensions: Sequence["Extension"],
+    ) -> PerMessageDeflate:
+        """
+        Process response parameters.
+
+        Return an extension instance.
+
+        """
+        if any(other.name == self.name for other in accepted_extensions):
+            raise NegotiationError(f"received duplicate {self.name}")
+
+        # Request parameters are available in instance variables.
+
+        # Load response parameters in local variables.
+        (
+            server_no_context_takeover,
+            client_no_context_takeover,
+            server_max_window_bits,
+            client_max_window_bits,
+        ) = _extract_parameters(params, is_server=False)
+
+        # After comparing the request and the response, the final
+        # configuration must be available in the local variables.
+
+        # server_no_context_takeover
+        #
+        #   Req.    Resp.   Result
+        #   ------  ------  --------------------------------------------------
+        #   False   False   False
+        #   False   True    True
+        #   True    False   Error!
+        #   True    True    True
+
+        if self.server_no_context_takeover:
+            if not server_no_context_takeover:
+                raise NegotiationError("expected server_no_context_takeover")
+
+        # client_no_context_takeover
+        #
+        #   Req.    Resp.   Result
+        #   ------  ------  --------------------------------------------------
+        #   False   False   False
+        #   False   True    True
+        #   True    False   True - must change value
+        #   True    True    True
+
+        if self.client_no_context_takeover:
+            if not client_no_context_takeover:
+                client_no_context_takeover = True
+
+        # server_max_window_bits
+
+        #   Req.    Resp.   Result
+        #   ------  ------  --------------------------------------------------
+        #   None    None    None
+        #   None    8≤M≤15  M
+        #   8≤N≤15  None    Error!
+        #   8≤N≤15  8≤M≤N   M
+        #   8≤N≤15  N<M≤15  Error!
+
+        if self.server_max_window_bits is None:
+            pass
+
+        else:
+            if server_max_window_bits is None:
+                raise NegotiationError("expected server_max_window_bits")
+            elif server_max_window_bits > self.server_max_window_bits:
+                raise NegotiationError("unsupported server_max_window_bits")
+
+        # client_max_window_bits
+
+        #   Req.    Resp.   Result
+        #   ------  ------  --------------------------------------------------
+        #   None    None    None
+        #   None    8≤M≤15  Error!
+        #   True    None    None
+        #   True    8≤M≤15  M
+        #   8≤N≤15  None    N - must change value
+        #   8≤N≤15  8≤M≤N   M
+        #   8≤N≤15  N<M≤15  Error!
+
+        if self.client_max_window_bits is None:
+            if client_max_window_bits is not None:
+                raise NegotiationError("unexpected client_max_window_bits")
+
+        elif self.client_max_window_bits is True:
+            pass
+
+        else:
+            if client_max_window_bits is None:
+                client_max_window_bits = self.client_max_window_bits
+            elif client_max_window_bits > self.client_max_window_bits:
+                raise NegotiationError("unsupported client_max_window_bits")
+
+        return PerMessageDeflate(
+            server_no_context_takeover,  # remote_no_context_takeover
+            client_no_context_takeover,  # local_no_context_takeover
+            server_max_window_bits or 15,  # remote_max_window_bits
+            client_max_window_bits or 15,  # local_max_window_bits
+            self.compress_settings,
+        )
+
+
+class ServerPerMessageDeflateFactory(ServerExtensionFactory):
+    """
+    Server-side extension factory for the Per-Message Deflate extension.
+
+    Parameters behave as described in `section 7.1 of RFC 7692`_. Set them to
+    ``True`` to include them in the negotiation offer without a value or to an
+    integer value to include them with this value.
+
+    .. _section 7.1 of RFC 7692: https://tools.ietf.org/html/rfc7692#section-7.1
+
+    :param server_no_context_takeover: defaults to ``False``
+    :param client_no_context_takeover: defaults to ``False``
+    :param server_max_window_bits: optional, defaults to ``None``
+    :param client_max_window_bits: optional, defaults to ``None``
+    :param compress_settings: optional, keyword arguments for
+        :func:`zlib.compressobj`, excluding ``wbits``
+
+    """
+
+    name = ExtensionName("permessage-deflate")
+
+    def __init__(
+        self,
+        server_no_context_takeover: bool = False,
+        client_no_context_takeover: bool = False,
+        server_max_window_bits: Optional[int] = None,
+        client_max_window_bits: Optional[int] = None,
+        compress_settings: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        Configure the Per-Message Deflate extension factory.
+
+        """
+        if not (server_max_window_bits is None or 8 <= server_max_window_bits <= 15):
+            raise ValueError("server_max_window_bits must be between 8 and 15")
+        if not (client_max_window_bits is None or 8 <= client_max_window_bits <= 15):
+            raise ValueError("client_max_window_bits must be between 8 and 15")
+        if compress_settings is not None and "wbits" in compress_settings:
+            raise ValueError(
+                "compress_settings must not include wbits, "
+                "set server_max_window_bits instead"
+            )
+
+        self.server_no_context_takeover = server_no_context_takeover
+        self.client_no_context_takeover = client_no_context_takeover
+        self.server_max_window_bits = server_max_window_bits
+        self.client_max_window_bits = client_max_window_bits
+        self.compress_settings = compress_settings
+
+    def process_request_params(
+        self,
+        params: Sequence[ExtensionParameter],
+        accepted_extensions: Sequence["Extension"],
+    ) -> Tuple[List[ExtensionParameter], PerMessageDeflate]:
+        """
+        Process request parameters.
+
+        Return response params and an extension instance.
+
+        """
+        if any(other.name == self.name for other in accepted_extensions):
+            raise NegotiationError(f"skipped duplicate {self.name}")
+
+        # Load request parameters in local variables.
+        (
+            server_no_context_takeover,
+            client_no_context_takeover,
+            server_max_window_bits,
+            client_max_window_bits,
+        ) = _extract_parameters(params, is_server=True)
+
+        # Configuration parameters are available in instance variables.
+
+        # After comparing the request and the configuration, the response must
+        # be available in the local variables.
+
+        # server_no_context_takeover
+        #
+        #   Config  Req.    Resp.
+        #   ------  ------  --------------------------------------------------
+        #   False   False   False
+        #   False   True    True
+        #   True    False   True - must change value to True
+        #   True    True    True
+
+        if self.server_no_context_takeover:
+            if not server_no_context_takeover:
+                server_no_context_takeover = True
+
+        # client_no_context_takeover
+        #
+        #   Config  Req.    Resp.
+        #   ------  ------  --------------------------------------------------
+        #   False   False   False
+        #   False   True    True (or False)
+        #   True    False   True - must change value to True
+        #   True    True    True (or False)
+
+        if self.client_no_context_takeover:
+            if not client_no_context_takeover:
+                client_no_context_takeover = True
+
+        # server_max_window_bits
+
+        #   Config  Req.    Resp.
+        #   ------  ------  --------------------------------------------------
+        #   None    None    None
+        #   None    8≤M≤15  M
+        #   8≤N≤15  None    N - must change value
+        #   8≤N≤15  8≤M≤N   M
+        #   8≤N≤15  N<M≤15  N - must change value
+
+        if self.server_max_window_bits is None:
+            pass
+
+        else:
+            if server_max_window_bits is None:
+                server_max_window_bits = self.server_max_window_bits
+            elif server_max_window_bits > self.server_max_window_bits:
+                server_max_window_bits = self.server_max_window_bits
+
+        # client_max_window_bits
+
+        #   Config  Req.    Resp.
+        #   ------  ------  --------------------------------------------------
+        #   None    None    None
+        #   None    True    None - must change value
+        #   None    8≤M≤15  M (or None)
+        #   8≤N≤15  None    Error!
+        #   8≤N≤15  True    N - must change value
+        #   8≤N≤15  8≤M≤N   M (or None)
+        #   8≤N≤15  N<M≤15  N
+
+        if self.client_max_window_bits is None:
+            if client_max_window_bits is True:
+                client_max_window_bits = self.client_max_window_bits
+
+        else:
+            if client_max_window_bits is None:
+                raise NegotiationError("required client_max_window_bits")
+            elif client_max_window_bits is True:
+                client_max_window_bits = self.client_max_window_bits
+            elif self.client_max_window_bits < client_max_window_bits:
+                client_max_window_bits = self.client_max_window_bits
+
+        return (
+            _build_parameters(
+                server_no_context_takeover,
+                client_no_context_takeover,
+                server_max_window_bits,
+                client_max_window_bits,
+            ),
+            PerMessageDeflate(
+                client_no_context_takeover,  # remote_no_context_takeover
+                server_no_context_takeover,  # local_no_context_takeover
+                client_max_window_bits or 15,  # remote_max_window_bits
+                server_max_window_bits or 15,  # local_max_window_bits
+                self.compress_settings,
+            ),
+        )

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/framing.py

@@ -0,0 +1,342 @@
+"""
+:mod:`websockets.framing` reads and writes WebSocket frames.
+
+It deals with a single frame at a time. Anything that depends on the sequence
+of frames is implemented in :mod:`websockets.protocol`.
+
+See `section 5 of RFC 6455`_.
+
+.. _section 5 of RFC 6455: http://tools.ietf.org/html/rfc6455#section-5
+
+"""
+
+import io
+import random
+import struct
+from typing import Any, Awaitable, Callable, NamedTuple, Optional, Sequence, Tuple
+
+from .exceptions import PayloadTooBig, ProtocolError
+from .typing import Data
+
+
+try:
+    from .speedups import apply_mask
+except ImportError:  # pragma: no cover
+    from .utils import apply_mask
+
+
+__all__ = [
+    "DATA_OPCODES",
+    "CTRL_OPCODES",
+    "OP_CONT",
+    "OP_TEXT",
+    "OP_BINARY",
+    "OP_CLOSE",
+    "OP_PING",
+    "OP_PONG",
+    "Frame",
+    "prepare_data",
+    "encode_data",
+    "parse_close",
+    "serialize_close",
+]
+
+DATA_OPCODES = OP_CONT, OP_TEXT, OP_BINARY = 0x00, 0x01, 0x02
+CTRL_OPCODES = OP_CLOSE, OP_PING, OP_PONG = 0x08, 0x09, 0x0A
+
+# Close code that are allowed in a close frame.
+# Using a list optimizes `code in EXTERNAL_CLOSE_CODES`.
+EXTERNAL_CLOSE_CODES = [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011]
+
+
+# Consider converting to a dataclass when dropping support for Python < 3.7.
+
+
+class Frame(NamedTuple):
+    """
+    WebSocket frame.
+
+    :param bool fin: FIN bit
+    :param bool rsv1: RSV1 bit
+    :param bool rsv2: RSV2 bit
+    :param bool rsv3: RSV3 bit
+    :param int opcode: opcode
+    :param bytes data: payload data
+
+    Only these fields are needed. The MASK bit, payload length and masking-key
+    are handled on the fly by :meth:`read` and :meth:`write`.
+
+    """
+
+    fin: bool
+    opcode: int
+    data: bytes
+    rsv1: bool = False
+    rsv2: bool = False
+    rsv3: bool = False
+
+    @classmethod
+    async def read(
+        cls,
+        reader: Callable[[int], Awaitable[bytes]],
+        *,
+        mask: bool,
+        max_size: Optional[int] = None,
+        extensions: Optional[Sequence["websockets.extensions.base.Extension"]] = None,
+    ) -> "Frame":
+        """
+        Read a WebSocket frame.
+
+        :param reader: coroutine that reads exactly the requested number of
+            bytes, unless the end of file is reached
+        :param mask: whether the frame should be masked i.e. whether the read
+            happens on the server side
+        :param max_size: maximum payload size in bytes
+        :param extensions: list of classes with a ``decode()`` method that
+            transforms the frame and return a new frame; extensions are applied
+            in reverse order
+        :raises ~websockets.exceptions.PayloadTooBig: if the frame exceeds
+            ``max_size``
+        :raises ~websockets.exceptions.ProtocolError: if the frame
+            contains incorrect values
+
+        """
+        # Read the header.
+        data = await reader(2)
+        head1, head2 = struct.unpack("!BB", data)
+
+        # While not Pythonic, this is marginally faster than calling bool().
+        fin = True if head1 & 0b10000000 else False
+        rsv1 = True if head1 & 0b01000000 else False
+        rsv2 = True if head1 & 0b00100000 else False
+        rsv3 = True if head1 & 0b00010000 else False
+        opcode = head1 & 0b00001111
+
+        if (True if head2 & 0b10000000 else False) != mask:
+            raise ProtocolError("incorrect masking")
+
+        length = head2 & 0b01111111
+        if length == 126:
+            data = await reader(2)
+            (length,) = struct.unpack("!H", data)
+        elif length == 127:
+            data = await reader(8)
+            (length,) = struct.unpack("!Q", data)
+        if max_size is not None and length > max_size:
+            raise PayloadTooBig(
+                f"payload length exceeds size limit ({length} > {max_size} bytes)"
+            )
+        if mask:
+            mask_bits = await reader(4)
+
+        # Read the data.
+        data = await reader(length)
+        if mask:
+            data = apply_mask(data, mask_bits)
+
+        frame = cls(fin, opcode, data, rsv1, rsv2, rsv3)
+
+        if extensions is None:
+            extensions = []
+        for extension in reversed(extensions):
+            frame = extension.decode(frame, max_size=max_size)
+
+        frame.check()
+
+        return frame
+
+    def write(
+        frame,
+        write: Callable[[bytes], Any],
+        *,
+        mask: bool,
+        extensions: Optional[Sequence["websockets.extensions.base.Extension"]] = None,
+    ) -> None:
+        """
+        Write a WebSocket frame.
+
+        :param frame: frame to write
+        :param write: function that writes bytes
+        :param mask: whether the frame should be masked i.e. whether the write
+            happens on the client side
+        :param extensions: list of classes with an ``encode()`` method that
+            transform the frame and return a new frame; extensions are applied
+            in order
+        :raises ~websockets.exceptions.ProtocolError: if the frame
+            contains incorrect values
+
+        """
+        # The first parameter is called `frame` rather than `self`,
+        # but it's the instance of class to which this method is bound.
+
+        frame.check()
+
+        if extensions is None:
+            extensions = []
+        for extension in extensions:
+            frame = extension.encode(frame)
+
+        output = io.BytesIO()
+
+        # Prepare the header.
+        head1 = (
+            (0b10000000 if frame.fin else 0)
+            | (0b01000000 if frame.rsv1 else 0)
+            | (0b00100000 if frame.rsv2 else 0)
+            | (0b00010000 if frame.rsv3 else 0)
+            | frame.opcode
+        )
+
+        head2 = 0b10000000 if mask else 0
+
+        length = len(frame.data)
+        if length < 126:
+            output.write(struct.pack("!BB", head1, head2 | length))
+        elif length < 65536:
+            output.write(struct.pack("!BBH", head1, head2 | 126, length))
+        else:
+            output.write(struct.pack("!BBQ", head1, head2 | 127, length))
+
+        if mask:
+            mask_bits = struct.pack("!I", random.getrandbits(32))
+            output.write(mask_bits)
+
+        # Prepare the data.
+        if mask:
+            data = apply_mask(frame.data, mask_bits)
+        else:
+            data = frame.data
+        output.write(data)
+
+        # Send the frame.
+
+        # The frame is written in a single call to write in order to prevent
+        # TCP fragmentation. See #68 for details. This also makes it safe to
+        # send frames concurrently from multiple coroutines.
+        write(output.getvalue())
+
+    def check(frame) -> None:
+        """
+        Check that reserved bits and opcode have acceptable values.
+
+        :raises ~websockets.exceptions.ProtocolError: if a reserved
+            bit or the opcode is invalid
+
+        """
+        # The first parameter is called `frame` rather than `self`,
+        # but it's the instance of class to which this method is bound.
+
+        if frame.rsv1 or frame.rsv2 or frame.rsv3:
+            raise ProtocolError("reserved bits must be 0")
+
+        if frame.opcode in DATA_OPCODES:
+            return
+        elif frame.opcode in CTRL_OPCODES:
+            if len(frame.data) > 125:
+                raise ProtocolError("control frame too long")
+            if not frame.fin:
+                raise ProtocolError("fragmented control frame")
+        else:
+            raise ProtocolError(f"invalid opcode: {frame.opcode}")
+
+
+def prepare_data(data: Data) -> Tuple[int, bytes]:
+    """
+    Convert a string or byte-like object to an opcode and a bytes-like object.
+
+    This function is designed for data frames.
+
+    If ``data`` is a :class:`str`, return ``OP_TEXT`` and a :class:`bytes`
+    object encoding ``data`` in UTF-8.
+
+    If ``data`` is a bytes-like object, return ``OP_BINARY`` and a bytes-like
+    object.
+
+    :raises TypeError: if ``data`` doesn't have a supported type
+
+    """
+    if isinstance(data, str):
+        return OP_TEXT, data.encode("utf-8")
+    elif isinstance(data, (bytes, bytearray)):
+        return OP_BINARY, data
+    elif isinstance(data, memoryview):
+        if data.c_contiguous:
+            return OP_BINARY, data
+        else:
+            return OP_BINARY, data.tobytes()
+    else:
+        raise TypeError("data must be bytes-like or str")
+
+
+def encode_data(data: Data) -> bytes:
+    """
+    Convert a string or byte-like object to bytes.
+
+    This function is designed for ping and pong frames.
+
+    If ``data`` is a :class:`str`, return a :class:`bytes` object encoding
+    ``data`` in UTF-8.
+
+    If ``data`` is a bytes-like object, return a :class:`bytes` object.
+
+    :raises TypeError: if ``data`` doesn't have a supported type
+
+    """
+    if isinstance(data, str):
+        return data.encode("utf-8")
+    elif isinstance(data, (bytes, bytearray)):
+        return bytes(data)
+    elif isinstance(data, memoryview):
+        return data.tobytes()
+    else:
+        raise TypeError("data must be bytes-like or str")
+
+
+def parse_close(data: bytes) -> Tuple[int, str]:
+    """
+    Parse the payload from a close frame.
+
+    Return ``(code, reason)``.
+
+    :raises ~websockets.exceptions.ProtocolError: if data is ill-formed
+    :raises UnicodeDecodeError: if the reason isn't valid UTF-8
+
+    """
+    length = len(data)
+    if length >= 2:
+        (code,) = struct.unpack("!H", data[:2])
+        check_close(code)
+        reason = data[2:].decode("utf-8")
+        return code, reason
+    elif length == 0:
+        return 1005, ""
+    else:
+        assert length == 1
+        raise ProtocolError("close frame too short")
+
+
+def serialize_close(code: int, reason: str) -> bytes:
+    """
+    Serialize the payload for a close frame.
+
+    This is the reverse of :func:`parse_close`.
+
+    """
+    check_close(code)
+    return struct.pack("!H", code) + reason.encode("utf-8")
+
+
+def check_close(code: int) -> None:
+    """
+    Check that the close code has an acceptable value for a close frame.
+
+    :raises ~websockets.exceptions.ProtocolError: if the close code
+        is invalid
+
+    """
+    if not (code in EXTERNAL_CLOSE_CODES or 3000 <= code < 5000):
+        raise ProtocolError("invalid status code")
+
+
+# at the bottom to allow circular import, because Extension depends on Frame
+import websockets.extensions.base  # isort:skip # noqa

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/handshake.py

@@ -0,0 +1,185 @@
+"""
+:mod:`websockets.handshake` provides helpers for the WebSocket handshake.
+
+See `section 4 of RFC 6455`_.
+
+.. _section 4 of RFC 6455: http://tools.ietf.org/html/rfc6455#section-4
+
+Some checks cannot be performed because they depend too much on the
+context; instead, they're documented below.
+
+To accept a connection, a server must:
+
+- Read the request, check that the method is GET, and check the headers with
+  :func:`check_request`,
+- Send a 101 response to the client with the headers created by
+  :func:`build_response` if the request is valid; otherwise, send an
+  appropriate HTTP error code.
+
+To open a connection, a client must:
+
+- Send a GET request to the server with the headers created by
+  :func:`build_request`,
+- Read the response, check that the status code is 101, and check the headers
+  with :func:`check_response`.
+
+"""
+
+import base64
+import binascii
+import hashlib
+import random
+from typing import List
+
+from .exceptions import InvalidHeader, InvalidHeaderValue, InvalidUpgrade
+from .headers import ConnectionOption, UpgradeProtocol, parse_connection, parse_upgrade
+from .http import Headers, MultipleValuesError
+
+
+__all__ = ["build_request", "check_request", "build_response", "check_response"]
+
+GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+
+def build_request(headers: Headers) -> str:
+    """
+    Build a handshake request to send to the server.
+
+    Update request headers passed in argument.
+
+    :param headers: request headers
+    :returns: ``key`` which must be passed to :func:`check_response`
+
+    """
+    raw_key = bytes(random.getrandbits(8) for _ in range(16))
+    key = base64.b64encode(raw_key).decode()
+    headers["Upgrade"] = "websocket"
+    headers["Connection"] = "Upgrade"
+    headers["Sec-WebSocket-Key"] = key
+    headers["Sec-WebSocket-Version"] = "13"
+    return key
+
+
+def check_request(headers: Headers) -> str:
+    """
+    Check a handshake request received from the client.
+
+    This function doesn't verify that the request is an HTTP/1.1 or higher GET
+    request and doesn't perform ``Host`` and ``Origin`` checks. These controls
+    are usually performed earlier in the HTTP request handling code. They're
+    the responsibility of the caller.
+
+    :param headers: request headers
+    :returns: ``key`` which must be passed to :func:`build_response`
+    :raises ~websockets.exceptions.InvalidHandshake: if the handshake request
+        is invalid; then the server must return 400 Bad Request error
+
+    """
+    connection: List[ConnectionOption] = sum(
+        [parse_connection(value) for value in headers.get_all("Connection")], []
+    )
+
+    if not any(value.lower() == "upgrade" for value in connection):
+        raise InvalidUpgrade("Connection", ", ".join(connection))
+
+    upgrade: List[UpgradeProtocol] = sum(
+        [parse_upgrade(value) for value in headers.get_all("Upgrade")], []
+    )
+
+    # For compatibility with non-strict implementations, ignore case when
+    # checking the Upgrade header. It's supposed to be 'WebSocket'.
+    if not (len(upgrade) == 1 and upgrade[0].lower() == "websocket"):
+        raise InvalidUpgrade("Upgrade", ", ".join(upgrade))
+
+    try:
+        s_w_key = headers["Sec-WebSocket-Key"]
+    except KeyError:
+        raise InvalidHeader("Sec-WebSocket-Key")
+    except MultipleValuesError:
+        raise InvalidHeader(
+            "Sec-WebSocket-Key", "more than one Sec-WebSocket-Key header found"
+        )
+
+    try:
+        raw_key = base64.b64decode(s_w_key.encode(), validate=True)
+    except binascii.Error:
+        raise InvalidHeaderValue("Sec-WebSocket-Key", s_w_key)
+    if len(raw_key) != 16:
+        raise InvalidHeaderValue("Sec-WebSocket-Key", s_w_key)
+
+    try:
+        s_w_version = headers["Sec-WebSocket-Version"]
+    except KeyError:
+        raise InvalidHeader("Sec-WebSocket-Version")
+    except MultipleValuesError:
+        raise InvalidHeader(
+            "Sec-WebSocket-Version", "more than one Sec-WebSocket-Version header found"
+        )
+
+    if s_w_version != "13":
+        raise InvalidHeaderValue("Sec-WebSocket-Version", s_w_version)
+
+    return s_w_key
+
+
+def build_response(headers: Headers, key: str) -> None:
+    """
+    Build a handshake response to send to the client.
+
+    Update response headers passed in argument.
+
+    :param headers: response headers
+    :param key: comes from :func:`check_request`
+
+    """
+    headers["Upgrade"] = "websocket"
+    headers["Connection"] = "Upgrade"
+    headers["Sec-WebSocket-Accept"] = accept(key)
+
+
+def check_response(headers: Headers, key: str) -> None:
+    """
+    Check a handshake response received from the server.
+
+    This function doesn't verify that the response is an HTTP/1.1 or higher
+    response with a 101 status code. These controls are the responsibility of
+    the caller.
+
+    :param headers: response headers
+    :param key: comes from :func:`build_request`
+    :raises ~websockets.exceptions.InvalidHandshake: if the handshake response
+        is invalid
+
+    """
+    connection: List[ConnectionOption] = sum(
+        [parse_connection(value) for value in headers.get_all("Connection")], []
+    )
+
+    if not any(value.lower() == "upgrade" for value in connection):
+        raise InvalidUpgrade("Connection", " ".join(connection))
+
+    upgrade: List[UpgradeProtocol] = sum(
+        [parse_upgrade(value) for value in headers.get_all("Upgrade")], []
+    )
+
+    # For compatibility with non-strict implementations, ignore case when
+    # checking the Upgrade header. It's supposed to be 'WebSocket'.
+    if not (len(upgrade) == 1 and upgrade[0].lower() == "websocket"):
+        raise InvalidUpgrade("Upgrade", ", ".join(upgrade))
+
+    try:
+        s_w_accept = headers["Sec-WebSocket-Accept"]
+    except KeyError:
+        raise InvalidHeader("Sec-WebSocket-Accept")
+    except MultipleValuesError:
+        raise InvalidHeader(
+            "Sec-WebSocket-Accept", "more than one Sec-WebSocket-Accept header found"
+        )
+
+    if s_w_accept != accept(key):
+        raise InvalidHeaderValue("Sec-WebSocket-Accept", s_w_accept)
+
+
+def accept(key: str) -> str:
+    sha1 = hashlib.sha1((key + GUID).encode()).digest()
+    return base64.b64encode(sha1).decode()

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/headers.py

@@ -0,0 +1,515 @@
+"""
+:mod:`websockets.headers` provides parsers and serializers for HTTP headers
+used in WebSocket handshake messages.
+
+These APIs cannot be imported from :mod:`websockets`. They must be imported
+from :mod:`websockets.headers`.
+
+"""
+
+import base64
+import binascii
+import re
+from typing import Callable, List, NewType, Optional, Sequence, Tuple, TypeVar, cast
+
+from .exceptions import InvalidHeaderFormat, InvalidHeaderValue
+from .typing import ExtensionHeader, ExtensionName, ExtensionParameter, Subprotocol
+
+
+__all__ = [
+    "parse_connection",
+    "parse_upgrade",
+    "parse_extension",
+    "build_extension",
+    "parse_subprotocol",
+    "build_subprotocol",
+    "build_www_authenticate_basic",
+    "parse_authorization_basic",
+    "build_authorization_basic",
+]
+
+
+T = TypeVar("T")
+
+ConnectionOption = NewType("ConnectionOption", str)
+UpgradeProtocol = NewType("UpgradeProtocol", str)
+
+
+# To avoid a dependency on a parsing library, we implement manually the ABNF
+# described in https://tools.ietf.org/html/rfc6455#section-9.1 with the
+# definitions from https://tools.ietf.org/html/rfc7230#appendix-B.
+
+
+def peek_ahead(header: str, pos: int) -> Optional[str]:
+    """
+    Return the next character from ``header`` at the given position.
+
+    Return ``None`` at the end of ``header``.
+
+    We never need to peek more than one character ahead.
+
+    """
+    return None if pos == len(header) else header[pos]
+
+
+_OWS_re = re.compile(r"[\t ]*")
+
+
+def parse_OWS(header: str, pos: int) -> int:
+    """
+    Parse optional whitespace from ``header`` at the given position.
+
+    Return the new position.
+
+    The whitespace itself isn't returned because it isn't significant.
+
+    """
+    # There's always a match, possibly empty, whose content doesn't matter.
+    match = _OWS_re.match(header, pos)
+    assert match is not None
+    return match.end()
+
+
+_token_re = re.compile(r"[-!#$%&\'*+.^_`|~0-9a-zA-Z]+")
+
+
+def parse_token(header: str, pos: int, header_name: str) -> Tuple[str, int]:
+    """
+    Parse a token from ``header`` at the given position.
+
+    Return the token value and the new position.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    match = _token_re.match(header, pos)
+    if match is None:
+        raise InvalidHeaderFormat(header_name, "expected token", header, pos)
+    return match.group(), match.end()
+
+
+_quoted_string_re = re.compile(
+    r'"(?:[\x09\x20-\x21\x23-\x5b\x5d-\x7e]|\\[\x09\x20-\x7e\x80-\xff])*"'
+)
+
+
+_unquote_re = re.compile(r"\\([\x09\x20-\x7e\x80-\xff])")
+
+
+def parse_quoted_string(header: str, pos: int, header_name: str) -> Tuple[str, int]:
+    """
+    Parse a quoted string from ``header`` at the given position.
+
+    Return the unquoted value and the new position.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    match = _quoted_string_re.match(header, pos)
+    if match is None:
+        raise InvalidHeaderFormat(header_name, "expected quoted string", header, pos)
+    return _unquote_re.sub(r"\1", match.group()[1:-1]), match.end()
+
+
+_quotable_re = re.compile(r"[\x09\x20-\x7e\x80-\xff]*")
+
+
+_quote_re = re.compile(r"([\x22\x5c])")
+
+
+def build_quoted_string(value: str) -> str:
+    """
+    Format ``value`` as a quoted string.
+
+    This is the reverse of :func:`parse_quoted_string`.
+
+    """
+    match = _quotable_re.fullmatch(value)
+    if match is None:
+        raise ValueError("invalid characters for quoted-string encoding")
+    return '"' + _quote_re.sub(r"\\\1", value) + '"'
+
+
+def parse_list(
+    parse_item: Callable[[str, int, str], Tuple[T, int]],
+    header: str,
+    pos: int,
+    header_name: str,
+) -> List[T]:
+    """
+    Parse a comma-separated list from ``header`` at the given position.
+
+    This is appropriate for parsing values with the following grammar:
+
+        1#item
+
+    ``parse_item`` parses one item.
+
+    ``header`` is assumed not to start or end with whitespace.
+
+    (This function is designed for parsing an entire header value and
+    :func:`~websockets.http.read_headers` strips whitespace from values.)
+
+    Return a list of items.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    # Per https://tools.ietf.org/html/rfc7230#section-7, "a recipient MUST
+    # parse and ignore a reasonable number of empty list elements"; hence
+    # while loops that remove extra delimiters.
+
+    # Remove extra delimiters before the first item.
+    while peek_ahead(header, pos) == ",":
+        pos = parse_OWS(header, pos + 1)
+
+    items = []
+    while True:
+        # Loop invariant: a item starts at pos in header.
+        item, pos = parse_item(header, pos, header_name)
+        items.append(item)
+        pos = parse_OWS(header, pos)
+
+        # We may have reached the end of the header.
+        if pos == len(header):
+            break
+
+        # There must be a delimiter after each element except the last one.
+        if peek_ahead(header, pos) == ",":
+            pos = parse_OWS(header, pos + 1)
+        else:
+            raise InvalidHeaderFormat(header_name, "expected comma", header, pos)
+
+        # Remove extra delimiters before the next item.
+        while peek_ahead(header, pos) == ",":
+            pos = parse_OWS(header, pos + 1)
+
+        # We may have reached the end of the header.
+        if pos == len(header):
+            break
+
+    # Since we only advance in the header by one character with peek_ahead()
+    # or with the end position of a regex match, we can't overshoot the end.
+    assert pos == len(header)
+
+    return items
+
+
+def parse_connection_option(
+    header: str, pos: int, header_name: str
+) -> Tuple[ConnectionOption, int]:
+    """
+    Parse a Connection option from ``header`` at the given position.
+
+    Return the protocol value and the new position.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    item, pos = parse_token(header, pos, header_name)
+    return cast(ConnectionOption, item), pos
+
+
+def parse_connection(header: str) -> List[ConnectionOption]:
+    """
+    Parse a ``Connection`` header.
+
+    Return a list of HTTP connection options.
+
+    :param header: value of the ``Connection`` header
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    return parse_list(parse_connection_option, header, 0, "Connection")
+
+
+_protocol_re = re.compile(
+    r"[-!#$%&\'*+.^_`|~0-9a-zA-Z]+(?:/[-!#$%&\'*+.^_`|~0-9a-zA-Z]+)?"
+)
+
+
+def parse_upgrade_protocol(
+    header: str, pos: int, header_name: str
+) -> Tuple[UpgradeProtocol, int]:
+    """
+    Parse an Upgrade protocol from ``header`` at the given position.
+
+    Return the protocol value and the new position.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    match = _protocol_re.match(header, pos)
+    if match is None:
+        raise InvalidHeaderFormat(header_name, "expected protocol", header, pos)
+    return cast(UpgradeProtocol, match.group()), match.end()
+
+
+def parse_upgrade(header: str) -> List[UpgradeProtocol]:
+    """
+    Parse an ``Upgrade`` header.
+
+    Return a list of HTTP protocols.
+
+    :param header: value of the ``Upgrade`` header
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    return parse_list(parse_upgrade_protocol, header, 0, "Upgrade")
+
+
+def parse_extension_item_param(
+    header: str, pos: int, header_name: str
+) -> Tuple[ExtensionParameter, int]:
+    """
+    Parse a single extension parameter from ``header`` at the given position.
+
+    Return a ``(name, value)`` pair and the new position.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    # Extract parameter name.
+    name, pos = parse_token(header, pos, header_name)
+    pos = parse_OWS(header, pos)
+    # Extract parameter value, if there is one.
+    value: Optional[str] = None
+    if peek_ahead(header, pos) == "=":
+        pos = parse_OWS(header, pos + 1)
+        if peek_ahead(header, pos) == '"':
+            pos_before = pos  # for proper error reporting below
+            value, pos = parse_quoted_string(header, pos, header_name)
+            # https://tools.ietf.org/html/rfc6455#section-9.1 says: the value
+            # after quoted-string unescaping MUST conform to the 'token' ABNF.
+            if _token_re.fullmatch(value) is None:
+                raise InvalidHeaderFormat(
+                    header_name, "invalid quoted header content", header, pos_before
+                )
+        else:
+            value, pos = parse_token(header, pos, header_name)
+        pos = parse_OWS(header, pos)
+
+    return (name, value), pos
+
+
+def parse_extension_item(
+    header: str, pos: int, header_name: str
+) -> Tuple[ExtensionHeader, int]:
+    """
+    Parse an extension definition from ``header`` at the given position.
+
+    Return an ``(extension name, parameters)`` pair, where ``parameters`` is a
+    list of ``(name, value)`` pairs, and the new position.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    # Extract extension name.
+    name, pos = parse_token(header, pos, header_name)
+    pos = parse_OWS(header, pos)
+    # Extract all parameters.
+    parameters = []
+    while peek_ahead(header, pos) == ";":
+        pos = parse_OWS(header, pos + 1)
+        parameter, pos = parse_extension_item_param(header, pos, header_name)
+        parameters.append(parameter)
+    return (cast(ExtensionName, name), parameters), pos
+
+
+def parse_extension(header: str) -> List[ExtensionHeader]:
+    """
+    Parse a ``Sec-WebSocket-Extensions`` header.
+
+    Return a list of WebSocket extensions and their parameters in this format::
+
+        [
+            (
+                'extension name',
+                [
+                    ('parameter name', 'parameter value'),
+                    ....
+                ]
+            ),
+            ...
+        ]
+
+    Parameter values are ``None`` when no value is provided.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    return parse_list(parse_extension_item, header, 0, "Sec-WebSocket-Extensions")
+
+
+parse_extension_list = parse_extension  # alias for backwards compatibility
+
+
+def build_extension_item(
+    name: ExtensionName, parameters: List[ExtensionParameter]
+) -> str:
+    """
+    Build an extension definition.
+
+    This is the reverse of :func:`parse_extension_item`.
+
+    """
+    return "; ".join(
+        [cast(str, name)]
+        + [
+            # Quoted strings aren't necessary because values are always tokens.
+            name if value is None else f"{name}={value}"
+            for name, value in parameters
+        ]
+    )
+
+
+def build_extension(extensions: Sequence[ExtensionHeader]) -> str:
+    """
+    Build a ``Sec-WebSocket-Extensions`` header.
+
+    This is the reverse of :func:`parse_extension`.
+
+    """
+    return ", ".join(
+        build_extension_item(name, parameters) for name, parameters in extensions
+    )
+
+
+build_extension_list = build_extension  # alias for backwards compatibility
+
+
+def parse_subprotocol_item(
+    header: str, pos: int, header_name: str
+) -> Tuple[Subprotocol, int]:
+    """
+    Parse a subprotocol from ``header`` at the given position.
+
+    Return the subprotocol value and the new position.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    item, pos = parse_token(header, pos, header_name)
+    return cast(Subprotocol, item), pos
+
+
+def parse_subprotocol(header: str) -> List[Subprotocol]:
+    """
+    Parse a ``Sec-WebSocket-Protocol`` header.
+
+    Return a list of WebSocket subprotocols.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    return parse_list(parse_subprotocol_item, header, 0, "Sec-WebSocket-Protocol")
+
+
+parse_subprotocol_list = parse_subprotocol  # alias for backwards compatibility
+
+
+def build_subprotocol(protocols: Sequence[Subprotocol]) -> str:
+    """
+    Build a ``Sec-WebSocket-Protocol`` header.
+
+    This is the reverse of :func:`parse_subprotocol`.
+
+    """
+    return ", ".join(protocols)
+
+
+build_subprotocol_list = build_subprotocol  # alias for backwards compatibility
+
+
+def build_www_authenticate_basic(realm: str) -> str:
+    """
+    Build a ``WWW-Authenticate`` header for HTTP Basic Auth.
+
+    :param realm: authentication realm
+
+    """
+    # https://tools.ietf.org/html/rfc7617#section-2
+    realm = build_quoted_string(realm)
+    charset = build_quoted_string("UTF-8")
+    return f"Basic realm={realm}, charset={charset}"
+
+
+_token68_re = re.compile(r"[A-Za-z0-9-._~+/]+=*")
+
+
+def parse_token68(header: str, pos: int, header_name: str) -> Tuple[str, int]:
+    """
+    Parse a token68 from ``header`` at the given position.
+
+    Return the token value and the new position.
+
+    :raises ~websockets.exceptions.InvalidHeaderFormat: on invalid inputs.
+
+    """
+    match = _token68_re.match(header, pos)
+    if match is None:
+        raise InvalidHeaderFormat(header_name, "expected token68", header, pos)
+    return match.group(), match.end()
+
+
+def parse_end(header: str, pos: int, header_name: str) -> None:
+    """
+    Check that parsing reached the end of header.
+
+    """
+    if pos < len(header):
+        raise InvalidHeaderFormat(header_name, "trailing data", header, pos)
+
+
+def parse_authorization_basic(header: str) -> Tuple[str, str]:
+    """
+    Parse an ``Authorization`` header for HTTP Basic Auth.
+
+    Return a ``(username, password)`` tuple.
+
+    :param header: value of the ``Authorization`` header
+    :raises InvalidHeaderFormat: on invalid inputs
+    :raises InvalidHeaderValue: on unsupported inputs
+
+    """
+    # https://tools.ietf.org/html/rfc7235#section-2.1
+    # https://tools.ietf.org/html/rfc7617#section-2
+    scheme, pos = parse_token(header, 0, "Authorization")
+    if scheme.lower() != "basic":
+        raise InvalidHeaderValue("Authorization", f"unsupported scheme: {scheme}")
+    if peek_ahead(header, pos) != " ":
+        raise InvalidHeaderFormat(
+            "Authorization", "expected space after scheme", header, pos
+        )
+    pos += 1
+    basic_credentials, pos = parse_token68(header, pos, "Authorization")
+    parse_end(header, pos, "Authorization")
+
+    try:
+        user_pass = base64.b64decode(basic_credentials.encode()).decode()
+    except binascii.Error:
+        raise InvalidHeaderValue(
+            "Authorization", "expected base64-encoded credentials"
+        ) from None
+    try:
+        username, password = user_pass.split(":", 1)
+    except ValueError:
+        raise InvalidHeaderValue(
+            "Authorization", "expected username:password credentials"
+        ) from None
+
+    return username, password
+
+
+def build_authorization_basic(username: str, password: str) -> str:
+    """
+    Build an ``Authorization`` header for HTTP Basic Auth.
+
+    This is the reverse of :func:`parse_authorization_basic`.
+
+    """
+    # https://tools.ietf.org/html/rfc7617#section-2
+    assert ":" not in username
+    user_pass = f"{username}:{password}"
+    basic_credentials = base64.b64encode(user_pass.encode()).decode()
+    return "Basic " + basic_credentials

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/http.py

@@ -0,0 +1,360 @@
+"""
+:mod:`websockets.http` module provides basic HTTP/1.1 support. It is merely
+:adequate for WebSocket handshake messages.
+
+These APIs cannot be imported from :mod:`websockets`. They must be imported
+from :mod:`websockets.http`.
+
+"""
+
+import asyncio
+import re
+import sys
+from typing import (
+    Any,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    MutableMapping,
+    Tuple,
+    Union,
+)
+
+from .version import version as websockets_version
+
+
+__all__ = [
+    "read_request",
+    "read_response",
+    "Headers",
+    "MultipleValuesError",
+    "USER_AGENT",
+]
+
+MAX_HEADERS = 256
+MAX_LINE = 4096
+
+USER_AGENT = f"Python/{sys.version[:3]} websockets/{websockets_version}"
+
+
+def d(value: bytes) -> str:
+    """
+    Decode a bytestring for interpolating into an error message.
+
+    """
+    return value.decode(errors="backslashreplace")
+
+
+# See https://tools.ietf.org/html/rfc7230#appendix-B.
+
+# Regex for validating header names.
+
+_token_re = re.compile(rb"[-!#$%&\'*+.^_`|~0-9a-zA-Z]+")
+
+# Regex for validating header values.
+
+# We don't attempt to support obsolete line folding.
+
+# Include HTAB (\x09), SP (\x20), VCHAR (\x21-\x7e), obs-text (\x80-\xff).
+
+# The ABNF is complicated because it attempts to express that optional
+# whitespace is ignored. We strip whitespace and don't revalidate that.
+
+# See also https://www.rfc-editor.org/errata_search.php?rfc=7230&eid=4189
+
+_value_re = re.compile(rb"[\x09\x20-\x7e\x80-\xff]*")
+
+
+async def read_request(stream: asyncio.StreamReader) -> Tuple[str, "Headers"]:
+    """
+    Read an HTTP/1.1 GET request and return ``(path, headers)``.
+
+    ``path`` isn't URL-decoded or validated in any way.
+
+    ``path`` and ``headers`` are expected to contain only ASCII characters.
+    Other characters are represented with surrogate escapes.
+
+    :func:`read_request` doesn't attempt to read the request body because
+    WebSocket handshake requests don't have one. If the request contains a
+    body, it may be read from ``stream`` after this coroutine returns.
+
+    :param stream: input to read the request from
+    :raises EOFError: if the connection is closed without a full HTTP request
+    :raises SecurityError: if the request exceeds a security limit
+    :raises ValueError: if the request isn't well formatted
+
+    """
+    # https://tools.ietf.org/html/rfc7230#section-3.1.1
+
+    # Parsing is simple because fixed values are expected for method and
+    # version and because path isn't checked. Since WebSocket software tends
+    # to implement HTTP/1.1 strictly, there's little need for lenient parsing.
+
+    try:
+        request_line = await read_line(stream)
+    except EOFError as exc:
+        raise EOFError("connection closed while reading HTTP request line") from exc
+
+    try:
+        method, raw_path, version = request_line.split(b" ", 2)
+    except ValueError:  # not enough values to unpack (expected 3, got 1-2)
+        raise ValueError(f"invalid HTTP request line: {d(request_line)}") from None
+
+    if method != b"GET":
+        raise ValueError(f"unsupported HTTP method: {d(method)}")
+    if version != b"HTTP/1.1":
+        raise ValueError(f"unsupported HTTP version: {d(version)}")
+    path = raw_path.decode("ascii", "surrogateescape")
+
+    headers = await read_headers(stream)
+
+    return path, headers
+
+
+async def read_response(stream: asyncio.StreamReader) -> Tuple[int, str, "Headers"]:
+    """
+    Read an HTTP/1.1 response and return ``(status_code, reason, headers)``.
+
+    ``reason`` and ``headers`` are expected to contain only ASCII characters.
+    Other characters are represented with surrogate escapes.
+
+    :func:`read_request` doesn't attempt to read the response body because
+    WebSocket handshake responses don't have one. If the response contains a
+    body, it may be read from ``stream`` after this coroutine returns.
+
+    :param stream: input to read the response from
+    :raises EOFError: if the connection is closed without a full HTTP response
+    :raises SecurityError: if the response exceeds a security limit
+    :raises ValueError: if the response isn't well formatted
+
+    """
+    # https://tools.ietf.org/html/rfc7230#section-3.1.2
+
+    # As in read_request, parsing is simple because a fixed value is expected
+    # for version, status_code is a 3-digit number, and reason can be ignored.
+
+    try:
+        status_line = await read_line(stream)
+    except EOFError as exc:
+        raise EOFError("connection closed while reading HTTP status line") from exc
+
+    try:
+        version, raw_status_code, raw_reason = status_line.split(b" ", 2)
+    except ValueError:  # not enough values to unpack (expected 3, got 1-2)
+        raise ValueError(f"invalid HTTP status line: {d(status_line)}") from None
+
+    if version != b"HTTP/1.1":
+        raise ValueError(f"unsupported HTTP version: {d(version)}")
+    try:
+        status_code = int(raw_status_code)
+    except ValueError:  # invalid literal for int() with base 10
+        raise ValueError(f"invalid HTTP status code: {d(raw_status_code)}") from None
+    if not 100 <= status_code < 1000:
+        raise ValueError(f"unsupported HTTP status code: {d(raw_status_code)}")
+    if not _value_re.fullmatch(raw_reason):
+        raise ValueError(f"invalid HTTP reason phrase: {d(raw_reason)}")
+    reason = raw_reason.decode()
+
+    headers = await read_headers(stream)
+
+    return status_code, reason, headers
+
+
+async def read_headers(stream: asyncio.StreamReader) -> "Headers":
+    """
+    Read HTTP headers from ``stream``.
+
+    Non-ASCII characters are represented with surrogate escapes.
+
+    """
+    # https://tools.ietf.org/html/rfc7230#section-3.2
+
+    # We don't attempt to support obsolete line folding.
+
+    headers = Headers()
+    for _ in range(MAX_HEADERS + 1):
+        try:
+            line = await read_line(stream)
+        except EOFError as exc:
+            raise EOFError("connection closed while reading HTTP headers") from exc
+        if line == b"":
+            break
+
+        try:
+            raw_name, raw_value = line.split(b":", 1)
+        except ValueError:  # not enough values to unpack (expected 2, got 1)
+            raise ValueError(f"invalid HTTP header line: {d(line)}") from None
+        if not _token_re.fullmatch(raw_name):
+            raise ValueError(f"invalid HTTP header name: {d(raw_name)}")
+        raw_value = raw_value.strip(b" \t")
+        if not _value_re.fullmatch(raw_value):
+            raise ValueError(f"invalid HTTP header value: {d(raw_value)}")
+
+        name = raw_name.decode("ascii")  # guaranteed to be ASCII at this point
+        value = raw_value.decode("ascii", "surrogateescape")
+        headers[name] = value
+
+    else:
+        raise websockets.exceptions.SecurityError("too many HTTP headers")
+
+    return headers
+
+
+async def read_line(stream: asyncio.StreamReader) -> bytes:
+    """
+    Read a single line from ``stream``.
+
+    CRLF is stripped from the return value.
+
+    """
+    # Security: this is bounded by the StreamReader's limit (default = 32 KiB).
+    line = await stream.readline()
+    # Security: this guarantees header values are small (hard-coded = 4 KiB)
+    if len(line) > MAX_LINE:
+        raise websockets.exceptions.SecurityError("line too long")
+    # Not mandatory but safe - https://tools.ietf.org/html/rfc7230#section-3.5
+    if not line.endswith(b"\r\n"):
+        raise EOFError("line without CRLF")
+    return line[:-2]
+
+
+class MultipleValuesError(LookupError):
+    """
+    Exception raised when :class:`Headers` has more than one value for a key.
+
+    """
+
+    def __str__(self) -> str:
+        # Implement the same logic as KeyError_str in Objects/exceptions.c.
+        if len(self.args) == 1:
+            return repr(self.args[0])
+        return super().__str__()
+
+
+class Headers(MutableMapping[str, str]):
+    """
+    Efficient data structure for manipulating HTTP headers.
+
+    A :class:`list` of ``(name, values)`` is inefficient for lookups.
+
+    A :class:`dict` doesn't suffice because header names are case-insensitive
+    and multiple occurrences of headers with the same name are possible.
+
+    :class:`Headers` stores HTTP headers in a hybrid data structure to provide
+    efficient insertions and lookups while preserving the original data.
+
+    In order to account for multiple values with minimal hassle,
+    :class:`Headers` follows this logic:
+
+    - When getting a header with ``headers[name]``:
+        - if there's no value, :exc:`KeyError` is raised;
+        - if there's exactly one value, it's returned;
+        - if there's more than one value, :exc:`MultipleValuesError` is raised.
+
+    - When setting a header with ``headers[name] = value``, the value is
+      appended to the list of values for that header.
+
+    - When deleting a header with ``del headers[name]``, all values for that
+      header are removed (this is slow).
+
+    Other methods for manipulating headers are consistent with this logic.
+
+    As long as no header occurs multiple times, :class:`Headers` behaves like
+    :class:`dict`, except keys are lower-cased to provide case-insensitivity.
+
+    Two methods support support manipulating multiple values explicitly:
+
+    - :meth:`get_all` returns a list of all values for a header;
+    - :meth:`raw_items` returns an iterator of ``(name, values)`` pairs.
+
+    """
+
+    __slots__ = ["_dict", "_list"]
+
+    def __init__(self, *args: Any, **kwargs: str) -> None:
+        self._dict: Dict[str, List[str]] = {}
+        self._list: List[Tuple[str, str]] = []
+        # MutableMapping.update calls __setitem__ for each (name, value) pair.
+        self.update(*args, **kwargs)
+
+    def __str__(self) -> str:
+        return "".join(f"{key}: {value}\r\n" for key, value in self._list) + "\r\n"
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._list!r})"
+
+    def copy(self) -> "Headers":
+        copy = self.__class__()
+        copy._dict = self._dict.copy()
+        copy._list = self._list.copy()
+        return copy
+
+    # Collection methods
+
+    def __contains__(self, key: object) -> bool:
+        return isinstance(key, str) and key.lower() in self._dict
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._dict)
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    # MutableMapping methods
+
+    def __getitem__(self, key: str) -> str:
+        value = self._dict[key.lower()]
+        if len(value) == 1:
+            return value[0]
+        else:
+            raise MultipleValuesError(key)
+
+    def __setitem__(self, key: str, value: str) -> None:
+        self._dict.setdefault(key.lower(), []).append(value)
+        self._list.append((key, value))
+
+    def __delitem__(self, key: str) -> None:
+        key_lower = key.lower()
+        self._dict.__delitem__(key_lower)
+        # This is inefficent. Fortunately deleting HTTP headers is uncommon.
+        self._list = [(k, v) for k, v in self._list if k.lower() != key_lower]
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Headers):
+            return NotImplemented
+        return self._list == other._list
+
+    def clear(self) -> None:
+        """
+        Remove all headers.
+
+        """
+        self._dict = {}
+        self._list = []
+
+    # Methods for handling multiple values
+
+    def get_all(self, key: str) -> List[str]:
+        """
+        Return the (possibly empty) list of all values for a header.
+
+        :param key: header name
+
+        """
+        return self._dict.get(key.lower(), [])
+
+    def raw_items(self) -> Iterator[Tuple[str, str]]:
+        """
+        Return an iterator of all values as ``(name, value)`` pairs.
+
+        """
+        return iter(self._list)
+
+
+HeadersLike = Union[Headers, Mapping[str, str], Iterable[Tuple[str, str]]]
+
+
+# at the bottom to allow circular import, because AbortHandshake depends on HeadersLike
+import websockets.exceptions  # isort:skip # noqa

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/server.py

@@ -0,0 +1,995 @@
+"""
+:mod:`websockets.server` defines the WebSocket server APIs.
+
+"""
+
+import asyncio
+import collections.abc
+import email.utils
+import functools
+import http
+import logging
+import socket
+import sys
+import warnings
+from types import TracebackType
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Generator,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+from .exceptions import (
+    AbortHandshake,
+    InvalidHandshake,
+    InvalidHeader,
+    InvalidMessage,
+    InvalidOrigin,
+    InvalidUpgrade,
+    NegotiationError,
+)
+from .extensions.base import Extension, ServerExtensionFactory
+from .extensions.permessage_deflate import ServerPerMessageDeflateFactory
+from .handshake import build_response, check_request
+from .headers import build_extension, parse_extension, parse_subprotocol
+from .http import USER_AGENT, Headers, HeadersLike, MultipleValuesError, read_request
+from .protocol import WebSocketCommonProtocol
+from .typing import ExtensionHeader, Origin, Subprotocol
+
+
+__all__ = ["serve", "unix_serve", "WebSocketServerProtocol", "WebSocketServer"]
+
+logger = logging.getLogger(__name__)
+
+
+HeadersLikeOrCallable = Union[HeadersLike, Callable[[str, Headers], HeadersLike]]
+
+HTTPResponse = Tuple[http.HTTPStatus, HeadersLike, bytes]
+
+
+class WebSocketServerProtocol(WebSocketCommonProtocol):
+    """
+    :class:`~asyncio.Protocol` subclass implementing a WebSocket server.
+
+    This class inherits most of its methods from
+    :class:`~websockets.protocol.WebSocketCommonProtocol`.
+
+    For the sake of simplicity, it doesn't rely on a full HTTP implementation.
+    Its support for HTTP responses is very limited.
+
+    """
+
+    is_client = False
+    side = "server"
+
+    def __init__(
+        self,
+        ws_handler: Callable[["WebSocketServerProtocol", str], Awaitable[Any]],
+        ws_server: "WebSocketServer",
+        *,
+        origins: Optional[Sequence[Optional[Origin]]] = None,
+        extensions: Optional[Sequence[ServerExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLikeOrCallable] = None,
+        process_request: Optional[
+            Callable[[str, Headers], Awaitable[Optional[HTTPResponse]]]
+        ] = None,
+        select_subprotocol: Optional[
+            Callable[[Sequence[Subprotocol], Sequence[Subprotocol]], Subprotocol]
+        ] = None,
+        **kwargs: Any,
+    ) -> None:
+        # For backwards compatibility with 6.0 or earlier.
+        if origins is not None and "" in origins:
+            warnings.warn("use None instead of '' in origins", DeprecationWarning)
+            origins = [None if origin == "" else origin for origin in origins]
+        self.ws_handler = ws_handler
+        self.ws_server = ws_server
+        self.origins = origins
+        self.available_extensions = extensions
+        self.available_subprotocols = subprotocols
+        self.extra_headers = extra_headers
+        self._process_request = process_request
+        self._select_subprotocol = select_subprotocol
+        super().__init__(**kwargs)
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        """
+        Register connection and initialize a task to handle it.
+
+        """
+        super().connection_made(transport)
+        # Register the connection with the server before creating the handler
+        # task. Registering at the beginning of the handler coroutine would
+        # create a race condition between the creation of the task, which
+        # schedules its execution, and the moment the handler starts running.
+        self.ws_server.register(self)
+        self.handler_task = self.loop.create_task(self.handler())
+
+    async def handler(self) -> None:
+        """
+        Handle the lifecycle of a WebSocket connection.
+
+        Since this method doesn't have a caller able to handle exceptions, it
+        attemps to log relevant ones and guarantees that the TCP connection is
+        closed before exiting.
+
+        """
+        try:
+
+            try:
+                path = await self.handshake(
+                    origins=self.origins,
+                    available_extensions=self.available_extensions,
+                    available_subprotocols=self.available_subprotocols,
+                    extra_headers=self.extra_headers,
+                )
+            except ConnectionError:
+                logger.debug("Connection error in opening handshake", exc_info=True)
+                raise
+            except Exception as exc:
+                if isinstance(exc, AbortHandshake):
+                    status, headers, body = exc.status, exc.headers, exc.body
+                elif isinstance(exc, InvalidOrigin):
+                    logger.debug("Invalid origin", exc_info=True)
+                    status, headers, body = (
+                        http.HTTPStatus.FORBIDDEN,
+                        Headers(),
+                        f"Failed to open a WebSocket connection: {exc}.\n".encode(),
+                    )
+                elif isinstance(exc, InvalidUpgrade):
+                    logger.debug("Invalid upgrade", exc_info=True)
+                    status, headers, body = (
+                        http.HTTPStatus.UPGRADE_REQUIRED,
+                        Headers([("Upgrade", "websocket")]),
+                        (
+                            f"Failed to open a WebSocket connection: {exc}.\n"
+                            f"\n"
+                            f"You cannot access a WebSocket server directly "
+                            f"with a browser. You need a WebSocket client.\n"
+                        ).encode(),
+                    )
+                elif isinstance(exc, InvalidHandshake):
+                    logger.debug("Invalid handshake", exc_info=True)
+                    status, headers, body = (
+                        http.HTTPStatus.BAD_REQUEST,
+                        Headers(),
+                        f"Failed to open a WebSocket connection: {exc}.\n".encode(),
+                    )
+                else:
+                    logger.warning("Error in opening handshake", exc_info=True)
+                    status, headers, body = (
+                        http.HTTPStatus.INTERNAL_SERVER_ERROR,
+                        Headers(),
+                        (
+                            b"Failed to open a WebSocket connection.\n"
+                            b"See server log for more information.\n"
+                        ),
+                    )
+
+                headers.setdefault("Date", email.utils.formatdate(usegmt=True))
+                headers.setdefault("Server", USER_AGENT)
+                headers.setdefault("Content-Length", str(len(body)))
+                headers.setdefault("Content-Type", "text/plain")
+                headers.setdefault("Connection", "close")
+
+                self.write_http_response(status, headers, body)
+                self.fail_connection()
+                await self.wait_closed()
+                return
+
+            try:
+                await self.ws_handler(self, path)
+            except Exception:
+                logger.error("Error in connection handler", exc_info=True)
+                if not self.closed:
+                    self.fail_connection(1011)
+                raise
+
+            try:
+                await self.close()
+            except ConnectionError:
+                logger.debug("Connection error in closing handshake", exc_info=True)
+                raise
+            except Exception:
+                logger.warning("Error in closing handshake", exc_info=True)
+                raise
+
+        except Exception:
+            # Last-ditch attempt to avoid leaking connections on errors.
+            try:
+                self.transport.close()
+            except Exception:  # pragma: no cover
+                pass
+
+        finally:
+            # Unregister the connection with the server when the handler task
+            # terminates. Registration is tied to the lifecycle of the handler
+            # task because the server waits for tasks attached to registered
+            # connections before terminating.
+            self.ws_server.unregister(self)
+
+    async def read_http_request(self) -> Tuple[str, Headers]:
+        """
+        Read request line and headers from the HTTP request.
+
+        If the request contains a body, it may be read from ``self.reader``
+        after this coroutine returns.
+
+        :raises ~websockets.exceptions.InvalidMessage: if the HTTP message is
+            malformed or isn't an HTTP/1.1 GET request
+
+        """
+        try:
+            path, headers = await read_request(self.reader)
+        except Exception as exc:
+            raise InvalidMessage("did not receive a valid HTTP request") from exc
+
+        logger.debug("%s < GET %s HTTP/1.1", self.side, path)
+        logger.debug("%s < %r", self.side, headers)
+
+        self.path = path
+        self.request_headers = headers
+
+        return path, headers
+
+    def write_http_response(
+        self, status: http.HTTPStatus, headers: Headers, body: Optional[bytes] = None
+    ) -> None:
+        """
+        Write status line and headers to the HTTP response.
+
+        This coroutine is also able to write a response body.
+
+        """
+        self.response_headers = headers
+
+        logger.debug("%s > HTTP/1.1 %d %s", self.side, status.value, status.phrase)
+        logger.debug("%s > %r", self.side, headers)
+
+        # Since the status line and headers only contain ASCII characters,
+        # we can keep this simple.
+        response = f"HTTP/1.1 {status.value} {status.phrase}\r\n"
+        response += str(headers)
+
+        self.transport.write(response.encode())
+
+        if body is not None:
+            logger.debug("%s > body (%d bytes)", self.side, len(body))
+            self.transport.write(body)
+
+    async def process_request(
+        self, path: str, request_headers: Headers
+    ) -> Optional[HTTPResponse]:
+        """
+        Intercept the HTTP request and return an HTTP response if appropriate.
+
+        If ``process_request`` returns ``None``, the WebSocket handshake
+        continues. If it returns 3-uple containing a status code, response
+        headers and a response body, that HTTP response is sent and the
+        connection is closed. In that case:
+
+        * The HTTP status must be a :class:`~http.HTTPStatus`.
+        * HTTP headers must be a :class:`~websockets.http.Headers` instance, a
+          :class:`~collections.abc.Mapping`, or an iterable of ``(name,
+          value)`` pairs.
+        * The HTTP response body must be :class:`bytes`. It may be empty.
+
+        This coroutine may be overridden in a :class:`WebSocketServerProtocol`
+        subclass, for example:
+
+        * to return a HTTP 200 OK response on a given path; then a load
+          balancer can use this path for a health check;
+        * to authenticate the request and return a HTTP 401 Unauthorized or a
+          HTTP 403 Forbidden when authentication fails.
+
+        Instead of subclassing, it is possible to override this method by
+        passing a ``process_request`` argument to the :func:`serve` function
+        or the :class:`WebSocketServerProtocol` constructor. This is
+        equivalent, except ``process_request`` won't have access to the
+        protocol instance, so it can't store information for later use.
+
+        ``process_request`` is expected to complete quickly. If it may run for
+        a long time, then it should await :meth:`wait_closed` and exit if
+        :meth:`wait_closed` completes, or else it could prevent the server
+        from shutting down.
+
+        :param path: request path, including optional query string
+        :param request_headers: request headers
+
+        """
+        if self._process_request is not None:
+            response = self._process_request(path, request_headers)
+            if isinstance(response, Awaitable):
+                return await response
+            else:
+                # For backwards compatibility with 7.0.
+                warnings.warn(
+                    "declare process_request as a coroutine", DeprecationWarning
+                )
+                return response  # type: ignore
+        return None
+
+    @staticmethod
+    def process_origin(
+        headers: Headers, origins: Optional[Sequence[Optional[Origin]]] = None
+    ) -> Optional[Origin]:
+        """
+        Handle the Origin HTTP request header.
+
+        :param headers: request headers
+        :param origins: optional list of acceptable origins
+        :raises ~websockets.exceptions.InvalidOrigin: if the origin isn't
+            acceptable
+
+        """
+        # "The user agent MUST NOT include more than one Origin header field"
+        # per https://tools.ietf.org/html/rfc6454#section-7.3.
+        try:
+            origin = cast(Origin, headers.get("Origin"))
+        except MultipleValuesError:
+            raise InvalidHeader("Origin", "more than one Origin header found")
+        if origins is not None:
+            if origin not in origins:
+                raise InvalidOrigin(origin)
+        return origin
+
+    @staticmethod
+    def process_extensions(
+        headers: Headers,
+        available_extensions: Optional[Sequence[ServerExtensionFactory]],
+    ) -> Tuple[Optional[str], List[Extension]]:
+        """
+        Handle the Sec-WebSocket-Extensions HTTP request header.
+
+        Accept or reject each extension proposed in the client request.
+        Negotiate parameters for accepted extensions.
+
+        Return the Sec-WebSocket-Extensions HTTP response header and the list
+        of accepted extensions.
+
+        :rfc:`6455` leaves the rules up to the specification of each
+        :extension.
+
+        To provide this level of flexibility, for each extension proposed by
+        the client, we check for a match with each extension available in the
+        server configuration. If no match is found, the extension is ignored.
+
+        If several variants of the same extension are proposed by the client,
+        it may be accepted severel times, which won't make sense in general.
+        Extensions must implement their own requirements. For this purpose,
+        the list of previously accepted extensions is provided.
+
+        This process doesn't allow the server to reorder extensions. It can
+        only select a subset of the extensions proposed by the client.
+
+        Other requirements, for example related to mandatory extensions or the
+        order of extensions, may be implemented by overriding this method.
+
+        :param headers: request headers
+        :param extensions: optional list of supported extensions
+        :raises ~websockets.exceptions.InvalidHandshake: to abort the
+            handshake with an HTTP 400 error code
+
+        """
+        response_header_value: Optional[str] = None
+
+        extension_headers: List[ExtensionHeader] = []
+        accepted_extensions: List[Extension] = []
+
+        header_values = headers.get_all("Sec-WebSocket-Extensions")
+
+        if header_values and available_extensions:
+
+            parsed_header_values: List[ExtensionHeader] = sum(
+                [parse_extension(header_value) for header_value in header_values], []
+            )
+
+            for name, request_params in parsed_header_values:
+
+                for ext_factory in available_extensions:
+
+                    # Skip non-matching extensions based on their name.
+                    if ext_factory.name != name:
+                        continue
+
+                    # Skip non-matching extensions based on their params.
+                    try:
+                        response_params, extension = ext_factory.process_request_params(
+                            request_params, accepted_extensions
+                        )
+                    except NegotiationError:
+                        continue
+
+                    # Add matching extension to the final list.
+                    extension_headers.append((name, response_params))
+                    accepted_extensions.append(extension)
+
+                    # Break out of the loop once we have a match.
+                    break
+
+                # If we didn't break from the loop, no extension in our list
+                # matched what the client sent. The extension is declined.
+
+        # Serialize extension header.
+        if extension_headers:
+            response_header_value = build_extension(extension_headers)
+
+        return response_header_value, accepted_extensions
+
+    # Not @staticmethod because it calls self.select_subprotocol()
+    def process_subprotocol(
+        self, headers: Headers, available_subprotocols: Optional[Sequence[Subprotocol]]
+    ) -> Optional[Subprotocol]:
+        """
+        Handle the Sec-WebSocket-Protocol HTTP request header.
+
+        Return Sec-WebSocket-Protocol HTTP response header, which is the same
+        as the selected subprotocol.
+
+        :param headers: request headers
+        :param available_subprotocols: optional list of supported subprotocols
+        :raises ~websockets.exceptions.InvalidHandshake: to abort the
+            handshake with an HTTP 400 error code
+
+        """
+        subprotocol: Optional[Subprotocol] = None
+
+        header_values = headers.get_all("Sec-WebSocket-Protocol")
+
+        if header_values and available_subprotocols:
+
+            parsed_header_values: List[Subprotocol] = sum(
+                [parse_subprotocol(header_value) for header_value in header_values], []
+            )
+
+            subprotocol = self.select_subprotocol(
+                parsed_header_values, available_subprotocols
+            )
+
+        return subprotocol
+
+    def select_subprotocol(
+        self,
+        client_subprotocols: Sequence[Subprotocol],
+        server_subprotocols: Sequence[Subprotocol],
+    ) -> Optional[Subprotocol]:
+        """
+        Pick a subprotocol among those offered by the client.
+
+        If several subprotocols are supported by the client and the server,
+        the default implementation selects the preferred subprotocols by
+        giving equal value to the priorities of the client and the server.
+
+        If no subprotocol is supported by the client and the server, it
+        proceeds without a subprotocol.
+
+        This is unlikely to be the most useful implementation in practice, as
+        many servers providing a subprotocol will require that the client uses
+        that subprotocol. Such rules can be implemented in a subclass.
+
+        Instead of subclassing, it is possible to override this method by
+        passing a ``select_subprotocol`` argument to the :func:`serve`
+        function or the :class:`WebSocketServerProtocol` constructor
+
+        :param client_subprotocols: list of subprotocols offered by the client
+        :param server_subprotocols: list of subprotocols available on the server
+
+        """
+        if self._select_subprotocol is not None:
+            return self._select_subprotocol(client_subprotocols, server_subprotocols)
+
+        subprotocols = set(client_subprotocols) & set(server_subprotocols)
+        if not subprotocols:
+            return None
+        priority = lambda p: (
+            client_subprotocols.index(p) + server_subprotocols.index(p)
+        )
+        return sorted(subprotocols, key=priority)[0]
+
+    async def handshake(
+        self,
+        origins: Optional[Sequence[Optional[Origin]]] = None,
+        available_extensions: Optional[Sequence[ServerExtensionFactory]] = None,
+        available_subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLikeOrCallable] = None,
+    ) -> str:
+        """
+        Perform the server side of the opening handshake.
+
+        Return the path of the URI of the request.
+
+        :param origins: list of acceptable values of the Origin HTTP header;
+            include ``None`` if the lack of an origin is acceptable
+        :param available_extensions: list of supported extensions in the order
+            in which they should be used
+        :param available_subprotocols: list of supported subprotocols in order
+            of decreasing preference
+        :param extra_headers: sets additional HTTP response headers when the
+            handshake succeeds; it can be a :class:`~websockets.http.Headers`
+            instance, a :class:`~collections.abc.Mapping`, an iterable of
+            ``(name, value)`` pairs, or a callable taking the request path and
+            headers in arguments and returning one of the above.
+        :raises ~websockets.exceptions.InvalidHandshake: if the handshake
+            fails
+
+        """
+        path, request_headers = await self.read_http_request()
+
+        # Hook for customizing request handling, for example checking
+        # authentication or treating some paths as plain HTTP endpoints.
+        early_response_awaitable = self.process_request(path, request_headers)
+        if isinstance(early_response_awaitable, Awaitable):
+            early_response = await early_response_awaitable
+        else:
+            # For backwards compatibility with 7.0.
+            warnings.warn("declare process_request as a coroutine", DeprecationWarning)
+            early_response = early_response_awaitable  # type: ignore
+
+        # Change the response to a 503 error if the server is shutting down.
+        if not self.ws_server.is_serving():
+            early_response = (
+                http.HTTPStatus.SERVICE_UNAVAILABLE,
+                [],
+                b"Server is shutting down.\n",
+            )
+
+        if early_response is not None:
+            raise AbortHandshake(*early_response)
+
+        key = check_request(request_headers)
+
+        self.origin = self.process_origin(request_headers, origins)
+
+        extensions_header, self.extensions = self.process_extensions(
+            request_headers, available_extensions
+        )
+
+        protocol_header = self.subprotocol = self.process_subprotocol(
+            request_headers, available_subprotocols
+        )
+
+        response_headers = Headers()
+
+        build_response(response_headers, key)
+
+        if extensions_header is not None:
+            response_headers["Sec-WebSocket-Extensions"] = extensions_header
+
+        if protocol_header is not None:
+            response_headers["Sec-WebSocket-Protocol"] = protocol_header
+
+        if callable(extra_headers):
+            extra_headers = extra_headers(path, self.request_headers)
+        if extra_headers is not None:
+            if isinstance(extra_headers, Headers):
+                extra_headers = extra_headers.raw_items()
+            elif isinstance(extra_headers, collections.abc.Mapping):
+                extra_headers = extra_headers.items()
+            for name, value in extra_headers:
+                response_headers[name] = value
+
+        response_headers.setdefault("Date", email.utils.formatdate(usegmt=True))
+        response_headers.setdefault("Server", USER_AGENT)
+
+        self.write_http_response(http.HTTPStatus.SWITCHING_PROTOCOLS, response_headers)
+
+        self.connection_open()
+
+        return path
+
+
+class WebSocketServer:
+    """
+    WebSocket server returned by :func:`~websockets.server.serve`.
+
+    This class provides the same interface as
+    :class:`~asyncio.AbstractServer`, namely the
+    :meth:`~asyncio.AbstractServer.close` and
+    :meth:`~asyncio.AbstractServer.wait_closed` methods.
+
+    It keeps track of WebSocket connections in order to close them properly
+    when shutting down.
+
+    Instances of this class store a reference to the :class:`~asyncio.Server`
+    object returned by :meth:`~asyncio.loop.create_server` rather than inherit
+    from :class:`~asyncio.Server` in part because
+    :meth:`~asyncio.loop.create_server` doesn't support passing a custom
+    :class:`~asyncio.Server` class.
+
+    """
+
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        # Store a reference to loop to avoid relying on self.server._loop.
+        self.loop = loop
+
+        # Keep track of active connections.
+        self.websockets: Set[WebSocketServerProtocol] = set()
+
+        # Task responsible for closing the server and terminating connections.
+        self.close_task: Optional[asyncio.Task[None]] = None
+
+        # Completed when the server is closed and connections are terminated.
+        self.closed_waiter: asyncio.Future[None] = loop.create_future()
+
+    def wrap(self, server: asyncio.AbstractServer) -> None:
+        """
+        Attach to a given :class:`~asyncio.Server`.
+
+        Since :meth:`~asyncio.loop.create_server` doesn't support injecting a
+        custom ``Server`` class, the easiest solution that doesn't rely on
+        private :mod:`asyncio` APIs is to:
+
+        - instantiate a :class:`WebSocketServer`
+        - give the protocol factory a reference to that instance
+        - call :meth:`~asyncio.loop.create_server` with the factory
+        - attach the resulting :class:`~asyncio.Server` with this method
+
+        """
+        self.server = server
+
+    def register(self, protocol: WebSocketServerProtocol) -> None:
+        """
+        Register a connection with this server.
+
+        """
+        self.websockets.add(protocol)
+
+    def unregister(self, protocol: WebSocketServerProtocol) -> None:
+        """
+        Unregister a connection with this server.
+
+        """
+        self.websockets.remove(protocol)
+
+    def is_serving(self) -> bool:
+        """
+        Tell whether the server is accepting new connections or shutting down.
+
+        """
+        try:
+            # Python ≥ 3.7
+            return self.server.is_serving()
+        except AttributeError:  # pragma: no cover
+            # Python < 3.7
+            return self.server.sockets is not None
+
+    def close(self) -> None:
+        """
+        Close the server.
+
+        This method:
+
+        * closes the underlying :class:`~asyncio.Server`;
+        * rejects new WebSocket connections with an HTTP 503 (service
+          unavailable) error; this happens when the server accepted the TCP
+          connection but didn't complete the WebSocket opening handshake prior
+          to closing;
+        * closes open WebSocket connections with close code 1001 (going away).
+
+        :meth:`close` is idempotent.
+
+        """
+        if self.close_task is None:
+            self.close_task = self.loop.create_task(self._close())
+
+    async def _close(self) -> None:
+        """
+        Implementation of :meth:`close`.
+
+        This calls :meth:`~asyncio.Server.close` on the underlying
+        :class:`~asyncio.Server` object to stop accepting new connections and
+        then closes open connections with close code 1001.
+
+        """
+        # Stop accepting new connections.
+        self.server.close()
+
+        # Wait until self.server.close() completes.
+        await self.server.wait_closed()
+
+        # Wait until all accepted connections reach connection_made() and call
+        # register(). See https://bugs.python.org/issue34852 for details.
+        await asyncio.sleep(
+            0, loop=self.loop if sys.version_info[:2] < (3, 8) else None
+        )
+
+        # Close OPEN connections with status code 1001. Since the server was
+        # closed, handshake() closes OPENING conections with a HTTP 503 error.
+        # Wait until all connections are closed.
+
+        # asyncio.wait doesn't accept an empty first argument
+        if self.websockets:
+            await asyncio.wait(
+                [websocket.close(1001) for websocket in self.websockets],
+                loop=self.loop if sys.version_info[:2] < (3, 8) else None,
+            )
+
+        # Wait until all connection handlers are complete.
+
+        # asyncio.wait doesn't accept an empty first argument.
+        if self.websockets:
+            await asyncio.wait(
+                [websocket.handler_task for websocket in self.websockets],
+                loop=self.loop if sys.version_info[:2] < (3, 8) else None,
+            )
+
+        # Tell wait_closed() to return.
+        self.closed_waiter.set_result(None)
+
+    async def wait_closed(self) -> None:
+        """
+        Wait until the server is closed.
+
+        When :meth:`wait_closed` returns, all TCP connections are closed and
+        all connection handlers have returned.
+
+        """
+        await asyncio.shield(self.closed_waiter)
+
+    @property
+    def sockets(self) -> Optional[List[socket.socket]]:
+        """
+        List of :class:`~socket.socket` objects the server is listening to.
+
+        ``None`` if the server is closed.
+
+        """
+        return self.server.sockets
+
+
+class Serve:
+    """
+
+    Create, start, and return a WebSocket server on ``host`` and ``port``.
+
+    Whenever a client connects, the server accepts the connection, creates a
+    :class:`WebSocketServerProtocol`, performs the opening handshake, and
+    delegates to the connection handler defined by ``ws_handler``. Once the
+    handler completes, either normally or with an exception, the server
+    performs the closing handshake and closes the connection.
+
+    Awaiting :func:`serve` yields a :class:`WebSocketServer`. This instance
+    provides :meth:`~websockets.server.WebSocketServer.close` and
+    :meth:`~websockets.server.WebSocketServer.wait_closed` methods for
+    terminating the server and cleaning up its resources.
+
+    When a server is closed with :meth:`~WebSocketServer.close`, it closes all
+    connections with close code 1001 (going away). Connections handlers, which
+    are running the ``ws_handler`` coroutine, will receive a
+    :exc:`~websockets.exceptions.ConnectionClosedOK` exception on their
+    current or next interaction with the WebSocket connection.
+
+    :func:`serve` can also be used as an asynchronous context manager. In
+    this case, the server is shut down when exiting the context.
+
+    :func:`serve` is a wrapper around the event loop's
+    :meth:`~asyncio.loop.create_server` method. It creates and starts a
+    :class:`~asyncio.Server` with :meth:`~asyncio.loop.create_server`. Then it
+    wraps the :class:`~asyncio.Server` in a :class:`WebSocketServer`  and
+    returns the :class:`WebSocketServer`.
+
+    The ``ws_handler`` argument is the WebSocket handler. It must be a
+    coroutine accepting two arguments: a :class:`WebSocketServerProtocol` and
+    the request URI.
+
+    The ``host`` and ``port`` arguments, as well as unrecognized keyword
+    arguments, are passed along to :meth:`~asyncio.loop.create_server`.
+
+    For example, you can set the ``ssl`` keyword argument to a
+    :class:`~ssl.SSLContext` to enable TLS.
+
+    The ``create_protocol`` parameter allows customizing the
+    :class:`~asyncio.Protocol` that manages the connection. It should be a
+    callable or class accepting the same arguments as
+    :class:`WebSocketServerProtocol` and returning an instance of
+    :class:`WebSocketServerProtocol` or a subclass. It defaults to
+    :class:`WebSocketServerProtocol`.
+
+    The behavior of ``ping_interval``, ``ping_timeout``, ``close_timeout``,
+    ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit`` is
+    described in :class:`~websockets.protocol.WebSocketCommonProtocol`.
+
+    :func:`serve` also accepts the following optional arguments:
+
+    * ``compression`` is a shortcut to configure compression extensions;
+      by default it enables the "permessage-deflate" extension; set it to
+      ``None`` to disable compression
+    * ``origins`` defines acceptable Origin HTTP headers; include ``None`` if
+      the lack of an origin is acceptable
+    * ``extensions`` is a list of supported extensions in order of
+      decreasing preference
+    * ``subprotocols`` is a list of supported subprotocols in order of
+      decreasing preference
+    * ``extra_headers`` sets additional HTTP response headers  when the
+      handshake succeeds; it can be a :class:`~websockets.http.Headers`
+      instance, a :class:`~collections.abc.Mapping`, an iterable of ``(name,
+      value)`` pairs, or a callable taking the request path and headers in
+      arguments and returning one of the above
+    * ``process_request`` allows intercepting the HTTP request; it must be a
+      coroutine taking the request path and headers in argument; see
+      :meth:`~WebSocketServerProtocol.process_request` for details
+    * ``select_subprotocol`` allows customizing the logic for selecting a
+      subprotocol; it must be a callable taking the subprotocols offered by
+      the client and available on the server in argument; see
+      :meth:`~WebSocketServerProtocol.select_subprotocol` for details
+
+    Since there's no useful way to propagate exceptions triggered in handlers,
+    they're sent to the ``'websockets.server'`` logger instead. Debugging is
+    much easier if you configure logging to print them::
+
+        import logging
+        logger = logging.getLogger('websockets.server')
+        logger.setLevel(logging.ERROR)
+        logger.addHandler(logging.StreamHandler())
+
+    """
+
+    def __init__(
+        self,
+        ws_handler: Callable[[WebSocketServerProtocol, str], Awaitable[Any]],
+        host: Optional[Union[str, Sequence[str]]] = None,
+        port: Optional[int] = None,
+        *,
+        path: Optional[str] = None,
+        create_protocol: Optional[Type[WebSocketServerProtocol]] = None,
+        ping_interval: float = 20,
+        ping_timeout: float = 20,
+        close_timeout: Optional[float] = None,
+        max_size: int = 2 ** 20,
+        max_queue: int = 2 ** 5,
+        read_limit: int = 2 ** 16,
+        write_limit: int = 2 ** 16,
+        loop: Optional[asyncio.AbstractEventLoop] = None,
+        legacy_recv: bool = False,
+        klass: Optional[Type[WebSocketServerProtocol]] = None,
+        timeout: Optional[float] = None,
+        compression: Optional[str] = "deflate",
+        origins: Optional[Sequence[Optional[Origin]]] = None,
+        extensions: Optional[Sequence[ServerExtensionFactory]] = None,
+        subprotocols: Optional[Sequence[Subprotocol]] = None,
+        extra_headers: Optional[HeadersLikeOrCallable] = None,
+        process_request: Optional[
+            Callable[[str, Headers], Awaitable[Optional[HTTPResponse]]]
+        ] = None,
+        select_subprotocol: Optional[
+            Callable[[Sequence[Subprotocol], Sequence[Subprotocol]], Subprotocol]
+        ] = None,
+        **kwargs: Any,
+    ) -> None:
+        # Backwards compatibility: close_timeout used to be called timeout.
+        if timeout is None:
+            timeout = 10
+        else:
+            warnings.warn("rename timeout to close_timeout", DeprecationWarning)
+        # If both are specified, timeout is ignored.
+        if close_timeout is None:
+            close_timeout = timeout
+
+        # Backwards compatibility: create_protocol used to be called klass.
+        if klass is None:
+            klass = WebSocketServerProtocol
+        else:
+            warnings.warn("rename klass to create_protocol", DeprecationWarning)
+        # If both are specified, klass is ignored.
+        if create_protocol is None:
+            create_protocol = klass
+
+        if loop is None:
+            loop = asyncio.get_event_loop()
+
+        ws_server = WebSocketServer(loop)
+
+        secure = kwargs.get("ssl") is not None
+
+        if compression == "deflate":
+            if extensions is None:
+                extensions = []
+            if not any(
+                ext_factory.name == ServerPerMessageDeflateFactory.name
+                for ext_factory in extensions
+            ):
+                extensions = list(extensions) + [ServerPerMessageDeflateFactory()]
+        elif compression is not None:
+            raise ValueError(f"unsupported compression: {compression}")
+
+        factory = functools.partial(
+            create_protocol,
+            ws_handler,
+            ws_server,
+            host=host,
+            port=port,
+            secure=secure,
+            ping_interval=ping_interval,
+            ping_timeout=ping_timeout,
+            close_timeout=close_timeout,
+            max_size=max_size,
+            max_queue=max_queue,
+            read_limit=read_limit,
+            write_limit=write_limit,
+            loop=loop,
+            legacy_recv=legacy_recv,
+            origins=origins,
+            extensions=extensions,
+            subprotocols=subprotocols,
+            extra_headers=extra_headers,
+            process_request=process_request,
+            select_subprotocol=select_subprotocol,
+        )
+
+        if path is None:
+            create_server = functools.partial(
+                loop.create_server, factory, host, port, **kwargs
+            )
+        else:
+            # unix_serve(path) must not specify host and port parameters.
+            assert host is None and port is None
+            create_server = functools.partial(
+                loop.create_unix_server, factory, path, **kwargs
+            )
+
+        # This is a coroutine function.
+        self._create_server = create_server
+        self.ws_server = ws_server
+
+    # async with serve(...)
+
+    async def __aenter__(self) -> WebSocketServer:
+        return await self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        self.ws_server.close()
+        await self.ws_server.wait_closed()
+
+    # await serve(...)
+
+    def __await__(self) -> Generator[Any, None, WebSocketServer]:
+        # Create a suitable iterator by calling __await__ on a coroutine.
+        return self.__await_impl__().__await__()
+
+    async def __await_impl__(self) -> WebSocketServer:
+        server = await self._create_server()
+        self.ws_server.wrap(server)
+        return self.ws_server
+
+    # yield from serve(...)
+
+    __iter__ = __await__
+
+
+serve = Serve
+
+
+def unix_serve(
+    ws_handler: Callable[[WebSocketServerProtocol, str], Awaitable[Any]],
+    path: str,
+    **kwargs: Any,
+) -> Serve:
+    """
+    Similar to :func:`serve`, but for listening on Unix sockets.
+
+    This function calls the event loop's
+    :meth:`~asyncio.loop.create_unix_server` method.
+
+    It is only available on Unix.
+
+    It's useful for deploying a server behind a reverse proxy such as nginx.
+
+    :param path: file system path to the Unix socket
+
+    """
+    return serve(ws_handler, path=path, **kwargs)

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/speedups.c

@@ -0,0 +1,206 @@
+/* C implementation of performance sensitive functions. */
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <stdint.h> /* uint32_t, uint64_t */
+
+#if __SSE2__
+#include <emmintrin.h>
+#endif
+
+static const Py_ssize_t MASK_LEN = 4;
+
+/* Similar to PyBytes_AsStringAndSize, but accepts more types */
+
+static int
+_PyBytesLike_AsStringAndSize(PyObject *obj, char **buffer, Py_ssize_t *length)
+{
+    // This supports bytes, bytearrays, and C-contiguous memoryview objects,
+    // which are the most useful data structures for handling byte streams.
+    // websockets.framing.prepare_data() returns only values of these types.
+    // Any object implementing the buffer protocol could be supported, however
+    // that would require allocation or copying memory, which is expensive.
+    if (PyBytes_Check(obj))
+    {
+        *buffer = PyBytes_AS_STRING(obj);
+        *length = PyBytes_GET_SIZE(obj);
+    }
+    else if (PyByteArray_Check(obj))
+    {
+        *buffer = PyByteArray_AS_STRING(obj);
+        *length = PyByteArray_GET_SIZE(obj);
+    }
+    else if (PyMemoryView_Check(obj))
+    {
+        Py_buffer *mv_buf;
+        mv_buf = PyMemoryView_GET_BUFFER(obj);
+        if (PyBuffer_IsContiguous(mv_buf, 'C'))
+        {
+            *buffer = mv_buf->buf;
+            *length = mv_buf->len;
+        }
+        else
+        {
+            PyErr_Format(
+                PyExc_TypeError,
+                "expected a contiguous memoryview");
+            return -1;
+        }
+    }
+    else
+    {
+        PyErr_Format(
+            PyExc_TypeError,
+            "expected a bytes-like object, %.200s found",
+            Py_TYPE(obj)->tp_name);
+        return -1;
+    }
+
+    return 0;
+}
+
+/* C implementation of websockets.utils.apply_mask */
+
+static PyObject *
+apply_mask(PyObject *self, PyObject *args, PyObject *kwds)
+{
+
+    // In order to support various bytes-like types, accept any Python object.
+
+    static char *kwlist[] = {"data", "mask", NULL};
+    PyObject *input_obj;
+    PyObject *mask_obj;
+
+    // A pointer to a char * + length will be extracted from the data and mask
+    // arguments, possibly via a Py_buffer.
+
+    char *input;
+    Py_ssize_t input_len;
+    char *mask;
+    Py_ssize_t mask_len;
+
+    // Initialize a PyBytesObject then get a pointer to the underlying char *
+    // in order to avoid an extra memory copy in PyBytes_FromStringAndSize.
+
+    PyObject *result;
+    char *output;
+
+    // Other variables.
+
+    Py_ssize_t i = 0;
+
+    // Parse inputs.
+
+    if (!PyArg_ParseTupleAndKeywords(
+            args, kwds, "OO", kwlist, &input_obj, &mask_obj))
+    {
+        return NULL;
+    }
+
+    if (_PyBytesLike_AsStringAndSize(input_obj, &input, &input_len) == -1)
+    {
+        return NULL;
+    }
+
+    if (_PyBytesLike_AsStringAndSize(mask_obj, &mask, &mask_len) == -1)
+    {
+        return NULL;
+    }
+
+    if (mask_len != MASK_LEN)
+    {
+        PyErr_SetString(PyExc_ValueError, "mask must contain 4 bytes");
+        return NULL;
+    }
+
+    // Create output.
+
+    result = PyBytes_FromStringAndSize(NULL, input_len);
+    if (result == NULL)
+    {
+        return NULL;
+    }
+
+    // Since we juste created result, we don't need error checks.
+    output = PyBytes_AS_STRING(result);
+
+    // Perform the masking operation.
+
+    // Apparently GCC cannot figure out the following optimizations by itself.
+
+    // We need a new scope for MSVC 2010 (non C99 friendly)
+    {
+#if __SSE2__
+
+        // With SSE2 support, XOR by blocks of 16 bytes = 128 bits.
+
+        // Since we cannot control the 16-bytes alignment of input and output
+        // buffers, we rely on loadu/storeu rather than load/store.
+
+        Py_ssize_t input_len_128 = input_len & ~15;
+        __m128i mask_128 = _mm_set1_epi32(*(uint32_t *)mask);
+
+        for (; i < input_len_128; i += 16)
+        {
+            __m128i in_128 = _mm_loadu_si128((__m128i *)(input + i));
+            __m128i out_128 = _mm_xor_si128(in_128, mask_128);
+            _mm_storeu_si128((__m128i *)(output + i), out_128);
+        }
+
+#else
+
+        // Without SSE2 support, XOR by blocks of 8 bytes = 64 bits.
+
+        // We assume the memory allocator aligns everything on 8 bytes boundaries.
+
+        Py_ssize_t input_len_64 = input_len & ~7;
+        uint32_t mask_32 = *(uint32_t *)mask;
+        uint64_t mask_64 = ((uint64_t)mask_32 << 32) | (uint64_t)mask_32;
+
+        for (; i < input_len_64; i += 8)
+        {
+            *(uint64_t *)(output + i) = *(uint64_t *)(input + i) ^ mask_64;
+        }
+
+#endif
+    }
+
+    // XOR the remainder of the input byte by byte.
+
+    for (; i < input_len; i++)
+    {
+        output[i] = input[i] ^ mask[i & (MASK_LEN - 1)];
+    }
+
+    return result;
+
+}
+
+static PyMethodDef speedups_methods[] = {
+    {
+        "apply_mask",
+        (PyCFunction)apply_mask,
+        METH_VARARGS | METH_KEYWORDS,
+        "Apply masking to websocket message.",
+    },
+    {NULL, NULL, 0, NULL},      /* Sentinel */
+};
+
+static struct PyModuleDef speedups_module = {
+    PyModuleDef_HEAD_INIT,
+    "websocket.speedups",       /* m_name */
+    "C implementation of performance sensitive functions.",
+                                /* m_doc */
+    -1,                         /* m_size */
+    speedups_methods,           /* m_methods */
+    NULL,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC
+PyInit_speedups(void)
+{
+    return PyModule_Create(&speedups_module);
+}

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/speedups.pyi

@@ -0,0 +1 @@
+def apply_mask(data: bytes, mask: bytes) -> bytes: ...

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/typing.py

@@ -0,0 +1,49 @@
+from typing import List, NewType, Optional, Tuple, Union
+
+
+__all__ = ["Data", "Origin", "ExtensionHeader", "ExtensionParameter", "Subprotocol"]
+
+Data = Union[str, bytes]
+
+Data__doc__ = """
+Types supported in a WebSocket message:
+
+- :class:`str` for text messages
+- :class:`bytes` for binary messages
+
+"""
+# Remove try / except when dropping support for Python < 3.7
+try:
+    Data.__doc__ = Data__doc__  # type: ignore
+except AttributeError:  # pragma: no cover
+    pass
+
+
+Origin = NewType("Origin", str)
+Origin.__doc__ = """Value of a Origin header"""
+
+
+ExtensionName = NewType("ExtensionName", str)
+ExtensionName.__doc__ = """Name of a WebSocket extension"""
+
+
+ExtensionParameter = Tuple[str, Optional[str]]
+
+ExtensionParameter__doc__ = """Parameter of a WebSocket extension"""
+try:
+    ExtensionParameter.__doc__ = ExtensionParameter__doc__  # type: ignore
+except AttributeError:  # pragma: no cover
+    pass
+
+
+ExtensionHeader = Tuple[ExtensionName, List[ExtensionParameter]]
+
+ExtensionHeader__doc__ = """Item parsed in a Sec-WebSocket-Extensions header"""
+try:
+    ExtensionHeader.__doc__ = ExtensionHeader__doc__  # type: ignore
+except AttributeError:  # pragma: no cover
+    pass
+
+
+Subprotocol = NewType("Subprotocol", str)
+Subprotocol.__doc__ = """Items parsed in a Sec-WebSocket-Protocol header"""

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/uri.py

@@ -0,0 +1,81 @@
+"""
+:mod:`websockets.uri` parses WebSocket URIs.
+
+See `section 3 of RFC 6455`_.
+
+.. _section 3 of RFC 6455: http://tools.ietf.org/html/rfc6455#section-3
+
+"""
+
+import urllib.parse
+from typing import NamedTuple, Optional, Tuple
+
+from .exceptions import InvalidURI
+
+
+__all__ = ["parse_uri", "WebSocketURI"]
+
+
+# Consider converting to a dataclass when dropping support for Python < 3.7.
+
+
+class WebSocketURI(NamedTuple):
+    """
+    WebSocket URI.
+
+    :param bool secure: secure flag
+    :param str host: lower-case host
+    :param int port: port, always set even if it's the default
+    :param str resource_name: path and optional query
+    :param str user_info: ``(username, password)`` tuple when the URI contains
+      `User Information`_, else ``None``.
+
+    .. _User Information: https://tools.ietf.org/html/rfc3986#section-3.2.1
+    """
+
+    secure: bool
+    host: str
+    port: int
+    resource_name: str
+    user_info: Optional[Tuple[str, str]]
+
+
+# Work around https://bugs.python.org/issue19931
+
+WebSocketURI.secure.__doc__ = ""
+WebSocketURI.host.__doc__ = ""
+WebSocketURI.port.__doc__ = ""
+WebSocketURI.resource_name.__doc__ = ""
+WebSocketURI.user_info.__doc__ = ""
+
+
+def parse_uri(uri: str) -> WebSocketURI:
+    """
+    Parse and validate a WebSocket URI.
+
+    :raises ValueError: if ``uri`` isn't a valid WebSocket URI.
+
+    """
+    parsed = urllib.parse.urlparse(uri)
+    try:
+        assert parsed.scheme in ["ws", "wss"]
+        assert parsed.params == ""
+        assert parsed.fragment == ""
+        assert parsed.hostname is not None
+    except AssertionError as exc:
+        raise InvalidURI(uri) from exc
+
+    secure = parsed.scheme == "wss"
+    host = parsed.hostname
+    port = parsed.port or (443 if secure else 80)
+    resource_name = parsed.path or "/"
+    if parsed.query:
+        resource_name += "?" + parsed.query
+    user_info = None
+    if parsed.username is not None:
+        # urllib.parse.urlparse accepts URLs with a username but without a
+        # password. This doesn't make sense for HTTP Basic Auth credentials.
+        if parsed.password is None:
+            raise InvalidURI(uri)
+        user_info = (parsed.username, parsed.password)
+    return WebSocketURI(secure, host, port, resource_name, user_info)

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/utils.py

@@ -0,0 +1,18 @@
+import itertools
+
+
+__all__ = ["apply_mask"]
+
+
+def apply_mask(data: bytes, mask: bytes) -> bytes:
+    """
+    Apply masking to the data of a WebSocket message.
+
+    :param data: Data to mask
+    :param mask: 4-bytes mask
+
+    """
+    if len(mask) != 4:
+        raise ValueError("mask must contain 4 bytes")
+
+    return bytes(b ^ m for b, m in zip(data, itertools.cycle(mask)))

third_party/wpt_tools/wpt/tools/third_party/websockets/src/websockets/version.py

@@ -0,0 +1 @@
+version = "8.1"

third_party/wpt_tools/wpt/tools/third_party/websockets/tox.ini

@@ -0,0 +1,28 @@
+[tox]
+envlist = py36,py37,py38,coverage,black,flake8,isort,mypy
+
+[testenv]
+commands = python -W default -m unittest {posargs}
+
+[testenv:coverage]
+commands =
+    python -m coverage erase
+    python -W default -m coverage run -m unittest {posargs}
+    python -m coverage report --show-missing --fail-under=100
+deps = coverage
+
+[testenv:black]
+commands = black --check src tests
+deps = black
+
+[testenv:flake8]
+commands = flake8 src tests
+deps = flake8
+
+[testenv:isort]
+commands = isort --check-only --recursive src tests
+deps = isort
+
+[testenv:mypy]
+commands = mypy --strict src
+deps = mypy

third_party/wpt_tools/wpt/tools/webdriver/webdriver/__init__.py

@@ -35,3 +35,5 @@ from .error import (
     UnknownMethodException,
     UnsupportedOperationException,
     WebDriverException)
+from .bidi import (
+    BidiSession)

third_party/wpt_tools/wpt/tools/webdriver/webdriver/bidi.py

@@ -0,0 +1,56 @@
+import copy
+import websockets
+
+from . import client
+
+class BidiSession(client.Session):
+    def __init__(self,
+                 host,
+                 port,
+                 url_prefix="/",
+                 capabilities=None,
+                 extension=None):
+        """
+        Add a capability of "webSocketUrl": True to enable
+        Bidirectional connection in session creation.
+        """
+        self.websocket_transport = None
+        capabilities = self._enable_websocket(capabilities)
+        super().__init__(host, port, url_prefix, capabilities, extension)
+
+    def _enable_websocket(self, caps):
+        if caps:
+            caps.setdefault("alwaysMatch", {}).update({"webSocketUrl": True})
+        else:
+            caps = {"alwaysMatch": {"webSocketUrl": True}}
+        return caps
+
+    def match(self, capabilities):
+        """Expensive match to see if capabilities is the same as previously
+        requested capabilities if websocket would be enabled.
+
+        :return Boolean.
+        """
+        caps = copy.deepcopy(capabilities)
+        caps = self._enable_websocket(caps)
+        return super().match(caps)
+
+    async def start(self):
+        """Start a new WebDriver Bidirectional session
+        with websocket connected.
+
+        :return: Dictionary with `capabilities` and `sessionId`.
+        """
+        value = super().start()
+
+        if not self.websocket_transport or not self.websocket_transport.open:
+            self.websocket_transport = await websockets.connect(self.capabilities["webSocketUrl"])
+        return value
+
+    async def end(self):
+        """Close websocket connection first before closing session.
+        """
+        if self.websocket_transport:
+            await self.websocket_transport.close()
+            self.websocket_transport = None
+        super().end()

third_party/wpt_tools/wpt/tools/webdriver/webdriver/client.py

@@ -2,8 +2,7 @@ from . import error
 from . import protocol
 from . import transport
 
-from six import string_types
-from six.moves.urllib import parse as urlparse
+from urllib import parse as urlparse
 
 
 def command(func):
@@ -435,7 +434,7 @@ class Cookies(object):
         cookie = {"name": name,
                   "value": None}
 
-        if isinstance(name, string_types):
+        if isinstance(name, str):
             cookie["value"] = value
         elif hasattr(value, "value"):
             cookie["value"] = value.value
@@ -506,6 +505,9 @@ class Session(object):
     def __del__(self):
         self.end()
 
+    def match(self, capabilities):
+        return self.requested_capabilities == capabilities
+
     def start(self):
         """Start a new WebDriver session.
 
@@ -753,7 +755,6 @@ class Session(object):
     def screenshot(self):
         return self.send_session_command("GET", "screenshot")
 
-
 class Element(object):
     """
     Representation of a web element.

third_party/wpt_tools/wpt/tools/webdriver/webdriver/error.py

@@ -1,8 +1,6 @@
 import collections
 import json
 
-from six import itervalues
-
 
 class WebDriverException(Exception):
     http_status = None
@@ -220,6 +218,6 @@ def get(error_code):
 
 
 _errors = collections.defaultdict()
-for item in list(itervalues(locals())):
+for item in list(locals().values()):
     if type(item) == type and issubclass(item, WebDriverException):
         _errors[item.status_code] = item

third_party/wpt_tools/wpt/tools/webdriver/webdriver/protocol.py

@@ -2,8 +2,6 @@ import json
 
 import webdriver
 
-from six import iteritems
-
 
 """WebDriver wire protocol codecs."""
 
@@ -45,5 +43,5 @@ class Decoder(json.JSONDecoder):
         elif isinstance(payload, dict) and webdriver.ShadowRoot.identifier in payload:
             return webdriver.ShadowRoot.from_json(payload, self.session)
         elif isinstance(payload, dict):
-            return {k: self.object_hook(v) for k, v in iteritems(payload)}
+            return {k: self.object_hook(v) for k, v in payload.items()}
         return payload

third_party/wpt_tools/wpt/tools/webdriver/webdriver/transport.py

@@ -1,10 +1,9 @@
 import json
 import select
 
-from six import text_type, PY3
-from six.moves.collections_abc import Mapping
-from six.moves.http_client import HTTPConnection
-from six.moves.urllib import parse as urlparse
+from collections.abc import Mapping
+from http.client import HTTPConnection
+from urllib import parse as urlparse
 
 from . import error
 
@@ -157,8 +156,6 @@ class HTTPWireProtocol(object):
         """Gets the current HTTP connection, or lazily creates one."""
         if not self._conn:
             conn_kwargs = {}
-            if not PY3:
-                conn_kwargs["strict"] = True
             # We are not setting an HTTP timeout other than the default when the
             # connection its created. The send method has a timeout value if needed.
             self._conn = HTTPConnection(self.host, self.port, **conn_kwargs)
@@ -240,7 +237,7 @@ class HTTPWireProtocol(object):
         return Response.from_http(response, decoder=decoder, **codec_kwargs)
 
     def _request(self, method, uri, payload, headers=None, timeout=None):
-        if isinstance(payload, text_type):
+        if isinstance(payload, str):
             payload = payload.encode("utf-8")
 
         if headers is None:

third_party/wpt_tools/wpt/tools/wpt/android.py

@@ -89,8 +89,8 @@ def install_android_packages(logger, sdk_path, no_prompt=False):
 
     #TODO: Not sure what's really needed here
     packages = ["platform-tools",
-                "build-tools;29.0.3",
-                "platforms;android-29",
+                "build-tools;30.0.2",
+                "platforms;android-30",
                 "emulator"]
 
     # TODO: make this work non-internactively

third_party/wpt_tools/wpt/tools/wpt/browser.py

@@ -9,7 +9,7 @@ from abc import ABCMeta, abstractmethod
 from datetime import datetime, timedelta
 from distutils.spawn import find_executable
 
-from six.moves.urllib.parse import urlsplit
+from urllib.parse import urlsplit
 import requests
 
 from .utils import call, get, rmtree, untar, unzip, get_download_to_descriptor, sha256sum

third_party/wpt_tools/wpt/tools/wpt/run.py

@@ -3,7 +3,6 @@ import os
 import platform
 import sys
 from distutils.spawn import find_executable
-from six.moves import input
 
 wpt_root = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir))
 sys.path.insert(0, os.path.abspath(os.path.join(wpt_root, "tools")))
@@ -757,9 +756,8 @@ def setup_logging(kwargs, default_config=None, formatter_defaults=None):
 
 def setup_wptrunner(venv, **kwargs):
     from wptrunner import wptcommandline
-    from six import iteritems
 
-    kwargs = utils.Kwargs(iteritems(kwargs))
+    kwargs = utils.Kwargs(kwargs.items())
 
     kwargs["product"] = kwargs["product"].replace("-", "_")
 

third_party/wpt_tools/wpt/tools/wpt/testfiles.py

@@ -6,7 +6,7 @@ import subprocess
 import sys
 
 from collections import OrderedDict
-from six import ensure_text, ensure_str, iteritems
+from six import ensure_text, ensure_str
 
 try:
     from ..manifest import manifest
@@ -98,7 +98,7 @@ def branch_point():
         branch_point = None
 
         # if there are any commits, take the first parent that is not in commits
-        for commit, parents in iteritems(commit_parents):
+        for commit, parents in commit_parents.items():
             for parent in parents:
                 if parent not in commit_parents:
                     branch_point = parent
@@ -251,7 +251,7 @@ def affected_testfiles(files_changed,  # type: Iterable[Text]
     nontests_changed = set(files_changed)
     wpt_manifest = load_manifest(manifest_path, manifest_update)
 
-    test_types = ["crashtest", "testharness", "reftest", "wdspec"]
+    test_types = ["crashtest", "print-reftest", "reftest", "testharness", "wdspec"]
     support_files = {os.path.join(wpt_root, path)
                      for _, path, _ in wpt_manifest.itertypes("support")}
     wdspec_test_files = {os.path.join(wpt_root, path)

third_party/wpt_tools/wpt/tools/wpt/utils.py

@@ -9,7 +9,7 @@ import time
 import zipfile
 from io import BytesIO
 from socket import error as SocketError  # NOQA: N812
-from six.moves.urllib.request import urlopen
+from urllib.request import urlopen
 
 MYPY = False
 if MYPY:

third_party/wpt_tools/wpt/tools/wpt/virtualenv.py

@@ -55,13 +55,9 @@ class Virtualenv(object):
 
     @property
     def pip_path(self):
-        if sys.version_info.major >= 3:
-            pip_executable = "pip3"
-        else:
-            pip_executable = "pip2"
-        path = find_executable(pip_executable, self.bin_path)
+        path = find_executable("pip3", self.bin_path)
         if path is None:
-            raise ValueError("%s not found" % pip_executable)
+            raise ValueError("pip3 not found")
         return path
 
     @property

third_party/wpt_tools/wpt/tools/wpt/wpt.py

@@ -6,7 +6,6 @@ import sys
 
 from tools import localpaths  # noqa: F401
 
-from six import iteritems
 from . import virtualenv
 
 
@@ -23,7 +22,7 @@ def load_commands():
         base_dir = os.path.dirname(abs_path)
         with open(abs_path, "r") as f:
             data = json.load(f)
-            for command, props in iteritems(data):
+            for command, props in data.items():
                 assert "path" in props
                 assert "script" in props
                 rv[command] = {
@@ -31,7 +30,6 @@ def load_commands():
                     "script": props["script"],
                     "parser": props.get("parser"),
                     "parse_known": props.get("parse_known", False),
-                    "py3only": props.get("py3only", False),
                     "help": props.get("help"),
                     "virtualenv": props.get("virtualenv", True),
                     "install": props.get("install", []),
@@ -50,12 +48,8 @@ def parse_args(argv, commands=load_commands()):
                         dest="skip_venv_setup",
                         help="Whether to use the virtualenv as-is. Must set --venv as well")
     parser.add_argument("--debug", action="store_true", help="Run the debugger in case of an exception")
-    parser.add_argument("--py3", action="store_true",
-                        help="Run with Python 3 (requires a `python3` binary on the PATH)")
-    parser.add_argument("--py2", action="store_true",
-                        help="Run with Python 2 (requires a `python2` binary on the PATH)")
     subparsers = parser.add_subparsers(dest="command")
-    for command, props in iteritems(commands):
+    for command, props in commands.items():
         subparsers.add_parser(command, help=props["help"], add_help=False)
 
     args, extra = parser.parse_known_args(argv)
@@ -100,8 +94,7 @@ def create_complete_parser():
     for command in commands:
         props = commands[command]
 
-        if (props["virtualenv"] and
-            (not props["py3only"] or sys.version_info.major == 3)):
+        if props["virtualenv"]:
             setup_virtualenv(None, False, props)
 
         subparser = import_command('wpt', command, props)[1]

third_party/wpt_tools/wpt/tools/wptrunner/requirements.txt

@@ -4,7 +4,7 @@ mozlog==7.1.0
 mozdebug==0.2
 # Pillow 7 requires Python 3
 pillow==6.2.2; python_version <= '2.7'  # pyup: <7.0
-pillow==8.1.0; python_version >= '3.0'
-urllib3[secure]==1.26.2
+pillow==8.1.2; python_version >= '3.0'
+urllib3[secure]==1.26.4
 requests==2.25.1
 six==1.15.0

third_party/wpt_tools/wpt/tools/wptrunner/requirements_safari.txt

@@ -1 +1,2 @@
 mozprocess==1.2.1
+psutil==5.8.0

third_party/wpt_tools/wpt/tools/wptrunner/tox.ini

@@ -2,7 +2,7 @@
 xfail_strict=true
 
 [tox]
-envlist = py27-{base,chrome,edge,firefox,ie,opera,safari,sauce,servo,webkit,webkitgtk_minibrowser,epiphany},{py35,py36,py37,py38}-base
+envlist = py38-{base,chrome,edge,firefox,ie,opera,safari,sauce,servo,webkit,webkitgtk_minibrowser,epiphany},{py36,py37}-base
 skip_missing_interpreters = False
 
 [testenv]

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/android_weblayer.py

@@ -1,9 +1,7 @@
-import subprocess
-
-from .base import Browser, ExecutorBrowser, require_arg
+from .base import require_arg
 from .base import get_timeout_multiplier   # noqa: F401
 from .chrome import executor_kwargs as chrome_executor_kwargs
-from ..webdriver_server import ChromeDriverServer
+from .chrome_android import ChromeAndroidBrowserBase
 from ..executors.executorwebdriver import (WebDriverTestharnessExecutor,  # noqa: F401
                                            WebDriverRefTestExecutor)  # noqa: F401
 from ..executors.executorchrome import ChromeDriverWdspecExecutor  # noqa: F401
@@ -32,7 +30,9 @@ def browser_kwargs(logger, test_type, run_info_data, config, **kwargs):
     return {"binary": kwargs["binary"],
             "device_serial": kwargs["device_serial"],
             "webdriver_binary": kwargs["webdriver_binary"],
-            "webdriver_args": kwargs.get("webdriver_args")}
+            "webdriver_args": kwargs.get("webdriver_args"),
+            "stackparser_script": kwargs.get("stackparser_script"),
+            "output_directory": kwargs.get("output_directory")}
 
 
 def executor_kwargs(logger, test_type, server_config, cache_manager, run_info_data,
@@ -74,61 +74,22 @@ def env_options():
     return {"server_host": "127.0.0.1"}
 
 
-#TODO: refactor common elements of WeblayerShell and ChromeAndroidBrowser
-class WeblayerShell(Browser):
+class WeblayerShell(ChromeAndroidBrowserBase):
     """Chrome is backed by chromedriver, which is supplied through
     ``wptrunner.webdriver.ChromeDriverServer``.
     """
 
-    def __init__(self, logger, binary, webdriver_binary="chromedriver",
+    def __init__(self, logger, binary,
+                 webdriver_binary="chromedriver",
+                 remote_queue=None,
                  device_serial=None,
-                 webdriver_args=None):
+                 webdriver_args=None,
+                 stackparser_script=None,
+                 output_directory=None):
         """Creates a new representation of Chrome.  The `binary` argument gives
         the browser binary to use for testing."""
-        Browser.__init__(self, logger)
+        super(WeblayerShell, self).__init__(logger,
+                webdriver_binary, remote_queue, device_serial,
+                webdriver_args, stackparser_script, output_directory)
         self.binary = binary
-        self.device_serial = device_serial
-        self.server = ChromeDriverServer(self.logger,
-                                         binary=webdriver_binary,
-                                         args=webdriver_args)
-        self.setup_adb_reverse()
-
-    def _adb_run(self, args):
-        cmd = ['adb']
-        if self.device_serial:
-            cmd.extend(['-s', self.device_serial])
-        cmd.extend(args)
-        self.logger.info(' '.join(cmd))
-        subprocess.check_call(cmd)
-
-    def setup_adb_reverse(self):
-        self._adb_run(['wait-for-device'])
-        self._adb_run(['forward', '--remove-all'])
-        self._adb_run(['reverse', '--remove-all'])
-        # "adb reverse" basically forwards network connection from device to
-        # host.
-        for port in _wptserve_ports:
-            self._adb_run(['reverse', 'tcp:%d' % port, 'tcp:%d' % port])
-
-    def start(self, **kwargs):
-        self.server.start(block=False)
-
-    def stop(self, force=False):
-        self.server.stop(force=force)
-
-    def pid(self):
-        return self.server.pid
-
-    def is_alive(self):
-        # TODO(ato): This only indicates the driver is alive,
-        # and doesn't say anything about whether a browser session
-        # is active.
-        return self.server.is_alive()
-
-    def cleanup(self):
-        self.stop()
-        self._adb_run(['forward', '--remove-all'])
-        self._adb_run(['reverse', '--remove-all'])
-
-    def executor_browser(self):
-        return ExecutorBrowser, {"webdriver_url": self.server.url}
+        self.wptserver_ports = _wptserve_ports

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/android_webview.py

@@ -1,9 +1,7 @@
-import subprocess
-
-from .base import Browser, ExecutorBrowser, require_arg
+from .base import require_arg
 from .base import get_timeout_multiplier   # noqa: F401
 from .chrome import executor_kwargs as chrome_executor_kwargs
-from ..webdriver_server import ChromeDriverServer
+from .chrome_android import ChromeAndroidBrowserBase
 from ..executors.executorwebdriver import (WebDriverTestharnessExecutor,  # noqa: F401
                                            WebDriverRefTestExecutor)  # noqa: F401
 from ..executors.executorchrome import ChromeDriverWdspecExecutor  # noqa: F401
@@ -32,7 +30,9 @@ def browser_kwargs(logger, test_type, run_info_data, config, **kwargs):
     return {"binary": kwargs["binary"],
             "device_serial": kwargs["device_serial"],
             "webdriver_binary": kwargs["webdriver_binary"],
-            "webdriver_args": kwargs.get("webdriver_args")}
+            "webdriver_args": kwargs.get("webdriver_args"),
+            "stackparser_script": kwargs.get("stackparser_script"),
+            "output_directory": kwargs.get("output_directory")}
 
 
 def executor_kwargs(logger, test_type, server_config, cache_manager, run_info_data,
@@ -51,10 +51,11 @@ def executor_kwargs(logger, test_type, server_config, cache_manager, run_info_da
     # Note that for WebView, we launch a test shell and have the test shell use WebView.
     # https://chromium.googlesource.com/chromium/src/+/HEAD/android_webview/docs/webview-shell.md
     capabilities["goog:chromeOptions"]["androidPackage"] = \
-        "org.chromium.webview_shell"
-    capabilities["goog:chromeOptions"]["androidActivity"] = ".WebPlatformTestsActivity"
-    if kwargs.get('device_serial'):
-        capabilities["goog:chromeOptions"]["androidDeviceSerial"] = kwargs['device_serial']
+        kwargs.get("package_name", "org.chromium.webview_shell")
+    capabilities["goog:chromeOptions"]["androidActivity"] = \
+        "org.chromium.webview_shell.WebPlatformTestsActivity"
+    if kwargs.get("device_serial"):
+        capabilities["goog:chromeOptions"]["androidDeviceSerial"] = kwargs["device_serial"]
 
     # Workaround: driver.quit() cannot quit SystemWebViewShell.
     executor_kwargs["pause_after_test"] = False
@@ -73,61 +74,21 @@ def env_options():
     return {"server_host": "127.0.0.1"}
 
 
-#TODO: refactor common elements of SystemWebViewShell and ChromeAndroidBrowser
-class SystemWebViewShell(Browser):
+class SystemWebViewShell(ChromeAndroidBrowserBase):
     """Chrome is backed by chromedriver, which is supplied through
     ``wptrunner.webdriver.ChromeDriverServer``.
     """
 
     def __init__(self, logger, binary, webdriver_binary="chromedriver",
+                 remote_queue=None,
                  device_serial=None,
-                 webdriver_args=None):
+                 webdriver_args=None,
+                 stackparser_script=None,
+                 output_directory=None):
         """Creates a new representation of Chrome.  The `binary` argument gives
         the browser binary to use for testing."""
-        Browser.__init__(self, logger)
+        super(SystemWebViewShell, self).__init__(logger,
+                webdriver_binary, remote_queue, device_serial,
+                webdriver_args, stackparser_script, output_directory)
         self.binary = binary
-        self.device_serial = device_serial
-        self.server = ChromeDriverServer(self.logger,
-                                         binary=webdriver_binary,
-                                         args=webdriver_args)
-        self.setup_adb_reverse()
-
-    def _adb_run(self, args):
-        cmd = ['adb']
-        if self.device_serial:
-            cmd.extend(['-s', self.device_serial])
-        cmd.extend(args)
-        self.logger.info(' '.join(cmd))
-        subprocess.check_call(cmd)
-
-    def setup_adb_reverse(self):
-        self._adb_run(['wait-for-device'])
-        self._adb_run(['forward', '--remove-all'])
-        self._adb_run(['reverse', '--remove-all'])
-        # "adb reverse" basically forwards network connection from device to
-        # host.
-        for port in _wptserve_ports:
-            self._adb_run(['reverse', 'tcp:%d' % port, 'tcp:%d' % port])
-
-    def start(self, **kwargs):
-        self.server.start(block=False)
-
-    def stop(self, force=False):
-        self.server.stop(force=force)
-
-    def pid(self):
-        return self.server.pid
-
-    def is_alive(self):
-        # TODO(ato): This only indicates the driver is alive,
-        # and doesn't say anything about whether a browser session
-        # is active.
-        return self.server.is_alive()
-
-    def cleanup(self):
-        self.stop()
-        self._adb_run(['forward', '--remove-all'])
-        self._adb_run(['reverse', '--remove-all'])
-
-    def executor_browser(self):
-        return ExecutorBrowser, {"webdriver_url": self.server.url}
+        self.wptserver_ports = _wptserve_ports

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/base.py

@@ -3,7 +3,6 @@ import platform
 import socket
 from abc import ABCMeta, abstractmethod
 from copy import deepcopy
-from six import iteritems
 
 from ..wptcommandline import require_arg  # noqa: F401
 
@@ -163,6 +162,10 @@ class Browser(object):
         with which it should be instantiated"""
         return ExecutorBrowser, {}
 
+    def maybe_parse_tombstone(self):
+        """Possibly parse tombstones on Android device for Android target"""
+        pass
+
     def check_crash(self, process, test):
         """Check if a crash occured and output any useful information to the
         log. Returns a boolean indicating whether a crash occured."""
@@ -202,5 +205,5 @@ class ExecutorBrowser(object):
     up the browser from the runner process.
     """
     def __init__(self, **kwargs):
-        for k, v in iteritems(kwargs):
+        for k, v in kwargs.items():
             setattr(self, k, v)

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/chrome.py

@@ -113,7 +113,7 @@ class ChromeBrowser(Browser):
     """
 
     def __init__(self, logger, binary, webdriver_binary="chromedriver",
-                 webdriver_args=None):
+                 webdriver_args=None, **kwargs):
         """Creates a new representation of Chrome.  The `binary` argument gives
         the browser binary to use for testing."""
         Browser.__init__(self, logger)

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/chrome_android.py

@@ -1,3 +1,4 @@
+import mozprocess
 import subprocess
 
 from .base import Browser, ExecutorBrowser, require_arg
@@ -33,7 +34,9 @@ def browser_kwargs(logger, test_type, run_info_data, config, **kwargs):
     return {"package_name": kwargs["package_name"],
             "device_serial": kwargs["device_serial"],
             "webdriver_binary": kwargs["webdriver_binary"],
-            "webdriver_args": kwargs.get("webdriver_args")}
+            "webdriver_args": kwargs.get("webdriver_args"),
+            "stackparser_script": kwargs.get("stackparser_script"),
+            "output_directory": kwargs.get("output_directory")}
 
 
 def executor_kwargs(logger, test_type, server_config, cache_manager, run_info_data,
@@ -68,21 +71,80 @@ def env_options():
     # allow the use of host-resolver-rules in lieu of modifying /etc/hosts file
     return {"server_host": "127.0.0.1"}
 
+class LogcatRunner(object):
+    def __init__(self, logger, browser, remote_queue):
+        self.logger = logger
+        self.browser = browser
+        self.remote_queue = remote_queue
 
-class ChromeAndroidBrowser(Browser):
-    """Chrome is backed by chromedriver, which is supplied through
-    ``wptrunner.webdriver.ChromeDriverServer``.
-    """
+    def start(self):
+        try:
+            self._run()
+        except KeyboardInterrupt:
+            self.stop()
 
-    def __init__(self, logger, package_name, webdriver_binary="chromedriver",
-                 device_serial=None, webdriver_args=None):
-        Browser.__init__(self, logger)
-        self.package_name = package_name
+    def _run(self):
+        try:
+            # TODO: adb logcat -c fail randomly with message
+            # "failed to clear the 'main' log"
+            self.browser.clear_log()
+        except subprocess.CalledProcessError:
+            self.logger.error("Failed to clear logcat buffer")
+
+        self._cmd = self.browser.logcat_cmd()
+        self._proc = mozprocess.ProcessHandler(
+            self._cmd,
+            processOutputLine=self.on_output,
+            storeOutput=False)
+        self._proc.run()
+
+    def _send_message(self, command, *args):
+        try:
+            self.remote_queue.put((command, args))
+        except AssertionError:
+            self.logger.warning("Error when send to remote queue")
+
+    def stop(self, force=False):
+        if self.is_alive():
+            kill_result = self._proc.kill()
+            if force and kill_result != 0:
+                self._proc.kill(9)
+
+    def is_alive(self):
+        return hasattr(self._proc, "proc") and self._proc.poll() is None
+
+    def on_output(self, line):
+        data = {
+            "process": "LOGCAT",
+            "command": "logcat",
+            "data": line
+        }
+        self._send_message("log", "process_output", data)
+
+class ChromeAndroidBrowserBase(Browser):
+    def __init__(self, logger,
+                 webdriver_binary="chromedriver",
+                 remote_queue = None,
+                 device_serial=None,
+                 webdriver_args=None,
+                 stackparser_script=None,
+                 output_directory=None):
+        super(ChromeAndroidBrowserBase, self).__init__(logger)
         self.device_serial = device_serial
+        self.stackparser_script = stackparser_script
+        self.output_directory = output_directory
+        self.remote_queue = remote_queue
         self.server = ChromeDriverServer(self.logger,
                                          binary=webdriver_binary,
                                          args=webdriver_args)
+        if self.remote_queue is not None:
+            self.logcat_runner = LogcatRunner(self.logger,
+                                          self, self.remote_queue)
+
+    def setup(self):
         self.setup_adb_reverse()
+        if self.remote_queue is not None:
+            self.logcat_runner.start()
 
     def _adb_run(self, args):
         cmd = ['adb']
@@ -92,14 +154,6 @@ class ChromeAndroidBrowser(Browser):
         self.logger.info(' '.join(cmd))
         subprocess.check_call(cmd)
 
-    def setup_adb_reverse(self):
-        self._adb_run(['wait-for-device'])
-        self._adb_run(['forward', '--remove-all'])
-        self._adb_run(['reverse', '--remove-all'])
-        # "adb reverse" forwards network connection from device to host.
-        for port in _wptserve_ports:
-            self._adb_run(['reverse', 'tcp:%d' % port, 'tcp:%d' % port])
-
     def start(self, **kwargs):
         self.server.start(block=False)
 
@@ -119,6 +173,54 @@ class ChromeAndroidBrowser(Browser):
         self.stop()
         self._adb_run(['forward', '--remove-all'])
         self._adb_run(['reverse', '--remove-all'])
+        if self.remote_queue is not None:
+            self.logcat_runner.stop(force=True)
 
     def executor_browser(self):
         return ExecutorBrowser, {"webdriver_url": self.server.url}
+
+    def clear_log(self):
+        self._adb_run(['logcat', '-c'])
+
+    def logcat_cmd(self):
+        cmd = ['adb']
+        if self.device_serial:
+            cmd.extend(['-s', self.device_serial])
+        cmd.extend(['logcat', '*:D'])
+        return cmd
+
+    def maybe_parse_tombstone(self, logger):
+        if self.stackparser_script:
+            cmd = [self.stackparser_script, "-a", "-w"]
+            if self.device_serial:
+                cmd.extend(["--device", self.device_serial])
+            cmd.extend(["--output-directory", self.output_directory])
+            raw_output = subprocess.check_output(cmd)
+            for line in raw_output.splitlines():
+                logger.process_output("TRACE", line, "logcat")
+
+    def setup_adb_reverse(self):
+        self._adb_run(['wait-for-device'])
+        self._adb_run(['forward', '--remove-all'])
+        self._adb_run(['reverse', '--remove-all'])
+        # "adb reverse" forwards network connection from device to host.
+        for port in self.wptserver_ports:
+            self._adb_run(['reverse', 'tcp:%d' % port, 'tcp:%d' % port])
+
+class ChromeAndroidBrowser(ChromeAndroidBrowserBase):
+    """Chrome is backed by chromedriver, which is supplied through
+    ``wptrunner.webdriver.ChromeDriverServer``.
+    """
+
+    def __init__(self, logger, package_name,
+                 webdriver_binary="chromedriver",
+                 remote_queue = None,
+                 device_serial=None,
+                 webdriver_args=None,
+                 stackparser_script=None,
+                 output_directory=None):
+        super(ChromeAndroidBrowser, self).__init__(logger,
+                webdriver_binary, remote_queue, device_serial,
+                webdriver_args, stackparser_script, output_directory)
+        self.package_name = package_name
+        self.wptserver_ports = _wptserve_ports

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/chrome_ios.py

@@ -51,7 +51,7 @@ class ChromeiOSBrowser(Browser):
 
     init_timeout = 120
 
-    def __init__(self, logger, webdriver_binary, webdriver_args=None):
+    def __init__(self, logger, webdriver_binary, webdriver_args=None, **kwargs):
         """Creates a new representation of Chrome."""
         Browser.__init__(self, logger)
         self.server = CWTChromeDriverServer(self.logger,

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/chrome_spki_certs.py

@@ -2,7 +2,7 @@
 # DO NOT EDIT MANUALLY.
 
 # tools/certs/web-platform.test.pem
-WPT_FINGERPRINT = 'OXb4O8pcDI8Nwx3KzqNuTbJ1Znf52VjEVWiYYCjHcIM='
+WPT_FINGERPRINT = 'LjjEE/m/0BKndI/KeccXvPp5wHuXfV09jw9QS7OGIvI='
 
 # signed-exchange/resources/127.0.0.1.sxg.pem
 SXG_WPT_FINGERPRINT = '0Rt4mT6SJXojEMHTnKnlJ/hBKMBcI4kteBlhR1eTTdk='

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/edge.py

@@ -68,7 +68,8 @@ class EdgeBrowser(Browser):
     used_ports = set()
     init_timeout = 60
 
-    def __init__(self, logger, webdriver_binary, timeout_multiplier=None, webdriver_args=None):
+    def __init__(self, logger, webdriver_binary,
+            timeout_multiplier=None, webdriver_args=None, **kwargs):
         Browser.__init__(self, logger)
         self.server = EdgeDriverServer(self.logger,
                                        binary=webdriver_binary,

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/edgechromium.py

@@ -85,7 +85,7 @@ class EdgeChromiumBrowser(Browser):
     """
 
     def __init__(self, logger, binary, webdriver_binary="msedgedriver",
-                 webdriver_args=None):
+                 webdriver_args=None, **kwargs):
         """Creates a new representation of MicrosoftEdge.  The `binary` argument gives
         the browser binary to use for testing."""
         Browser.__init__(self, logger)

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/epiphany.py

@@ -72,6 +72,6 @@ def run_info_extras(**kwargs):
 
 class EpiphanyBrowser(WebKitBrowser):
     def __init__(self, logger, binary=None, webdriver_binary=None,
-                 webdriver_args=None):
+                 webdriver_args=None, **kwargs):
         WebKitBrowser.__init__(self, logger, binary, webdriver_binary,
                                webdriver_args)

third_party/wpt_tools/wpt/tools/wptrunner/wptrunner/browsers/firefox.py

@@ -196,7 +196,8 @@ def run_info_extras(**kwargs):
           "fission": kwargs.get("enable_fission") or get_bool_pref("fission.autostart"),
           "sessionHistoryInParent": (kwargs.get("enable_fission") or
                                      get_bool_pref("fission.autostart") or
-                                     get_bool_pref("fission.sessionHistoryInParent"))}
+                                     get_bool_pref("fission.sessionHistoryInParent")),
+          "swgl": get_bool_pref("gfx.webrender.software")}
 
     # The value of `sw-e10s` defaults to whether the "parent_intercept"
     # implementation is enabled for the current build. This value, however,
@@ -226,7 +227,7 @@ def run_info_browser_version(**kwargs):
 
 
 def update_properties():
-    return (["os", "debug", "webrender", "fission", "e10s", "sw-e10s", "processor"],
+    return (["os", "debug", "webrender", "fission", "e10s", "sw-e10s", "processor", "swgl"],
             {"os": ["version"], "processor": ["bits"]})