# Copyright 2016 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

# This is more akin to a .pyl/JSON file, so it's expected to be long.
# pylint: disable=too-many-lines

from collections.abc import Callable
from enum import Enum
import json
import logging
import os
import posixpath
import time
import urllib.parse

from telemetry.internal.browser import browser as browser_module

import gpu_path_util
from gpu_tests import common_browser_args as cba
from gpu_tests import crop_actions as ca
from gpu_tests import overlay_support
from gpu_tests import skia_gold_heartbeat_integration_test_base as sghitb
from gpu_tests import skia_gold_matching_algorithms as algo
from gpu_tests.util import websocket_server as wss

CRASH_TYPE_BROWSER = 'browser'
CRASH_TYPE_GPU = 'gpu-process'
CRASH_TYPE_RENDERER = 'renderer'

EXPECTED_CRASHES_PLATFORM_DEFAULT = ''
EXPECTED_CRASHES_PLATFORM_FUCHSIA = 'fuchsia'

SHORT_GLOBAL_TIMEOUT = 30

# Meant to be used when we know a test is going to be noisy, and we want any
# images it generates to be auto-triaged until we have enough data to calculate
# more suitable/less permissive parameters.
VERY_PERMISSIVE_SOBEL_ALGO = algo.SobelMatchingAlgorithm(
    max_different_pixels=100000000,
    pixel_delta_threshold=255,
    edge_threshold=0,
    ignored_border_thickness=1)

# The optimizer script spat out pretty similar values for most MP4 tests, so
# combine into a single set of parameters.
GENERAL_MP4_ALGO = algo.SobelMatchingAlgorithm(
    max_different_pixels=56300,
    pixel_per_channel_delta_threshold=15,
    edge_threshold=80,
    ignored_border_thickness=1)

ROUNDING_ERROR_ALGO = algo.FuzzyMatchingAlgorithm(
    max_different_pixels=100000000, pixel_per_channel_delta_threshold=1)

BrowserArgType = list[str]


def DoNotCaptureFullScreenshot(_) -> bool:
  return False


def DoNotRequireFullscreenOsScreenshot() -> bool:
  return False


class PixelTestPage(sghitb.SkiaGoldHeartbeatTestCase):
  """A wrapper class mimicking the functionality of the PixelTestsStorySet
  from the old-style GPU tests.
  """

  def __init__(  # pylint: disable=too-many-arguments
      self,
      url: str,
      name: str,
      *args,
      crop_action: ca.BaseCropAction | None = None,
      browser_args: BrowserArgType | None = None,
      restart_browser_after_test: bool = False,
      other_args: dict | None = None,
      expected_per_process_crashes: dict[str, dict[str, int]] | None = None,
      timeout: int = 300,
      should_capture_full_screenshot_func: Callable[[browser_module.Browser],
                                                    bool] | None = None,
      requires_fullscreen_os_screenshot_func: Callable[[], bool] | None = None,
      known_flaky_output_test: bool = False,
      **kwargs):
    # Video tests can result in non-hermetic test behavior due to overlays, so
    # do a full refresh after each one. See crbug.com/1484212.
    is_video_test = 'video' in name.lower()
    super().__init__(name, refresh_after_finish=is_video_test, *args, **kwargs)
    self.url = url
    self.crop_action = crop_action
    self.browser_args = browser_args
    # Whether the browser should be forcibly restarted after the test
    # runs. The browser is always restarted after running tests with
    # optional_actions.
    self.restart_browser_after_test = restart_browser_after_test
    # These are used to pass additional arguments to the test harness.
    # VideoPathTraceTest and OverlayModeTest support the following boolean
    # arguments: pixel_format, zero_copy, no_overlay, video_is_rotated and
    # full_size.
    self.other_args = other_args
    # This lets the test runner know that one or more crashes are expected as
    # part of the test. Should be a map of platform name (str) to a map of
    # process type (str) to crashes (int)
    self.expected_per_process_crashes = expected_per_process_crashes or {}
    # Test timeout
    self.timeout = timeout
    # Most tests will use the standard capture code path which captures an image
    # that is more representative of what is shown to a user, but some tests
    # require capturing the entire web contents for some reason.
    if should_capture_full_screenshot_func is None:
      should_capture_full_screenshot_func = DoNotCaptureFullScreenshot
    self.ShouldCaptureFullScreenshot = should_capture_full_screenshot_func
    # Some tests may require to capture a full OS screenshot to exercise
    # end-to-end integration. That is, such browsers as LaCros do delegated
    # compositing and they are interested in comparing the result produced
    # by the OS compositor rather than Chromium's one.
    if requires_fullscreen_os_screenshot_func is None:
      requires_fullscreen_os_screenshot_func = (
          DoNotRequireFullscreenOsScreenshot)
    self.RequiresFullScreenOSScreenshot = requires_fullscreen_os_screenshot_func
    # Some tests are known to produce flaky output that cannot be handled with
    # inexact matching without relaxing comparison parameters so much that
    # regressions could make it in. Such tests are allowed to potentially run
    # multiple times so that inexact matching with stricter parameters can
    # match.
    self.known_flaky_output_test = known_flaky_output_test

# pytype: disable=signature-mismatch

class TestActionCrashGpuProcess(sghitb.TestAction):
  """Runs JavaScript to crash the GPU process once."""
  def Run(self, test_case: PixelTestPage, tab_data: sghitb.TabData,
          loop_state: sghitb.LoopState,
          test_instance: sghitb.SkiaGoldHeartbeatIntegrationTestBase) -> None:
    sghitb.EvalInTestIframe(tab_data.tab,
                            'chrome.gpuBenchmarking.crashGpuProcess()')


class TestActionSwitchTabs(sghitb.TestAction):
  """Opens and briefly switches to a new tab before switching back."""
  def Run(self, test_case: PixelTestPage, tab_data: sghitb.TabData,
          loop_state: sghitb.LoopState,
          test_instance: sghitb.SkiaGoldHeartbeatIntegrationTestBase) -> None:
    tab = tab_data.tab
    if not tab.browser.supports_tab_control:
      test_instance.fail('Browser must support tab control')
    dummy_tab = tab.browser.tabs.New()
    dummy_tab.Activate()
    # Wait for 2 seconds so that the new tab becomes visible.
    dummy_tab.action_runner.Wait(2)
    tab.Activate()


class TestActionSwitchTabsAndCopyImage(sghitb.TestAction):
  """Opens and closes a new tab before running test-specific JavaScript."""
  def Run(self, test_case: PixelTestPage, tab_data: sghitb.TabData,
          loop_state: sghitb.LoopState,
          test_instance: sghitb.SkiaGoldHeartbeatIntegrationTestBase) -> None:
    tab = tab_data.tab
    if not tab.browser.supports_tab_control:
      test_instance.fail('Browser must support tab control')
    dummy_tab = tab.browser.tabs.New()
    dummy_tab.Activate()
    # Wait for 2 seconds so that the new tab becomes visible.
    dummy_tab.action_runner.Wait(2)
    dummy_tab.Close()
    sghitb.EvalInTestIframe(tab, 'copyImage()')


class TestActionSleepBeforeRender(sghitb.TestAction):
  """Wait for 2 seconds before webgpu rendering."""

  def Run(self, test_case: PixelTestPage, tab_data: sghitb.TabData,
          loop_state: sghitb.LoopState,
          test_instance: sghitb.SkiaGoldHeartbeatIntegrationTestBase) -> None:
    tab = tab_data.tab
    time.sleep(2)
    sghitb.EvalInTestIframe(tab, 'render()')


class TestActionRunOffscreenCanvasIBRCWebGLLowPerfTest(sghitb.TestAction):
  """Runs steps for an offscreen canvas IBRC WebGL test on the low power GPU."""
  def Run(self, test_case: PixelTestPage, tab_data: sghitb.TabData,
          loop_state: sghitb.LoopState,
          test_instance: sghitb.SkiaGoldHeartbeatIntegrationTestBase) -> None:
    tab = tab_data.tab
    test_instance.AssertLowPowerGPU()
    sghitb.EvalInTestIframe(tab, 'setup()')
    # Wait a few seconds for any (incorrect) GPU switched notifications to
    # propagate throughout the system.
    time.sleep(5)
    test_instance.AssertLowPowerGPU()
    sghitb.EvalInTestIframe(tab, 'render()')


class TestActionRunOffscreenCanvasIBRCWebGLHighPerfTest(sghitb.TestAction):
  """Runs steps for an offscreen canvas IBRC WebGL test on the high perf GPU."""
  def Run(self, test_case: PixelTestPage, tab_data: sghitb.TabData,
          loop_state: sghitb.LoopState,
          test_instance: sghitb.SkiaGoldHeartbeatIntegrationTestBase) -> None:
    tab = tab_data.tab
    test_instance.AssertLowPowerGPU()
    sghitb.EvalInTestIframe(tab, 'setup(true)')
    # Wait a few seconds for any (incorrect) GPU switched notifications to
    # propagate throughout the system.
    time.sleep(5)
    test_instance.AssertHighPerformanceGPU()
    sghitb.EvalInTestIframe(tab, 'render()')


