Bug 1868470 - Add new OffscreenCanvas and WebCodecs talos tests. r=perftest-reviewers,sparky

This patch adds new variants of the glvideo/canvas2dvideo talos tests,
but this time focused on OffscreenCanvas and WebCodecs.

There are test variants for each:
- Execution thread (main thread or DOM worker)
- Canvas type (WebGL or 2D canvas)
- Codec type (H264, VP9 or AV1)

They are included as part of the existing webgl talos job.

Differential Revision: https://phabricator.services.mozilla.com/D196465

.prettierignore

@@ -1187,6 +1187,8 @@ testing/mozbase/mozprofile/tests/files/prefs_with_comments.js
 testing/mozharness/configs/test/test_malformed.json
 testing/talos/talos/startup_test/sessionrestore/profile/sessionstore.js
 testing/talos/talos/startup_test/sessionrestore/profile-manywindows/sessionstore.js
+testing/talos/talos/tests/offscreencanvas/benchmarks/video/demuxer_mp4.js
+testing/talos/talos/tests/offscreencanvas/benchmarks/video/mp4box.all.min.js
 # Python json.
 testing/talos/talos/unittests/test_talosconfig_browser_config.json
 testing/talos/talos/unittests/test_talosconfig_test_config.json

taskcluster/ci/test/talos.yml

@@ -724,6 +724,7 @@ talos-webgl-profiling:
         extra-options:
             - --suite=webgl
             - --gecko-profile
+            - --setpref=dom.media.webcodecs.enabled=true
 
 talos-xperf:
     description: Talos xperf

testing/talos/moz.build

@@ -29,6 +29,9 @@ with Files("talos/tests/dromaeo/**"):
 with Files("talos/tests/kraken/**"):
     BUG_COMPONENT = ("Core", "JavaScript Engine")
 
+with Files("talos/tests/offscreencanvas/**"):
+    BUG_COMPONENT = ("Core", "Graphics: Canvas2D")
+
 with Files("talos/tests/scroll/**"):
     BUG_COMPONENT = ("Core", "Graphics")
 

testing/talos/perfdocs/config.yml

@@ -135,6 +135,222 @@ suites:
                         ticks to measure how much time it will spend for a video texture upload
                         to be a Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore
                         the first found. Lower results are better.