class TestActionRunTestWithHighPerformanceTab(sghitb.TestAction):
  """Runs steps for a specific test with a high perf second tab present."""
  def Run(self, test_case: PixelTestPage, tab_data: sghitb.TabData,
          loop_state: sghitb.LoopState,
          test_instance: sghitb.SkiaGoldHeartbeatIntegrationTestBase) -> None:
    tab = tab_data.tab
    if not test_instance.IsDualGPUMacLaptop():
      # Short-circuit this test.
      logging.info('Short-circuiting test because not running on dual-GPU Mac '
                   'laptop')
      sghitb.EvalInTestIframe(tab, 'initialize(false)')
      return

    high_performance_tab = tab.browser.tabs.New()
    high_performance_file = posixpath.join(
        gpu_path_util.GPU_DATA_RELATIVE_PATH,
        'functional_webgl_high_performance.html')
    high_performance_websocket_server = wss.WebsocketServer()
    high_performance_websocket_server.StartServer()
    high_performance_tab_data = sghitb.TabData(
        high_performance_tab, high_performance_websocket_server)
    high_performance_loop_state = sghitb.LoopState()
    try:
      test_instance.NavigateTo(high_performance_file,
                               tab_data=high_performance_tab_data)
      test_instance.HandleMessageLoop(SHORT_GLOBAL_TIMEOUT,
                                      loop_state=high_performance_loop_state,
                                      tab_data=high_performance_tab_data)
      assert high_performance_loop_state.test_finished

      # Wait a few seconds for the GPU switched notification to propagate
      # throughout the system.
      time.sleep(5)
      # Switch back to the main tab and quickly start its rendering, while the
      # high-power GPU is still active.
      tab.Activate()
      sghitb.EvalInTestIframe(tab, 'initialize(true)')
      test_instance.HandleMessageLoop(SHORT_GLOBAL_TIMEOUT,
                                      loop_state=loop_state,
                                      tab_data=tab_data)
      high_performance_tab.Close()
    finally:
      high_performance_websocket_server.StopServer()
    # Wait for ~15 seconds for the system to switch back to the
    # integrated GPU.
    time.sleep(15)
    # Run the page to completion.
    sghitb.EvalInTestIframe(tab, 'setTimeout(runToCompletion, 0)')


class TestActionRunLowToHighPowerTest(sghitb.TestAction):
  """Runs steps for the low to high power GPU transition test."""
  def Run(self, test_case: PixelTestPage, tab_data: sghitb.TabData,
          loop_state: sghitb.LoopState,
          test_instance: sghitb.SkiaGoldHeartbeatIntegrationTestBase) -> None:
    is_dual_gpu = test_instance.IsDualGPUMacLaptop()
    sghitb.EvalInTestIframe(tab_data.tab,
                            f'initialize({json.dumps(is_dual_gpu)})')
# pytype: enable=signature-mismatch


def GetMediaStreamTestBrowserArgs(
    media_stream_source_relpath: str) -> list[str]:
  return [
      '--use-fake-device-for-media-stream', '--use-fake-ui-for-media-stream',
      '--use-file-for-fake-video-capture=' +
      os.path.join(gpu_path_util.CHROMIUM_SRC_DIR, media_stream_source_relpath)
  ]


def RequiresFullScreenOSScreenshot() -> bool:
  return True


def CaptureFullScreenshotOnFuchsia(browser: browser_module.Browser) -> bool:
  return browser.platform.GetOSName() == 'fuchsia'