+            offscreencanvas_webcodecs_main_webgl_h264: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_main_webgl_h264 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p H264 video on the main thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a H264 video file using WebCodecs and ask WebGL to draw video
+                        frames as WebGL textures for 100 frames on the main thread. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_main_webgl_vp9: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_main_webgl_vp9 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p VP9 video on the main thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a VP9 video file using WebCodecs and ask WebGL to draw video
+                        frames as WebGL textures for 100 frames on the main thread. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_main_webgl_av1: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_main_webgl_av1 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p AV1 video on the main thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a AV1 video file using WebCodecs and ask WebGL to draw video
+                        frames as WebGL textures for 100 frames on the main thread. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_worker_webgl_h264: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_worker_webgl_h264 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p H264 video on a DOM worker thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a H264 video file using WebCodecs and ask WebGL to draw video
+                        frames as WebGL textures for 100 frames on a DOM worker. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_worker_webgl_vp9: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_worker_webgl_vp9 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p VP9 video on a DOM worker thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a VP9 video file using WebCodecs and ask WebGL to draw video
+                        frames as WebGL textures for 100 frames on a DOM worker. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_worker_webgl_av1: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_worker_webgl_av1 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas WebGL video texture update with WebCodecs and 1080p AV1 video on a DOM worker thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a AV1 video file using WebCodecs and ask WebGL to draw video
+                        frames as WebGL textures for 100 frames on a DOM worker. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        WebGL texture (gl.texImage2D). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_main_2d_h264: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_main_2d_h264 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p H264 video on the main thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a H264 video file using WebCodecs and ask Canvas2D to draw video
+                        frames as Canvas2D textures for 100 frames on the main thread. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_main_2d_vp9: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_main_2d_vp9 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p VP9 video on the main thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l819>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a VP9 video file using WebCodecs and ask Canvas2D to draw video
+                        frames as Canvas2D textures for 100 frames on the main thread. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_main_2d_av1: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_main_2d_av1 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p AV1 video on the main thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l843>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a AV1 video file using WebCodecs and ask Canvas2D to draw video
+                        frames as Canvas2D textures for 100 frames on the main thread. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_worker_2d_h264: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_worker_2d_h264 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p H264 video on a DOM worker thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a H264 video file using WebCodecs and ask Canvas2D to draw video
+                        frames as Canvas2D textures for 100 frames on a DOM worker thread. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_worker_2d_vp9: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_worker_2d_vp9 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p VP9 video on a DOM worker thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a VP9 video file using WebCodecs and ask Canvas2D to draw video
+                        frames as Canvas2D textures for 100 frames on a DOM worker thread. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
+                        results are better.
+            offscreencanvas_webcodecs_worker_2d_av1: >
+                - contact: :aosmond and gfx
+                - source: `offscreencanvas_webcodecs_worker_2d_av1 <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/tests/offscreencanvas/benchmarks/video>`__
+                - type: `Page load`_
+                - data: 5 cycles of the entire benchmark, each subtest will have 5 data points (see below)
+                - summarization: OffscreenCanvas 2D video texture update with WebCodecs and 1080p AV1 video on a DOM worker thread. Measures mean frame time across 100 frames.
+                    * subtest: `ignore first`_ data point, then take the `median`_ of the remaining 4; `source:
+                        test.py <https://dxr.mozilla.org/mozilla-central/source/testing/talos/talos/test.py#l795>`__
+                    * suite: `geometric mean`_ of the 4 subtest results.
+                - **Lower is better**
+                - **Example Data**
+                    * 0;Mean frame time across 100 frames: ;54.6916;49.0534;51.21645;51.239650000000005;52.44295
+                - description:
+                      | This test extracts frames from a AV1 video file using WebCodecs and ask Canvas2D to draw video
+                        frames as Canvas2D textures for 100 frames on a DOM worker thread. It collects the mean frame time
+                        across 100 frames to measure how much time it will spend for a video texture upload to be a
+                        Canvas2D texture (ctx.drawImage). We run it for 5 times and ignore the first found. Lower
+                        results are better.
             cpstartup: >
                 - contact: :mconley, Firefox Desktop Front-end team, Gijs, fqueze, and dthayer
                 - measuring: Time from opening a new tab (which creates a new content process) to having that new content process be ready to load URLs.

testing/talos/talos.json