class PixelTestPages():
  @staticmethod
  def DefaultPages(base_name: str) -> list[PixelTestPage]:
    sw_compositing_args = [cba.DISABLE_GPU_COMPOSITING]
    experimental_hdr_args = [cba.ENABLE_EXPERIMENTAL_WEB_PLATFORM_FEATURES]

    switch_tab_test_actions = [
        sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
        TestActionSwitchTabs(),
        sghitb.TestActionWaitForFinish(SHORT_GLOBAL_TIMEOUT),
    ]

    low_power_test_actions = [
        sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
        TestActionRunOffscreenCanvasIBRCWebGLLowPerfTest(),
        sghitb.TestActionWaitForFinish(SHORT_GLOBAL_TIMEOUT),
    ]

    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 350, 350))

    return [
        PixelTestPage(
            'pixel_background_image.html',
            base_name + '_BackgroundImage',
            crop_action=ca.FixedRectCropAction(20, 20, 370, 370),
            # Small Fuchsia screens result in an incomplete capture
            # without this.
            should_capture_full_screenshot_func=CaptureFullScreenshotOnFuchsia,
            matching_algorithm=ROUNDING_ERROR_ALGO),
        PixelTestPage('pixel_reflected_div.html',
                      base_name + '_ReflectedDiv',
                      crop_action=standard_crop),
        PixelTestPage('pixel_canvas2d.html',
                      base_name + '_Canvas2DRedBox',
                      crop_action=standard_crop,
                      matching_algorithm=algo.FuzzyMatchingAlgorithm(
                          max_different_pixels=130,
                          pixel_per_channel_delta_threshold=2)),
        PixelTestPage('pixel_canvas2d_blit.html',
                      base_name + '_Canvas2DBlitText',
                      crop_action=ca.NonWhiteContentCropAction(
                          initial_crop=ca.FixedRectCropAction(0, 0, 1000, 300)),
                      matching_algorithm=algo.FuzzyMatchingAlgorithm(
                          max_different_pixels=5,
                          pixel_per_channel_delta_threshold=2)),
        PixelTestPage('pixel_canvas2d_untagged.html',
                      base_name + '_Canvas2DUntagged',
                      crop_action=standard_crop),
        PixelTestPage('pixel_css3d.html',
                      base_name + '_CSS3DBlueBox',
                      crop_action=standard_crop,
                      matching_algorithm=algo.SobelMatchingAlgorithm(
                          max_different_pixels=0,
                          pixel_delta_threshold=0,
                          edge_threshold=90)),
        PixelTestPage('pixel_webgl_aa_alpha.html',
                      base_name + '_WebGLGreenTriangle_AA_Alpha',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl_noaa_alpha.html',
                      base_name + '_WebGLGreenTriangle_NoAA_Alpha',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl_aa_noalpha.html',
                      base_name + '_WebGLGreenTriangle_AA_NoAlpha',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl_noaa_noalpha.html',
                      base_name + '_WebGLGreenTriangle_NoAA_NoAlpha',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl_noalpha_implicit_clear.html',
                      base_name +
                      '_WebGLTransparentGreenTriangle_NoAlpha_ImplicitClear',
                      crop_action=standard_crop),
        PixelTestPage(
            'pixel_webgl_context_restored.html',
            base_name + '_WebGLContextRestored',
            crop_action=standard_crop,
            test_actions=[
                sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
                TestActionCrashGpuProcess(),
                sghitb.TestActionWaitForFinish(SHORT_GLOBAL_TIMEOUT),
            ],
            expected_per_process_crashes={
                # Fuchsia is special cased due to the way it checks for crashes
                # (asking the browser) vs. how other platforms handle it
                # (looking for minidumps). The method for crashing the GPU
                # process in this test is recorded as a crash but does not
                # generate a minidump.
                EXPECTED_CRASHES_PLATFORM_FUCHSIA: {
                    CRASH_TYPE_GPU: 1,
                },
            }),
        PixelTestPage(
            'pixel_webgl_sad_canvas.html',
            base_name + '_WebGLSadCanvas',
            crop_action=standard_crop,
            test_actions=[
                sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
                TestActionCrashGpuProcess(),
                sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
                TestActionCrashGpuProcess(),
                sghitb.TestActionWaitForFinish(SHORT_GLOBAL_TIMEOUT),
            ],
            expected_per_process_crashes={
                # Fuchsia is special cased due to the way it checks for crashes
                # (asking the browser) vs. how other platforms handle it
                # (looking for minidumps). The method for crashing the GPU
                # process in this test is recorded as a crash but does not
                # generate a minidump.
                EXPECTED_CRASHES_PLATFORM_FUCHSIA: {
                    CRASH_TYPE_GPU: 2,
                },
            }),
        PixelTestPage('pixel_scissor.html',
                      base_name + '_ScissorTestWithPreserveDrawingBuffer',
                      crop_action=standard_crop),
        PixelTestPage('pixel_canvas2d_webgl.html',
                      base_name + '_2DCanvasWebGL',
                      crop_action=standard_crop),
        PixelTestPage(
            'pixel_background.html',
            base_name + '_SolidColorBackground',
            crop_action=ca.FixedRectCropAction(500, 500, 600, 600),
            # Small Fuchsia screens result in an incomplete capture
            # without this.
            should_capture_full_screenshot_func=CaptureFullScreenshotOnFuchsia),
        PixelTestPage(
            'pixel_video_mp4.html?width=240&height=135&use_timer=1',
            base_name + '_Video_MP4',
            crop_action=standard_crop,
            # Most images are actually very similar, but Pixel 2
            # tends to produce images with all colors shifted by a
            # small amount.
            matching_algorithm=GENERAL_MP4_ALGO),
        PixelTestPage(
            'pixel_video_mp4_four_colors_aspect_4x3.html'
            '?width=240&height=135&use_timer=1',
            base_name + '_Video_MP4_FourColors_Aspect_4x3',
            crop_action=standard_crop,
            matching_algorithm=algo.SobelMatchingAlgorithm(
                max_different_pixels=41700,
                pixel_per_channel_delta_threshold=5,
                edge_threshold=40,
                ignored_border_thickness=1)),
        PixelTestPage(
            'pixel_video_mp4_four_colors_rot_90.html'
            '?width=270&height=240&use_timer=1',
            base_name + '_Video_MP4_FourColors_Rot_90',
            crop_action=standard_crop,
            matching_algorithm=GENERAL_MP4_ALGO),
        PixelTestPage(
            'pixel_video_mp4_four_colors_rot_180.html'
            '?width=240&height=135&use_timer=1',
            base_name + '_Video_MP4_FourColors_Rot_180',
            crop_action=standard_crop,
            matching_algorithm=GENERAL_MP4_ALGO),
        PixelTestPage(
            'pixel_video_mp4_four_colors_rot_270.htm'
            'l?width=270&height=240&use_timer=1',
            base_name + '_Video_MP4_FourColors_Rot_270',
            crop_action=standard_crop,
            matching_algorithm=GENERAL_MP4_ALGO),
        PixelTestPage(
            'pixel_video_mp4_rounded_corner.html'
            '?width=240&height=135&use_timer=1',
            base_name + '_Video_MP4_Rounded_Corner',
            crop_action=standard_crop,
            matching_algorithm=algo.SobelMatchingAlgorithm(
                max_different_pixels=30500,
                pixel_per_channel_delta_threshold=5,
                edge_threshold=70,
                ignored_border_thickness=1)),
        PixelTestPage('pixel_video_vp9.html?width=240&height=135&use_timer=1',
                      base_name + '_Video_VP9',
                      crop_action=standard_crop,
                      matching_algorithm=algo.SobelMatchingAlgorithm(
                          max_different_pixels=114000,
                          pixel_per_channel_delta_threshold=15,
                          edge_threshold=20,
                          ignored_border_thickness=1)),
        PixelTestPage('pixel_video_av1.html?width=240&height=135&use_timer=1',
                      base_name + '_Video_AV1',
                      crop_action=standard_crop,
                      matching_algorithm=algo.SobelMatchingAlgorithm(
                          max_different_pixels=114000,
                          pixel_per_channel_delta_threshold=15,
                          edge_threshold=20,
                          ignored_border_thickness=1)),
        PixelTestPage('pixel_video_hevc.html?width=240&height=135&use_timer=1',
                      base_name + '_Video_HEVC',
                      crop_action=standard_crop,
                      matching_algorithm=algo.SobelMatchingAlgorithm(
                          max_different_pixels=114000,
                          pixel_per_channel_delta_threshold=15,
                          edge_threshold=20,
                          ignored_border_thickness=1)),
        PixelTestPage(
            'pixel_video_media_stream_incompatible_stride.html',
            base_name + '_Video_Media_Stream_Incompatible_Stride',
            browser_args=GetMediaStreamTestBrowserArgs(
                'media/test/data/four-colors-incompatible-stride.y4m'),
            crop_action=standard_crop,
            matching_algorithm=VERY_PERMISSIVE_SOBEL_ALGO),

        # The MP4 contains H.264 which is primarily hardware decoded on bots.
        PixelTestPage(
            'pixel_video_context_loss.html?src='
            '/media/test/data/four-colors.mp4',
            base_name + '_Video_Context_Loss_MP4',
            crop_action=standard_crop,
            # Optimizer script spat out a value of 255 for the Sobel edge
            # threshold, so use fuzzy for now since it's slightly more
            # efficient.
            matching_algorithm=algo.FuzzyMatchingAlgorithm(
                max_different_pixels=31700,
                pixel_per_channel_delta_threshold=10),
            expected_per_process_crashes={
                EXPECTED_CRASHES_PLATFORM_DEFAULT: {
                    CRASH_TYPE_GPU: 1,
                },
            },
            restart_browser_after_test=True),

        # The VP9 test clip is primarily software decoded on bots.
        PixelTestPage(('pixel_video_context_loss.html'
                       '?src=/media/test/data/four-colors-vp9.webm'),
                      base_name + '_Video_Context_Loss_VP9',
                      crop_action=standard_crop,
                      matching_algorithm=algo.SobelMatchingAlgorithm(
                          max_different_pixels=54400,
                          pixel_per_channel_delta_threshold=15,
                          edge_threshold=250,
                          ignored_border_thickness=1),
                      expected_per_process_crashes={
                          EXPECTED_CRASHES_PLATFORM_DEFAULT: {
                              CRASH_TYPE_GPU: 1,
                          },
                      },
                      restart_browser_after_test=True),
        PixelTestPage(
            'pixel_video_backdrop_filter.html?width=240&height=135&use_timer=1',
            base_name + '_Video_BackdropFilter',
            crop_action=standard_crop,
            matching_algorithm=algo.SobelMatchingAlgorithm(
                max_different_pixels=1000,
                pixel_per_channel_delta_threshold=10,
                edge_threshold=40,
                ignored_border_thickness=1)),
        PixelTestPage('pixel_webgl_premultiplied_alpha_false.html',
                      base_name + '_WebGL_PremultipliedAlpha_False',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl2_blitframebuffer_result_displayed.html',
                      base_name + '_WebGL2_BlitFramebuffer_Result_Displayed',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl2_clearbufferfv_result_displayed.html',
                      base_name + '_WebGL2_ClearBufferfv_Result_Displayed',
                      crop_action=standard_crop),
        PixelTestPage('pixel_repeated_webgl_to_2d.html',
                      base_name + '_RepeatedWebGLTo2D',
                      crop_action=standard_crop),
        PixelTestPage('pixel_repeated_webgl_to_2d.html',
                      base_name + '_RepeatedWebGLTo2D_SoftwareCompositing',
                      crop_action=standard_crop,
                      browser_args=sw_compositing_args),
        PixelTestPage('pixel_canvas2d_tab_switch.html',
                      base_name + '_Canvas2DTabSwitch',
                      crop_action=standard_crop,
                      test_actions=switch_tab_test_actions),
        PixelTestPage('pixel_canvas2d_tab_switch.html',
                      base_name + '_Canvas2DTabSwitch_SoftwareCompositing',
                      crop_action=standard_crop,
                      browser_args=sw_compositing_args,
                      test_actions=switch_tab_test_actions),
        PixelTestPage('pixel_webgl_copy_image.html',
                      base_name + '_WebGLCopyImage',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl_texture_from_webgl_readback.html',
                      base_name + '_WebGLTextureFromWebGLReadback',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl_read_pixels_tab_switch.html',
                      base_name + '_WebGLReadPixelsTabSwitch',
                      crop_action=standard_crop,
                      test_actions=switch_tab_test_actions),
        PixelTestPage('pixel_webgl_read_pixels_tab_switch.html',
                      base_name +
                      '_WebGLReadPixelsTabSwitch_SoftwareCompositing',
                      crop_action=standard_crop,
                      browser_args=sw_compositing_args,
                      test_actions=switch_tab_test_actions),
        PixelTestPage('pixel_offscreen_canvas_ibrc_webgl_main.html',
                      base_name + '_OffscreenCanvasIBRCWebGLMain',
                      crop_action=standard_crop,
                      test_actions=low_power_test_actions),
        PixelTestPage('pixel_offscreen_canvas_ibrc_webgl_worker.html',
                      base_name + '_OffscreenCanvasIBRCWebGLWorker',
                      crop_action=standard_crop,
                      test_actions=low_power_test_actions),
        PixelTestPage(
            'pixel_webgl_preserved_after_tab_switch.html',
            base_name + '_WebGLPreservedAfterTabSwitch',
            crop_action=standard_crop,
            test_actions=[
                sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
                TestActionSwitchTabsAndCopyImage(),
                sghitb.TestActionWaitForFinish(SHORT_GLOBAL_TIMEOUT),
            ]),
        PixelTestPage('pixel_svg_huge.html',
                      base_name + '_SVGHuge',
                      crop_action=ca.FixedRectCropAction(0, 0, 400, 400),
                      matching_algorithm=algo.SobelMatchingAlgorithm(
                          max_different_pixels=0,
                          pixel_delta_threshold=0,
                          edge_threshold=90)),
        PixelTestPage('pixel_webgl_display_p3.html',
                      base_name + '_WebGLDisplayP3',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl_float.html',
                      base_name + '_WebGLFloat',
                      crop_action=standard_crop,
                      browser_args=experimental_hdr_args),
        PixelTestPage('pixel_offscreenCanvas_ibrc_worker.html',
                      base_name + '_OffscreenCanvasIBRCWorker',
                      crop_action=standard_crop),
        PixelTestPage('pixel_webgl_resized_canvas.html',
                      base_name + '_WebglResizedCanvas',
                      crop_action=standard_crop),
        PixelTestPage(
            'pixel_render_passes.html',
            base_name + '_RenderPasses',
            crop_action=ca.FixedRectCropAction(3, 90, 485, 245),
            requires_fullscreen_os_screenshot_func=\
            RequiresFullScreenOSScreenshot
        ),
        PixelTestPage('pixel_view_transitions_capture.html',
                      base_name + '_ViewTransitionsCapture',
                      crop_action=standard_crop,
                      matching_algorithm=algo.SobelMatchingAlgorithm(
                          max_different_pixels=0,
                          pixel_delta_threshold=0,
                          edge_threshold=90)),
        PixelTestPage(
            'pixel_perspective_paint.html',
            base_name + '_PerspectiveTest',
            crop_action=ca.NonWhiteContentCropAction(
                initial_crop=ca.FixedRectCropAction(0, 0, 500, 300)),
        ),

        # The following tests are a subset of the above, only that they
        # run in TreesInViz mode, to make sure basic graphics features render
        # correctly in this mode. They should be deleted once TreesInViz is
        # turned on by default on GPU bots.
        PixelTestPage('pixel_canvas2d.html',
            base_name + '_Canvas2DRedBox' + '_TreesInViz',
            crop_action=standard_crop,
            matching_algorithm=algo.FuzzyMatchingAlgorithm(
                max_different_pixels=130,
                pixel_per_channel_delta_threshold=2),
            browser_args=['--enable-features=TreesInViz']),
        PixelTestPage('pixel_css3d.html',
            base_name + '_CSS3DBlueBox' + '_TreesInViz',
            crop_action=standard_crop,
            matching_algorithm=algo.SobelMatchingAlgorithm(
                max_different_pixels=0,
                pixel_delta_threshold=0,
                edge_threshold=90),
            browser_args=['--enable-features=TreesInViz']),
        PixelTestPage('pixel_webgl_aa_alpha.html',
            base_name + '_WebGLGreenTriangle_AA_Alpha' + '_TreesInViz',
            crop_action=standard_crop,
            browser_args=['--enable-features=TreesInViz']),
        PixelTestPage(
            'pixel_video_mp4.html?width=240&height=135&use_timer=1',
            base_name + '_Video_MP4' + '_TreesInViz',
            crop_action=standard_crop,
            # Most images are actually very similar, but Pixel 2
            # tends to produce images with all colors shifted by a
            # small amount.
            matching_algorithm=GENERAL_MP4_ALGO,
            browser_args=['--enable-features=TreesInViz']),
        PixelTestPage('pixel_view_transitions_capture.html',
            base_name + '_ViewTransitionsCapture' + '_TreesInViz',
            crop_action=standard_crop,
            matching_algorithm=algo.SobelMatchingAlgorithm(
                max_different_pixels=0,
                pixel_delta_threshold=0,
                edge_threshold=90),
            browser_args=['--enable-features=TreesInViz']),
        PixelTestPage('pixel_background.html',
            base_name + '_SolidColorBackground' + '_TreesInViz',
            crop_action=ca.FixedRectCropAction(500, 500, 600, 600),
            # Small Fuchsia screens result in an incomplete capture
            # without this.
            should_capture_full_screenshot_func=(
                CaptureFullScreenshotOnFuchsia),
            browser_args=['--enable-features=TreesInViz']),
        # TODO(crbug.com/431824747): Re-enable once the issue with TreesInViz
        # capturing non-browser content is fixed.
        # PixelTestPage('pixel_render_passes.html',
        #     base_name + '_RenderPasses' + '_TreesInViz',
        #     crop_action=ca.FixedRectCropAction(3, 90, 485, 245),
        #     requires_fullscreen_os_screenshot_func=\
        #     RequiresFullScreenOSScreenshot,
        #     browser_args=['--enable-features=TreesInViz']),
    ]

  @staticmethod
  def WebGPUPages(base_name) -> list[PixelTestPage]:

    class Mode(Enum):
      WEBGPU_DEFAULT = 0
      WEBGPU_SWIFTSHADER = 1
      VULKAN_SWIFTSHADER = 2

    def webgpu_pages_helper(base_name, mode):
      webgpu_args = [cba.ENABLE_EXPERIMENTAL_WEB_PLATFORM_FEATURES]
      video_frame_query_params = '?sourceType=hw_decoder'
      if mode == Mode.WEBGPU_SWIFTSHADER:
        base_name += '_WebGPUSwiftShader'
        webgpu_args += [
            '--enable-features=Vulkan', '--use-webgpu-adapter=swiftshader'
        ]
        video_frame_query_params = '?sourceType=sw_decoder'
      elif mode == Mode.VULKAN_SWIFTSHADER:
        base_name += '_VulkanSwiftShader'
        webgpu_args += [
            '--enable-features=Vulkan', '--use-angle=swiftshader',
            '--use-vulkan=swiftshader', '--use-webgpu-adapter=swiftshader',
            '--disable-vulkan-surface', '--enable-unsafe-webgpu'
        ]
        video_frame_query_params = '?sourceType=sw_decoder'

      # For most tests which have a few elements of interest.
      standard_crop = ca.NonWhiteContentCropAction(
          initial_crop=ca.FixedRectCropAction(0, 0, 500, 500))
      # For tests which don't have a white background to remove. In this case,
      # we're effectively just making sure the color is correct.
      fixed_crop = ca.FixedRectCropAction(0, 0, 300, 300)

      # For testing VideoFrame with HDR color space.
      hdr_params = '?sourceType=hdr_canvas'
      hdr_args = ['--enable-blink-features=CanvasHDR,WebCodecsHBDFormats']

      return [
          PixelTestPage('pixel_webgpu_import_video_frame.html' +
                        video_frame_query_params,
                        base_name + '_WebGPUImportVideoFrame',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage(
              'pixel_webgpu_import_video_frame.html' + video_frame_query_params,
              base_name + '_WebGPUImportVideoFrameUnaccelerated',
              crop_action=standard_crop,
              browser_args=webgpu_args + [cba.DISABLE_ACCELERATED_2D_CANVAS]),
          PixelTestPage(
              'pixel_webgpu_import_video_frame_offscreen_canvas.html' +
              video_frame_query_params,
              base_name + '_WebGPUImportVideoFrameOffscreenCanvas',
              crop_action=standard_crop,
              browser_args=webgpu_args),
          PixelTestPage(
              'pixel_webgpu_import_video_frame_offscreen_canvas.html' +
              video_frame_query_params,
              base_name + '_WebGPUImportVideoFrameUnacceleratedOffscreenCanvas',
              crop_action=standard_crop,
              browser_args=webgpu_args + [cba.DISABLE_ACCELERATED_2D_CANVAS]),
          PixelTestPage('pixel_webgpu_import_video_frame_hdr.html' + hdr_params,
                        base_name + '_WebGPUImportVideoFrameHDR',
                        crop_action=standard_crop,
                        browser_args=webgpu_args + hdr_args),
          PixelTestPage('pixel_webgpu_webgl_teximage2d.html',
                        base_name + '_WebGPUWebGLTexImage2D',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_canvas2d_drawimage.html',
                        base_name + '_WebGPUCanvas2DDrawImage',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_texture_storage.html',
                        base_name + '_WebGPUCanvasTextureStorage',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_copy_image.html',
                        base_name + '_WebGPUToDataURL',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_cached_swap_buffer_invalidated.html',
                        base_name +
                        '_WebGPUCachedSwapBufferInvalidatedShouldBeBlank',
                        crop_action=fixed_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_copy_externalImage_2d_canvas.html',
                        base_name + '_WebGPUCopyExternalImage2DCanvas',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_copy_externalImage_imageData.html',
                        base_name + '_WebGPUCopyExternalImageImageData',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_copy_externalImage_imageBitmap.html',
                        base_name + '_WebGPUCopyExternalImageImageBitmap',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_copy_externalImage_offscreenCanvas.html',
                        base_name + '_WebGPUCopyExternalImageOffscreenCanvas',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_copy_externalImage_webgl_canvas.html',
                        base_name + '_WebGPUCopyExternalImageWebGLCanvas',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_copy_externalImage_webgpu_canvas.html',
                        base_name + '_WebGPUCopyExternalImageWebGPUCanvas',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_display_p3.html',
                        base_name + '_WebGPUDisplayP3',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
          PixelTestPage('pixel_webgpu_canvas_format_reinterpretation.html',
                        base_name + '_WebGPUCanvasFormatReinterpretation',
                        crop_action=standard_crop,
                        browser_args=webgpu_args),
      ]

    return (webgpu_pages_helper(base_name, mode=Mode.WEBGPU_DEFAULT) +
            webgpu_pages_helper(base_name, mode=Mode.WEBGPU_SWIFTSHADER) +
            webgpu_pages_helper(base_name, mode=Mode.VULKAN_SWIFTSHADER))

  @staticmethod
  def WebGPUCanvasCapturePages(base_name) -> list[PixelTestPage]:
    webgpu_args = [cba.ENABLE_EXPERIMENTAL_WEB_PLATFORM_FEATURES]

    browser_args_canvas_one_copy_capture = webgpu_args + [
        '--enable-features=OneCopyCanvasCapture'
    ]
    other_args_canvas_one_copy_capture = {'one_copy': True}

    browser_args_canvas_disable_one_copy_capture = webgpu_args + [
        '--disable-features=OneCopyCanvasCapture'
    ]
    other_args_canvas_accelerated_two_copy = {
        'one_copy': False,
        'accelerated_two_copy': True
    }

    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 500, 500))

    return [
        # Enabled OneCopyCapture
        PixelTestPage('pixel_webgpu_canvas_capture_to_video.html',
                      base_name + '_WebGPUCanvasOneCopyCapture',
                      crop_action=standard_crop,
                      matching_algorithm=GENERAL_MP4_ALGO,
                      browser_args=browser_args_canvas_one_copy_capture,
                      other_args=other_args_canvas_one_copy_capture),
        PixelTestPage('pixel_webgpu_canvas_capture_to_video.html?hidden=true',
                      base_name + '_WebGPUCanvasOneCopyCapture_Hidden',
                      crop_action=standard_crop,
                      matching_algorithm=GENERAL_MP4_ALGO,
                      browser_args=browser_args_canvas_one_copy_capture,
                      other_args=other_args_canvas_one_copy_capture),
        # Disabled OneCopyCapture + canvas is opaque
        PixelTestPage(
            'pixel_webgpu_canvas_capture_to_video.html?has_alpha=false',
            base_name + '_WebGPUCanvasDisableOneCopyCapture_Accelerated',
            crop_action=standard_crop,
            matching_algorithm=GENERAL_MP4_ALGO,
            browser_args=browser_args_canvas_disable_one_copy_capture,
            other_args=other_args_canvas_accelerated_two_copy),
    ]

  @staticmethod
  def WebGPUDeviceDestroyPages(base_name) -> list[PixelTestPage]:
    webgpu_args = [cba.ENABLE_EXPERIMENTAL_WEB_PLATFORM_FEATURES]

    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 320, 210))

    offscreen_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 210, 210))

    methods = [
        'drawImage', 'toDataURL', 'toBlob', 'captureStream',
        'transferToImageBitmap', 'copyExternalImageToTexture', 'glTexImage2D'
    ]
    canvas_tyes = ['onscreen', 'offscreen', 'transferToOffscreen']

    test_actions = [
        sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
        TestActionSleepBeforeRender(),
        sghitb.TestActionWaitForFinish(SHORT_GLOBAL_TIMEOUT),
    ]

    testPages = []
    for method in methods:
      for canvas_type in canvas_tyes:
        if method == 'toDataURL' and canvas_type != 'onscreen':
          continue  # toDataURL is only supported for onscreen canvas
        if method == 'captureStream' and canvas_type != 'onscreen':
          continue  # only test captureStream for onscreen canvas
        if method == 'transferToImageBitmap' and canvas_type == 'onscreen':
          continue  # transferToImageBitmap only works on OffScreenCanvas

        arguments = '?method=' + method + '&canvas=' + canvas_type

        canvas_type_name = canvas_type[0].upper() + canvas_type[1:]
        method_name = method[0].upper() + method[1:]
        test_name = canvas_type_name + 'Canvas' + '_' + method_name

        crop = standard_crop
        if canvas_type == 'offscreen':
          crop = offscreen_crop

        testPages.append(
            PixelTestPage('pixel_destroyed_webgpu_canvas.html' + arguments,
                          base_name + '_WebGPUDestroyed_' + test_name,
                          crop_action=crop,
                          browser_args=webgpu_args,
                          test_actions=test_actions))

    return testPages

  # Pages that should be run with GPU rasterization enabled.
  @staticmethod
  def GpuRasterizationPages(base_name: str) -> list[PixelTestPage]:
    browser_args = [
        cba.ENABLE_GPU_RASTERIZATION,
        cba.DISABLE_SOFTWARE_COMPOSITING_FALLBACK,
    ]

    return [
        PixelTestPage('pixel_background.html',
                      base_name + '_GpuRasterization_BlueBox',
                      crop_action=ca.FixedRectCropAction(0, 0, 220, 220),
                      browser_args=browser_args),
        PixelTestPage('concave_paths.html',
                      base_name + '_GpuRasterization_ConcavePaths',
                      crop_action=ca.NonWhiteContentCropAction(
                          initial_crop=ca.FixedRectCropAction(0, 0, None, 200)),
                      browser_args=browser_args),
        PixelTestPage(
            'pixel_precision_rounded_corner.html',
            base_name + '_PrecisionRoundedCorner',
            # Entire image is typically too big to be captured fully via the
            # default screenshot path, so continue to use the historical crop
            # bounds which results in a small section of the rendered circle
            # being captured.
            crop_action=ca.FixedRectCropAction(0, 0, 400, 400),
            browser_args=browser_args,
            matching_algorithm=algo.SobelMatchingAlgorithm(
                max_different_pixels=10,
                pixel_per_channel_delta_threshold=15,
                edge_threshold=100),
            # Small Fuchsia screens result in an incomplete capture
            # without this.
            should_capture_full_screenshot_func=CaptureFullScreenshotOnFuchsia),
    ]

  # Pages that should be run with off-thread paint worklet flags.
  @staticmethod
  def PaintWorkletPages(base_name: str) -> list[PixelTestPage]:
    browser_args = [
        '--enable-blink-features=OffMainThreadCSSPaint',
        '--enable-gpu-rasterization'
    ]

    return [
        PixelTestPage('pixel_paintWorklet_transform.html',
                      base_name + '_PaintWorkletTransform',
                      crop_action=ca.NonWhiteContentCropAction(
                          initial_crop=ca.FixedRectCropAction(0, 0, 200, 200)),
                      browser_args=browser_args),
    ]

  # Pages that should be run with experimental canvas features.
  @staticmethod
  def ExperimentalCanvasFeaturesPages(base_name: str) -> list[PixelTestPage]:
    browser_args = [
        cba.ENABLE_EXPERIMENTAL_WEB_PLATFORM_FEATURES,
    ]
    accelerated_args = [
        cba.DISABLE_SOFTWARE_COMPOSITING_FALLBACK,
    ]
    unaccelerated_args = [
        cba.DISABLE_ACCELERATED_2D_CANVAS,
        cba.DISABLE_GPU_COMPOSITING,
    ]
    unaccelerated_canvas_accelerated_compositing_args = [
        cba.DISABLE_ACCELERATED_2D_CANVAS,
        cba.DISABLE_SOFTWARE_COMPOSITING_FALLBACK,
    ]

    # The sRGB tests have been observed to create a large number
    # (~15,000) of pixels with difference ~3.
    srgb_fuzzy_algo = algo.FuzzyMatchingAlgorithm(
        max_different_pixels=20000, pixel_per_channel_delta_threshold=2)

    # Small number of differing pixels. May need to be upgraded to sobel in the
    # future since there are a number of hard edges in the image.
    offscreen_canvas_algo = algo.FuzzyMatchingAlgorithm(
        max_different_pixels=100, pixel_per_channel_delta_threshold=3)

    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 400, 400))

    return [
        PixelTestPage('pixel_offscreenCanvas_transfer_after_style_resize.html',
                      base_name + '_OffscreenCanvasTransferAfterStyleResize',
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_offscreenCanvas_transfer_before_style_resize.html',
                      base_name + '_OffscreenCanvasTransferBeforeStyleResize',
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_offscreenCanvas_webgl_paint_after_resize.html',
                      base_name + '_OffscreenCanvasWebGLPaintAfterResize',
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_offscreenCanvas_transferToImageBitmap_main.html',
                      base_name + '_OffscreenCanvasTransferToImageBitmap',
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage(
            'pixel_offscreenCanvas_transferToImageBitmap_main.html',
            base_name +
            '_OffscreenCanvasTransferToImageBitmapSoftwareCompositing',
            crop_action=standard_crop,
            browser_args=browser_args + unaccelerated_args),
        PixelTestPage('pixel_offscreenCanvas_transferToImageBitmap_worker.html',
                      base_name + '_OffscreenCanvasTransferToImageBitmapWorker',
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_offscreenCanvas_webgl_commit_main.html',
                      base_name + '_OffscreenCanvasWebGLDefault',
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_offscreenCanvas_webgl_commit_worker.html',
                      base_name + '_OffscreenCanvasWebGLDefaultWorker',
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_offscreenCanvas_webgl_commit_main.html',
                      base_name + '_OffscreenCanvasWebGLSoftwareCompositing',
                      crop_action=standard_crop,
                      browser_args=browser_args +
                      [cba.DISABLE_GPU_COMPOSITING]),
        PixelTestPage(
            'pixel_offscreenCanvas_webgl_commit_worker.html',
            base_name + '_OffscreenCanvasWebGLSoftwareCompositingWorker',
            crop_action=standard_crop,
            browser_args=browser_args + [cba.DISABLE_GPU_COMPOSITING]),
        PixelTestPage('pixel_offscreenCanvas_2d_commit_main.html',
                      base_name + '_OffscreenCanvasAccelerated2D',
                      crop_action=standard_crop,
                      browser_args=browser_args + accelerated_args,
                      matching_algorithm=offscreen_canvas_algo),
        PixelTestPage('pixel_offscreenCanvas_2d_commit_worker.html',
                      base_name + '_OffscreenCanvasAccelerated2DWorker',
                      crop_action=standard_crop,
                      browser_args=browser_args + accelerated_args,
                      matching_algorithm=offscreen_canvas_algo),
        PixelTestPage('pixel_offscreenCanvas_2d_commit_main.html',
                      base_name + '_OffscreenCanvasUnaccelerated2D',
                      crop_action=standard_crop,
                      browser_args=browser_args + unaccelerated_args),
        PixelTestPage('pixel_offscreenCanvas_2d_commit_worker.html',
                      base_name + '_OffscreenCanvasUnaccelerated2DWorker',
                      crop_action=standard_crop,
                      browser_args=browser_args + unaccelerated_args),
        PixelTestPage('pixel_offscreenCanvas_2d_commit_main.html',
                      base_name +
                      '_OffscreenCanvasUnaccelerated2DGPUCompositing',
                      crop_action=standard_crop,
                      browser_args=browser_args +
                      unaccelerated_canvas_accelerated_compositing_args),
        PixelTestPage('pixel_offscreenCanvas_2d_commit_worker.html',
                      base_name +
                      '_OffscreenCanvasUnaccelerated2DGPUCompositingWorker',
                      crop_action=standard_crop,
                      browser_args=browser_args +
                      unaccelerated_canvas_accelerated_compositing_args),
        PixelTestPage('pixel_offscreenCanvas_2d_resize_on_worker.html',
                      base_name + '_OffscreenCanvas2DResizeOnWorker',
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_offscreenCanvas_webgl_resize_on_worker.html',
                      base_name + '_OffscreenCanvasWebglResizeOnWorker',
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_canvas_display_srgb.html',
                      base_name + '_CanvasDisplaySRGBAccelerated2D',
                      crop_action=standard_crop,
                      browser_args=browser_args + accelerated_args,
                      matching_algorithm=srgb_fuzzy_algo),
        PixelTestPage('pixel_canvas_display_srgb.html',
                      base_name + '_CanvasDisplaySRGBUnaccelerated2D',
                      crop_action=standard_crop,
                      browser_args=browser_args + unaccelerated_args,
                      matching_algorithm=srgb_fuzzy_algo),
        PixelTestPage(
            'pixel_canvas_display_srgb.html',
            base_name + '_CanvasDisplaySRGBUnaccelerated2DGPUCompositing',
            crop_action=standard_crop,
            browser_args=browser_args + [cba.DISABLE_ACCELERATED_2D_CANVAS],
            matching_algorithm=srgb_fuzzy_algo),
        PixelTestPage('pixel_webgl_webcodecs_breakoutbox_displays_frame.html',
                      base_name + '_WebGLWebCodecsBreakoutBoxDisplaysFrame',
                      crop_action=standard_crop,
                      browser_args=browser_args)
    ]

  @staticmethod
  def LowLatencyPages(base_name: str) -> list[PixelTestPage]:
    unaccelerated_args = [
        cba.DISABLE_ACCELERATED_2D_CANVAS,
        cba.DISABLE_GPU_COMPOSITING,
    ]

    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 250, 250))

    return [
        PixelTestPage('pixel_canvas_low_latency_2d.html',
                      base_name + '_CanvasLowLatency2D',
                      crop_action=standard_crop),
        PixelTestPage('pixel_canvas_low_latency_2d.html',
                      base_name + '_CanvasUnacceleratedLowLatency2D',
                      crop_action=standard_crop,
                      browser_args=unaccelerated_args),
        PixelTestPage('pixel_canvas_low_latency_webgl.html',
                      base_name + '_CanvasLowLatencyWebGL',
                      crop_action=standard_crop),
        PixelTestPage('pixel_canvas_low_latency_webgl_alpha_false.html',
                      base_name + '_CanvasLowLatencyWebGLAlphaFalse',
                      crop_action=standard_crop),
        PixelTestPage('pixel_canvas_low_latency_2d_draw_image.html',
                      base_name + '_CanvasLowLatency2DDrawImage',
                      crop_action=standard_crop),
        PixelTestPage('pixel_canvas_low_latency_webgl_draw_image.html',
                      base_name + '_CanvasLowLatencyWebGLDrawImage',
                      crop_action=standard_crop),
        PixelTestPage('pixel_canvas_low_latency_2d_image_data.html',
                      base_name + '_CanvasLowLatency2DImageData',
                      crop_action=standard_crop),
        PixelTestPage('pixel_canvas_low_latency_webgl_rounded_corners.html',
                      base_name + '_CanvasLowLatencyWebGLRoundedCorners',
                      crop_action=standard_crop,
                      matching_algorithm=ROUNDING_ERROR_ALGO),
        PixelTestPage('pixel_canvas_low_latency_webgl_occluded.html',
                      base_name + '_CanvasLowLatencyWebGLOccluded',
                      crop_action=standard_crop,
                      other_args={'no_overlay': True}),
    ]

  # Only add these tests on platforms where SwiftShader is enabled.
  # Currently this is Windows and Linux.
  @staticmethod
  def SwiftShaderPages(base_name: str) -> list[PixelTestPage]:
    browser_args = [
        cba.DISABLE_GPU, '--enable-features=AllowSwiftShaderFallback',
        '--disable-features=AllowD3D11WarpFallback'
    ]
    suffix = '_SwiftShader'
    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 350, 350))
    return [
        PixelTestPage('pixel_canvas2d.html',
                      base_name + '_Canvas2DRedBox' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_css3d.html',
                      base_name + '_CSS3DBlueBox' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_webgl_aa_alpha.html',
                      base_name + '_WebGLGreenTriangle_AA_Alpha' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_repeated_webgl_to_2d.html',
                      base_name + '_RepeatedWebGLTo2D' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args),
    ]

  # Only add these tests on platforms where D3D11 WARP is enabled.
  # Currently this is Windows.
  @staticmethod
  def WARPPages(base_name: str) -> list[PixelTestPage]:
    browser_args = [
        cba.DISABLE_GPU, '--disable-features=AllowSwiftShaderFallback',
        '--enable-features=AllowD3D11WarpFallback'
    ]
    suffix = '_WARP'
    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 350, 350))
    return [
        PixelTestPage('pixel_canvas2d.html',
                      base_name + '_Canvas2DRedBox' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_css3d.html',
                      base_name + '_CSS3DBlueBox' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_webgl_aa_alpha.html',
                      base_name + '_WebGLGreenTriangle_AA_Alpha' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args),
        PixelTestPage('pixel_repeated_webgl_to_2d.html',
                      base_name + '_RepeatedWebGLTo2D' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args),
    ]

  # Test rendering where GPU process is blocked.
  @staticmethod
  def NoGpuProcessPages(base_name: str) -> list[PixelTestPage]:
    browser_args = [cba.DISABLE_GPU, cba.DISABLE_SOFTWARE_RASTERIZER]
    suffix = '_NoGpuProcess'
    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 350, 350))
    return [
        PixelTestPage('pixel_canvas2d.html',
                      base_name + '_Canvas2DRedBox' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args,
                      gpu_process_disabled=True),
        PixelTestPage('pixel_css3d.html',
                      base_name + '_CSS3DBlueBox' + suffix,
                      crop_action=standard_crop,
                      browser_args=browser_args,
                      gpu_process_disabled=True),
    ]

  # Pages that should be run with various macOS specific command line
  # arguments.
  @staticmethod
  def MacSpecificPages(base_name: str) -> list[PixelTestPage]:
    unaccelerated_2d_canvas_args = [cba.DISABLE_ACCELERATED_2D_CANVAS]

    non_chromium_image_args = ['--disable-webgl-image-chromium']

    # This disables the Core Animation compositor, falling back to the
    # old GLRenderer path, but continuing to allocate IOSurfaces for
    # WebGL's back buffer.
    no_overlays_args = ['--disable-features=CoreAnimationRenderer']

    angle_gl = ['--use-angle=gl']

    # The filter effect tests produce images with lots of gradients and blurs
    # which don't play nicely with Sobel filters, so a fuzzy algorithm instead
    # of Sobel. The images are also relatively large (360k pixels), and large
    # portions of the image are prone to noise, hence the large max different
    # pixels value.
    filter_effect_fuzzy_algo = algo.FuzzyMatchingAlgorithm(
        max_different_pixels=57500, pixel_per_channel_delta_threshold=10)

    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 350, 350))

    # Use a fixed crop since the fuzziness of the image is liable to make the
    # image size change randomly.
    filter_effects_crop = ca.FixedRectCropAction(0, 0, 300, 300)

    return [
        PixelTestPage('pixel_canvas2d_webgl.html',
                      base_name + '_IOSurface2DCanvasWebGL',
                      crop_action=standard_crop),

        # On macOS, test WebGL non-Chromium Image compositing path.
        PixelTestPage('pixel_webgl_aa_alpha.html',
                      base_name +
                      '_WebGLGreenTriangle_NonChromiumImage_AA_Alpha',
                      crop_action=standard_crop,
                      browser_args=non_chromium_image_args),
        PixelTestPage('pixel_webgl_noaa_alpha.html',
                      base_name +
                      '_WebGLGreenTriangle_NonChromiumImage_NoAA_Alpha',
                      crop_action=standard_crop,
                      browser_args=non_chromium_image_args),
        PixelTestPage('pixel_webgl_aa_noalpha.html',
                      base_name +
                      '_WebGLGreenTriangle_NonChromiumImage_AA_NoAlpha',
                      crop_action=standard_crop,
                      browser_args=non_chromium_image_args),
        PixelTestPage('pixel_webgl_noaa_noalpha.html',
                      base_name +
                      '_WebGLGreenTriangle_NonChromiumImage_NoAA_NoAlpha',
                      crop_action=standard_crop,
                      browser_args=non_chromium_image_args),

        # On macOS, test CSS filter effects with and without the CA compositor.
        PixelTestPage('filter_effects.html',
                      base_name + '_CSSFilterEffects',
                      crop_action=filter_effects_crop,
                      matching_algorithm=filter_effect_fuzzy_algo),
        PixelTestPage('filter_effects.html',
                      base_name + '_CSSFilterEffects_NoOverlays',
                      crop_action=filter_effects_crop,
                      browser_args=no_overlays_args,
                      matching_algorithm=filter_effect_fuzzy_algo),

        # Test WebGL's premultipliedAlpha:false without the CA compositor.
        PixelTestPage('pixel_webgl_premultiplied_alpha_false.html',
                      base_name + '_WebGL_PremultipliedAlpha_False_NoOverlays',
                      crop_action=standard_crop,
                      browser_args=no_overlays_args),

        # Test GpuBenchmarking::AddCoreAnimationStatusEventListener.
        # Error code is 0 (gfx::kCALayerSuccess) when it succeeds.
        # --enable-gpu-benchmarking is added by default and it's required to run
        # this test.
        PixelTestPage('core_animation_status_api.html?error=0',
                      base_name + '_CoreAnimationStatusApiNoError',
                      crop_action=standard_crop),
        # Test GpuBenchmarking::AddCoreAnimationStatusEventListener.
        # Error code is 32 (gfx::kCALayerFailedOverlayDisabled) when
        # CoreAnimationRenderer is disabled.
        # --enable-gpu-benchmarking is added by default and it's required to run
        # this test.
        PixelTestPage('core_animation_status_api.html?error=32',
                      base_name + '_CoreAnimationStatusApiWithError',
                      crop_action=standard_crop,
                      browser_args=no_overlays_args),

        # --enable-gpu-benchmarking is required to run this test. it's added to
        # the pixel tests by default.
        PixelTestPage('canvas_uses_overlay.html',
                      base_name + '_CanvasUsesOverlay',
                      crop_action=standard_crop),

        # --enable-gpu-benchmarking is required to run this test. it's added to
        # the pixel tests by default.
        PixelTestPage('canvas_uses_overlay.html',
                      base_name + '_UnacceleratedCanvasUsesOverlay',
                      crop_action=standard_crop,
                      browser_args=unaccelerated_2d_canvas_args),

        # --enable-gpu-benchmarking is required to run this test. it's added to
        # the pixel tests by default.
        PixelTestPage(
            'offscreencanvas_imagebitmap_from_worker_uses_overlay.html',
            base_name + '_OffscreenCanvasImageBitmapWorkerUsesOverlay',
            crop_action=standard_crop),

        # --enable-gpu-benchmarking is required to run this test. it's added to
        # the pixel tests by default.
        PixelTestPage(
            'offscreencanvas_imagebitmap_from_worker_uses_overlay.html',
            base_name +
            '_UnacceleratedOffscreenCanvasImageBitmapWorkerUsesOverlay',
            crop_action=standard_crop,
            browser_args=unaccelerated_2d_canvas_args),

        # --enable-gpu-benchmarking is required to run this test. it's added to
        # the pixel tests by default.
        PixelTestPage('offscreencanvas_imagebitmap_uses_overlay.html',
                      base_name + '_OffscreenCanvasImageBitmapUsesOverlay',
                      crop_action=standard_crop),

        # --enable-gpu-benchmarking is required to run this test. it's added to
        # the pixel tests by default.
        PixelTestPage('offscreencanvas_imagebitmap_uses_overlay.html',
                      base_name +
                      '_UnacceleratedOffscreenCanvasImageBitmapUsesOverlay',
                      crop_action=standard_crop,
                      browser_args=unaccelerated_2d_canvas_args),

        # Regression test for crbug.com/1410696
        PixelTestPage('pixel_offscreenCanvas_ibrc_worker.html',
                      base_name + '_OffscreenCanvasIBRCWorkerAngleGL',
                      crop_action=standard_crop,
                      browser_args=angle_gl),
    ]

  # Pages that should be run only on dual-GPU MacBook Pros (at the
  # present time, anyway).
  @staticmethod
  def DualGPUMacSpecificPages(base_name: str) -> list[PixelTestPage]:

    low_to_high_power_test_actions = [
        sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
        TestActionRunLowToHighPowerTest(),
        sghitb.TestActionWaitForFinish(SHORT_GLOBAL_TIMEOUT),
    ]

    high_perf_test_actions = [
        sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
        TestActionRunOffscreenCanvasIBRCWebGLHighPerfTest(),
        sghitb.TestActionWaitForFinish(SHORT_GLOBAL_TIMEOUT),
    ]

    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 350, 350))

    return [
        PixelTestPage(
            'pixel_webgl_high_to_low_power.html',
            base_name + '_WebGLHighToLowPower',
            crop_action=standard_crop,
            test_actions=[
                sghitb.TestActionWaitForContinue(SHORT_GLOBAL_TIMEOUT),
                TestActionRunTestWithHighPerformanceTab(),
                sghitb.TestActionWaitForFinish(SHORT_GLOBAL_TIMEOUT),
            ]),
        PixelTestPage('pixel_webgl_low_to_high_power.html',
                      base_name + '_WebGLLowToHighPower',
                      crop_action=standard_crop,
                      test_actions=low_to_high_power_test_actions),
        PixelTestPage('pixel_webgl_low_to_high_power_alpha_false.html',
                      base_name + '_WebGLLowToHighPowerAlphaFalse',
                      crop_action=standard_crop,
                      test_actions=low_to_high_power_test_actions),
        PixelTestPage('pixel_offscreen_canvas_ibrc_webgl_main.html',
                      base_name + '_OffscreenCanvasIBRCWebGLHighPerfMain',
                      crop_action=standard_crop,
                      test_actions=high_perf_test_actions),
        PixelTestPage('pixel_offscreen_canvas_ibrc_webgl_worker.html',
                      base_name + '_OffscreenCanvasIBRCWebGLHighPerfWorker',
                      crop_action=standard_crop,
                      test_actions=high_perf_test_actions),
    ]

  # pylint: disable=too-many-locals
  @staticmethod
  def DirectCompositionPages(base_name: str,
                             swap_count: int | None = None
                             ) -> list[PixelTestPage]:
    browser_args = [
        cba.ENABLE_DIRECT_COMPOSITION_VIDEO_OVERLAYS,
        # All bots are connected with a power source, however, we want to to
        # test with the code path that's enabled with battery power.
        cba.DISABLE_DIRECT_COMPOSITION_VP_SCALING,
    ]
    browser_args_NV12 = browser_args + [
        '--direct-composition-video-swap-chain-format=nv12'
    ]
    browser_args_YUY2 = browser_args + [
        '--direct-composition-video-swap-chain-format=yuy2'
    ]
    browser_args_BGRA = browser_args + [
        '--direct-composition-video-swap-chain-format=bgra'
    ]
    browser_args_vp_scaling = [
        cba.ENABLE_DIRECT_COMPOSITION_VIDEO_OVERLAYS,
        cba.ENABLE_DIRECT_COMPOSITION_VP_SCALING,
    ]
    browser_args_sw_decode = browser_args + [
        cba.DISABLE_ACCELERATED_VIDEO_DECODE
    ]

    # 16 was the highest value set for any test before switching to allow
    # configurable swap count.
    swap_count = swap_count or 16
    swap_param = f'swaps={swap_count}'

    # Most tests fall roughly into 3 tiers of noisiness.
    # Parameter values were determined using the automated optimization script,
    # and similar values combined into a single set using the most permissive
    # value for each parameter in that tier.
    strict_dc_sobel_algorithm = algo.SobelMatchingAlgorithm(
        max_different_pixels=2000,
        pixel_per_channel_delta_threshold=3,
        edge_threshold=250,
        ignored_border_thickness=1)
    permissive_dc_sobel_algorithm = algo.SobelMatchingAlgorithm(
        max_different_pixels=16800,
        pixel_per_channel_delta_threshold=10,
        edge_threshold=30,
        ignored_border_thickness=1)
    very_permissive_dc_sobel_algorithm = algo.SobelMatchingAlgorithm(
        max_different_pixels=30400,
        pixel_per_channel_delta_threshold=20,
        edge_threshold=10,
        ignored_border_thickness=1,
    )

    h264 = overlay_support.ZeroCopyCodec.H264
    vp9 = overlay_support.ZeroCopyCodec.VP9

    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 300, 300))
    mp4_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 600, 600))
    large_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 1000, 600))

    MP4_FULLSIZE_WIDTH = 960
    MP4_FULLSIZE_HEIGHT = 540
    MP4_HALF_WIDTH = MP4_FULLSIZE_WIDTH / 2
    MP4_HALF_HEIGHT = MP4_FULLSIZE_HEIGHT / 2

    return [
        PixelTestPage(
            f'pixel_video_mp4.html?width={MP4_HALF_WIDTH}&'
            f'height={MP4_HALF_HEIGHT}&{swap_param}',
            base_name + '_DirectComposition_Video_MP4',
            crop_action=mp4_crop,
            browser_args=browser_args,
            other_args={
                'codec': h264,
            },
            matching_algorithm=permissive_dc_sobel_algorithm),
        PixelTestPage(
            f'pixel_video_mp4.html?width={MP4_FULLSIZE_WIDTH}&'
            f'height={MP4_FULLSIZE_HEIGHT}&{swap_param}',
            base_name + '_DirectComposition_Video_MP4_Fullsize',
            browser_args=browser_args,
            other_args={
                'full_size': True,
                'codec': h264,
            },
            crop_action=large_crop,
            matching_algorithm=strict_dc_sobel_algorithm),
        PixelTestPage(
            f'pixel_video_mp4.html?width={MP4_HALF_WIDTH}&'
            f'height={MP4_HALF_HEIGHT}&{swap_param}',
            base_name + '_DirectComposition_Video_MP4_NV12',
            crop_action=mp4_crop,
            browser_args=browser_args_NV12,
            other_args={
                'pixel_format': overlay_support.PixelFormat.NV12,
                'codec': h264,
            },
            matching_algorithm=permissive_dc_sobel_algorithm),
        PixelTestPage(
            f'pixel_video_mp4.html?width={MP4_HALF_WIDTH}&'
            f'height={MP4_HALF_HEIGHT}&{swap_param}',
            base_name + '_DirectComposition_Video_MP4_YUY2',
            crop_action=mp4_crop,
            browser_args=browser_args_YUY2,
            other_args={
                'pixel_format': overlay_support.PixelFormat.YUY2,
                'codec': h264,
            },
            matching_algorithm=permissive_dc_sobel_algorithm),
        PixelTestPage(
            f'pixel_video_mp4.html?width={MP4_FULLSIZE_WIDTH}&'
            f'height={MP4_FULLSIZE_HEIGHT}&{swap_param}',
            base_name + '_DirectComposition_Video_MP4_BGRA',
            crop_action=large_crop,
            browser_args=browser_args_BGRA,
            other_args={
                'pixel_format': overlay_support.PixelFormat.BGRA8,
                'codec': h264,
            },
            matching_algorithm=permissive_dc_sobel_algorithm),
        PixelTestPage(
            f'pixel_video_mp4.html?width={MP4_HALF_WIDTH}&'
            f'height={MP4_HALF_HEIGHT}&{swap_param}',
            base_name + '_DirectComposition_Video_MP4_VP_SCALING',
            crop_action=mp4_crop,
            browser_args=browser_args_vp_scaling,
            other_args={
                'zero_copy': False,
                'codec': h264,
            },
            matching_algorithm=permissive_dc_sobel_algorithm),
        PixelTestPage(
            (f'pixel_video_mp4_four_colors_aspect_4x3.html?'
             f'width={MP4_HALF_WIDTH}&height={MP4_HALF_HEIGHT}&{swap_param}'),
            base_name + '_DirectComposition_Video_MP4_FourColors_Aspect_4x3',
            crop_action=mp4_crop,
            browser_args=browser_args,
            other_args={
                'codec': h264,
            },
            matching_algorithm=permissive_dc_sobel_algorithm),
        PixelTestPage(
            (f'pixel_video_mp4_four_colors_rot_90.html?'
             f'width={MP4_HALF_HEIGHT}&height={MP4_HALF_WIDTH}&{swap_param}'),
            base_name + '_DirectComposition_Video_MP4_FourColors_Rot_90',
            crop_action=mp4_crop,
            browser_args=browser_args,
            other_args={
                'video_rotation': overlay_support.VideoRotation.ROT90,
                'codec': h264,
            },
            matching_algorithm=strict_dc_sobel_algorithm),
        PixelTestPage(
            (f'pixel_video_mp4_four_colors_rot_180.html?'
             f'width={MP4_HALF_WIDTH}&height={MP4_HALF_HEIGHT}&{swap_param}'),
            base_name + '_DirectComposition_Video_MP4_FourColors_Rot_180',
            crop_action=mp4_crop,
            browser_args=browser_args,
            other_args={
                'video_rotation': overlay_support.VideoRotation.ROT180,
                'codec': h264,
            },
            matching_algorithm=strict_dc_sobel_algorithm),
        PixelTestPage(
            (f'pixel_video_mp4_four_colors_rot_270.html?'
             f'width={MP4_HALF_HEIGHT}&height={MP4_HALF_WIDTH}&{swap_param}'),
            base_name + '_DirectComposition_Video_MP4_FourColors_Rot_270',
            crop_action=mp4_crop,
            browser_args=browser_args,
            other_args={
                'video_rotation': overlay_support.VideoRotation.ROT270,
                'codec': h264,
            },
            matching_algorithm=strict_dc_sobel_algorithm),
        PixelTestPage(f'pixel_video_vp9.html?width=240&height=135&{swap_param}',
                      base_name + '_DirectComposition_Video_VP9',
                      crop_action=standard_crop,
                      browser_args=browser_args,
                      other_args={
                          'codec': vp9,
                      },
                      matching_algorithm=very_permissive_dc_sobel_algorithm),
        PixelTestPage(
            f'pixel_video_vp9.html?width=960&height=540&{swap_param}',
            base_name + '_DirectComposition_Video_VP9_Fullsize',
            crop_action=large_crop,
            browser_args=browser_args,
            other_args={
                'full_size': True,
                'codec': vp9,
            },
            # Much larger image than other VP9 tests.
            matching_algorithm=algo.SobelMatchingAlgorithm(
                max_different_pixels=504000,
                pixel_per_channel_delta_threshold=5,
                edge_threshold=10,
                ignored_border_thickness=1,
            )),
        PixelTestPage(f'pixel_video_vp9.html?width=240&height=135&{swap_param}',
                      base_name + '_DirectComposition_Video_VP9_NV12',
                      crop_action=standard_crop,
                      browser_args=browser_args_NV12,
                      other_args={
                          'pixel_format': overlay_support.PixelFormat.NV12,
                          'codec': vp9,
                      },
                      matching_algorithm=very_permissive_dc_sobel_algorithm),
        PixelTestPage(f'pixel_video_vp9.html?width=240&height=135&{swap_param}',
                      base_name + '_DirectComposition_Video_VP9_YUY2',
                      crop_action=standard_crop,
                      browser_args=browser_args_YUY2,
                      other_args={
                          'pixel_format': overlay_support.PixelFormat.YUY2,
                          'codec': vp9,
                      },
                      matching_algorithm=very_permissive_dc_sobel_algorithm),
        PixelTestPage(f'pixel_video_vp9.html?width=960&height=540&{swap_param}',
                      base_name + '_DirectComposition_Video_VP9_BGRA',
                      crop_action=large_crop,
                      browser_args=browser_args_BGRA,
                      other_args={
                          'pixel_format': overlay_support.PixelFormat.BGRA8,
                          'codec': vp9
                      },
                      matching_algorithm=very_permissive_dc_sobel_algorithm),
        PixelTestPage((f'pixel_video_vp9_i420a.html?'
                       f'width=240&height=135&{swap_param}'),
                      base_name + '_DirectComposition_Video_VP9_I420A',
                      crop_action=standard_crop,
                      browser_args=browser_args,
                      other_args={
                          'no_overlay': True,
                          'codec': vp9
                      },
                      matching_algorithm=strict_dc_sobel_algorithm),
        PixelTestPage(f'pixel_video_vp9.html?width=240&height=135&{swap_param}',
                      base_name + '_DirectComposition_Video_VP9_VP_SCALING',
                      crop_action=standard_crop,
                      browser_args=browser_args_vp_scaling,
                      other_args={
                          'zero_copy': False,
                          'codec': vp9,
                      },
                      matching_algorithm=very_permissive_dc_sobel_algorithm),
        PixelTestPage(
            (f'pixel_video_underlay.html?'
             f'width=240&height=136&{swap_param}'),
            base_name + '_DirectComposition_Underlay',
            crop_action=standard_crop,
            browser_args=browser_args,
            # Underlay zero copy usage seems to track H.264 zero copy
            # support.
            other_args={
                'codec': h264,
            },
            matching_algorithm=permissive_dc_sobel_algorithm),
        PixelTestPage(
            (f'pixel_video_underlay.html?'
             f'width=960&height=540&{swap_param}'),
            base_name + '_DirectComposition_Underlay_Fullsize',
            crop_action=large_crop,
            browser_args=browser_args,
            # Underlay zero copy usage seems to track H.264 zero copy
            # support.
            other_args={
                'full_size': True,
                'codec': h264,
            },
            matching_algorithm=strict_dc_sobel_algorithm),
        PixelTestPage((f'pixel_video_mp4_rounded_corner.html?'
                       f'width=240&height=135&{swap_param}'),
                      base_name + '_DirectComposition_Video_MP4_Rounded_Corner',
                      crop_action=standard_crop,
                      browser_args=browser_args,
                      other_args={
                          'codec': h264,
                      },
                      matching_algorithm=permissive_dc_sobel_algorithm),
        PixelTestPage((f'pixel_video_backdrop_filter.html?'
                       f'width=240&height=135&{swap_param}'),
                      base_name + '_DirectComposition_Video_BackdropFilter',
                      crop_action=standard_crop,
                      browser_args=browser_args,
                      other_args={
                          'no_overlay': True,
                      }),
        PixelTestPage(
            f'pixel_video_mp4.html?width=240&height=135&{swap_param}',
            base_name + '_DirectComposition_Video_Disable_Overlays',
            crop_action=standard_crop,
            browser_args=[cba.DISABLE_DIRECT_COMPOSITION_VIDEO_OVERLAYS],
            other_args={'no_overlay': True},
            matching_algorithm=very_permissive_dc_sobel_algorithm),
        PixelTestPage(f'pixel_video_mp4.html?width=240&height=135&{swap_param}',
                      base_name + '_DirectComposition_Video_SW_Decode',
                      crop_action=standard_crop,
                      browser_args=browser_args_sw_decode,
                      other_args={
                          'zero_copy': False,
                      },
                      matching_algorithm=very_permissive_dc_sobel_algorithm),
        PixelTestPage(
            'pixel_media_foundation_clear_dcomp.html?src='
            '/media/test/data/four-colors.mp4',
            base_name + '_MediaFoundationClearDirectComposition',
            crop_action=standard_crop,
            browser_args=[
                '--enable-features=MediaFoundationClearPlayback, \
                MediaFoundationClearRendering:strategy/direct-composition'
            ],
            matching_algorithm=VERY_PERMISSIVE_SOBEL_ALGO),
    ]

  # pylint: enable=too-many-locals

  @staticmethod
  def VideoFromCanvasPages(base_name: str) -> list[PixelTestPage]:
    # Tests for <video> element rendering results of <canvas> capture.
    # It's important for video conference software.

    match_algo = VERY_PERMISSIVE_SOBEL_ALGO
    # Use shorter timeout since the tests are not supposed to be long.
    timeout = 150
    standard_crop = ca.NonWhiteContentCropAction(
        initial_crop=ca.FixedRectCropAction(0, 0, 250, 200))

    return [
        PixelTestPage('pixel_video_from_canvas_2d.html',
                      base_name + '_VideoStreamFrom2DCanvas',
                      crop_action=standard_crop,
                      browser_args=[],
                      matching_algorithm=match_algo,
                      timeout=timeout),
        PixelTestPage('pixel_video_from_canvas_2d_alpha.html',
                      base_name + '_VideoStreamFrom2DAlphaCanvas',
                      crop_action=standard_crop,
                      browser_args=[],
                      matching_algorithm=match_algo,
                      timeout=timeout),
        PixelTestPage('pixel_video_from_canvas_webgl2_alpha.html',
                      base_name + '_VideoStreamFromWebGLAlphaCanvas',
                      crop_action=standard_crop,
                      browser_args=[],
                      matching_algorithm=match_algo,
                      timeout=timeout),
        PixelTestPage('pixel_video_from_canvas_webgl2.html',
                      base_name + '_VideoStreamFromWebGLCanvas',
                      crop_action=standard_crop,
                      browser_args=[],
                      matching_algorithm=match_algo,
                      timeout=timeout),

        # Safeguard against repeating crbug.com/1371308
        PixelTestPage(
            'pixel_video_from_canvas_2d.html',
            base_name +
            '_VideoStreamFrom2DAlphaCanvas_DisableReadbackFromTexture',
            crop_action=standard_crop,
            browser_args=[
                '--disable-features=GpuMemoryBufferReadbackFromTexture'
            ],
            matching_algorithm=match_algo,
            timeout=timeout),

        # Test OneCopyCanvasCapture
        PixelTestPage('pixel_video_from_canvas_webgl2.html',
                      base_name + '_VideoStreamFromWebGLCanvas_OneCopy',
                      crop_action=standard_crop,
                      browser_args=['--enable-features=OneCopyCanvasCapture'],
                      other_args={'one_copy': True},
                      matching_algorithm=match_algo,
                      timeout=timeout),
        # TwoCopyCanvasCapture
        PixelTestPage('pixel_video_from_canvas_webgl2.html',
                      base_name +
                      '_VideoStreamFromWebGLCanvas_TwoCopy_Accelerated',
                      crop_action=standard_crop,
                      browser_args=['--disable-features=OneCopyCanvasCapture'],
                      other_args={
                          'one_copy': False,
                          'accelerated_two_copy': True
                      },
                      matching_algorithm=match_algo,
                      timeout=timeout),
    ]

  @staticmethod
  def HdrTestPages(base_name: str) -> list[PixelTestPage]:
    standard_crop = ca.NonWhiteContentCropAction(
        ca.FixedRectCropAction(0, 0, 300, 300))

    return [
        PixelTestPage('pixel_canvas2d.html',
                      base_name + '_Canvas2DRedBoxScrgbLinear',
                      crop_action=standard_crop,
                      browser_args=['--force-color-profile=scrgb-linear']),
        PixelTestPage('pixel_canvas2d.html',
                      base_name + '_Canvas2DRedBoxHdr10',
                      crop_action=standard_crop,
                      browser_args=['--force-color-profile=hdr10']),
    ]

  # This should only be used with the cast_streaming suite.
  @staticmethod
  def CastStreamingReceiverPages(base_name) -> list[PixelTestPage]:
    return [
        PixelTestPage(
            'receiver.html',
            base_name + '_VP8_1Frame',
            crop_action=ca.NoOpCropAction(),
        ),
    ]

  @staticmethod
  def MeetEffectsPages(base_name: str) -> list[PixelTestPage]:
    test_cases_path = os.path.join(gpu_path_util.MEET_EFFECTS_VIDEO_DIR,
                                   'test_cases.json')
    video_path = os.path.join(gpu_path_util.MEET_EFFECTS_VIDEO_DIR,
                              'effects-normal-light.y4m')
    video_args = [
        '--auto-accept-camera-and-microphone-capture',
        '--use-fake-device-for-media-stream',
        f'--use-file-for-fake-video-capture={video_path}'
    ]
    meet_sample_area_matching = algo.SampleAreaMatchingAlgorithm(
        sample_area_width=5,
        max_different_pixels_per_area=2,
        sample_area_channel_delta_threshold=5,
        combine_inexact_matches=True)
    # The video is rather large on the page, which can cause a horizontal
    # scrollbar to appear along the bottom. So, crop that first.
    standard_crop = ca.NonWhiteContentCropAction(
        ca.FixedRectCropAction(0, 60, None, -20))
    # These tests are known to produce flaky output that cannot be consistently
    # handled by inexact matching without relaxing inexact matching parameters
    # to the point of letting basically any image through. This is mostly
    # caused by rendered content shifting by a fraction of a pixel, which causes
    # a large number of differences along edges. See b/434910221 for more
    # information.
    output = []
    with open(test_cases_path, 'r', encoding='utf-8') as f:
      for name, value in json.load(f).items():
        query_params = {'config': json.dumps(value['processingConfig'])}
        if 'extraFlags' in value:
          query_params['extraFlags'] = json.dumps(value['extraFlags'])
        params = urllib.parse.urlencode(query_params)
        output.append(
            PixelTestPage(f'meet_effects/meet-gpu-tests/index.html?{params}',
                          f'{base_name}_MeetEffects_{name.replace(" ", "_")}',
                          crop_action=standard_crop,
                          browser_args=video_args,
                          matching_algorithm=meet_sample_area_matching,
                          known_flaky_output_test=True))

    return output