@@ -88,7 +88,24 @@
       "pagesets_name": "tp5n.zip"
     },
     "webgl": {
-      "tests": ["canvas2dvideo", "glterrain", "glvideo", "motionmark_webgl"]
+      "tests": [
+        "canvas2dvideo",
+        "glterrain",
+        "glvideo",
+        "motionmark_webgl",
+        "offscreencanvas_webcodecs_main_webgl_h264",
+        "offscreencanvas_webcodecs_main_webgl_vp9",
+        "offscreencanvas_webcodecs_main_webgl_av1",
+        "offscreencanvas_webcodecs_worker_webgl_h264",
+        "offscreencanvas_webcodecs_worker_webgl_vp9",
+        "offscreencanvas_webcodecs_worker_webgl_av1",
+        "offscreencanvas_webcodecs_main_2d_h264",
+        "offscreencanvas_webcodecs_main_2d_vp9",
+        "offscreencanvas_webcodecs_main_2d_av1",
+        "offscreencanvas_webcodecs_worker_2d_h264",
+        "offscreencanvas_webcodecs_worker_2d_vp9",
+        "offscreencanvas_webcodecs_worker_2d_av1"
+      ]
     },
     "xperf": {
       "tests": ["tp5n"],

testing/talos/talos/test.py

@@ -659,6 +659,330 @@ class canvas2dvideo(PageloaderTest):
     unit = "ms"
 
 
+@register_test()
+class offscreencanvas_webcodecs_main_webgl_h264(PageloaderTest):
+    """
+    OffscreenCanvas WebGL video texture update on the main thread with WebCodecs and 1080p H264 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs texImage2D(<videoFrame>))
+    """
+
+    tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_h264.manifest"
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = "CanvasRenderer,MediaSupervisor"
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_main_webgl_vp9(PageloaderTest):
+    """
+    OffscreenCanvas WebGL video texture update on the main thread with WebCodecs and 1080p VP9 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs texImage2D(<videoFrame>))
+    """
+
+    tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_vp9.manifest"
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = "CanvasRenderer,MediaSupervisor"
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_main_webgl_av1(PageloaderTest):
+    """
+    OffscreenCanvas WebGL video texture update on the main thread with WebCodecs and 1080p AV1 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs texImage2D(<videoFrame>))
+    """
+
+    tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_av1.manifest"
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = "CanvasRenderer,MediaSupervisor"
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_worker_webgl_h264(PageloaderTest):
+    """
+    OffscreenCanvas WebGL video texture update on a DOM worker thread with WebCodecs and 1080p H264 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs texImage2D(<videoFrame>))
+    """
+
+    tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_h264.manifest"
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = "DOM Worker,CanvasRenderer,MediaSupervisor"
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_worker_webgl_vp9(PageloaderTest):
+    """
+    OffscreenCanvas WebGL video texture update on a DOM worker thread with WebCodecs and 1080p VP9 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs texImage2D(<videoFrame>))
+    """
+
+    tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_vp9.manifest"
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = "DOM Worker,CanvasRenderer,MediaSupervisor"
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_worker_webgl_av1(PageloaderTest):
+    """
+    OffscreenCanvas WebGL video texture update on a DOM worker thread with WebCodecs and 1080p AV1 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs texImage2D(<videoFrame>))
+    """
+
+    tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_av1.manifest"
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = "DOM Worker,CanvasRenderer,MediaSupervisor"
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_main_2d_h264(PageloaderTest):
+    """
+    OffscreenCanvas 2D video texture update on the main thread with WebCodecs and 1080p H264 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs drawImage(<videoFrame>))
+    """
+
+    tpmanifest = (
+        "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_h264.manifest"
+    )
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = "CanvasRenderer,CanvasWorker,MediaSupervisor"
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_main_2d_vp9(PageloaderTest):
+    """
+    OffscreenCanvas 2D video texture update on the main thread with WebCodecs and 1080p VP9 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs drawImage(<videoFrame>))
+    """
+
+    tpmanifest = (
+        "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_vp9.manifest"
+    )
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = "CanvasRenderer,CanvasWorker,MediaSupervisor"
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_main_2d_av1(PageloaderTest):
+    """
+    OffscreenCanvas 2D video texture update on the main thread with WebCodecs and 1080p AV1 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs drawImage(<videoFrame>))
+    """
+
+    tpmanifest = (
+        "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_av1.manifest"
+    )
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = "CanvasRenderer,CanvasWorker,MediaSupervisor"
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_worker_2d_h264(PageloaderTest):
+    """
+    OffscreenCanvas 2D video texture update on a DOM worker thread with WebCodecs and 1080p H264 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs drawImage(<videoFrame>))
+    """
+
+    tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_h264.manifest"
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = (
+        "DOM Worker,CanvasRenderer,CanvasWorker,MediaSupervisor"
+    )
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_worker_2d_vp9(PageloaderTest):
+    """
+    OffscreenCanvas 2D video texture update on a DOM worker thread with WebCodecs and 1080p VP9 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs drawImage(<videoFrame>))
+    """
+
+    tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_vp9.manifest"
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = (
+        "DOM Worker,CanvasRenderer,CanvasWorker,MediaSupervisor"
+    )
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
+@register_test()
+class offscreencanvas_webcodecs_worker_2d_av1(PageloaderTest):
+    """
+    OffscreenCanvas 2D video texture update on a DOM worker thread with WebCodecs and 1080p AV1 video.
+    Measures mean frame time across 100 frames.
+    (decodes each frame and performs drawImage(<videoFrame>))
+    """
+
+    tpmanifest = "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_av1.manifest"
+    tpcycles = 1
+    tppagecycles = 5
+    tploadnocache = True
+    tpmozafterpaint = False
+    tpchrome = False
+    timeout = 600
+    gecko_profile_interval = 2
+    gecko_profile_extra_threads = (
+        "DOM Worker,CanvasRenderer,CanvasWorker,MediaSupervisor"
+    )
+    win_counters = w7_counters = linux_counters = mac_counters = None
+    preferences = {
+        "dom.media.webcodecs.enabled": True,
+        "dom.media.webcodecs.force-osx-h264-enabled": True,
+    }
+    filters = filter.ignore_first.prepare(1) + filter.median.prepare()
+    unit = "ms"
+
+
 @register_test()
 class tp5n(PageloaderTest):
     """

testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_av1_main.html

@@ -0,0 +1,22 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="mp4box.all.min.js" type="text/javascript"></script>
+<script src="demuxer_mp4.js" type="text/javascript"></script>
+<script src="shared.js" type="text/javascript"></script>
+<script src="helper_main.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.av1.short.mp4";
+  runTest("offscreencanvas_webcodecs_main_2d_av1", "2d", videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_av1_worker.html

@@ -0,0 +1,20 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="helper_worker.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+const worker = new Worker("worker.js");
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.av1.short.mp4";
+  runTest("offscreencanvas_webcodecs_worker_2d_av1", "2d", worker, videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_h264_main.html

@@ -0,0 +1,22 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="mp4box.all.min.js" type="text/javascript"></script>
+<script src="demuxer_mp4.js" type="text/javascript"></script>
+<script src="shared.js" type="text/javascript"></script>
+<script src="helper_main.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.h264.short.mp4";
+  runTest("offscreencanvas_webcodecs_main_2d_h264", "2d", videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_h264_worker.html

@@ -0,0 +1,20 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="helper_worker.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+const worker = new Worker("worker.js");
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.h264.short.mp4";
+  runTest("offscreencanvas_webcodecs_worker_2d_h264", "2d", worker, videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_vp9_main.html

@@ -0,0 +1,22 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="mp4box.all.min.js" type="text/javascript"></script>
+<script src="demuxer_mp4.js" type="text/javascript"></script>
+<script src="shared.js" type="text/javascript"></script>
+<script src="helper_main.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.vp9.short.mp4";
+  runTest("offscreencanvas_webcodecs_main_2d_vp9", "2d", videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/2d_vp9_worker.html

@@ -0,0 +1,20 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="helper_worker.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+const worker = new Worker("worker.js");
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.vp9.short.mp4";
+  runTest("offscreencanvas_webcodecs_worker_2d_vp9", "2d", worker, videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/demuxer_mp4.js

@@ -0,0 +1,113 @@
+/**
+ * This software or document includes material copied from or derived from:
+ * https://github.com/w3c/webcodecs/blob/main/samples/video-decode-display/demuxer_mp4.js
+ *
+ * Copyright (c) 2022-2023 World Wide Web Consortium.
+ * https://www.w3.org/copyright/software-license-2023/
+ */
+
+// Wraps an MP4Box File as a WritableStream underlying sink.
+class MP4FileSink {
+  #setStatus = null;
+  #file = null;
+  #offset = 0;
+
+  constructor(file, setStatus) {
+    this.#file = file;
+    this.#setStatus = setStatus;
+  }
+
+  write(chunk) {
+    // MP4Box.js requires buffers to be ArrayBuffers, but we have a Uint8Array.
+    const buffer = new ArrayBuffer(chunk.byteLength);
+    new Uint8Array(buffer).set(chunk);
+
+    // Inform MP4Box where in the file this chunk is from.
+    buffer.fileStart = this.#offset;
+    this.#offset += buffer.byteLength;
+
+    // Append chunk.
+    this.#setStatus("fetch", (this.#offset / (1024 ** 2)).toFixed(1) + " MiB");
+    this.#file.appendBuffer(buffer);
+  }
+
+  close() {
+    this.#setStatus("fetch", "Done");
+    this.#file.flush();
+  }
+}
+
+// Demuxes the first video track of an MP4 file using MP4Box, calling
+// `onConfig()` and `onChunk()` with appropriate WebCodecs objects.
+class MP4Demuxer {
+  #onConfig = null;
+  #onChunk = null;
+  #setStatus = null;
+  #file = null;
+
+  constructor(uri, {onConfig, onChunk, setStatus}) {
+    this.#onConfig = onConfig;
+    this.#onChunk = onChunk;
+    this.#setStatus = setStatus;
+
+    // Configure an MP4Box File for demuxing.
+    this.#file = MP4Box.createFile();
+    this.#file.onError = error => setStatus("demux", error);
+    this.#file.onReady = this.#onReady.bind(this);
+    this.#file.onSamples = this.#onSamples.bind(this);
+
+    // Fetch the file and pipe the data through.
+    const fileSink = new MP4FileSink(this.#file, setStatus);
+    fetch(uri).then(response => {
+      // highWaterMark should be large enough for smooth streaming, but lower is
+      // better for memory usage.
+      response.body.pipeTo(new WritableStream(fileSink, {highWaterMark: 2}));
+    });
+  }
+
+  // Get the appropriate `description` for a specific track. Assumes that the
+  // track is H.264, H.265, VP8, VP9, or AV1.
+  #description(track) {
+    const trak = this.#file.getTrackById(track.id);
+    for (const entry of trak.mdia.minf.stbl.stsd.entries) {
+      const box = entry.avcC || entry.hvcC || entry.vpcC || entry.av1C;
+      if (box) {
+        const stream = new DataStream(undefined, 0, DataStream.BIG_ENDIAN);
+        box.write(stream);
+        return new Uint8Array(stream.buffer, 8);  // Remove the box header.
+      }
+    }
+    throw new Error("avcC, hvcC, vpcC, or av1C box not found");
+  }
+
+  #onReady(info) {
+    this.#setStatus("demux", "Ready");
+    const track = info.videoTracks[0];
+
+    // Generate and emit an appropriate VideoDecoderConfig.
+    this.#onConfig({
+      // Browser doesn't support parsing full vp8 codec (eg: `vp08.00.41.08`),
+      // they only support `vp8`.
+      codec: track.codec.startsWith('vp08') ? 'vp8' : track.codec,
+      codedHeight: track.video.height,
+      codedWidth: track.video.width,
+      description: this.#description(track),
+    });
+
+    // Start demuxing.
+    this.#file.setExtractionOptions(track.id);
+    this.#file.start();
+  }
+
+  #onSamples(track_id, ref, samples) {
+    // Generate and emit an EncodedVideoChunk for each demuxed sample.
+    for (const sample of samples) {
+      this.#onChunk(new EncodedVideoChunk({
+        type: sample.is_sync ? "key" : "delta",
+        timestamp: 1e6 * sample.cts / sample.timescale,
+        duration: 1e6 * sample.duration / sample.timescale,
+        data: sample.data
+      }));
+    }
+  }
+}

testing/talos/talos/tests/offscreencanvas/benchmarks/video/helper_main.js

@@ -0,0 +1,57 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*global runTestInternal b:true*/
+
+function runTest(testName, canvasType, videoUri) {
+  const canvas = document.createElement("canvas");
+  canvas.width = 1920;
+  canvas.height = 1080;
+  document.body.appendChild(canvas);
+
+  const offscreenCanvas = canvas.transferControlToOffscreen();
+
+  return new Promise((resolve, reject) => {
+    try {
+      runTestInternal(
+        testName,
+        canvasType,
+        offscreenCanvas,
+        /* isWorker */ false,
+        videoUri,
+        resolve,
+        reject
+      );
+    } catch (e) {
+      reject(e);
+    }
+  })
+    .then(result => {
+      let name =
+        result.testName +
+        " Mean time across " +
+        result.totalFrames +
+        " frames: ";
+      let value = result.elapsed / result.totalFrames;
+      let msg = name + value + "\n";
+      dump("[talos offscreen-canvas-webcodecs result] " + msg);
+
+      if (window.tpRecordTime) {
+        // Within talos - report the results
+        tpRecordTime(value, 0, name);
+      } else {
+        alert(msg);
+      }
+    })
+    .catch(e => {
+      let msg = "caught error " + e;
+      dump("[talos offscreen-canvas-webcodecs result] " + msg);
+      if (window.tpRecordTime) {
+        // Within talos - report the results
+        tpRecordTime("", 0, "");
+      } else {
+        alert(msg);
+      }
+    });
+}

testing/talos/talos/tests/offscreencanvas/benchmarks/video/helper_worker.js

@@ -0,0 +1,53 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function runTest(testName, canvasType, worker, videoUri) {
+  const canvas = document.createElement("canvas");
+  canvas.width = 1920;
+  canvas.height = 1080;
+  document.body.appendChild(canvas);
+
+  const offscreenCanvas = canvas.transferControlToOffscreen();
+
+  return new Promise((resolve, reject) => {
+    worker.onmessage = e => {
+      if (e.data.errorMessage) {
+        reject(e.data.errorMessage);
+      } else {
+        resolve(e.data);
+      }
+    };
+
+    worker.postMessage({ offscreenCanvas, testName, canvasType, videoUri }, [
+      offscreenCanvas,
+    ]);
+  })
+    .then(result => {
+      let name =
+        result.testName +
+        " Mean time across " +
+        result.totalFrames +
+        " frames: ";
+      let value = result.elapsed / result.totalFrames;
+      let msg = name + value + "\n";
+      dump("[talos offscreen-canvas-webcodecs result] " + msg);
+
+      if (window.tpRecordTime) {
+        // Within talos - report the results
+        tpRecordTime(value, 0, name);
+      } else {
+        alert(msg);
+      }
+    })
+    .catch(e => {
+      let msg = "caught error " + e;
+      dump("[talos offscreen-canvas-webcodecs result] " + msg);
+      if (window.tpRecordTime) {
+        // Within talos - report the results
+        tpRecordTime("", 0, "");
+      } else {
+        alert(msg);
+      }
+    });
+}

testing/talos/talos/tests/offscreencanvas/benchmarks/video/mp4box.js-LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2012. Telecom ParisTech/TSI/MM/GPAC Cyril Concolato
+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 the copyright holder 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 <COPYRIGHT HOLDER> 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.

testing/talos/talos/tests/offscreencanvas/benchmarks/video/shared.js

@@ -0,0 +1,128 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*global MP4Demuxer b:true*/
+
+const kTotalFrames = 100;
+
+let start;
+let frameCount;
+
+function runTestInternal(
+  testName,
+  canvasType,
+  canvas,
+  isWorker,
+  videoUri,
+  resolve,
+  reject
+) {
+  const runContext = isWorker ? "worker" : "main";
+  dump(
+    "[" +
+      canvasType +
+      " webcodecs " +
+      runContext +
+      "] load video '" +
+      videoUri +
+      "'\n"
+  );
+
+  let drawImage;
+  if (canvasType == "2d") {
+    const ctx = canvas.getContext("2d");
+    drawImage = function (frame) {
+      ctx.drawImage(frame, 0, 0);
+    };
+  } else if (canvasType == "webgl") {
+    const gl = canvas.getContext("webgl");
+    gl.bindTexture(gl.TEXTURE_2D, gl.createTexture());
+    drawImage = function (frame) {
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        frame
+      );
+    };
+  } else {
+    dump("[" + canvasType + " webcodecs " + runContext + "] unknown type\n");
+    reject("unknown type " + canvasType);
+    return;
+  }
+
+  frameCount = 0;
+
+  const decoder = new VideoDecoder({
+    output(frame) {
+      if (frameCount == 0) {
+        start = performance.now();
+      }
+      ++frameCount;
+
+      dump(
+        "[" +
+          canvasType +
+          " webcodecs " +
+          runContext +
+          "] draw frame " +
+          frameCount +
+          "\n"
+      );
+      drawImage(frame);
+      frame.close();
+
+      if (frameCount == kTotalFrames) {
+        var elapsed = performance.now() - start;
+        setTimeout(() => {
+          resolve({ testName, elapsed, totalFrames: kTotalFrames });
+        }, 0);
+
+        dump(
+          "[" + canvasType + " webcodecs " + runContext + "] close decoder\n"
+        );
+        decoder.close();
+      }
+    },
+    error(e) {
+      dump(
+        "[" +
+          canvasType +
+          " webcodecs " +
+          runContext +
+          "] decoder error " +
+          e +
+          "\n"
+      );
+      decoder.close();
+      reject(e);
+    },
+  });
+
+  new MP4Demuxer(videoUri, {
+    onConfig(config) {
+      dump(
+        "[" + canvasType + " webcodecs " + runContext + "] demuxer config\n"
+      );
+      decoder.configure(config);
+    },
+    onChunk(chunk) {
+      dump("[" + canvasType + " webcodecs " + runContext + "] demuxer chunk\n");
+      decoder.decode(chunk);
+    },
+    setStatus(msg) {
+      dump(
+        "[" +
+          canvasType +
+          " webcodecs " +
+          runContext +
+          "] demuxer status - " +
+          msg +
+          "\n"
+      );
+    },
+  });
+}

testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_av1_main.html

@@ -0,0 +1,22 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="mp4box.all.min.js" type="text/javascript"></script>
+<script src="demuxer_mp4.js" type="text/javascript"></script>
+<script src="shared.js" type="text/javascript"></script>
+<script src="helper_main.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.av1.short.mp4";
+  runTest("offscreencanvas_webcodecs_main_av1_webgl", "webgl", videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_av1_worker.html

@@ -0,0 +1,20 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="helper_worker.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+const worker = new Worker("worker.js");
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.av1.short.mp4";
+  runTest("offscreencanvas_webcodecs_worker_webgl_av1", "webgl", worker, videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_h264_main.html

@@ -0,0 +1,22 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="mp4box.all.min.js" type="text/javascript"></script>
+<script src="demuxer_mp4.js" type="text/javascript"></script>
+<script src="shared.js" type="text/javascript"></script>
+<script src="helper_main.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.h264.short.mp4";
+  runTest("offscreencanvas_webcodecs_main_webgl_h264", "webgl", videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_h264_worker.html

@@ -0,0 +1,20 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="helper_worker.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+const worker = new Worker("worker.js");
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.h264.short.mp4";
+  runTest("offscreencanvas_webcodecs_worker_webgl_h264", "webgl", worker, videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_vp9_main.html

@@ -0,0 +1,22 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="mp4box.all.min.js" type="text/javascript"></script>
+<script src="demuxer_mp4.js" type="text/javascript"></script>
+<script src="shared.js" type="text/javascript"></script>
+<script src="helper_main.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.vp9.short.mp4";
+  runTest("offscreencanvas_webcodecs_main_webgl_vp9", "webgl", videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/webgl_vp9_worker.html

@@ -0,0 +1,20 @@
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this file,
+   - You can obtain one at http://mozilla.org/MPL/2.0/.  -->
+<html>
+<head>
+<script src="helper_worker.js" type="text/javascript"></script>
+<script language="javascript" type="text/javascript">
+const worker = new Worker("worker.js");
+
+function init() {
+  const videoUri = "../../../video/clips/testsrc.1080p.60fps.vp9.short.mp4";
+  runTest("offscreencanvas_webcodecs_worker_webgl_vp9", "webgl", worker, videoUri);
+}
+
+</script>
+
+</head>
+<body id="body" onload="init();">
+</body>
+</html>

testing/talos/talos/tests/offscreencanvas/benchmarks/video/worker.js

@@ -0,0 +1,30 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+importScripts("mp4box.all.min.js");
+importScripts("demuxer_mp4.js");
+importScripts("shared.js");
+
+self.onmessage = e => {
+  const resolve = result => {
+    self.postMessage(result);
+  };
+  const reject = errorMessage => {
+    self.postMessage({ errorMessage });
+  };
+
+  try {
+    runTestInternal(
+      e.data.testName,
+      e.data.canvasType,
+      e.data.offscreenCanvas,
+      /* isWorker */ true,
+      e.data.videoUri,
+      resolve,
+      reject
+    );
+  } catch (e) {
+    reject(e);
+  }
+};

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_av1.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/2d_av1_main.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_h264.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/2d_h264_main.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_vp9.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/2d_vp9_main.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_av1.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_av1_main.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_h264.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_h264_main.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_vp9.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_vp9_main.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_av1.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/2d_av1_worker.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_h264.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/2d_h264_worker.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_vp9.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/2d_vp9_worker.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_av1.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_av1_worker.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_h264.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_h264_worker.html

testing/talos/talos/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_vp9.manifest

@@ -0,0 +1 @@
+% http://localhost/tests/offscreencanvas/benchmarks/video/webgl_vp9_worker.html

testing/talos/talos/unittests/test_config.py

@@ -273,6 +273,18 @@ class Test_get_config(object):
         cls.argv_canvas2dvideo = (
             "--activeTests canvas2dvideo -e /some/random/path".split()
         )
+        cls.argv_offscreencanvas_webcodecs_main_webgl_h264 = "--activeTests offscreencanvas_webcodecs_main_webgl_h264 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_main_webgl_vp9 = "--activeTests offscreencanvas_webcodecs_main_webgl_vp9 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_main_webgl_av1 = "--activeTests offscreencanvas_webcodecs_main_webgl_av1 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_worker_webgl_h264 = "--activeTests offscreencanvas_webcodecs_worker_webgl_h264 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_worker_webgl_vp9 = "--activeTests offscreencanvas_webcodecs_worker_webgl_vp9 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_worker_webgl_av1 = "--activeTests offscreencanvas_webcodecs_worker_webgl_av1 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_main_2d_h264 = "--activeTests offscreencanvas_webcodecs_main_2d_h264 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_main_2d_vp9 = "--activeTests offscreencanvas_webcodecs_main_2d_vp9 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_main_2d_av1 = "--activeTests offscreencanvas_webcodecs_main_2d_av1 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_worker_2d_h264 = "--activeTests offscreencanvas_webcodecs_worker_2d_h264 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_worker_2d_vp9 = "--activeTests offscreencanvas_webcodecs_worker_2d_vp9 -e /some/random/path".split()
+        cls.argv_offscreencanvas_webcodecs_worker_2d_av1 = "--activeTests offscreencanvas_webcodecs_worker_2d_av1 -e /some/random/path".split()
         cls.argv_tp5n = "--activeTests tp5n -e /some/random/path".split()
         cls.argv_tp5o = "--activeTests tp5o -e /some/random/path".split()
         cls.argv_tp5o_webext = "--activeTests tp5o_webext -e /some/random/path".split()
@@ -641,6 +653,282 @@ class Test_get_config(object):
         assert test_config["filters"] is not None
         assert test_config["unit"] == "ms"
 
+    def test_offscreencanvas_webcodecs_main_webgl_h264_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_main_webgl_h264)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_main_webgl_h264"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_h264.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_main_webgl_vp9_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_main_webgl_vp9)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_main_webgl_vp9"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_vp9.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_main_webgl_av1_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_main_webgl_av1)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_main_webgl_av1"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_webgl_av1.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_worker_webgl_h264_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_worker_webgl_h264)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_worker_webgl_h264"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_h264.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_worker_webgl_vp9_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_worker_webgl_vp9)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_worker_webgl_vp9"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_vp9.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_worker_webgl_av1_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_worker_webgl_av1)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_worker_webgl_av1"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_webgl_av1.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_main_2d_h264_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_main_2d_h264)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_main_2d_h264"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_h264.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_main_2d_vp9_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_main_2d_vp9)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_main_2d_vp9"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_vp9.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_main_2d_av1_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_main_2d_av1)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_main_2d_av1"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_main_2d_av1.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_worker_2d_h264_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_worker_2d_h264)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_worker_2d_h264"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_h264.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_worker_2d_vp9_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_worker_2d_vp9)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_worker_2d_vp9"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_vp9.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
+    def test_offscreencanvas_webcodecs_worker_2d_av1_has_expected_attributes(self):
+        config = get_config(self.argv_offscreencanvas_webcodecs_worker_2d_av1)
+        test_config = config["tests"][0]
+
+        assert test_config["name"] == "offscreencanvas_webcodecs_worker_2d_av1"
+        assert (
+            test_config["tpmanifest"]
+            != "${talos}/tests/offscreencanvas/offscreencanvas_webcodecs_worker_2d_av1.manifest"
+        )
+        assert test_config["tpcycles"] == 1
+        assert test_config["tppagecycles"] == 5
+        assert test_config["tploadnocache"] is True
+        assert test_config["tpmozafterpaint"] is False
+        assert test_config["tpchrome"] is False
+        assert test_config["gecko_profile_interval"] == 2
+        assert test_config["gecko_profile_entries"] == 2000000
+        assert "win_counters" not in test_config
+        assert "w7_counters" not in test_config
+        assert "linux_counters" not in test_config
+        assert "mac_counters" not in test_config
+        assert test_config["filters"] is not None
+        assert test_config["unit"] == "ms"
+
     @mock.patch("talos.config.build_manifest", conftest.patched_build_manifest)
     def test_tp5n_has_expected_attributes(self):
         config = get_config(self.argv_tp5n)

tools/rewriting/ThirdPartyPaths.txt

@@ -165,6 +165,8 @@ testing/mozbase/mozproxy/mozproxy/backends/mitm/scripts/catapult/
 testing/talos/talos/tests/devtools/addon/content/pages/
 testing/talos/talos/tests/dromaeo/
 testing/talos/talos/tests/kraken/
+testing/talos/talos/tests/offscreencanvas/benchmarks/video/demuxer_mp4.js
+testing/talos/talos/tests/offscreencanvas/benchmarks/video/mp4box.all.min.js
 testing/talos/talos/tests/v8_7/
 testing/web-platform/tests/resources/webidl2/
 testing/web-platform/tests/tools/third_party/