test_suites.pyl

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

# This is a .pyl, or "Python Literal", file. You can treat it just like a
# .json file, with the following exceptions:
# * all keys must be quoted (use single quotes, please);
# * comments are allowed, using '#' syntax; and
# * trailing commas are allowed.

# The test suites understood by the waterfalls. Two kinds of entries
# are supported here:
#  1. Dictionaries that directly define test suites.
#  2. Compositions, in the form of lists which refer to other test
#     suites.
#
# This file must be sorted by key. Run ./generate_buildbot_json.py -c to check
# your ordering; it will print out incorrectly sorted keys if there are any.

{
  # Test suites.
  'basic_suites': {
    'android_ar_gtests': {
      'monochrome_public_test_ar_apk': {},
      # Name is vr_*, but actually has AR tests.
      'vr_android_unittests': {},
    },
    'android_ddready_vr_gtests': {
      'chrome_public_test_vr_apk-ddready-cardboard': {
        'args': [
          '--shared-prefs-file=//chrome/android/shared_preference_files/test/vr_cardboard_skipdon_setupcomplete.json',
        ],
        'mixins': [
          'vr_instrumentation_test',
        ],
        'swarming': {
          'shards': 2,
        },
        'test': 'chrome_public_test_vr_apk',
      },
      'chrome_public_test_vr_apk-ddready-ddview': {
        'args': [
          '--shared-prefs-file=//chrome/android/shared_preference_files/test/vr_ddview_skipdon_setupcomplete.json',
          '--additional-apk=//third_party/gvr-android-sdk/test-apks/vr_keyboard/vr_keyboard_current.apk',
        ],
        'mixins': [
          'skia_gold_test',
          'vr_instrumentation_test',
        ],
        'swarming': {
          'shards': 4,
        },
        'test': 'chrome_public_test_vr_apk',
      },
      'chrome_public_test_vr_apk-ddready-don-enabled': {
        'args': [
          '--shared-prefs-file=//chrome/android/shared_preference_files/test/vr_ddview_don_setupcomplete.json',
          '--additional-apk=//third_party/gvr-android-sdk/test-apks/vr_keyboard/vr_keyboard_current.apk',
          '--annotation=Restriction=VR_DON_Enabled',
          '--vr-don-enabled',
        ],
        'mixins': [
          'vr_instrumentation_test',
        ],
        'test': 'chrome_public_test_vr_apk',
      },
    },

    'android_emulator_specific_chrome_public_tests': {
      'chrome_public_test_apk': {
        'args': [
            # These tests launch external intent thus require playstore to be
            # present. See crbug.com/1056330 for more details.
            # Exclude them here since this test suite will run on emulator
            # on images that do not have playstore.
            # They will be ran in chrome_public_test_apk_with_playstore below.
            '--gtest_filter=-'
            'org.chromium.chrome.browser.contextualsearch.ContextualSearchManagerTest.test*ExternalNavigationWithUserGesture*'
        ],
        'swarming': {
          'shards': 20,
        },
        'mixins': [
          'skia_gold_test',
          'emulator-8-cores',  # Use 8-core to shorten test runtime.
        ],
      },
      'chrome_public_test_apk_with_playstore': {
        'args': [
            # These tests launch external intent thus require playstore to be
            # present. See crbug.com/1056330 for more details.
            # They should be ran in emulator on images that have playstore.
            '--gtest_filter='
            'org.chromium.chrome.browser.contextualsearch.ContextualSearchManagerTest.test*ExternalNavigationWithUserGesture*'
        ],
        'mixins': [
          'skia_gold_test',
        ],
        'test': 'chrome_public_test_apk',
      },
      'chrome_public_unit_test_apk': {
        'mixins': [
          'skia_gold_test',
        ],
      },
    },

    'android_isolated_scripts': {
      'content_shell_crash_test': {
        'args': [
          '--platform=android',
        ],
        'resultdb': {
          'enable': True,
          'result_format': 'single'
        },
      },
    },

    # List gtests with ci_only set to True so that they run on the CI of
    # android-marshmallow-arm64-rel but not the mirrored CQ.
    # Includes the following compound test suites:
    # * android_modern_smoke_tests
    # * android_smoke_tests
    # * chromium_gtests_for_devices_with_graphical_output
    # * chrome_public_tests
    # * linux_flavor_specific_chromium_gtests
    'android_marshmallow_device_ci_only_gtests': {
      'cc_unittests': {
        'ci_only': True,
      },
      'chrome_modern_public_bundle_smoke_test': {
        'ci_only': True,
      },
      'chrome_public_smoke_test': {
        'ci_only': True,
      },
      'chrome_public_test_apk': {
        'ci_only': True,
        'swarming': {
          'shards': 20,
        },
        'mixins': [
          'skia_gold_test',
        ],
      },
      'chrome_public_unit_test_apk': {
        'ci_only': True,
        'mixins': [
          'skia_gold_test',
        ],
      },
      'device_unittests': {
        'ci_only': True,
      },
      'display_unittests': {
        'ci_only': True,
      },
      'gfx_unittests': {
        'ci_only': True,
      },
      'sandbox_linux_unittests': {
        'ci_only': True,
      },
      'unit_tests': {
        'ci_only': True,
        'android_swarming': {
          'shards': 2,
        },
      },
      'viz_unittests': {
        'ci_only': True,
      },
    },

    # List gtests that are part of other composition test suites.
    # MM emulator CQ builder currently has limited capacity so some composition
    # test suites cannot be fullly enabled at once.
    'android_marshmallow_emulator_limited_capacity_gtests': {
      # Tests from chromium_gtests
      'webkit_unit_tests':{
        'test': 'blink_unittests',
          'android_swarming': {
            'shards': 6,
          },
      },
    },

    'android_modern_smoke_tests': {
      'chrome_modern_public_bundle_smoke_test': {},
    },

    'android_monochrome_smoke_tests': {
      'monochrome_public_bundle_smoke_test': {},
      'monochrome_public_smoke_test': {},
    },

    'android_oreo_standard_gtests': {
      'chrome_public_test_apk': {
        'swarming': {
          'shards': 5,
        },
        'mixins': [
          'skia_gold_test',
        ],
      },
      'chrome_public_unit_test_apk': {
        'mixins': [
          'skia_gold_test',
        ],
      },
      'webview_instrumentation_test_apk': {
        'swarming': {
          'expiration': 10800,
          'shards': 5,
        },
      },
    },

    'android_pagecontroller_self_tests': {
      'chrome_java_test_pagecontroller_tests': {},
    },

    # TODO(crbug.com/1111436): Deprecate this group in favor of
    # android_pie_rel_gtests if/when android Pie capacity is fully restored.
    'android_pie_rel_reduced_capacity_gtests': {
      'android_browsertests': {},
      'blink_platform_unittests': {},
      'cc_unittests': {},
      'content_browsertests': {
        'swarming': {
          'shards': 15,
        },
      },
      'viz_unittests': {},
      'weblayer_bundle_test': {},
      'weblayer_instrumentation_test_apk': {},
      'webview_instrumentation_test_apk': {
        'swarming': {
          'shards': 7,
        },
      },
    },

    'android_smoke_tests': {
      'chrome_public_smoke_test': {},
    },

    'android_specific_chromium_gtests': {
      'android_browsertests': {
        'swarming': {
          'shards': 1,
        },
      },
      'android_sync_integration_tests': {
        'swarming': {
          'shards': 1,
        },
        'args': [
          '--test-launcher-batch-limit=1',
        ],
      },
      'android_webview_unittests': {},
      'breakpad_unittests': {},
      'content_shell_test_apk': {
        'swarming': {
          'shards': 3,
        },
      },
      'gl_tests_validating': {
        'test': 'gl_tests',
        # TODO(kbr): these are actually run on many of the GPU bots, which have
        # physical hardware for several of the desktop OSs. Once the GPU JSON
        # generation script is merged with this one, this should be promoted from
        # the Android-specific section.
        'args': [
          '--use-cmd-decoder=validating',
        ],
      },
      'gl_unittests': {
        # TODO(kbr): these are actually run on many of the GPU bots, which have
        # physical hardware for several of the desktop OSs. Once the GPU JSON
        # generation script is merged with this one, this should be promoted from
        # the Android-specific section.
      },
      'mojo_test_apk': {},
      'ui_android_unittests': {},
      'webview_instrumentation_test_apk': {
        'swarming': {
          'shards': 7,
        },
      },
    },

    'android_trichrome_smoke_tests': {
      'trichrome_chrome_bundle_smoke_test': {},
    },

    'android_webview_gpu_telemetry_tests': {
      'pixel_skia': {
        'name': 'android_webview_pixel_skia_gold_test',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--test-machine-name',
          '${buildername}',
        ],
        'mixins': [
          'skia_gold_test',
          'has_native_resultdb_integration',
        ],
        'telemetry_test_name': 'pixel',
      },
    },

    'android_wpr_record_replay_tests': {
      'chrome_java_test_wpr_tests': {
        'mixins': [
          'skia_gold_test',
        ],
      },
    },

    'aura_gtests': {
      'aura_unittests': {},
      'compositor_unittests': {},
      'wm_unittests': {},
    },

    'backuprefptr_generic_gtests': {
      'base_unittests': {},
      'blink_common_unittests': {},
      'blink_platform_unittests': {},
      'cast_unittests': {},
      'cc_unittests': {},
      'components_unittests': {
        'android_swarming': {
          'shards': 6,
        },
      },
      'content_unittests': {
        'android_swarming': {
          'shards': 3,
        },
      },
      'unit_tests': {
        'android_swarming': {
          'shards': 2,
        },
      },
      'webkit_unit_tests': {
        'test': 'blink_unittests',
        'android_swarming': {
          'shards': 6,
        },
      },
      'wtf_unittests': {},
    },

    'bfcache_android_specific_gtests': {
      'bf_cache_android_browsertests': {
        'args': [
          '--enable-features=BackForwardCache,BackForwardCacheSameSiteForBots,BackForwardCacheNoTimeEviction,ProactivelySwapBrowsingInstance',
        ],
        'test': 'android_browsertests',
      },
      'bf_cache_chrome_public_test_apk': {
        'args': [
          '--enable-features=BackForwardCache,BackForwardCacheSameSiteForBots,BackForwardCacheNoTimeEviction,ProactivelySwapBrowsingInstance',
        ],
        'swarming': {
          'shards': 20,
        },
        'mixins': [
          'skia_gold_test',
        ],
        'test': 'chrome_public_test_apk',
      },
      'bf_cache_chrome_public_unit_test_apk': {
        'args': [
          '--enable-features=BackForwardCache,BackForwardCacheSameSiteForBots,BackForwardCacheNoTimeEviction,ProactivelySwapBrowsingInstance',
        ],
        'mixins': [
          'skia_gold_test',
        ],
        'test': 'chrome_public_unit_test_apk',
      },
      'bf_cache_content_shell_test_apk': {
        'args': [
          '--enable-features=BackForwardCache,BackForwardCacheSameSiteForBots,BackForwardCacheNoTimeEviction,ProactivelySwapBrowsingInstance',
        ],
        'swarming': {
          'shards': 5,
        },
        'test': 'content_shell_test_apk',
      },
    },

    'bfcache_generic_gtests': {
      'bf_cache_content_browsertests': {
        'args': [
          '--enable-features=BackForwardCache,BackForwardCacheSameSiteForBots,BackForwardCacheNoTimeEviction,ProactivelySwapBrowsingInstance',
        ],
        'swarming': {
          'shards': 20,
        },
        'test': 'content_browsertests',
      },
      'bf_cache_content_unittests': {
        'args': [
          '--enable-features=BackForwardCache,BackForwardCacheSameSiteForBots,BackForwardCacheNoTimeEviction,ProactivelySwapBrowsingInstance',
        ],
        'swarming': {
          'shards': 10,
        },
        'test': 'content_unittests',
      },
      'bf_cache_unit_tests': {
        'args': [
          '--enable-features=BackForwardCache,BackForwardCacheSameSiteForBots,BackForwardCacheNoTimeEviction,ProactivelySwapBrowsingInstance',
          '--test-launcher-filter-file=../../testing/buildbot/filters/bfcache.unit_tests.filter'
        ],
        'swarming': {
          'shards': 10,
        },
        'test': 'unit_tests',
      },
    },

    'bfcache_linux_specific_gtests': {
      'bf_cache_browser_tests': {
        'args': [
          '--enable-features=BackForwardCache,BackForwardCacheSameSiteForBots,BackForwardCacheNoTimeEviction,ProactivelySwapBrowsingInstance',
        ],
        'swarming': {
          'shards': 10,
        },
       'test': 'browser_tests',
      },
    },

    'blink_unittests': {
      'blink_unit_tests': {
        'test': 'blink_unittests',
      },
    },

    'cast_audio_specific_chromium_gtests': {
      'cast_audio_backend_unittests': {},
      'cast_base_unittests': {},
      'cast_cast_core_unittests': {},
      'cast_crash_unittests': {},
      'cast_media_unittests': {},
      'cast_shell_browsertests': {
        'args': [
          '--enable-local-file-accesses',
          '--ozone-platform=headless',
          '--no-sandbox',
          '--test-launcher-jobs=1',
        ],
        'swarming': {
          'can_use_on_swarming_builders': False,  # https://crbug.com/861753
        },
      },
      'cast_shell_unittests': {},
    },

    'cast_junit_tests': {
      'cast_base_junit_tests': {},
      'cast_shell_junit_tests': {},
    },

    'cast_video_specific_chromium_gtests': {
      'cast_accessibility_unittests': {},
      'cast_display_settings_unittests': {
        'experiment_percentage': 100,
      },
      'cast_graphics_unittests': {},
      'exo_unittests': {},
      'views_unittests': {
        'experiment_percentage': 100,
      },
    },

    'chrome_isolated_script_tests': {
      'chrome_sizes': {
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
        },
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'variations_smoke_tests': {
        'isolate_name': 'variations_smoke_tests',
        'resultdb': {
          'enable': True,
          'result_format': 'single'
        },
      },
    },

    'chrome_public_tests': {
      'chrome_public_test_apk': {
        'swarming': {
          'shards': 20,
        },
        'mixins': [
          'skia_gold_test',
        ],
      },
      'chrome_public_unit_test_apk': {
        'mixins': [
          'skia_gold_test',
        ],
      },
      'chrome_webapk_integration_tests': {},
    },

    'chrome_public_wpt': {
      'chrome_public_wpt': {
        'args': [
          '--log-wptreport',
        ],
        'swarming': {
          'shards': 36,
          'expiration': 18000,
          'hard_timeout': 14400,
        },
        'experiment_percentage': 100,
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'results_handler': 'layout tests',
      },
    },

    'chrome_sizes': {
      'chrome_sizes': {
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
        },
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
    },

    'chrome_sizes_android': {
      'chrome_sizes': {
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
        },
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'args': [
          '--platform=android',
        ],
        'swarming': {
          "dimension_sets": [
            {
              "cpu": "x86-64",
              "os": "Ubuntu-18.04"
            }
          ],
        },
        'remove_mixins': [
          'android_r',
          'bullhead',
          'flame',
          'hammerhead',
          'kitkat',
          'marshmallow',
          'marshmallow_generic',
          'mdarcy',
          'nougat_generic',
          'oreo_fleet',
          'pie_fleet',
          'walleye',
        ],
      },
    },

    'chromedriver_py_tests_isolated_scripts': {
      'chromedriver_py_tests': {
        'args': [
          '--test-type=integration',
        ],
        'resultdb': {
          'enable': True,
        },
      },
      'chromedriver_replay_unittests': {},
    },

    'chromeos_browser_finch_tests': {
      'chrome_variations_tast_tests': {
        'swarming': {
          'idempotent': False,  # https://crbug.com/923426#c27
        },
        'resultdb': {
          'enable': True,
        },
        'experiment_percentage': 100,
      },
    },

    'chromeos_browser_integration_tests': {
      'chrome_all_tast_tests': {
        'swarming': {
          'idempotent': False,  # https://crbug.com/923426#c27
          # Tast test doesn't always output. See crbug.com/1306300
          'io_timeout': 3600,
          'shards': 7,
        },
        'resultdb': {
          'enable': True,
        },
      },
      'disk_usage_tast_test': {
        "args": [
          # Stripping gives more accurate disk usage data.
          "--strip-chrome",
        ],
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
        },
        'swarming': {
          'idempotent': False,  # https://crbug.com/923426#c27
        },
      },
    },

    # GTests to run on Chrome OS devices, but not Chrome OS VMs. Any differences
    # between this and chromeos_system_friendly_gtests below should only be due
    # to resource constraints (ie: not enough devices).
    'chromeos_device_only_gtests': {
      'base_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/chromeos.base_unittests.filter',
        ],
      },
    },

    'chromeos_isolated_scripts': {
      # TODO(crbug.com/1202958): Remove these SkiaRenderer variants when
      # SkiaRenderer is shipped by default on Chrome OS.
      'skia_renderer_telemetry_perf_unittests': {
        'isolate_name': 'telemetry_perf_unittests',
        'args': [
          '--browser=cros-chrome',
          '--extra-browser-args=--enable-features=UseSkiaRenderer',
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
          '--xvfb',
          # 3 is arbitrary, but if we're having more than 3 of these tests
          # fail in a single shard, then something is probably wrong, so fail
          # fast.
          '--typ-max-failures=3',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 6,
        },
      },
      'skia_renderer_telemetry_unittests': {
        'isolate_name': 'telemetry_unittests',
        'args': [
          '--jobs=1',
          '--browser=cros-chrome',
          '--extra-browser-args=--enable-features=UseSkiaRenderer',
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
          # 3 is arbitrary, but if we're having more than 3 of these tests
          # fail in a single shard, then something is probably wrong, so fail
          # fast.
          '--typ-max-failures=3',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 24,
        },
      },
      'telemetry_perf_unittests': {
        'args': [
          '--browser=cros-chrome',
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
          '--xvfb',
          # 3 is arbitrary, but if we're having more than 3 of these tests
          # fail in a single shard, then something is probably wrong, so fail
          # fast.
          '--typ-max-failures=3',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 12,
        },
        'resultdb': {
          'enable': True,
        },
      },
      'telemetry_unittests': {
        'args': [
          '--jobs=1',
          '--browser=cros-chrome',
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
          # 3 is arbitrary, but if we're having more than 3 of these tests
          # fail in a single shard, then something is probably wrong, so fail
          # fast.
          '--typ-max-failures=3',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 24,
        },
        'resultdb': {
          'enable': True,
        },
      },
    },

    'chromeos_remote_device_isolated_tests': {
      'telemetry_perf_unittests': {
        'args': [
          '--browser=cros-chrome',
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
          '--xvfb',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 2,
        },
        'resultdb': {
          'enable': True,
        },
      },
      'telemetry_unittests': {
        'args': [
          '--browser=cros-chrome',
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
          '--jobs=1',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 10,
        },
        'resultdb': {
          'enable': True,
        },
      },
    },

    # Tests that run on Chrome OS systems (ie: VMs, Chromebooks), *not*
    # linux-chromeos.
    # NOTE: We only want a small subset of test suites here, because most
    # suites assume that they stub out the underlying device hardware.
    # https://crbug.com/865693
    'chromeos_system_friendly_gtests': {
      'aura_unittests': {
        'args': [
          '--ozone-platform=headless',
        ],
      },
      'base_unittests': {},
      'capture_unittests': {
        'args': [
          '--test-launcher-jobs=1',
          # Don't run CaptureMJpeg tests on ChromeOS VM because vivid,
          # which is the virtual video capture device, doesn't support MJPEG.
          '--gtest_filter=-*UsingRealWebcam_CaptureMjpeg*',
        ],
      },
      'cc_unittests': {},
      'crypto_unittests': {},
      'display_unittests': {},
      'google_apis_unittests': {},
      'ipc_tests': {},
      'latency_unittests': {},
      'libcups_unittests': {},
      'media_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/chromeos.media_unittests.filter',
        ],
      },
      'midi_unittests': {},
      'mojo_unittests': {},
      # net_unittests has a test-time dependency on vpython. So add a CIPD'ed
      # vpython of the right arch to the task, and tell the test runner to copy
      # it over to the VM before the test runs.
      'net_unittests': {
        'args': [
          '--vpython-dir=../../vpython_dir_linux_amd64',
          # PythonUtils.PythonRunTime (as opposed to Python3RunTime) requires a
          # copy of Python 2, but it's testing test helpers that are only used
          # outside of net_unittests. This bot runs out of space if trying to
          # ship two vpythons, so we exclude Python 2 and the one test which
          # uses it.
          '--gtest_filter=-PythonUtils.PythonRunTime',
        ],
        'swarming': {
          'cipd_packages': [
            {
              "cipd_package": 'infra/3pp/tools/cpython3/linux-amd64',
              'location': 'vpython_dir_linux_amd64',
              'revision': 'version:2@3.8.10.chromium.21',
            },
            {
              "cipd_package": 'infra/tools/luci/vpython/linux-amd64',
              'location': 'vpython_dir_linux_amd64',
              'revision': 'git_revision:0f694cdc06ba054b9960aa1ae9766e45b53d02c1',
            }
          ],
          'shards': 3,
        },
      },
      'ozone_gl_unittests': {
        'args': [
          '--stop-ui',
        ],
      },
      'ozone_unittests': {},
      'pdf_unittests': {},
      'printing_unittests': {},
      'profile_provider_unittest': {
        'args': [
          '--stop-ui',
          '--test-launcher-jobs=1',
        ],
      },
      'sql_unittests': {},
      'url_unittests': {},
      'vaapi_unittest': {
        'args': [
          '--stop-ui',
          # Tell libva to do dummy encoding/decoding. For more info, see:
          # https://github.com/intel/libva/blob/master/va/va_fool.c#L47
          '--env-var', 'LIBVA_DRIVERS_PATH', '/usr/local/lib64',
          '--env-var', 'LIBVA_DRIVER_NAME', 'fake',
          '--env-var', 'LIBVA_FOOL_DECODE', '1',
          '--env-var', 'LIBVA_FOOL_POSTP', '1',
          '--gtest_filter="VaapiTest.*"',
        ],
      },
    },

    'chromium_android_asan_gtests': {
      # TODO(kbr): reduce duplication among these tests, and with other
      # test suites.
      'base_unittests': {
        'args': [
          '--tool=asan',
        ],
      },
    },

    'chromium_android_asan_junit_tests': {
      'base_junit_tests': {},
    },

    'chromium_android_scripts': {
      'check_network_annotations': {
        'script': 'check_network_annotations.py',
      },
    },

    'chromium_android_webkit_gtests': {
      'blink_heap_unittests': {},
      'webkit_unit_tests': {
        'test': 'blink_unittests',
      },
    },

    'chromium_browser_tests': {
      'browser_tests': {
        'swarming': {
          'shards': 10,
        },
      },
      'components_browsertests': {},
      'content_browsertests': {},
      'interactive_ui_tests': {
        'swarming': {
          'shards': 10,
        },
      },
    },

    'chromium_gtests': {
      'absl_hardening_tests': {},
      'angle_unittests': {
        'args': [
          'angle_unittests',
        ],
        'android_args': [
          '-v',
        ],
        'use_isolated_scripts_api': True,
      },
      'base_unittests': {},
      'blink_common_unittests': {},
      'blink_heap_unittests': {},
      'blink_platform_unittests': {},
      'boringssl_crypto_tests': {},
      'boringssl_ssl_tests': {},
      'capture_unittests': {
        'args': [
          '--gtest_filter=-*UsingRealWebcam*',
        ],
      },
      'cast_unittests': {},
      'components_browsertests': {},
      'components_unittests': {
        'android_swarming': {
          'shards': 6,
        },
      },
      'content_browsertests': {
        'android_swarming': {
          'shards': 15,
        },
        'swarming': {
          'shards': 6,
        },
      },
      'content_unittests': {
        'android_swarming': {
          'shards': 3,
        },
      },
      'crashpad_tests': {},
      'crypto_unittests': {},
      'events_unittests': {},
      'gcm_unit_tests': {},
      'gin_unittests': {},
      'google_apis_unittests': {},
      'gpu_unittests': {},
      'gwp_asan_unittests': {},
      'ipc_tests': {},
      'latency_unittests': {},
      'libjingle_xmpp_unittests': {},
      'liburlpattern_unittests': {},
      'media_unittests': {},
      'midi_unittests': {},
      'mojo_unittests': {},
      'net_unittests': {
        'android_swarming': {
          'shards': 3,
        },
      },
      'perfetto_unittests': {},
      'services_unittests': {},
      'shell_dialogs_unittests': {},
      'skia_unittests': {},
      'sql_unittests': {},
      'storage_unittests': {},
      'ui_base_unittests': {},
      'ui_touch_selection_unittests': {},
      'url_unittests': {},
      'webkit_unit_tests': {
        'test': 'blink_unittests',
        'android_swarming': {
          'shards': 6,
        },
      },
      'wtf_unittests': {},
      'zlib_unittests': {},
    },

    'chromium_gtests_for_devices_with_graphical_output': {
      'cc_unittests': {},
      'device_unittests': {},
      'display_unittests': {},
      'gfx_unittests': {},
      'unit_tests': {
        'android_swarming': {
          'shards': 2,
        },
      },
      'viz_unittests': {},
    },

    'chromium_gtests_for_linux_and_chromeos_only': {
      'dbus_unittests': {},
      'mojo_core_unittests': {},
    },

    'chromium_gtests_for_linux_and_mac_only': {
      'openscreen_unittests': {},
    },

    'chromium_gtests_for_linux_only': {
      'ozone_x11_unittests': {},
    },

    'chromium_gtests_for_win_and_linux_only': {
    },

    'chromium_junit_tests': {
      'android_webview_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'base_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'chrome_java_test_pagecontroller_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'chrome_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'components_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'content_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'device_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'incremental_javac_junit_tests':{
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'junit_unit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'keyboard_accessory_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'media_base_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'module_installer_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'net_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'paint_preview_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'password_check_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'password_manager_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'services_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'touch_to_fill_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'ui_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'webapk_client_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'webapk_shell_apk_h2o_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'webapk_shell_apk_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
      },
      'weblayer_junit_tests': {
        'remove_mixins': [
          'nougat-x86-emulator',
        ],
        # Experimental until we're sure these are stable.
        'experiment_percentage': 100
      },
    },

    'chromium_linux_scripts': {
      'check_network_annotations': {
        'script': 'check_network_annotations.py',
      },
      'check_static_initializers': {
        'script': 'check_static_initializers.py',
      },
      'checkdeps': {
        'script': 'checkdeps.py',
      },
      'checkperms': {
        'script': 'checkperms.py',
      },
      'headless_python_unittests': {
        'script': 'headless_python_unittests.py',
      },
      'metrics_python_tests': {
        'script': 'metrics_python_tests.py',
      },
      'webkit_lint': {
        'script': 'blink_lint_expectations.py',
      },
    },

    'chromium_mac_scripts': {
      'check_static_initializers': {
        'script': 'check_static_initializers.py',
      },
      'metrics_python_tests': {
        'script': 'metrics_python_tests.py',
      },
      'webkit_lint': {
        'script': 'blink_lint_expectations.py',
      },
    },

    'chromium_swarm_android_gtests': {
      'base_unittests': {},
      'chrome_modern_public_bundle_smoke_test': {},
      'weblayer_bundle_test': {},
    },

    'chromium_swarm_desktop_gtests': {
      'base_unittests': {},
      'content_browsertests': {},
      'content_unittests': {},
      'interactive_ui_tests': {},
      'net_unittests': {},
      'unit_tests': {},
    },

    'chromium_swarm_linux_gtests': {
      'base_unittests': {
        'swarming': {
          'dimension_sets': [
            {
              'cores': '8',
            },
          ],
        },
      },
      'browser_tests': {
        'swarming': {
          'dimension_sets': [
            {
              'cores': '8',
            },
          ],
          'shards': 2,
        },
      },
      'content_browsertests': {
        'swarming': {
          'dimension_sets': [
            {
              'cores': '8',
            },
          ],
        },
      },
      'content_unittests': {
        'swarming': {
          'dimension_sets': [
            {
              'cores': '2',
            },
          ],
        },
      },
      'interactive_ui_tests': {
        'swarming': {
          'dimension_sets': [
            {
              'cores': '8',
            },
          ],
        },
      },
      'net_unittests': {
        'swarming': {
          'dimension_sets': [
            {
              'cores': '8',
            },
          ],
        },
      },
      'unit_tests': {
        'swarming': {
          'dimension_sets': [
            {
              'cores': '2',
            },
          ],
        },
      },
    },

    # On some bots we don't have capacity to run all standard tests (for example
    # Android Pie), however there are tracing integration tests we want to
    # ensure are still working.
    'chromium_tracing_gtests': {
      'services_unittests': {},
    },

    'chromium_web_tests_and_wpt_webdriver_isolated_scripts': {
      'blink_web_tests': {
        # layout test failures are retried 3 times when '--test-list' is not
        # passed, but 0 times when '--test-list' is passed. We want to always
        # retry 3 times, so we explicitly specify it.
        'args': [
          '--num-retries=3',
        ],
        'isolate_name': 'blink_web_tests',
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'mixins': [
          'skia_gold_test',
        ],
        'resultdb': {
          'enable': True,
        },
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 12,
        },
      },
      'webdriver_tests_suite': {
        'isolate_name': 'webdriver_wpt_tests',
         'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'swarming': {
          'shards': 4,
        },
      },
    },

    'chromium_web_tests_high_dpi_isolated_scripts': {
      'high_dpi_blink_web_tests': {
        # high_dpi_blink_web_tests provides coverage for
        # running Layout Tests with forced device scale factor.
        'args': [
          '--flag-specific=highdpi',

          # layout test failures are retried 3 times when '--test-list' is not
          # passed, but 0 times when '--test-list' is passed. We want to always
          # retry 3 times, so we explicitly specify it.
          '--num-retries=3',
        ],
        'isolate_name': 'blink_web_tests',
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'mixins': [
          'skia_gold_test',
        ],
        'resultdb': {
          'enable': True,
        },
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 4,
        },
      },
    },

    'chromium_webkit_isolated_scripts': {
      'blink_web_tests': {
        # layout test failures are retried 3 times when '--test-list' is not
        # passed, but 0 times when '--test-list' is passed. We want to always
        # retry 3 times, so we explicitly specify it.
        'args': [
          '--num-retries=3',
        ],
        'isolate_name': 'blink_web_tests',
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'mixins': [
          'skia_gold_test',
        ],
        'resultdb': {
          'enable': True,
        },
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 12,
        }
      },
    },

    'chromium_win_scripts': {
      'check_network_annotations': {
        'script': 'check_network_annotations.py',
      },
      'metrics_python_tests': {
        'script': 'metrics_python_tests.py',
      },
      'webkit_lint': {
        'script': 'blink_lint_expectations.py',
      },
    },

    'client_v8_chromium_gtests': {
      'app_shell_unittests': {},
      'browser_tests': {
        'swarming': {
          'shards': 10,
        },
      },
      'chrome_app_unittests': {},
      'chromedriver_unittests': {},
      'components_browsertests': {},
      'components_unittests': {},
      'compositor_unittests': {},
      'content_browsertests': {},
      'content_unittests': {},
      'device_unittests': {},
      'extensions_browsertests': {},
      'extensions_unittests': {},
      'gcm_unit_tests': {},
      'gin_unittests': {},
      'google_apis_unittests': {},
      'gpu_unittests': {},
      'headless_browsertests': {},
      'headless_unittests': {},
      'interactive_ui_tests': {},
      'nacl_loader_unittests': {},
      'net_unittests': {},
      'pdf_unittests': {},
      'ppapi_unittests': {},
      'remoting_unittests': {},
      'services_unittests': {},
      'sync_integration_tests': {},
      'unit_tests': {},
    },

    'client_v8_chromium_isolated_scripts': {
      'content_shell_crash_test': {
        'resultdb': {
          'enable': True,
          'result_format': 'single'
        }
      },
      'telemetry_gpu_unittests': {
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
        },
        'resultdb': {
          'enable': True,
        },
      },
      'telemetry_perf_unittests': {
        'args': [
          '--xvfb',
          # TODO(crbug.com/1077284): Remove this once Crashpad is the default.
          '--extra-browser-args=--enable-crashpad',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 12,
        },
        'resultdb': {
          'enable': True,
        },
      },
      'telemetry_unittests': {
        'args': [
          '--jobs=1',
          # Disable GPU compositing, telemetry_unittests runs on VMs.
          # https://crbug.com/871955
          '--extra-browser-args=--disable-gpu',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 4,
        },
        'resultdb': {
          'enable': True,
        },
      },
    },

    # TODO(crbug.com/1255748): Remove after chromium_gtests are enabled on
    # android_marshmallow_emulator_gtests
    'components_capacity_tests': {
      'components_unittests': {
        'android_swarming': {
          'shards': 6,
        },
      },
    },

    'components_perftests_isolated_scripts' : {
      'components_perftests': {
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
          'args': [
            '--smoke-test-mode',
          ],
        },
        'args': [
          '--gtest-benchmark-name=components_perftests',
        ],
      },
    },

    'cronet_gtests': {
      'cronet_sample_test_apk': {},
      'cronet_smoketests_missing_native_library_instrumentation_apk': {},
      'cronet_smoketests_platform_only_instrumentation_apk': {},
      'cronet_test_instrumentation_apk': {},
      'cronet_tests_android': {},
      'cronet_unittests_android': {},
      'net_unittests': {
        'swarming': {
          'shards': 4,
        },
      },
    },

    'cronet_resource_sizes': {
      'resource_sizes_cronet_sample_apk': {
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
        },
        'swarming': {
          'dimension_sets': [
            # This suite simply analyzes build targets without running them.
            # It can thus run on a standard linux machine w/o a device.
            {
              'os': 'Ubuntu-18.04',
              'cpu': 'x86'
            },
          ],
        },
        'resultdb': {
          'enable': True,
          'result_format': 'single'
        },
      },
    },

    'cronet_sizes': {
      'cronet_sizes': {
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
        },
        'swarming': {
          'dimension_sets': [
            # This suite simply analyzes build targets without running them.
            # It can thus run on a standard linux machine w/o a device.
            {
              'os': 'Ubuntu-18.04',
              'cpu': 'x86'
            },
          ],
        },
        'resultdb': {
          'enable': True,
          'result_format': 'single',
          'result_file': '${ISOLATED_OUTDIR}/sizes/test_results.json'
        },
        'remove_mixins': [
          'android_r',
          'bullhead',
          'flame',
          'hammerhead',
          'kitkat',
          'marshmallow',
          'marshmallow_generic',
          'mdarcy',
          'nougat_generic',
          'oreo_fleet',
          'pie_fleet',
          'walleye',
        ],
      },
    },

    'desktop_chromium_isolated_scripts': {
      'blink_python_tests': {
        'resultdb': {
          'enable': True,
        }
      },
      'blink_web_tests': {
        # layout test failures are retried 3 times when '--test-list' is not
        # passed, but 0 times when '--test-list' is passed. We want to always
        # retry 3 times, so we explicitly specify it.
        'args': [
          '--num-retries=3',
        ],
        'isolate_name': 'blink_web_tests',
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'mixins': [
          'skia_gold_test',
        ],
        'resultdb': {
          'enable': True,
        },
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 12,
        }
      },
      'content_shell_crash_test': {
        'resultdb': {
          'enable': True,
          'result_format': 'single'
        }
      },
      'flatbuffers_unittests': {
        'resultdb': {
          'enable': True,
          'result_format': 'single'
        }
      },
      'grit_python_unittests': {
        'resultdb': {
          'enable': True,
        },
      },
      'telemetry_gpu_unittests': {
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
        },
        'resultdb': {
          'enable': True,
        },
      },
      'telemetry_unittests': {
        'args': [
          '--jobs=1',
          # Disable GPU compositing, telemetry_unittests runs on VMs.
          # https://crbug.com/871955
          '--extra-browser-args=--disable-gpu',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 8,
        },
        'resultdb': {
          'enable': True,
        },
      },
      'views_perftests': {
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
          'args': [
            '--smoke-test-mode',
          ],
        },
        'args': [
          '--gtest-benchmark-name=views_perftests',
        ],
      },
    },

    'devtools_browser_tests' : {
      'devtools_browser_tests': {
        'args': [
          '--gtest_filter=*DevTools*',
        ],
        'swarming': {
          'shards': 1,
        },
        'test': 'browser_tests',
      }
    },

    'devtools_webkit_isolated_scripts': {
      'blink_web_tests': {
        # layout test failures are retried 3 times when '--test-list' is not
        # passed, but 0 times when '--test-list' is passed. We want to always
        # retry 3 times, so we explicitly specify it.
        'args': [
          '--num-retries=3',
        ],
        'isolate_name': 'blink_web_tests',
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'mixins': [
          'skia_gold_test',
        ],
        'resultdb': {
          'enable': True,
        },
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 12,
        }
      },
      'webkit_layout_from_devtools': {
        # TODO(crbug.com/816629) - Move these args into //BUILD.gn .
        # layout test failures are retried 3 times when '--test-list' is not
        # passed, but 0 times when '--test-list' is passed. We want to always
        # retry 3 times, so we explicitly specify it.
        'args': [
          '--num-retries=3',
          '--layout-tests-directory=../../third_party/devtools-frontend/src/test/webtests/',
          'http/tests/devtools',
        ],
        'isolate_name': 'devtools_web_tests',
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'resultdb': {
          'enable': True,
        },
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 4,
        }
      },
    },

    'fieldtrial_browser_tests': {
      'browser_tests_no_field_trial': {
        'args': [
          '--disable-field-trial-config',
        ],
        'swarming': {
          'shards': 10,
        },
        'test': 'browser_tests',
      },
      'components_browsertests_no_field_trial': {
        'args': [
          '--disable-field-trial-config',
        ],
        'test': 'components_browsertests',
      },
      'content_browsertests_no_field_trial': {
        'args': [
          '--disable-field-trial-config',
        ],
        'test': 'content_browsertests',
      },
      'interactive_ui_tests_no_field_trial': {
        'args': [
          '--disable-field-trial-config',
        ],
        'test': 'interactive_ui_tests',
      },
      'sync_integration_tests_no_field_trial': {
        'args': [
          '--disable-field-trial-config',
        ],
        'test': 'sync_integration_tests',
      },
      'xr_browser_tests_no_field_trial': {
        'args': [
          '--disable-field-trial-config',
        ],
        'test': 'xr_browser_tests',
      },
    },

    'fieldtrial_isolated_scripts': {
      'telemetry_perf_unittests_no_field_trial': {
        'args': [
          '--xvfb',
          '--jobs=1',
          '--extra-browser-args=\'--enable-crashpad --disable-field-trial-config\'',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 12,
        },
        'resultdb': {
          'enable': True,
        },
        'isolate_name': 'telemetry_perf_unittests',
      },
      'telemetry_unittests_no_field_trial': {
        'args': [
          '--jobs=1',
          # Disable GPU compositing, telemetry_unittests runs on VMs.
          # https://crbug.com/871955
          '--extra-browser-args=\'--disable-gpu --disable-field-trial-config\'',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 8,
        },
        'resultdb': {
          'enable': True,
        },
        'isolate_name': 'telemetry_unittests',
      },
    },

    'finch_smoke_tests': {
      # TODO(crbug.com/1227222): Change this to the actual finch smoke test
      # once it exists.
      'base_unittests': {},
    },

    'fuchsia_chrome_gtests': {
      'courgette_unittests': {},
      'extensions_unittests': {},
      'headless_unittests': {},
      'message_center_unittests': {},
      'views_examples_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.views_examples_unittests.filter',
        ],
      },
      'views_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.views_unittests.filter',
        ],
      },
    },

    'fuchsia_common_gtests': {
      'absl_hardening_tests': {},
      'accessibility_unittests': {},
      'aura_unittests': {},
      'base_unittests': {},
      'blink_common_unittests': {},
      'blink_heap_unittests': {},
      'blink_platform_unittests': {},
      'blink_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.blink_unittests.filter',
        ],
      },
      'boringssl_crypto_tests': {},
      'boringssl_ssl_tests': {},
      'capture_unittests': {},
      'color_unittests': {},
      'components_browsertests': {},
      'components_unittests': {
        'swarming': {
          'shards': 2,
        },
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.components_unittests.filter',
        ],
      },
      'compositor_unittests': {},
      'content_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.content_unittests.filter',
        ],
      },
      'crypto_unittests': {},
      'events_unittests': {},
      'fuchsia_mojo_unittests': {},
      'gcm_unit_tests': {},
      'gin_unittests': {},
      'google_apis_unittests': {},
      'gpu_unittests': {},
      'gwp_asan_unittests': {},
      'headless_browsertests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.headless_browsertests.filter',
        ],
      },
      'ipc_tests': {},
      'latency_unittests': {},
      'media_unittests': {},
      'midi_unittests': {},
      'mojo_core_unittests': {},
      'mojo_unittests': {},
      'native_theme_unittests': {},
      'net_unittests': {
        'swarming': {
          'shards': 4,
        },
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.net_unittests.filter',
        ],
      },
      'ozone_gl_unittests': {
        'args': [
          '--child-arg=--ozone-platform=headless',
        ],
      },
      'ozone_unittests': {},
      'perfetto_unittests': {},
      'service_manager_unittests': {},
      'services_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.services_unittests.filter',
        ],
      },
      'shell_dialogs_unittests': {},
      'skia_unittests': {},
      'snapshot_unittests': {},
      'sql_unittests': {},
      'storage_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.storage_unittests.filter',
        ],
      },
      'ui_base_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.ui_base_unittests.filter',
        ],
      },
      'ui_touch_selection_unittests': {},
      'url_unittests': {},
      'wm_unittests': {},
      'wtf_unittests': {},
      'zlib_unittests': {},
    },

    'fuchsia_common_gtests_with_graphical_output': {
      'cc_unittests': {
        'swarming': {
          'shards': 2,
        },
      },
      'display_unittests': {},
      'gfx_unittests': {},
      'viz_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.viz_unittests.filter',
        ],
      },
    },

    'fuchsia_experimental_gtests': {
      'browser_tests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.browser_tests.filter',
          '--',
          '--test-launcher-timeout=60000',
        ],
        'swarming': {
          'shards': 40,
        },
      },
      'content_browsertests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.content_browsertests.filter',
          '--',
          '--disable-gpu',
          '--headless',
          '--ozone-platform=headless',
        ],
        'swarming': {
          'shards': 6,
        },
      },
      'unit_tests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/fuchsia.unit_tests.filter',
        ],
      },
    },

    'fuchsia_sizes_tests': {
      'fuchsia_sizes': {
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
        },
        'args': [
          '--sizes-path',
          'fuchsia/release/size_tests/fyi_sizes_smoketest.json',
        ],
      },
    },

    'gl_gtests_passthrough': {
      'gl_tests_passthrough': {
        'test': 'gl_tests',
        'args': [
          '--use-cmd-decoder=passthrough',
        ],
        'linux_args': ['--no-xvfb'],
        'swarming': {
          'shards': 2,
        },
      },
      'gl_unittests': {},
    },

    'goma_gtests': {
      'base_unittests': {},
      'content_unittests': {},
    },

    'goma_mac_gtests': {
      'base_unittests': {
        'swarming': {
          'dimension_sets': [
            {
              'cpu': 'x86-64',
              'os': 'Mac-10.13',
            },
          ],
        }
      },
      'content_unittests': {
        'swarming': {
          'dimension_sets': [
            {
              'cpu': 'x86-64',
              'os': 'Mac-10.13',
            },
          ],
        },
      },
    },

    # BEGIN tests which run on the GPU bots

    'gpu_angle_deqp_egl_d3d11_gtests': {
      'angle_deqp_egl_d3d11_tests': {
        'args': [
          'angle_deqp_egl_tests',
          '--use-angle=d3d11',
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_egl_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_egl_gl_gtests': {
      'angle_deqp_egl_gl_tests': {
        'args': [
          'angle_deqp_egl_tests',
          '--use-angle=gl',
          '--bot-mode',
          # Flaky when run with multiple processes.
          '--max-processes=1',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_egl_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_egl_gles_gtests': {
      'angle_deqp_egl_gles_tests': {
        'args': [
          'angle_deqp_egl_tests',
          '--use-angle=gles',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'android_swarming': {
          'shards': 4,
        },
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_egl_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_egl_vulkan_gtests': {
      'angle_deqp_egl_vulkan_tests': {
        'args': [
          'angle_deqp_egl_tests',
          '--use-angle=vulkan',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'android_swarming': {
          'shards': 4,
        },
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 2,
        },
        'test': 'angle_deqp_egl_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles2_d3d11_gtests': {
      'angle_deqp_gles2_d3d11_tests': {
        'args': [
          'angle_deqp_gles2_tests',
          '--use-angle=d3d11',
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_gles2_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles2_gl_gtests': {
      'angle_deqp_gles2_gl_tests': {
        'args': [
          'angle_deqp_gles2_tests',
          '--use-angle=gl',
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_gles2_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles2_gles_gtests': {
      'angle_deqp_gles2_gles_tests': {
        'args': [
          'angle_deqp_gles2_tests',
          '--use-angle=gles',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'android_swarming': {
          'shards': 4,
        },
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_gles2_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles2_vulkan_gtests': {
      'angle_deqp_gles2_vulkan_tests': {
        'args': [
          'angle_deqp_gles2_tests',
          '--use-angle=vulkan',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'android_swarming': {
          'shards': 4,
        },
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_gles2_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles31_d3d11_gtests': {
      'angle_deqp_gles31_d3d11_tests': {
        'args': [
          'angle_deqp_gles31_tests',
          '--use-angle=d3d11',
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 2,
        },
        'test': 'angle_deqp_gles31_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles31_gl_gtests': {
      'angle_deqp_gles31_gl_tests': {
        'args': [
          'angle_deqp_gles31_tests',
          '--use-angle=gl',
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 2,
        },
        'test': 'angle_deqp_gles31_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles31_vulkan_gtests': {
      'angle_deqp_gles31_vulkan_tests': {
        'args': [
          'angle_deqp_gles31_tests',
          '--use-angle=vulkan',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'android_swarming': {
          'shards': 20,
        },
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 2,
        },
        'test': 'angle_deqp_gles31_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles31_vulkan_rotate180_gtests': {
      'angle_deqp_gles31_vulkan_rotate180_tests': {
        'args': [
          'angle_deqp_gles31_rotate180_tests',
          '--use-angle=vulkan',
        ],
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 1,
        },
        'test': 'angle_deqp_gles31_rotate180_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles31_vulkan_rotate270_gtests': {
      'angle_deqp_gles31_vulkan_rotate270_tests': {
        'args': [
          'angle_deqp_gles31_rotate270_tests',
          '--use-angle=vulkan',
        ],
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 1,
        },
        'test': 'angle_deqp_gles31_rotate270_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles31_vulkan_rotate90_gtests': {
      'angle_deqp_gles31_vulkan_rotate90_tests': {
        'args': [
          'angle_deqp_gles31_rotate90_tests',
          '--use-angle=vulkan',
        ],
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 1,
        },
        'test': 'angle_deqp_gles31_rotate90_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles3_d3d11_gtests': {
      'angle_deqp_gles3_d3d11_tests': {
        'args': [
          'angle_deqp_gles3_tests',
          '--use-angle=d3d11',
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 2,
        },
        'test': 'angle_deqp_gles3_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles3_gl_gtests': {
      'angle_deqp_gles3_gl_tests': {
        'args': [
          'angle_deqp_gles3_tests',
          '--use-angle=gl',
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 4,
        },
        'test': 'angle_deqp_gles3_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles3_gles_gtests': {
      'angle_deqp_gles3_gles_tests': {
        'args': [
          'angle_deqp_gles3_tests',
          '--use-angle=gles',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'android_swarming': {
          'shards': 12,
        },
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_gles3_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles3_vulkan_gtests': {
      'angle_deqp_gles3_vulkan_tests': {
        'args': [
          'angle_deqp_gles3_tests',
          '--use-angle=vulkan',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'android_swarming': {
          'shards': 12,
        },
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 4,
        },
        'test': 'angle_deqp_gles3_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles3_vulkan_rotate180_gtests': {
      'angle_deqp_gles3_vulkan_rotate180_tests': {
        'args': [
          'angle_deqp_gles3_rotate180_tests',
          '--use-angle=vulkan',
        ],
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 2,
        },
        'test': 'angle_deqp_gles3_rotate180_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles3_vulkan_rotate270_gtests': {
      'angle_deqp_gles3_vulkan_rotate270_tests': {
        'args': [
          'angle_deqp_gles3_rotate270_tests',
          '--use-angle=vulkan',
        ],
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 2,
        },
        'test': 'angle_deqp_gles3_rotate270_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_gles3_vulkan_rotate90_gtests': {
      'angle_deqp_gles3_vulkan_rotate90_tests': {
        'args': [
          'angle_deqp_gles3_rotate90_tests',
          '--use-angle=vulkan',
        ],
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'swarming': {
          'shards': 2,
        },
        'test': 'angle_deqp_gles3_rotate90_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_khr_gles2_vulkan_gtests': {
      'angle_deqp_khr_gles2_vulkan_tests': {
        'args': [
          'angle_deqp_khr_gles2_tests',
          '--use-angle=vulkan',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'desktop_args': [
          '--bot-mode',
        ],
        'test': 'angle_deqp_khr_gles2_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_khr_gles31_vulkan_gtests': {
      'angle_deqp_khr_gles31_vulkan_tests': {
        'args': [
          'angle_deqp_khr_gles31_tests',
          '--use-angle=vulkan',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'android_swarming': {
          'shards': 2,
        },
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_khr_gles31_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_khr_gles32_vulkan_gtests': {
      'angle_deqp_khr_gles32_vulkan_tests': {
        'args': [
          'angle_deqp_khr_gles32_tests',
          '--use-angle=vulkan',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_khr_gles32_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_deqp_khr_gles3_vulkan_gtests': {
      'angle_deqp_khr_gles3_vulkan_tests': {
        'args': [
          'angle_deqp_khr_gles3_tests',
          '--use-angle=vulkan',
        ],
        'android_args': [
          '-v',
          '--shard-timeout=500',
        ],
        'android_swarming': {
          'shards': 2,
        },
        'desktop_args': [
          '--bot-mode',
        ],
        'merge': {
          'script': '//third_party/angle/scripts/angle_deqp_test_merge.py',
        },
        'test': 'angle_deqp_khr_gles3_tests',
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_end2end_gtests': {
      'angle_end2end_tests': {
        'android_args': [
          '--shard-timeout=180',
          '-v',
        ],
        'android_swarming': {
          'shards': 4,
        },
        'args': [
          'angle_end2end_tests',
          '--gtest_filter=-*Vulkan_SwiftShader*',
        ],
        'desktop_args': [
          '--bot-mode',
        ],
        # Linux has issues with creating too many windows at once.
        'linux_args': [
          '--max-processes=4',
        ],
        'swarming': {
          'shards': 2,
        },
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_fuchsia_unittests_isolated_scripts': {
      'angle_unittests': {
        'args': [
          'bin/run_angle_unittests',
        ],
        'mixins': ['fuchsia_logs'],
      },
    },

    'gpu_angle_unit_gtests': {
      'angle_unittests': {
        'args': [
          'angle_unittests',
        ],
        'android_args': [
          '-v',
        ],
        'use_isolated_scripts_api': True,
      },
    },

    'gpu_angle_white_box_gtests': {
      # TODO(ynovikov): the old generator script said the white box
      # tests are supposed to run everywhere angle_end2end_tests do, but
      # they actually ran only on Windows and Linux.
      'angle_white_box_tests': {
        'android_args': [
          '--shard-timeout=180',
          '-v',
        ],
        'args': [
          'angle_white_box_tests',
        ],
        'desktop_args': [
          '--bot-mode',
        ],
        'use_isolated_scripts_api': True,
      },
    },
    # The command buffer perf tests are only run on Windows.
    # They are mostly driver and platform independent.
    'gpu_command_buffer_perf_passthrough_isolated_scripts': {
      'passthrough_command_buffer_perftests': {
        'args': [
          '--gtest-benchmark-name=passthrough_command_buffer_perftests',
          '-v',
          '--use-cmd-decoder=passthrough',
          '--use-angle=gl-null',
          '--fast-run',
        ],
        'isolate_name': 'command_buffer_perftests',
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
          'args': [
            '--smoke-test-mode',
          ],
        },
        'should_retry_with_patch': False,
      },
    },

    'gpu_common_and_optional_telemetry_tests': {
      'info_collection': {
        'args': [
          '--expected-vendor-id',
          '${gpu_vendor_id}',
          '$$MAGIC_SUBSTITUTION_GPUExpectedDeviceId',
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--force_high_performance_gpu',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'trace_test': {
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
    },

    # GPU gtests which run on both the main and FYI waterfalls.
    'gpu_common_gtests_passthrough': {
      'gl_tests_passthrough': {
        'test': 'gl_tests',
        'args' : [
          '--use-cmd-decoder=passthrough',
          '--use-gl=angle',
        ],
        'desktop_args': [
          '--use-gpu-in-tests',
        ],
        'linux_args': ['--no-xvfb'],
        'swarming': {
          'shards': 2,
        },
      },
      'gl_unittests': {
        'desktop_args': ['--use-gpu-in-tests'],
        'linux_args': ['--no-xvfb'],
      },
    },
    'gpu_common_gtests_validating': {
      'gl_tests_validating': {
        'test': 'gl_tests',
        'args' : [
          '--use-cmd-decoder=validating',
        ],
        'desktop_args': [
          '--use-gpu-in-tests',
        ],
        'linux_args': ['--no-xvfb'],
      },
      'gl_unittests': {
        'desktop_args': ['--use-gpu-in-tests'],
        'linux_args': ['--no-xvfb'],
      },
    },

    # GPU gtests that test only Dawn
    'gpu_dawn_gtests': {
      'dawn_end2end_skip_validation_tests': {
        'mixins': ['dawn_end2end_gpu_test'],
        'args': [
          '--enable-toggles=skip_validation',
        ],
        'linux_args': [ '--no-xvfb' ],
        'test': 'dawn_end2end_tests',
      },
      'dawn_end2end_tests': {
        'mixins': ['dawn_end2end_gpu_test'],
        'linux_args': [ '--no-xvfb' ],
      },
      'dawn_end2end_wire_tests': {
        'mixins': ['dawn_end2end_gpu_test'],
        'args': [
          '--use-wire',
        ],
        'linux_args': [ '--no-xvfb' ],
        'test': 'dawn_end2end_tests',
      },
    },

    # For Windows. Use the D3D12 backend validation layers but without GPU-based
    # validation and shader patching. This avoids hangs on less powerful systems.
    'gpu_dawn_gtests_with_partial_validation': {
      'dawn_end2end_validation_layers_tests': {
        'mixins': ['dawn_end2end_gpu_test'],
        'args': [
          '--enable-backend-validation=partial',
        ],
        'linux_args': [ '--no-xvfb' ],
        'test': 'dawn_end2end_tests',
      },
    },

    # GPU gtests that test only Dawn with backend validation layers
    'gpu_dawn_gtests_with_validation': {
      'dawn_end2end_validation_layers_tests': {
        'mixins': ['dawn_end2end_gpu_test'],
        'args': [
          '--enable-backend-validation',
        ],
        'linux_args': [ '--no-xvfb' ],
        'test': 'dawn_end2end_tests',
      },
    },

    'gpu_dawn_perf_smoke_isolated_scripts': {
      'dawn_perf_tests': {
        'args': [
          # Tell the tests to only run one step for faster iteration.
          '--override-steps=1',
          '--gtest-benchmark-name=dawn_perf_tests',
          '-v',
        ],
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
          # Does not upload to the perf dashboard
          'args': [
            '--smoke-test-mode',
          ],
        },
      },
    },

    'gpu_dawn_telemetry_cts_tests': {
      'webgpu_cts': {
        'args': [
          '--extra-browser-args=--force_high_performance_gpu',
        ],
        'linux_args': [
          '--extra-browser-args=--enable-features=UseSkiaRenderer,Vulkan',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 4,
        },
        # TODO(crbug.com/1297379): Remove this once we actually start running
        # tests instead of skipping all of them.
        'experiment_percentage': 100,
      },
    },

    'gpu_dawn_telemetry_cts_tests_with_partial_validation': {
      'webgpu_cts_with_validation': {
        'args': [
          '--extra-browser-args=--force_high_performance_gpu',
          '--is-backend-validation',
          '--override-timeout=30',
        ],
        'linux_args': [
          '--extra-browser-args=--enable-features=UseSkiaRenderer,Vulkan',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 4,
        },
        'telemetry_test_name': 'webgpu_cts',
        # TODO(crbug.com/1297379): Remove this once we actually start running
        # tests instead of skipping all of them.
        'experiment_percentage': 100,
      },
    },

    'gpu_dawn_telemetry_cts_tests_with_validation': {
      'webgpu_cts_with_validation': {
        'args': [
          '--extra-browser-args=--force_high_performance_gpu',
          '--is-backend-validation',
          '--override-timeout=30',
        ],
        'linux_args': [
          '--extra-browser-args=--enable-features=UseSkiaRenderer,Vulkan',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 4,
        },
        'telemetry_test_name': 'webgpu_cts',
        # TODO(crbug.com/1297379): Remove this once we actually start running
        # tests instead of skipping all of them.
        'experiment_percentage': 100,
      },
    },

    'gpu_default_and_optional_win_specific_gtests': {
      'xr_browser_tests': {
        # The Windows machines this is run on should always meet all the
        # requirements, so skip the runtime checks to help catch issues, e.g.
        # if we're incorrectly being told a DirectX 11.1 device isn't
        # available
        'args': [
          '--ignore-runtime-requirements=*',
        ],
        'test': 'xr_browser_tests',
      },
    },

    'gpu_desktop_specific_gtests': {
      'tab_capture_end2end_tests': {
        'args': [
          '--enable-gpu',
          '--test-launcher-bot-mode',
          '--test-launcher-jobs=1',
          '--gtest_filter=TabCaptureApiPixelTest.EndToEnd*',
        ],
        'linux_args': [ '--no-xvfb' ],
        'test': 'browser_tests',
      },
    },

    'gpu_fuchsia_common_telemetry_tests': {
      'info_collection': {
        'args': [
          '--expected-vendor-id',
          '${gpu_vendor_id}',
          '$$MAGIC_SUBSTITUTION_GPUExpectedDeviceId',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'pixel_skia_validating': {
        'name': 'pixel_skia_gold_validating_test',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--test-machine-name',
          '${buildername}',
          '--extra-browser-args=--use-cmd-decoder=validating',
        ],
        'mixins': [
          'skia_gold_test',
          'has_native_resultdb_integration',
        ],
        'telemetry_test_name': 'pixel',
      },
      'screenshot_sync_validating': {
        'name': 'screenshot_sync_validating_tests',
        'telemetry_test_name': 'screenshot_sync',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--extra-browser-args=--use-cmd-decoder=validating',
         ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'trace_test': {
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'webgl_conformance': {
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 18,
        },
      }
    },

    'gpu_fyi_and_optional_non_linux_gtests': {
      # gpu_unittests is killing the Swarmed Linux GPU bots similarly to
      # how content_unittests was: http://crbug.com/763498 .
      'gpu_unittests': {
      },
    },

    'gpu_fyi_and_optional_win_specific_gtests': {
      'gles2_conform_d3d9_test': {
        'args': [
          '--use-gpu-in-tests',
          '--use-angle=d3d9',
        ],
        'test': 'gles2_conform_test',
      },
      'gles2_conform_gl_test': {
        'args': [
          '--use-gpu-in-tests',
          '--use-angle=gl',
          '--disable-gpu-sandbox',
        ],
        'test': 'gles2_conform_test',
      },
    },

    'gpu_fyi_mac_specific_gtests': {
      # Face and barcode detection unit tests, which currently only run on
      # Mac OS, and require physical hardware.
      'services_unittests': {
        'args': [
          '--gtest_filter=*Detection*',
          '--use-gpu-in-tests'
        ],
      },
    },

    'gpu_fyi_vulkan_swiftshader_gtests': {
      'vulkan_swiftshader_content_browsertests': {
        'args': [
          '--enable-gpu',
          '--test-launcher-bot-mode',
          '--test-launcher-jobs=1',
          '--test-launcher-filter-file=../../testing/buildbot/filters/vulkan.content_browsertests.filter',
          '--enable-features=UseSkiaRenderer,UiGpuRasterization,Vulkan',
          '--use-vulkan=swiftshader',
          '--enable-gpu-rasterization',
          '--disable-software-compositing-fallback',
          '--disable-vulkan-fallback-to-gl-for-testing',
          '--disable-headless-mode',
        ],
        'linux_args': [ '--no-xvfb' ],
        'test': 'content_browsertests',
      },
    },

    # TODO(crbug.com/1202958): Remove all gpu_gl_renderer_* targets when
    # SkiaRenderer is shipped on all platforms.
    'gpu_gl_renderer_full_telemetry_tests': {
      'gl_renderer_context_lost_tests': {
        'telemetry_test_name': 'context_lost',
        'args': [
          '--extra-browser-args=--disable-features=UseSkiaRenderer',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'gl_renderer_gpu_process_launch_tests': {
        'telemetry_test_name': 'gpu_process',
        'args': [
          '--extra-browser-args=--disable-features=UseSkiaRenderer',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'gl_renderer_hardware_accelerated_feature_tests': {
        'telemetry_test_name': 'hardware_accelerated_feature',
        'args': [
          '--extra-browser-args=--disable-features=UseSkiaRenderer',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'gl_renderer_maps_pixel_tests': {
        'telemetry_test_name': 'maps',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--test-machine-name',
          '${buildername}',
          '--extra-browser-args=--disable-features=UseSkiaRenderer',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'mixins': [
          'has_native_resultdb_integration',
          'skia_gold_test',
        ],
      },
      'gl_renderer_pixel_skia_gold_tests': {
        'telemetry_test_name': 'pixel',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--test-machine-name',
          '${buildername}',
          '--extra-browser-args=--disable-features=UseSkiaRenderer',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'mixins': [
          'has_native_resultdb_integration',
          'skia_gold_test',
        ],
      },
    },

    'gpu_gles2_conform_gtests': {
      # The gles2_conform_tests are closed-source and deliberately only
      # run on the FYI waterfall and the optional tryservers.
      'gles2_conform_test': {
        'args': ['--use-gpu-in-tests'],
      },
    },

    'gpu_info_collection_telemetry_tests': {
      'info_collection': {
        'args': [
          '--expected-vendor-id',
          '${gpu_vendor_id}',
          '$$MAGIC_SUBSTITUTION_GPUExpectedDeviceId',
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--force_high_performance_gpu',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
    },

    'gpu_mediapipe_passthrough_telemetry_tests': {
      'mediapipe_passthrough': {
        'name': 'mediapipe_passthrough_tests',
        'telemetry_test_name': 'mediapipe',
        'args': [
          '--extra-browser-args=--force_higher_performance_gpu --use-cmd-decoder=passthrough --use-gl=angle',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
    },

    'gpu_mediapipe_validating_telemetry_tests': {
      'mediapipe_validating': {
        'name': 'mediapipe_validating_tests',
        'telemetry_test_name': 'mediapipe',
        'args': [
          '--extra-browser-args=--force_higher_performance_gpu --use-cmd-decoder=validating',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
    },

    'gpu_noop_sleep_telemetry_test': {
      # The former GPU-specific generator script contained logic to
      # detect whether the so-called "experimental" GPU bots, which test
      # newer driver versions, were identical to the "stable" versions
      # of the bots, and if so to mirror their configurations. We prefer
      # to keep this new script simpler and to just configure this by
      # hand in waterfalls.pyl.
      'noop_sleep': {
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
      },
    },

    'gpu_passthrough_telemetry_tests': {
      'context_lost_passthrough': {
        'name': 'context_lost_passthrough_tests',
        'telemetry_test_name': 'context_lost',
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'args': [
          '--extra-browser-args=--use-cmd-decoder=passthrough --use-gl=angle',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'gpu_process': {
        'name': 'gpu_process_launch_tests',
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'hardware_accelerated_feature': {
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'maps_passthrough': {
        'name': 'maps_pixel_passthrough_test',
        'telemetry_test_name': 'maps',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--test-machine-name',
          '${buildername}',
          '--extra-browser-args=--use-cmd-decoder=passthrough --use-gl=angle',
        ],
        'android_args': [
          # TODO(crbug.com/1093085): Remove this once we fix the tests.
          '--extra-browser-args=--force-online-connection-state-for-indicator',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'skia_gold_test',
          'has_native_resultdb_integration',
        ],
      },
      'pixel_skia_passthrough': {
        'name': 'pixel_skia_gold_passthrough_test',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--test-machine-name',
          '${buildername}',
          '--extra-browser-args=--use-cmd-decoder=passthrough --use-gl=angle',
        ],
        'android_args': [
          # TODO(crbug.com/1093085): Remove this once we fix the tests.
          '--extra-browser-args=--force-online-connection-state-for-indicator',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'skia_gold_test',
          'has_native_resultdb_integration',
        ],
        'telemetry_test_name': 'pixel',
      },
      'screenshot_sync_passthrough': {
        'name': 'screenshot_sync_passthrough_tests',
        'telemetry_test_name': 'screenshot_sync',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--extra-browser-args=--use-cmd-decoder=passthrough --use-gl=angle',
        ],
        'android_args': [
          # TODO(crbug.com/1093085): Remove this once we fix the tests.
          '--extra-browser-args=--force-online-connection-state-for-indicator',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
    },

    'gpu_skia_renderer_vulkan_passthrough_telemetry_tests': {
      'vulkan_pixel_skia': {
        'name': 'vulkan_pixel_skia_gold_test',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--test-machine-name',
          '${buildername}',
          '--extra-browser-args=--use-vulkan=native --disable-vulkan-fallback-to-gl-for-testing --enable-features=UseSkiaRenderer,Vulkan --use-gl=angle --use-angle=gl --use-cmd-decoder=passthrough',
        ],
        'android_args': [
          # TODO(crbug.com/1093085): Remove this once we fix the tests.
          '--extra-browser-args=--force-online-connection-state-for-indicator',
        ],
        'mixins': [
          'skia_gold_test',
          'has_native_resultdb_integration',
        ],
        'telemetry_test_name': 'pixel',
      },
    },

    'gpu_swiftshader_gtests': {
      'swiftshader_unittests': {
      },
    },

    'gpu_validating_telemetry_tests': {
      'context_lost_validating': {
        'name': 'context_lost_validating_tests',
        'telemetry_test_name': 'context_lost',
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'args': [
          '--extra-browser-args=--use-cmd-decoder=validating',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'gpu_process': {
        'name': 'gpu_process_launch_tests',
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'hardware_accelerated_feature': {
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
      'maps_validating': {
        'name': 'maps_pixel_validating_test',
        'telemetry_test_name': 'maps',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--test-machine-name',
          '${buildername}',
          '--extra-browser-args=--use-cmd-decoder=validating',
        ],
        'android_args': [
          # TODO(crbug.com/1093085): Remove this once we fix the tests.
          '--extra-browser-args=--force-online-connection-state-for-indicator',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'skia_gold_test',
          'has_native_resultdb_integration',
        ],
      },
      'pixel_skia_validating': {
        'name': 'pixel_skia_gold_validating_test',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--test-machine-name',
          '${buildername}',
          '--extra-browser-args=--use-cmd-decoder=validating',
        ],
        'android_args': [
          # TODO(crbug.com/1093085): Remove this once we fix the tests.
          '--extra-browser-args=--force-online-connection-state-for-indicator',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'skia_gold_test',
          'has_native_resultdb_integration',
        ],
        'telemetry_test_name': 'pixel',
      },
      'screenshot_sync_validating': {
        'name': 'screenshot_sync_validating_tests',
        'telemetry_test_name': 'screenshot_sync',
        'args': [
          '--dont-restore-color-profile-after-test',
          '--extra-browser-args=--use-cmd-decoder=validating',
         ],
        'android_args': [
          # TODO(crbug.com/1093085): Remove this once we fix the tests.
          '--extra-browser-args=--force-online-connection-state-for-indicator',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
    },

    'gpu_vulkan_gtests': {
      'vulkan_tests': {
        'desktop_args': [
          '--use-gpu-in-tests',
        ],
      },
    },

    'gpu_webcodecs_telemetry_test': {
      'webcodecs': {
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
      },
    },

    'gpu_webgl2_conformance_d3d11_passthrough_telemetry_tests': {
      'webgl2_conformance_d3d11_passthrough_tests': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          '--webgl-conformance-version=2.0.1',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl2_conformance_tests_output.json',
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=d3d11 --use-cmd-decoder=passthrough --force_high_performance_gpu',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          # These tests currently take about an hour and fifteen minutes
          # to run. Split them into roughly 5-minute shards.
          'shards': 20,
        },
      },
    },

    'gpu_webgl2_conformance_gl_passthrough_telemetry_tests': {
      'webgl2_conformance_gl_passthrough_tests': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          '--webgl-conformance-version=2.0.1',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl2_conformance_tests_output.json',
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=gl --use-cmd-decoder=passthrough --force_high_performance_gpu',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          # These tests currently take about an hour and fifteen minutes
          # to run. Split them into roughly 5-minute shards.
          'shards': 20,
        },
      },
    },

    'gpu_webgl2_conformance_gles_passthrough_telemetry_tests': {
      'webgl2_conformance_gles_passthrough_tests': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          '--webgl-conformance-version=2.0.1',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl2_conformance_tests_output.json',
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=gles --use-cmd-decoder=passthrough --force_high_performance_gpu',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          # These tests currently take about an hour and fifteen minutes
          # to run. Split them into roughly 5-minute shards.
          'shards': 20,
        },
      },
    },

    'gpu_webgl2_conformance_metal_passthrough_telemetry_tests': {
      'webgl2_conformance_metal_passthrough_tests': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          '--webgl-conformance-version=2.0.1',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl2_conformance_tests_output.json',
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=metal --use-cmd-decoder=passthrough --force_high_performance_gpu',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 20,
        },
      },
    },

    'gpu_webgl2_conformance_telemetry_tests': {
      'webgl2_conformance_tests': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          '--webgl-conformance-version=2.0.1',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl2_conformance_tests_output.json',
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--force_high_performance_gpu',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          # These tests currently take about an hour and fifteen minutes
          # to run. Split them into roughly 5-minute shards.
          'shards': 20,
        },
      },
    },

    'gpu_webgl2_conformance_validating_telemetry_tests': {
      'webgl2_conformance_validating_tests': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          '--webgl-conformance-version=2.0.1',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl2_conformance_tests_output.json',
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-cmd-decoder=validating --force_high_performance_gpu',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          # These tests currently take about an hour and fifteen minutes
          # to run. Split them into roughly 5-minute shards.
          'shards': 20,
        },
      },
    },

    'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests': {
      'webgl_conformance_d3d11_passthrough': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=d3d11 --use-cmd-decoder=passthrough --force_high_performance_gpu',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl_conformance_tests_output.json',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 2,
        },
      },
    },

    'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests': {
      'webgl_conformance_d3d9_passthrough': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=d3d9 --use-cmd-decoder=passthrough --force_high_performance_gpu',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl_conformance_tests_output.json',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 2,
        },
      },
    },

    'gpu_webgl_conformance_fast_call_passthrough_telemetry_tests': {
      'webgl_conformance_fast_call': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--enable-unsafe-fast-js-calls --enable-fake-no-alloc-direct-call-for-testing --use-gl=angle --use-cmd-decoder=passthrough --force_high_performance_gpu',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 2,
        },
      },
    },

    'gpu_webgl_conformance_gl_passthrough_telemetry_tests': {
      'webgl_conformance_gl_passthrough': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=gl --use-cmd-decoder=passthrough --force_high_performance_gpu',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl_conformance_tests_output.json',
        ],
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 2,
        },
      },
    },

    'gpu_webgl_conformance_gles_passthrough_telemetry_tests': {
      'webgl_conformance_gles_passthrough': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=gles --use-cmd-decoder=passthrough --force_high_performance_gpu',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl_conformance_tests_output.json',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 6,
        },
      },
    },

    'gpu_webgl_conformance_metal_passthrough_telemetry_tests': {
      'webgl_conformance_metal_passthrough': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=metal --use-cmd-decoder=passthrough --force_high_performance_gpu',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl_conformance_tests_output.json',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 3,
        },
      },
    },

    'gpu_webgl_conformance_swangle_passthrough_representative_telemetry_tests': {
      'webgl_conformance_swangle_passthrough': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-gl=angle --use-angle=swiftshader --use-cmd-decoder=passthrough --force_high_performance_gpu',
          # We are only interested in running a 'smoketest' to test swangle
          # integration, not the full conformance suite.
          '--test-filter=conformance/rendering/gl-drawelements.html',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 1,
        },
      },
    },

    'gpu_webgl_conformance_swangle_passthrough_telemetry_tests': {
      'webgl_conformance_swangle_passthrough': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          '--extra-browser-args=--use-gl=angle --use-angle=swiftshader --use-cmd-decoder=passthrough',
          '--xvfb',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 1,
        },
      },
    },

    'gpu_webgl_conformance_telemetry_tests': {
      'webgl_conformance': {
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--force_high_performance_gpu',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl_conformance_tests_output.json',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 2,
        },
        'android_swarming': {
          'shards': 12,
        },
        'chromeos_swarming': {
          'shards': 20,
        },
      },
    },

    'gpu_webgl_conformance_validating_telemetry_tests': {
      'webgl_conformance_validating': {
        'telemetry_test_name': 'webgl_conformance',
        'chromeos_args': [
          '$$MAGIC_SUBSTITUTION_ChromeOSTelemetryRemote',
        ],
        'lacros_args': [
          '--extra-browser-args=--enable-features=UseOzonePlatform --ozone-platform=wayland',
          '--xvfb',
          '--no-xvfb',
          '--use-weston',
          '--weston-use-gl',
        ],
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-cmd-decoder=validating --force_high_performance_gpu',
          # The current working directory when run via isolate is
          # out/Debug or out/Release. Reference this file relatively to
          # it.
          '--read-abbreviated-json-results-from=../../content/test/data/gpu/webgl_conformance_tests_output.json',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 2,
        },
        'android_swarming': {
          'shards': 6,
        },
      },
    },

    'gpu_webgl_conformance_vulkan_passthrough_telemetry_tests': {
      'webgl_conformance_vulkan_passthrough': {
        'telemetry_test_name': 'webgl_conformance',
        'args': [
          # On dual-GPU devices we want the high-performance GPU to be active
          '--extra-browser-args=--use-angle=vulkan --use-cmd-decoder=passthrough --force_high_performance_gpu',
        ],
        'mixins': [
          'has_native_resultdb_integration',
        ],
        'swarming': {
          'shards': 2,
        },
      },
    },

    'gpu_webgpu_integration_backend_validation_isolated_scripts': {
      'webgpu_blink_web_tests_with_backend_validation': {
        'name': 'webgpu_blink_web_tests_with_backend_validation',
        'isolate_name': 'webgpu_blink_web_tests',
        'args': [
          '--flag-specific=webgpu-with-backend-validation',
          # Increase the timeout when using backend validation layers (crbug.com/1208253)
          '--timeout-ms=30000',
        ],
        'mixins': [
          'webgpu_cts',
          'skia_gold_test',
        ],
        'swarming': {
          'shards': 4,
        },
      },
    },

    'gpu_webgpu_integration_isolated_scripts': {
      'webgpu_blink_web_tests': {
        'name': 'webgpu_blink_web_tests',
        'isolate_name': 'webgpu_blink_web_tests',
        'args': [
          '--flag-specific=webgpu',
        ],
        'mixins': [
          'webgpu_cts',
          'skia_gold_test',
        ],
        'swarming': {
          'shards': 4,
        },
      },
    },

    # For Windows. Use the D3D12 backend validation layers but without GPU-based
    # validation and shader patching. This avoids hangs on less powerful systems.
    'gpu_webgpu_integration_partial_backend_validation_isolated_scripts': {
      'webgpu_blink_web_tests_with_backend_validation': {
        'name': 'webgpu_blink_web_tests_with_partial_backend_validation',
        'isolate_name': 'webgpu_blink_web_tests',
        'args': [
          '--flag-specific=webgpu-with-partial-backend-validation',
          # Increase the timeout when using backend validation layers (crbug.com/1208253)
          '--timeout-ms=30000',
        ],
        'mixins': [
          'webgpu_cts',
          'skia_gold_test',
        ],
        'swarming': {
          'shards': 4,
        },
      },
    },

    'gpu_win_intel_specific_telemetry_tests': {
      'power_measurement_test': {
        'telemetry_test_name': 'power',
        'mixins': [
          'has_native_resultdb_integration',
        ],
      },
    },

    'headless_browser_gtests': {
      'headless_browsertests': {},
      'headless_unittests': {},
    },

    'ios_clang_tests': {
      'absl_hardening_tests': {},
      'base_unittests': {},
      'boringssl_crypto_tests': {},
      'boringssl_ssl_tests': {},
      'components_unittests': {},
      'crypto_unittests': {},
      'gfx_unittests': {},
      'google_apis_unittests': {},
      'ios_chrome_unittests': {},
      'ios_net_unittests': {},
      'ios_web_inttests': {},
      'ios_web_unittests': {},
      'ios_web_view_inttests': {},
      'net_unittests': {},
      'skia_unittests': {},
      'sql_unittests': {},
      'ui_base_unittests': {},
      'url_unittests': {},
    },

    'ios_common_tests': {
      'absl_hardening_tests': {},
      'boringssl_crypto_tests': {},
      'boringssl_ssl_tests': {},
      'crypto_unittests': {},
      'google_apis_unittests': {},
      'ios_components_unittests': {},
      'ios_net_unittests': {
        'swarming': {
          'shards': 3,
        },
      },
      'ios_remoting_unittests': {},
      'ios_testing_unittests': {},
      'net_unittests': {},
      'services_unittests': {},
      'sql_unittests': {},
      'url_unittests': {},
    },

    # TODO(crbug.com/1288850): Move this into ios_common_tests when green.
    'ios_crash_unittests': {
      'crashpad_tests': {},
    },

    'ios_crash_xcuitests': {
      'ios_crash_xcuitests_module': {},
    },

    'ios_cronet_tests': {
      'cronet_test': {},
    },

    'ios_eg2_cq_tests': {
      'ios_chrome_integration_eg2tests_module': {
        'swarming': {
          'shards': 8,
        },
      },
      'ios_chrome_signin_eg2tests_module': {},
      'ios_chrome_ui_eg2tests_module': {
        'swarming': {
          'shards': 12,
        },
      },
      'ios_web_shell_eg2tests_module': {},
    },

    'ios_eg2_tests': {
      'ios_chrome_bookmarks_eg2tests_module': {},
      'ios_chrome_settings_eg2tests_module': {
        'swarming': {
          'shards': 3,
        },
      },
      'ios_chrome_smoke_eg2tests_module': {},
      'ios_chrome_web_eg2tests_module': {},
      'ios_showcase_eg2tests_module': {},
    },

    'ios_remoting_fyi_unittests': {
      'ios_remoting_unittests': {},
    },

    'ios_screen_size_dependent_tests': {
      'base_unittests': {},
      'components_unittests': {},
      'gfx_unittests': {},
      'ios_chrome_unittests': {},
      'ios_web_inttests': {},
      'ios_web_unittests': {},
      'ios_web_view_inttests': {},
      'ios_web_view_unittests': {},
      'skia_unittests': {},
      'ui_base_unittests': {},
    },

    'ios_swift_interop_xcuitests': {
      'ios_swift_interop_xcuitests_module': {},
    },

    # END tests which run on the GPU bots

    'js_code_coverage_browser_tests' : {
      'js_code_coverage_browser_tests': {
        'args': [
          '--gtest_filter=*FilesApp*'
        ],
        'test': 'browser_tests',
      }
    },

    'js_code_coverage_browser_tests_reduced' : {
      'js_code_coverage_browser_tests_reduced': {
        'args': [
          '--gtest_filter=*DevToolsListenerBrowserTest*'
        ],
        'test': 'browser_tests',
      }
    },

    'lacros_all_tast_tests': {
      'lacros_all_tast_tests': {
        'swarming': {
          'idempotent': False,  # https://crbug.com/923426#c27
        },
        'resultdb': {
          'enable': True,
        },
      },
    },

    'lacros_all_tast_tests_informational': {
      'lacros_all_tast_tests_informational': {
        'swarming': {
          'idempotent': False,  # https://crbug.com/923426#c27
        },
        'resultdb': {
          'enable': True,
        },
      },
    },

    # TODO(crbug.com/1204231): Re-enable vaapi_unittest.
    'lacros_device_or_vm_gtests': {
      'aura_unittests': {},
      'cc_unittests': {},
      'interactive_ui_tests': {},
      'ozone_unittests': {},
    },

    'lacros_fyi_tast_tests': {
      'lacros_fyi_tast_tests': {
        'swarming': {
          'idempotent': False,  # https://crbug.com/923426#c27
        },
        'resultdb': {
          'enable': True,
        },
      },
    },

    # TODO(crbug.com/1283076): ozone_unittests and viz_unittests have failures
    # remove the filter when the tests are shown to be stable in
    # lacros-arm-generic-chrome-fyi
    'lacros_skylab_arm_tests': {
      'lacros_all_tast_tests': {
        'tast_expr': '("group:mainline" && "dep:lacros" && !informational)',
        'timeout_sec': 10800,
      },
      'ozone_unittests': {
        'timeout_sec': 3600,
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/lacros-arm.ozone_unittests.filter']
      },
      'viz_unittests': {
        'timeout_sec': 3600,
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/lacros-arm.viz_unittests.filter']
      },
    },

    # create this temporary lacros arm test suites that runs on skylab
    # TODO(crbug.com/1247425): remove it if it is the same as
    # lacros_skylab_poc
    'lacros_skylab_arm_tests_fyi': {
      'lacros_all_tast_tests': {
        'tast_expr': '("group:mainline" && "dep:lacros" && !informational)',
        'timeout_sec': 10800,
      },
      'ozone_unittests': {
        'timeout_sec': 3600,
      },
      'viz_unittests': {
        'timeout_sec': 3600,
      },
    },

    'lacros_skylab_poc': {
      'lacros_fyi_tast_tests': {
        'tast_expr': '("group:mainline" && "dep:lacros" && !informational)',
        'timeout_sec': 10800,
      },
      'ozone_unittests': {
        'timeout_sec': 3600,
      },
    },

    # Lacros tests that run on Skylab, and these tests are usually HW sensative,
    # For example, Tast tests and GPU/display related gtest tests.
    'lacros_skylab_tests': {
      'lacros_all_tast_tests': {
        'tast_expr': '("group:mainline" && "dep:lacros" && !informational)',
        'timeout_sec': 10800,
      },
    },

    'layout_ng_gtests': {
      'webkit_unit_tests_ng': {
        'args': [
          '--disable-blink-features=LayoutNG,LayoutNGBlockFragmentation'
        ],
        'test': 'blink_unittests',
      },
    },

    'leak_detection_isolated_scripts': {
      'memory.leak_detection': {
        'args': [
          '--pageset-repeat=1',
          '--test-shard-map-filename=linux_leak_detection_shard_map.json',
          '--upload-results',
          '--output-format=histograms',
          '--browser=release',
          '--xvfb'
        ],
        'isolate_name': 'performance_test_suite',
        'override_compile_targets': [
          'performance_test_suite',
        ],
        'merge': {
          'args': [
            '--smoke-test-mode',
          ],
          'script': '//tools/perf/process_perf_results.py',
        },
        'swarming': {
          'expiration': 36000,
          'hard_timeout': 10800,
          'ignore_task_failure': False,
          'io_timeout': 3600,
          'shards': 10
        },
      },
    },

    'linux_cfm_gtests': {
      'chromeos_unittests': {},
      'unit_tests': {},
    },

    'linux_chromeos_browser_tests_require_lacros': {
      'browser_tests_require_lacros': {
        'name': 'browser_tests_require_lacros',
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/linux-chromeos.browser_tests.require_lacros.filter',
          '--lacros-chrome-path=lacros_clang_x64',
        ],
        # TODO(crbug.com/1195974): Decides whether we want to run this on CQ.
        # This target is heavy, which currently takes ~1 hour to run.
        'ci_only': True,
        'test': 'browser_tests',
        'swarming': {
          'shards': 4,
        },
      },
    },

    'linux_chromeos_lacros_gtests': {
      # Chrome OS (Ash) and Lacros only.
      'chromeos_unittests': {},
    },

    'linux_chromeos_oobe_specific_tests': {
      # TODO(crbug.com/1071693): Merge this suite back in to the main
      # browser_tests when the tests no longer fail on MSAN.
      'oobe_only_browser_tests': {
        'name': 'oobe_only_browser_tests',
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/chromeos.msan.browser_tests.oobe_positive.filter',
        ],
        'experiment_percentage': 100,
        'test': 'browser_tests',
        'swarming': {
          'shards': 20,
        },
      },
    },

    # TODO(crbug.com/1202958): Remove this when SkiaRenderer is fully shipped
    # on Chrome OS.
    'linux_chromeos_skia_renderer_specific_gtests': {
      # TODO(b/195938162): Re-enable this when animation tests are deflaked.
      # 'skia_renderer_ash_unittests': {
      #   'test': 'ash_unittests',
      #   'args': [
      #     '--enable-features=UseSkiaRenderer',
      #   ],
      # },
      'skia_renderer_aura_unittests': {
        'test': 'aura_unittests',
        'args': [
          '--enable-features=UseSkiaRenderer',
        ],
      },
    },

    'linux_chromeos_specific_gtests': {
      # Chrome OS only.
      'ash_components_unittests': {},
      'ash_unittests': {
        'swarming': {
          'shards': 5,
        },
      },
      'ash_webui_unittests': {},
      'aura_unittests': {},
      'chromeos_components_unittests': {},
      'exo_unittests': {},
      'gl_unittests_ozone': {},
      'keyboard_unittests': {},
      'ozone_gl_unittests': {
        'args': [
          '--ozone-platform=headless',
        ],
      },
      'ozone_unittests': {},
      'ozone_x11_unittests': {},
      'shell_encryption_unittests': {},
      'ui_chromeos_unittests': {},
      'usage_time_limit_unittests': {
        'experiment_percentage': 100,
      },
      'wayland_client_perftests': {},
      'wayland_client_tests': {},
    },

    'linux_example_builder_gtests': {
      'base_unittests': {},
      'interactive_ui_tests': {
        'swarming': {
          'shards': 3,
        },
      },
    },

    'linux_flavor_specific_chromium_gtests': {
      # Android, Chrome OS and Linux
      'sandbox_linux_unittests': {},
    },

    'linux_lacros_chrome_browsertests_version_skew': {
      'lacros_chrome_browsertests': { },
      'lacros_chrome_browsertests_run_in_series': { },
    },

    'linux_lacros_specific_gtests': {
      'lacros_chrome_unittests': {},
    },

    'linux_specific_chromium_isolated_scripts': {
      'not_site_per_process_blink_web_tests': {
        # not_site_per_process_blink_web_tests provides coverage for
        # running Layout Tests without site-per-process.  This is the mode used
        # on Android and Android bots currently do not run the full set of
        # layout tests.  Running in this mode on linux compensates for lack of
        # direct Android coverage.
        'args': [
          '--flag-specific=disable-site-isolation-trials',
          # layout test failures are retried 3 times when '--test-list' is not
          # passed, but 0 times when '--test-list' is passed. We want to always
          # retry 3 times, so we explicitly specify it.
          '--num-retries=3',
        ],
        'isolate_name': 'blink_web_tests',
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'mixins': [
          'skia_gold_test',
        ],
        'resultdb': {
          'enable': True,
        },
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 10,
        },
      },
      'webdriver_tests_suite': {
        'isolate_name': 'webdriver_wpt_tests',
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'swarming': {
          'shards': 4,
        },
      },
    },

    'linux_specific_xr_gtests': {
      'xr_browser_tests': {
        'test': 'xr_browser_tests',
      }
    },

    'mac_specific_chromium_gtests': {
      'power_sampler_unittests': {},
      'sandbox_mac_unittests': {},
      'updater_tests': {
        'args': [
          # Timeouts based on empirical observations of test runtimes, 2021-07.
          '--test-launcher-timeout=90000',
          '--ui-test-action-max-timeout=45000',
          '--ui-test-action-timeout=40000',
        ],
      },
      'xr_browser_tests': {
        'test': 'xr_browser_tests',
      },
    },

    'mac_specific_isolated_scripts': {
      'mac_signing_tests': {},
    },

    'mojo_chromiumos_specific_gtests': {
      'wayland_client_perftests': {},
    },

    'mojo_python_unittests_isolated_scripts': {
      'mojo_python_unittests': {
        'resultdb': {
          'enable': True,
        },
      },
    },

    'mojo_windows_specific_gtests': {
      'services_unittests': {},
    },

    'monochrome_public_apk_checker_isolated_script': {
      'monochrome_public_apk_checker': {
        'swarming': {
          'dimension_sets': [
            {
              'os': 'Ubuntu-18.04',
              'cpu': 'x86',
              'device_os': None,
              'device_os_flavor': None,
              'device_playstore_version': None,
              'device_type': None,
            },
          ],
        },
        'remove_mixins': [
          'android_r',
          'bullhead',
          'flame',
          'hammerhead',
          'kitkat',
          'marshmallow',
          'marshmallow_generic',
          'mdarcy',
          'nougat_generic',
          'oreo_fleet',
          'pie_fleet',
          'walleye',
        ],
      },
    },

    'network_service_fyi_gtests': {
      'network_service_web_request_proxy_browser_tests': {
        'args': [
          '--enable-features=ForceWebRequestProxyForTest',
        ],
        'swarming': {
          'shards': 15,
        },
        'test': 'browser_tests',
      },
    },

    'nocompile_tests': {
      'content_nocompile_tests': {},
    },

    'non_android_and_cast_and_chromeos_chromium_gtests': {
      'cronet_tests': {},
      'cronet_unittests': {},
      'headless_browsertests': {},
      'headless_unittests': {},
    },

    'non_android_chromium_gtests': {
      'accessibility_unittests': {},
      'app_shell_unittests': {},
      'blink_fuzzer_unittests': {},
      'browser_tests': {
        'swarming': {
          'shards': 10,
        },
      },
      'chrome_app_unittests': {},
      'chromedriver_unittests': {},
      'color_unittests': {},
      'extensions_browsertests': {},
      'extensions_unittests': {},
      'filesystem_service_unittests': {},  # https://crbug.com/862712
      'interactive_ui_tests': {
        'swarming': {
          'shards': 3,
        },
      },
      'message_center_unittests': {},
      'nacl_loader_unittests': {},
      'native_theme_unittests': {},
      'pdf_unittests': {},
      'ppapi_unittests': {},
      'printing_unittests': {},
      'remoting_unittests': {},
      'service_manager_unittests': {}, # https://crbug.com/843134
      'snapshot_unittests': {},
      'sync_integration_tests': {},
      'views_unittests': {},
    },

    'non_android_chromium_gtests_no_nacl': {
      'accessibility_unittests': {},
      'app_shell_unittests': {},
      'blink_fuzzer_unittests': {},
      'browser_tests': {
        'swarming': {
          'shards': 10,
        },
      },
      'chrome_app_unittests': {},
      'chromedriver_unittests': {},
      'extensions_browsertests': {},
      'extensions_unittests': {},
      'filesystem_service_unittests': {},  # https://crbug.com/862712
      'interactive_ui_tests': {
        'swarming': {
          'shards': 3,
        },
      },
      'message_center_unittests': {},
      'native_theme_unittests': {},
      'pdf_unittests': {},
      'ppapi_unittests': {},
      'printing_unittests': {},
      'remoting_unittests': {},
      'service_manager_unittests': {}, # https://crbug.com/843134
      'snapshot_unittests': {},
      'sync_integration_tests': {},
      'views_unittests': {},
    },

    'non_android_chromium_gtests_skia_gold': {
      'views_examples_unittests': {
        'mixins': [
          'skia_gold_test',
        ],
      },
    },

    'opus_tests': {
      'opus_tests': {
        'args': [
          '--shard-timeout=3000'
        ],
        'test': 'opus_tests',
       },
     },

    # TODO(petermcneeley) : Remove once OverlayPrioritization has landed on
    # all ozone platforms.
    'overlay_prioritization_gtests': {
      'overlay_prioritization_viz_unittests': {
        'args': [
          '--enable-features=EnableOverlayPrioritization'
        ],
        'test': 'viz_unittests',
      },
    },

    'paeverywhere_common_tests': {
      # Run popular tests other than capture_unittests, crashpad_tests,
      # content_browsertests, and perfetto_unittests because they fail.
      'absl_hardening_tests': {},
      'angle_end2end_tests': {},
      'angle_unittests': {
        'args': [
          'angle_unittests',
        ],
        'android_args': [
          '-v',
        ],
        'use_isolated_scripts_api': True,
      },
      'base_unittests': {},
      'blink_common_unittests': {},
      'blink_heap_unittests': {},
      'blink_platform_unittests': {},
      'blink_unittests': {},
      'boringssl_crypto_tests': {},
      'boringssl_ssl_tests': {},
      'browser_tests': {
        'swarming': {
          'shards': 10,
        },
      },
      'cast_unittests': {},
      'components_browsertests': {},
      'components_unittests': {
        'android_swarming': {
          'shards': 6,
        },
      },
      'content_unittests': {
        'android_swarming': {
          'shards': 3,
        },
      },
      'crypto_unittests': {},
      'gcm_unit_tests': {},
      'gin_unittests': {},
      'gl_tests': {},
      'gl_unittests': {},
      'google_apis_unittests': {},
      'gpu_unittests': {},
      'gwp_asan_unittests': {},
      'headless_browsertests': {},
      'headless_unittests': {},
      'interactive_ui_tests': {
        'swarming': {
          'shards': 3,
        },
      },
      'ipc_tests': {},
      'latency_unittests': {},
      'libjingle_xmpp_unittests': {},
      'liburlpattern_unittests': {},
      'media_unittests': {},
      'midi_unittests': {},
      'mojo_unittests': {},
      'net_unittests': {
        'android_swarming': {
          'shards': 3,
        },
      },
      'remoting_unittests': {},
      'services_unittests': {},
      'shell_dialogs_unittests': {},
      'skia_unittests': {},
      'sql_unittests': {},
      'storage_unittests': {},
      'ui_base_unittests': {},
      'ui_touch_selection_unittests': {},
      'unit_tests': {},
      'url_unittests': {},
      'webkit_unit_tests': {
        'test': 'blink_unittests',
        'android_swarming': {
          'shards': 6,
        },
      },
      'wtf_unittests': {},
      'zlib_unittests': {},
    },

    'perfetto_gtests': {
      'base_unittests': {},
      'perfetto_unittests': {},
      'services_unittests': {},
    },

    'performance_smoke_test_isolated_scripts': {
      'performance_test_suite': {
        'args': [
          '--pageset-repeat=1',
          '--test-shard-map-filename=smoke_test_benchmark_shard_map.json',
        ],
        'swarming': {
          'hard_timeout': 960,
          'shards': 2,
        },
        'merge': {
          'args': [
            '--smoke-test-mode',
          ],
          'script': '//tools/perf/process_perf_results.py',
        },
        'resultdb': {
          'enable': True,
        },
      },
    },

    'pixel_browser_tests_gtests': {
      'pixel_browser_tests': {
        'name': 'pixel_browser_tests',
        'args': [
          '--browser-ui-tests-verify-pixels',
          '--enable-pixel-output-in-tests',
          '--test-launcher-filter-file=../../testing/buildbot/filters/pixel_browser_tests.filter',
        ],
        'test': 'browser_tests',
        'mixins': [
          'skia_gold_test',
        ],
      },
    },

    # TODO(dpranke): These are run on the p/chromium waterfall; they should
    # probably be run on other builders, and we should get rid of the p/chromium
    # waterfall.
    'public_build_scripts': {
      'checkbins': {
        'script': 'checkbins.py',
      },
    },

    'rendering_desktop_representative_perf_tests_isolated_scripts': {
      'rendering_representative_perf_tests': {
        'isolate_name': 'rendering_representative_perf_tests',
        'args': [
          "../../tools/perf/run_benchmark",
          "--benchmarks=rendering.desktop",
        ],
        'swarming': {},
      }
    },

    'rendering_mobile_representative_perf_tests_isolated_scripts': {
      'rendering_representative_perf_tests': {
        'isolate_name': 'rendering_representative_perf_tests_android_chrome',
        'args': [
          "../../tools/perf/run_benchmark",
          "--benchmarks=rendering.mobile",
          "--browser=android-chromium"
        ],
        'swarming': {},
      }
    },

    'rendering_mobile_representative_perf_tests_isolated_scripts_experimental': {
      'rendering_representative_perf_tests': {
        'isolate_name': 'rendering_representative_perf_tests_android_chrome',
        'args': [
          "../../tools/perf/run_benchmark",
          "--benchmarks=rendering.mobile",
          "--browser=android-chromium"
        ],
        'swarming': {},
        'experiment_percentage': 10,
      }
    },

    'rust_gtests': {
      'base_unittests': {},
      'rust_gtest_interop_unittests': {},
      'test_cpp_including_rust_unittests': {
        'swarming': {},
        'test': 'test_cpp_including_rust_unittests',
      },
      'test_serde_json_lenient': {
        'swarming': {},
        'test': 'test_serde_json_lenient',
      },
    },

    'rust_native_tests': {
      'build_rust_tests': {
        'swarming': {},
        'test': 'build_rust_tests',
      },
      'mojo_rust_tests': {
        'swarming': {},
        'test': 'mojo_rust_tests',
      },
    },

    'site_isolation_android_fyi_gtests': {
      'site_per_process_android_browsertests': {
        'args': [
          '--site-per-process',
        ],
        'swarming': {
          'shards': 1,
        },
        'test': 'android_browsertests',
      },
      'site_per_process_chrome_public_test_apk': {
        'args': [
          '--site-per-process',
        ],
        'swarming': {
          'shards': 20,
        },
        'mixins': [
          'skia_gold_test',
          'has_native_resultdb_integration',
        ],
        'test': 'chrome_public_test_apk',
      },
      'site_per_process_chrome_public_unit_test_apk': {
        'args': [
          '--site-per-process',
        ],
        'mixins': [
          'skia_gold_test',
        ],
        'test': 'chrome_public_unit_test_apk',
      },
      'site_per_process_components_browsertests': {
        'args': [
          '--site-per-process',
        ],
        'test': 'components_browsertests',
      },
      'site_per_process_components_unittests': {
        'args': [
          '--site-per-process',
        ],
        'swarming': {
          'shards': 5,
        },
        'test': 'components_unittests',
      },
      'site_per_process_content_browsertests': {
        'args': [
          '--site-per-process',
          '--test-launcher-filter-file=../../testing/buildbot/filters/site_isolation_android.content_browsertests.filter',

        ],
        'swarming': {
          'shards': 10,
        },
        'test': 'content_browsertests',
      },
      'site_per_process_content_shell_test_apk': {
        'args': [
          '--site-per-process',
        ],
        'swarming': {
          'shards': 3,
        },
        'test': 'content_shell_test_apk',
      },
      'site_per_process_content_unittests': {
        'args': [
          '--site-per-process'
        ],
        'test': 'content_unittests',
      },
      'site_per_process_unit_tests': {
        'args': [
          '--site-per-process'
        ],
        'swarming': {
          'shards': 10,
        },
        'test': 'unit_tests',
      },
    },

    'swangle_gtests': {
      'angle_deqp_egl_tests': {
        'args': [
          'angle_deqp_egl_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_gles2_tests': {
        'args': [
          'angle_deqp_gles2_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_gles31_rotate180_tests': {
        'args': [
          'angle_deqp_gles31_rotate180_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_gles31_rotate270_tests': {
        'args': [
          'angle_deqp_gles31_rotate270_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_gles31_rotate90_tests': {
        'args': [
          'angle_deqp_gles31_rotate90_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_gles31_tests': {
        'args': [
          'angle_deqp_gles31_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'swarming': {
          'shards': 10,
        },
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_gles3_rotate180_tests': {
        'args': [
          'angle_deqp_gles3_rotate180_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_gles3_rotate270_tests': {
        'args': [
          'angle_deqp_gles3_rotate270_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_gles3_rotate90_tests': {
        'args': [
          'angle_deqp_gles3_rotate90_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_gles3_tests': {
        'args': [
          'angle_deqp_gles3_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'swarming': {
          'shards': 4,
        },
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_khr_gles2_tests': {
        'args': [
          'angle_deqp_khr_gles2_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_khr_gles31_tests': {
        'args': [
          'angle_deqp_khr_gles31_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_deqp_khr_gles3_tests': {
        'args': [
          'angle_deqp_khr_gles3_tests',
          '--use-angle=swiftshader',
          '--bot-mode',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
      'angle_end2end_tests': {
        'args': [
          'angle_end2end_tests',
          '--bot-mode',
          '--gtest_filter=*Vulkan_SwiftShader*',
        ],
        'linux_args': [
          '--xvfb',
        ],
        'use_isolated_scripts_api': True,
      },
    },

    'system_webview_shell_instrumentation_tests': {
      'system_webview_shell_layout_test_apk': {},
    },

    'system_webview_wpt': {
      'system_webview_wpt': {
        'swarming': {
          'shards': 25,
          'expiration': 18000,
          'hard_timeout': 14400,
        },
        'experiment_percentage': 100,
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'results_handler': 'layout tests',
      },
    },

    'telemetry_android_minidump_unittests_isolated_scripts': {
      'telemetry_chromium_minidump_unittests': {
        'args': [
          'BrowserMinidumpTest',
          '--browser=android-chromium',
          '-v',
          '--passthrough',
          '--retry-limit=2',
        ],
        'isolate_name': 'telemetry_perf_unittests_android_chrome',
        'resultdb': {
          'enable': True,
        },
      },
      'telemetry_monochrome_minidump_unittests': {
        'args': [
          'BrowserMinidumpTest',
          '--browser=android-chromium-monochrome',
          '-v',
          '--passthrough',
          '--retry-limit=2',
        ],
        'isolate_name': 'telemetry_perf_unittests_android_monochrome',
        'resultdb': {
          'enable': True,
        },
      },
    },

    'telemetry_desktop_minidump_unittests_isolated_scripts': {
      # Takes ~2.5 minutes of bot time to run.
      'telemetry_desktop_minidump_unittests': {
        'args': [
          'BrowserMinidumpTest',
          '-v',
          '--passthrough',
          '--retry-limit=2',
        ],
        'isolate_name': 'telemetry_perf_unittests',
        'resultdb': {
          'enable': True,
        },
      },
    },

    'telemetry_perf_unittests_isolated_scripts': {
      'telemetry_perf_unittests': {
        'args': [
          # TODO(crbug.com/1077284): Remove this once Crashpad is the default.
          '--extra-browser-args=--enable-crashpad',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 12,
        },
        'resultdb': {
          'enable': True,
        },
      },
    },

    'telemetry_perf_unittests_isolated_scripts_android': {
      'telemetry_perf_unittests': {
        'isolate_name': 'telemetry_perf_unittests_android_chrome',
        'args': [
          # TODO(crbug.com/1077284): Remove this once Crashpad is the default.
          '--extra-browser-args=--enable-crashpad',
        ],
        'swarming': {
          'idempotent': False,  # https://crbug.com/549140
          'shards': 12,
        },
        'resultdb': {
          'enable': True,
        },
      },
    },

    'test_buildbucket_api_gpu_use_cases': {
      'test_buildbucket_api_gpu_use_cases': {},
    },

    'test_traffic_annotation_auditor_script': {
      'test_traffic_annotation_auditor': {
        'hard_timeout': 14400,
        'io_timeout': 14400,
        'script': 'test_traffic_annotation_auditor.py',
      },
    },

    'updater_gtests_mac': {
      'updater_tests': {
        'args': [
          # Timeouts based on empirical observations of test runtimes, 2021-07.
          '--test-launcher-timeout=90000',
          '--ui-test-action-max-timeout=45000',
          '--ui-test-action-timeout=40000',
        ],
      },
      'updater_tests_system': {
        'args': [
          # Timeouts based on empirical observations of test runtimes, 2021-07.
          '--test-launcher-timeout=90000',
          '--ui-test-action-max-timeout=45000',
          '--ui-test-action-timeout=40000',
        ],
        'swarming': {
          'dimension_sets': [
            {
              # These tests require passwordless sudo on mac.
              'pool': 'chromium.updater.mac',
            }
          ]
        },
      },
    },

    'updater_gtests_win': {
      'updater_tests': {
        'args': [
          # Timeouts based on empirical observations of test runtimes, 2021-07.
          '--test-launcher-timeout=90000',
          '--ui-test-action-max-timeout=45000',
          '--ui-test-action-timeout=40000',
        ],
      },
      'updater_tests_system': {
        'args': [
          # Timeouts based on empirical observations of test runtimes, 2021-07.
          '--test-launcher-timeout=90000',
          '--ui-test-action-max-timeout=45000',
          '--ui-test-action-timeout=40000',
        ],
        'swarming': {
          'dimension_sets': [
            {
              'integrity': 'high',
            }
          ]
        }
      },
    },

    'updater_gtests_win_uac': {
      'updater_tests_system': {
        'args': [
          # Timeouts based on empirical observations of test runtimes, 2021-07.
          '--test-launcher-timeout=90000',
          '--ui-test-action-max-timeout=45000',
          '--ui-test-action-timeout=40000',
        ],
        'swarming': {
          'dimension_sets': [
            {
              'integrity': 'high',
            }
          ]
        }
      },
      'updater_tests_win_uac': {
        'args': [
          # Timeouts based on empirical observations of test runtimes, 2021-07.
          '--test-launcher-timeout=90000',
          '--ui-test-action-max-timeout=45000',
          '--ui-test-action-timeout=40000',
        ],
      },
    },

    'upload_perfetto': {
      'upload_trace_processor': {},
    },

    'variations_smoke_tests': {
      'variations_smoke_tests': {
        'isolate_name': 'variations_smoke_tests',
        'resultdb': {
          'enable': True,
          'result_format': 'single'
        },
      },
    },

    # Not applicable for android x86 & x64 since the targets here assert
    # "enable_vr" in GN which is only true for android arm & arm64.
    # For details, see the following files:
    #  * //chrome/android/BUILD.gn
    #  * //chrome/browser/android/vr/BUILD.gn
    #  * //device/vr/buildflags/buildflags.gni
    'vr_android_specific_chromium_tests': {
      'chrome_public_test_vr_apk': {
        'args': [
          '--shared-prefs-file=//chrome/android/shared_preference_files/test/vr_cardboard_skipdon_setupcomplete.json',
          '--additional-apk=//third_party/gvr-android-sdk/test-apks/vr_services/vr_services_current.apk',
        ],
        'swarming': {
          'shards': 2,
        },
      },
      'vr_android_unittests': {},
    },

    'vr_platform_specific_chromium_gtests': {
      # Only run on platforms that intend to support WebVR in the near
      # future.
      'vr_common_unittests': {},
      'vr_pixeltests': {},
    },

    'vulkan_swiftshader_isolated_scripts': {
      'vulkan_swiftshader_blink_web_tests': {
        # layout test failures are retried 3 times when '--test-list' is not
        # passed, but 0 times when '--test-list' is passed. We want to always
        # retry 3 times, so we explicitly specify it.
        'args': [
          '--num-retries=3',
          '--skipped=always',
          '--test-list=../../testing/buildbot/filters/gpu.skiarenderer_vulkan_blink_web_tests.filter',
          '--flag-specific=skia-vulkan-swiftshader',
        ],
        'isolate_name': 'blink_web_tests',
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'mixins': [
          'skia_gold_test',
        ],
        'resultdb': {
          'enable': True,
        },
        'results_handler': 'layout tests',
      },
    },

    'web_engine_gtests': {
      'cast_runner_browsertests': {},
      'cast_runner_integration_tests': {},
      'cast_runner_unittests': {},
      'cr_fuchsia_base_unittests': {},
      'web_engine_browsertests': {},
      'web_engine_integration_tests': {
        'args': [
          '--child-arg=--vmodule=test_navigation_listener=1',
        ],
      },
      'web_engine_unittests': {},
      'web_runner_integration_tests': {},
    },

    'weblayer_android_gtests': {
      'weblayer_bundle_test': {
      },
      'weblayer_instrumentation_test_apk': {
      },
      'weblayer_private_instrumentation_test_apk': {
      },
    },


    'weblayer_gtests': {
      'weblayer_browsertests': {
      },
      'weblayer_unittests': {
      },
    },

    'weblayer_instrumentation_tests': {
      'weblayer_instrumentation_test_apk': {
      }
    },

    'weblayer_shell_wpt': {
      'weblayer_shell_wpt': {
        'swarming': {
          'shards': 18,
          'expiration': 18000,
          'hard_timeout': 14400,
        },
        'experiment_percentage': 100,
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'results_handler': 'layout tests',
      },
    },

    'weblayer_skew_tests': {
      'weblayer_skew_tests': {
        'swarming': {
          'shards': 2,
        },
        'args': [
          '--additional-apk=apks/WebLayerShellSystemWebView.apk',
        ],
      },
    },

    'weblayer_skew_tests_with_chrome': {
      'weblayer_skew_tests_with_chrome': {
        'swarming': {
          'shards': 2,
        },
        'args': [
          '--additional-apk=apks/ChromePublic.apk'
        ],
      },
    },

    # TODO(crbug.com/888429): Port remaining WebRTC tests to swarming.
    'webrtc_chromium_baremetal_gtests': {
      'browser_tests': {
        'args': [
          '--gtest_filter=WebRtcStatsPerfBrowserTest.*:'
           'WebRtcVideoDisplayPerfBrowserTests*:'
           'WebRtcVideoQualityBrowserTests*:'
           'WebRtcVideoHighBitrateBrowserTest*:'
           'WebRtcWebcamBrowserTests*',
          '--run-manual',
          '--ui-test-action-max-timeout=300000',
          '--test-launcher-timeout=350000',
          '--test-launcher-jobs=1',
          '--test-launcher-bot-mode',
          '--test-launcher-print-test-stdio=always',
        ],
        'annotate': 'graphing',
        'perf_config': {
          'a_default_rev': 'r_webrtc_git',
          'r_webrtc_git': '${webrtc_got_rev}'
        },
        'swarming': {
          'can_use_on_swarming_builders': False,
        },
      },
      # Run capture unittests as well since our bots have real webcams.
      'capture_unittests': {
        'args': ['--enable-logging', '--v=1', '--test-launcher-jobs=1',
                 '--test-launcher-print-test-stdio=always'],
        'swarming': {
          'can_use_on_swarming_builders': False,
        },
      },
    },

    'webrtc_chromium_gtests': {
      'browser_tests_apprtc': {
        'args': ['--gtest_filter=WebRtcApprtcBrowserTest.*',
                 '--run-manual', '--test-launcher-jobs=1'],
      },
      'browser_tests_functional': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/webrtc_functional.browser_tests.filter',
          '--run-manual', '--test-launcher-jobs=1'],
        'test': 'browser_tests',
      },
      'content_browsertests': {
        # Run all normal WebRTC content_browsertests. This is mostly so
        # the FYI bots can detect breakages.
        'args': ['--gtest_filter=WebRtc*'],
      },
      'content_browsertests_stress': {
        'args': ['--gtest_filter=WebRtc*MANUAL*:-UsingRealWebcam*',
                 '--run-manual', '--ui-test-action-max-timeout=110000',
                 '--test-launcher-timeout=120000'],
        'test': 'content_browsertests',
      },
      'content_unittests': {
        'args': [
          '--test-launcher-filter-file=../../testing/buildbot/filters/webrtc.content_unittests.filter',
        ],
      },
      'remoting_unittests': {
        'args': ['--gtest_filter=Webrtc*'],
      },
    },

    'webrtc_chromium_simple_baremetal_gtests': {
      'content_browsertests_sequential': {
        # These run a few tests that require webcam access. They need to
        # run sequentially, otherwise tests may interfere with each other.
        'args': ['--gtest_filter=UsingRealWebcam*', '--run-manual',
                 '--test-launcher-jobs=1'],
        'test': 'content_browsertests',
      },
    },

    'webrtc_chromium_simple_gtests': {
      'content_browsertests': {
        'args': ['--gtest_filter=WebRtc*'],
      },
    },

    'webview_64_cts_tests_gtest': {
      'webview_64_cts_tests': {
        'swarming': {
          'shards': 2,
          'cipd_packages': [
            {
              "cipd_package": 'chromium/android_webview/tools/cts_archive',
              'location': 'android_webview/tools/cts_archive',
              'revision': 'ai8Ig4HlO0vG6aP_JP2uhyruE2yPzze8PFP1g8Z4_hgC',
            }
          ]
        },
      },
    },

    'webview_bot_instrumentation_test_apk_gtest': {
      'webview_instrumentation_test_apk': {
        'swarming': {
          'shards': 12,
        },
      },
    },

    'webview_bot_instrumentation_test_apk_no_field_trial_gtest': {
      'webview_instrumentation_test_apk_no_field_trial': {
        'args': ['--disable-field-trials'],
        'swarming': {
          'shards': 12,
        },
        'test': 'webview_instrumentation_test_apk',
      },
    },

    'webview_bot_unittests_gtest': {
      'android_webview_unittests': {},
    },

    'webview_cts_tests_gtest': {
      'webview_cts_tests': {
        'swarming': {
          'shards': 2,
          'cipd_packages': [
            {
              "cipd_package": 'chromium/android_webview/tools/cts_archive',
              'location': 'android_webview/tools/cts_archive',
              'revision': 'ai8Ig4HlO0vG6aP_JP2uhyruE2yPzze8PFP1g8Z4_hgC',
            }
          ]
        },
      },
    },

    'webview_cts_tests_gtest_no_field_trial': {
      'webview_cts_tests_no_field_trial': {
        'args': [
          '--disable-field-trial-config',
        ],
        'swarming': {
          'shards': 2,
          'cipd_packages': [
            {
              "cipd_package": 'chromium/android_webview/tools/cts_archive',
              'location': 'android_webview/tools/cts_archive',
              'revision': 'ai8Ig4HlO0vG6aP_JP2uhyruE2yPzze8PFP1g8Z4_hgC',
            }
          ]
        },
        'test': 'webview_cts_tests',
      },
    },

    'webview_ui_instrumentation_tests': {
      'webview_ui_test_app_test_apk': {},
    },

    'webview_ui_instrumentation_tests_no_field_trial': {
      'webview_ui_test_app_test_apk_no_field_trial': {
        'args': [
          '--disable-field-trial-config',
        ],
        'test': 'webview_ui_test_app_test_apk',
      },
    },

    'win7_32_bit_gtests': {
      'base_unittests': {},
      'browser_tests': {
        'swarming': {
          'shards': 10,
        },
      },
      'sbox_integration_tests': {
        'swarming': {
          'dimension_sets': [
            {
              'integrity': 'high',
            }
          ],
        },
      },
      'sbox_unittests': {},
      'sbox_validation_tests': {},
    },

    'win_specific_chromium_gtests': {
      'browser_switcher_bho_unittests': {},
      'chrome_cleaner_unittests': {},
      'chrome_elf_unittests': {},
      'courgette_unittests': {},
      'delayloads_unittests': {},
      'elevation_service_unittests': {},
      'gcp_unittests': {},
      'install_static_unittests': {},
      'installer_util_unittests': {
        'swarming': {
          'dimension_sets': [
            {
              'integrity': 'high',
            }
          ],
        },
      },
      'mojo_core_unittests': {},
      'notification_helper_unittests': {},
      'sbox_integration_tests': {
        'swarming': {
          'dimension_sets': [
            {
              'integrity': 'high',
            }
          ],
        },
      },
      'sbox_unittests': {},
      'sbox_validation_tests': {},
      'setup_unittests': {
        'swarming': {
          'dimension_sets': [
            {
              'integrity': 'high',
            }
          ],
        },
      },
      'updater_tests': {
        'args': [
          # Timeouts based on empirical observations of test runtimes, 2021-07.
          '--test-launcher-timeout=90000',
          '--ui-test-action-max-timeout=45000',
          '--ui-test-action-timeout=40000',
        ],
      },
      'updater_tests_system': {
        'args': [
          '--test-launcher-print-test-stdio=always',
          # Timeouts based on empirical
          # observations of test runtimes,
          # 2021-07.
          '--test-launcher-timeout=90000',
          '--ui-test-action-max-timeout=45000',
          '--ui-test-action-timeout=40000',
          '--ui-test-action-timeout=40000',
        ],
      },
      'zucchini_unittests': {},
    },

    'win_specific_isolated_scripts': {
      'mini_installer_tests': {
        'swarming': {
          'dimension_sets': [
            {
              'integrity': 'high',
            }
          ],
        },
      },
      'polymer_tools_python_unittests': {
        'experiment_percentage': 100,
      },
    },

    'win_specific_xr_perf_tests': {
      'xr.webxr.static': {
        'args': [
          '--benchmarks=xr.webxr.static',
          '-v',
          '--upload-results',
          '--output-format=histograms',
          '--browser=release_x64',
        ],
        'isolate_name': 'vr_perf_tests',
        'merge': {
          'script': '//tools/perf/process_perf_results.py',
        },
        'name': 'xr.webxr.static',
        # Experimental until we're sure these are stable.
        'experiment_percentage': 100,
      }
    },

    'wpt_web_tests': {
      'wpt_tests_suite': {
        'args': [
          '--child-processes=20',
        ],
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'isolate_name': 'wpt_tests_isolate',
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 15,
        },
        'experiment_percentage': 100,
      },
    },

    'wpt_web_tests_identity': {
      'wpt_tests_suite': {
        'args': [
          'webauthn/',
        ],
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'isolate_name': 'wpt_tests_isolate',
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 1,
        },
      },
    },

    'wpt_web_tests_input': {
      'wpt_tests_suite': {
        'args': [
          'infrastructure/testdriver/actions/',
          'input-events/',
          'pointerevents/',
          'touch-events/',
          'uievents/',
        ],
        'merge': {
          'args': [
            '--verbose',
          ],
          'script': '//third_party/blink/tools/merge_web_test_results.py',
        },
        'isolate_name': 'wpt_tests_isolate',
        'results_handler': 'layout tests',
        'swarming': {
          'shards': 1,
        },
        'experiment_percentage': 100,
      },
    },
  },

  ##############################################################################
  # Compound test suites.                                                      #
  ##############################################################################

  'compound_suites': {
    'android_10_rel_gtests': [
      'android_trichrome_smoke_tests',
      'android_ar_gtests',
      'android_ddready_vr_gtests',
    ],

    'android_11_emulator_gtests': [
      'android_emulator_specific_chrome_public_tests',
      'android_monochrome_smoke_tests',
      'android_smoke_tests',
      'android_specific_chromium_gtests',  # Already includes gl_gtests.
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'linux_flavor_specific_chromium_gtests',
      'system_webview_shell_instrumentation_tests', # Not an experimental test
      'weblayer_android_gtests',
      'weblayer_gtests',
      'webview_cts_tests_gtest',
      'webview_ui_instrumentation_tests',
    ],

    'android_12_dbg_emulator_gtests': [
      'android_trichrome_smoke_tests',
    ],

    'android_12_emulator_gtests': [
      'android_emulator_specific_chrome_public_tests',
      'android_monochrome_smoke_tests',
      'android_smoke_tests',
      'android_specific_chromium_gtests',  # Already includes gl_gtests.
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'linux_flavor_specific_chromium_gtests',
      'system_webview_shell_instrumentation_tests', # Not an experimental test
      'weblayer_android_gtests',
      'weblayer_gtests',
      'webview_64_cts_tests_gtest',
      'webview_ui_instrumentation_tests',
    ],

    # This is the same as 'android_marshmallow_gtests'
    # with the addition of 'webview_cts_tests_gtest' and
    # 'webview_ui_instrumentation_tests'
    'android_marshmallow_coverage_gtests': [
      'android_modern_smoke_tests',
      'android_smoke_tests',
      'android_specific_chromium_gtests',  # Already includes gl_gtests.
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chrome_public_tests',
      'linux_flavor_specific_chromium_gtests',
      'vr_android_specific_chromium_tests',
      'vr_platform_specific_chromium_gtests',
      'weblayer_android_gtests',
      'weblayer_gtests',
      'webview_cts_tests_gtest',
      'webview_ui_instrumentation_tests',
    ],

    # List gtests that run on android-marshmallow-arm64-rel builder.
    # TODO(crbug.com/1127110): Use android_marshmallow_gtests when
    # android-marshmallow-x86-rel is not mirrored to CQ.
    'android_marshmallow_device_gtests': [
      'android_marshmallow_device_ci_only_gtests',

      # TODO(crbug.com/1127110): Remove once webview_instrumentation_test_apk
      # and content_shell_test_apk are enabled on android-marshmallow-x86-rel
      'android_specific_chromium_gtests',  # Already includes gl_gtests.

      'chromium_gtests',
      'vr_android_specific_chromium_tests',
      'vr_platform_specific_chromium_gtests',
      'weblayer_android_gtests',
      'weblayer_gtests',
    ],

    # List gtests that run on android-marshmallow-x86-rel builder.
    # Test suites will be gradually moved from
    # android_marshmallow_emulator_non_cq_gtests
    # to this one, when there are more GCE capacity.
    'android_marshmallow_emulator_gtests': [
      'android_emulator_specific_chrome_public_tests',
      # TODO(crbug.com/1127110): Deprecate this when all the test suites below
      # it are re-enabled.
      'android_marshmallow_emulator_limited_capacity_gtests',

      'android_modern_smoke_tests',
      'android_smoke_tests',
      'android_specific_chromium_gtests',  # Already includes gl_gtests.
      'android_wpr_record_replay_tests',
      #'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      # TODO(crbug.com/1255748): Remove components_capacity_tests when
      # chromium_gtests are enabled in this suite.
      'components_capacity_tests',
      'linux_flavor_specific_chromium_gtests',
      #'weblayer_android_gtests',
      #'weblayer_gtests',
    ],

    # Note that tests here are gradually moved to
    # android_marshmallow_emulator_gtests (crbug.com/1127110)
    #
    # The diff between android_marshmallow_device_gtests and
    # (android_marshmallow_emulator_non_cq_gtests +
    # android_marshmallow_emulator_gtests)
    # is android_wpr_record_replay_tests
    'android_marshmallow_emulator_non_cq_gtests': [
      'chromium_gtests',
      'weblayer_android_gtests',
      'weblayer_gtests',
    ],

    'android_marshmallow_gtests': [
      'android_modern_smoke_tests',
      'android_smoke_tests',
      'android_specific_chromium_gtests',  # Already includes gl_gtests.
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chrome_public_tests',
      'linux_flavor_specific_chromium_gtests',
      'vr_android_specific_chromium_tests',
      'vr_platform_specific_chromium_gtests',
      'weblayer_android_gtests',
      'weblayer_gtests',
    ],

    'android_nougat_emulator_gtests': [
      'android_emulator_specific_chrome_public_tests',
      'android_monochrome_smoke_tests',
      'android_smoke_tests',
      'android_specific_chromium_gtests',  # Already includes gl_gtests.
      'android_wpr_record_replay_tests',
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'linux_flavor_specific_chromium_gtests',
      'system_webview_shell_instrumentation_tests', # Not an experimental test
      'weblayer_android_gtests',
      'weblayer_gtests',
      'webview_cts_tests_gtest',
      'webview_ui_instrumentation_tests',
    ],

    'android_nougat_gtests': [
      'android_ar_gtests',
      'android_ddready_vr_gtests',
      'android_monochrome_smoke_tests',
      'android_smoke_tests',
    ],

    'android_oreo_gtests': [
      'android_ar_gtests',
      'android_ddready_vr_gtests',
      'android_monochrome_smoke_tests',
      'android_oreo_standard_gtests',
      'android_smoke_tests',
    ],

    'android_pie_gtests': [
      'android_ar_gtests',
      'android_ddready_vr_gtests',
      'android_monochrome_smoke_tests',
      'android_pagecontroller_self_tests',
      'android_smoke_tests',
      'chromium_tracing_gtests',
      # No standard tests due to capacity, no Vega tests since it's currently
      # O only.
    ],

     # Keep in sync with android_pie_rel_gtests below, except for
     # vr_{android,platform}_specific_chromium_gtests which are not applicable
     # to android emulators on x86 & x64.
    'android_pie_rel_emulator_gtests': [
      'android_emulator_specific_chrome_public_tests',
      'android_monochrome_smoke_tests',
      'android_pagecontroller_self_tests',
      'android_smoke_tests',
      'android_specific_chromium_gtests',  # Already includes gl_gtests.
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'linux_flavor_specific_chromium_gtests',
      'system_webview_shell_instrumentation_tests', # Not an experimental test
      'weblayer_android_gtests',
      'weblayer_gtests',
      'webview_cts_tests_gtest',
      'webview_ui_instrumentation_tests',
    ],

    'android_pie_rel_gtests': [
      # TODO(crbug.com/1111436): Deprecate this when all the test suites below
      # it are re-enabled.
      'android_pie_rel_reduced_capacity_gtests',

      'android_monochrome_smoke_tests',
      'android_pagecontroller_self_tests',
      'android_smoke_tests',
    #   'android_specific_chromium_gtests',  # Already includes gl_gtests.
    #   'chromium_gtests',
    #   'chromium_gtests_for_devices_with_graphical_output',
      'chrome_public_tests',
    #   'linux_flavor_specific_chromium_gtests',
    #   'system_webview_shell_instrumentation_tests', # Not an experimental test
    #   'vr_android_specific_chromium_tests',
    #   'vr_platform_specific_chromium_gtests',
    #   'weblayer_android_gtests',
      'weblayer_gtests',
      'webview_64_cts_tests_gtest',
      'webview_ui_instrumentation_tests',
    ],

    'backuprefptr_gtests': [
      'backuprefptr_generic_gtests',
    ],

    'bfcache_android_gtests': [
      'bfcache_android_specific_gtests',
      'bfcache_generic_gtests',
    ],

    'bfcache_linux_gtests': [
      'bfcache_generic_gtests',
      'bfcache_linux_specific_gtests',
    ],

    'chromeos_device_gtests': [
      'chromeos_browser_integration_tests',
      'chromeos_device_only_gtests',
    ],

    'chromeos_vm_gtests': [
      'chromeos_browser_finch_tests',
      'chromeos_browser_integration_tests',
      'chromeos_system_friendly_gtests',
    ],

    'chromium_android_gtests': [
      'android_smoke_tests',
      'android_specific_chromium_gtests',  # Already includes gl_gtests.
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chrome_public_tests',
      'linux_flavor_specific_chromium_gtests',
      'vr_android_specific_chromium_tests',
      'vr_platform_specific_chromium_gtests',
    ],

    'chromium_dbg_isolated_scripts': [
      'desktop_chromium_isolated_scripts',
      'performance_smoke_test_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts',
    ],

    # This is meant to be a superset of 'chromium_linux_and_gl_gtests'. Any
    # changes there must be reflected here.
    'chromium_linux_and_gl_and_vulkan_gtests': [
      'aura_gtests',
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_linux_and_chromeos_only',
      'chromium_gtests_for_linux_and_mac_only',
      'chromium_gtests_for_linux_only',
      'chromium_gtests_for_win_and_linux_only',
      'linux_flavor_specific_chromium_gtests',
      'linux_specific_xr_gtests',
      'gl_gtests_passthrough',
      'gpu_fyi_vulkan_swiftshader_gtests',
      'non_android_and_cast_and_chromeos_chromium_gtests',
      'non_android_chromium_gtests',
      'vr_platform_specific_chromium_gtests',
      'weblayer_gtests',
    ],

    # gl_tests requires dedicated slaves with GPUs on linux, so have a separate
    # test list with gl_tests included. This is chromium_linux_gtests + gl_gtests.
    'chromium_linux_and_gl_gtests': [
      'aura_gtests',
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_linux_and_chromeos_only',
      'chromium_gtests_for_linux_and_mac_only',
      'chromium_gtests_for_linux_only',
      'chromium_gtests_for_win_and_linux_only',
      'linux_flavor_specific_chromium_gtests',
      'linux_specific_xr_gtests',
      'gl_gtests_passthrough',
      'non_android_and_cast_and_chromeos_chromium_gtests',
      'non_android_chromium_gtests',
      'vr_platform_specific_chromium_gtests',
      'weblayer_gtests',
    ],

    'chromium_linux_cast_audio_gtests': [
      'cast_audio_specific_chromium_gtests',
      'chromium_gtests',
      'linux_flavor_specific_chromium_gtests',
    ],

    'chromium_linux_cast_video_gtests': [
      'cast_audio_specific_chromium_gtests',
      'cast_video_specific_chromium_gtests',
      'chromium_gtests',
      'linux_flavor_specific_chromium_gtests',
    ],

    'chromium_linux_dbg_isolated_scripts': [
      'desktop_chromium_isolated_scripts',
      'linux_specific_chromium_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts',
    ],

    # When changing something here, change chromium_linux_and_gl_gtests,
    # chromium_linux_and_gl_and_vulkan_gtests, linux_ozone_x11_ci_tests and
    # linux_ozone_wayland_ci_tests in the same way.
    'chromium_linux_gtests': [
      'aura_gtests',
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_linux_and_chromeos_only',
      'chromium_gtests_for_linux_and_mac_only',
      'chromium_gtests_for_linux_only',
      'chromium_gtests_for_win_and_linux_only',
      'linux_flavor_specific_chromium_gtests',
      'linux_specific_xr_gtests',
      'non_android_and_cast_and_chromeos_chromium_gtests',
      'non_android_chromium_gtests',
      'vr_platform_specific_chromium_gtests',
      'overlay_prioritization_gtests',
      'weblayer_gtests',
    ],

    'chromium_linux_rel_isolated_scripts': [
      'chromedriver_py_tests_isolated_scripts',
      'desktop_chromium_isolated_scripts',
      'linux_specific_chromium_isolated_scripts',
      'mojo_python_unittests_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts',
      'vulkan_swiftshader_isolated_scripts',
      'chromium_web_tests_high_dpi_isolated_scripts',
    ],

    'chromium_mac_gtests': [
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_linux_and_mac_only',
      'mac_specific_chromium_gtests',
      'nocompile_tests',
      'non_android_and_cast_and_chromeos_chromium_gtests',
      'non_android_chromium_gtests',
    ],

    'chromium_mac_gtests_no_nacl': [
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_linux_and_mac_only',
      'mac_specific_chromium_gtests',
      'nocompile_tests',
      'non_android_and_cast_and_chromeos_chromium_gtests',
      'non_android_chromium_gtests_no_nacl',
    ],

    'chromium_mac_gtests_no_nacl_no_nocompile': [
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'mac_specific_chromium_gtests',
      'non_android_and_cast_and_chromeos_chromium_gtests',
      'non_android_chromium_gtests_no_nacl',
    ],

    'chromium_mac_rel_isolated_scripts': [
      'chromedriver_py_tests_isolated_scripts',
      'components_perftests_isolated_scripts',
      'desktop_chromium_isolated_scripts',
      'mac_specific_isolated_scripts',
      'mojo_python_unittests_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts',
    ],

    'chromium_mac_rel_isolated_scripts_and_sizes': [
      'chrome_sizes',
      'chromedriver_py_tests_isolated_scripts',
      'components_perftests_isolated_scripts',
      'desktop_chromium_isolated_scripts',
      'mac_specific_isolated_scripts',
      'mojo_python_unittests_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts',
    ],

    # Pixel tests only enabled on Win 10. So this is
    # 'chromium_win_gtests' + 'pixel_browser_tests_gtests' +
    # 'non_android_chromium_gtests_skia_gold'.
    'chromium_win10_gtests': [
      'aura_gtests',
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_win_and_linux_only',
      'non_android_and_cast_and_chromeos_chromium_gtests',
      'non_android_chromium_gtests',
      'non_android_chromium_gtests_skia_gold',
      'pixel_browser_tests_gtests',
      'vr_platform_specific_chromium_gtests',
      'weblayer_gtests',
      'win_specific_chromium_gtests',
    ],

    'chromium_win_dbg_isolated_scripts': [
      'chromedriver_py_tests_isolated_scripts',
      'components_perftests_isolated_scripts',
      'desktop_chromium_isolated_scripts',
      'performance_smoke_test_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts',
    ],

    'chromium_win_gtests': [
      'aura_gtests',
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_win_and_linux_only',
      'non_android_and_cast_and_chromeos_chromium_gtests',
      'non_android_chromium_gtests',
      'vr_platform_specific_chromium_gtests',
      'weblayer_gtests',
      'win_specific_chromium_gtests',
    ],

    'chromium_win_rel_isolated_scripts': [
      'chromedriver_py_tests_isolated_scripts',
      'components_perftests_isolated_scripts',
      'desktop_chromium_isolated_scripts',
      'mojo_python_unittests_isolated_scripts',
      'telemetry_desktop_minidump_unittests_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts',
      'win_specific_isolated_scripts',
    ],

    'cronet_dbg_isolated_scripts': [
      'cronet_sizes',
    ],

    'cronet_rel_isolated_scripts': [
      'cronet_resource_sizes',
      'cronet_sizes',
    ],

    'devtools_gtests': [
      'devtools_browser_tests',
      'blink_unittests',
    ],

    'fuchsia_arm64_isolated_scripts': [
      'fuchsia_sizes_tests',
      'gpu_angle_fuchsia_unittests_isolated_scripts',
    ],

    # All gtests that can be run on Fuchsia CI/CQ
    'fuchsia_gtests': [
      'fuchsia_chrome_gtests',
      'fuchsia_common_gtests',
      'fuchsia_common_gtests_with_graphical_output',
      'web_engine_gtests',
    ],

    'fuchsia_isolated_scripts': [
      'chromium_webkit_isolated_scripts',
      'gpu_angle_fuchsia_unittests_isolated_scripts'
    ],

    'fuchsia_web_engine_non_graphical_gtests': [
      'fuchsia_common_gtests',
      'web_engine_gtests',
    ],

    # BEGIN composition test suites used by the GPU bots

    'gpu_angle_android_gtests': [
      'gpu_angle_deqp_egl_gles_gtests',
      'gpu_angle_deqp_gles2_gles_gtests',
      'gpu_angle_deqp_gles3_gles_gtests',
      'gpu_angle_end2end_gtests',
      'gpu_angle_unit_gtests',
    ],

    'gpu_angle_gtests': [
      'gpu_angle_end2end_gtests',
      'gpu_angle_unit_gtests',
    ],

    'gpu_angle_linux_gtests': [
      'gpu_angle_end2end_gtests',
      'gpu_angle_unit_gtests',
      'gpu_angle_white_box_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_gles2_conform_gtests',
    ],

    'gpu_angle_linux_intel_gtests': [
      'gpu_angle_deqp_gles2_gl_gtests',
      'gpu_angle_end2end_gtests',
      'gpu_angle_unit_gtests',
      'gpu_angle_white_box_gtests',
    ],

    'gpu_angle_linux_nvidia_gtests': [
      'gpu_angle_deqp_egl_gl_gtests',
      'gpu_angle_deqp_egl_vulkan_gtests',
      'gpu_angle_deqp_gles2_gl_gtests',
      'gpu_angle_deqp_gles2_vulkan_gtests',
      'gpu_angle_deqp_gles31_gl_gtests',
      'gpu_angle_deqp_gles31_vulkan_gtests',
      'gpu_angle_deqp_gles31_vulkan_rotate180_gtests',
      'gpu_angle_deqp_gles31_vulkan_rotate270_gtests',
      'gpu_angle_deqp_gles31_vulkan_rotate90_gtests',
      'gpu_angle_deqp_gles3_gl_gtests',
      'gpu_angle_deqp_gles3_vulkan_gtests',
      'gpu_angle_deqp_gles3_vulkan_rotate180_gtests',
      'gpu_angle_deqp_gles3_vulkan_rotate270_gtests',
      'gpu_angle_deqp_gles3_vulkan_rotate90_gtests',
      'gpu_angle_deqp_khr_gles2_vulkan_gtests',
      'gpu_angle_deqp_khr_gles31_vulkan_gtests',
      'gpu_angle_deqp_khr_gles32_vulkan_gtests',
      'gpu_angle_deqp_khr_gles3_vulkan_gtests',
      'gpu_angle_end2end_gtests',
      'gpu_angle_unit_gtests',
      'gpu_angle_white_box_gtests',
    ],

    'gpu_angle_linux_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_webgl2_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
    ],

    'gpu_angle_mac_passthrough_telemetry_tests': [
      'gpu_info_collection_telemetry_tests',
      'gpu_webgl2_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_metal_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_metal_passthrough_telemetry_tests',
      'gpu_webgl_conformance_swangle_passthrough_representative_telemetry_tests',
    ],

    'gpu_angle_mac_telemetry_tests': [
      'gpu_info_collection_telemetry_tests',
      'gpu_webgl2_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_metal_passthrough_telemetry_tests',
      'gpu_webgl_conformance_validating_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_metal_passthrough_telemetry_tests',
      'gpu_webgl_conformance_swangle_passthrough_representative_telemetry_tests',
    ],

    'gpu_angle_win7_nvidia_gtests': [
      'gpu_angle_end2end_gtests',
      'gpu_angle_unit_gtests',
      'gpu_angle_white_box_gtests',
      'gpu_angle_deqp_egl_d3d11_gtests',
      'gpu_angle_deqp_gles2_d3d11_gtests',
      'gpu_angle_deqp_gles3_d3d11_gtests',
    ],

    'gpu_angle_win_intel_gtests': [
      'gpu_angle_deqp_gles2_d3d11_gtests',
      'gpu_angle_end2end_gtests',
      'gpu_angle_unit_gtests',
      'gpu_angle_white_box_gtests',
    ],

    'gpu_angle_win_intel_nvidia_telemetry_tests': [
      'gpu_info_collection_telemetry_tests',
      'gpu_webgl2_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_vulkan_passthrough_telemetry_tests',
    ],

    'gpu_angle_win_nvidia_gtests': [
      'gpu_angle_deqp_egl_d3d11_gtests',
      'gpu_angle_deqp_egl_gl_gtests',
      'gpu_angle_deqp_egl_vulkan_gtests',
      'gpu_angle_deqp_gles2_d3d11_gtests',
      'gpu_angle_deqp_gles2_gl_gtests',
      'gpu_angle_deqp_gles2_vulkan_gtests',
      'gpu_angle_deqp_gles31_d3d11_gtests',
      'gpu_angle_deqp_gles31_gl_gtests',
      'gpu_angle_deqp_gles31_vulkan_gtests',
      'gpu_angle_deqp_gles31_vulkan_rotate180_gtests',
      'gpu_angle_deqp_gles31_vulkan_rotate270_gtests',
      'gpu_angle_deqp_gles31_vulkan_rotate90_gtests',
      'gpu_angle_deqp_gles3_d3d11_gtests',
      'gpu_angle_deqp_gles3_gl_gtests',
      'gpu_angle_deqp_gles3_vulkan_gtests',
      'gpu_angle_deqp_gles3_vulkan_rotate180_gtests',
      'gpu_angle_deqp_gles3_vulkan_rotate270_gtests',
      'gpu_angle_deqp_gles3_vulkan_rotate90_gtests',
      'gpu_angle_deqp_khr_gles2_vulkan_gtests',
      'gpu_angle_deqp_khr_gles31_vulkan_gtests',
      'gpu_angle_deqp_khr_gles32_vulkan_gtests',
      'gpu_angle_deqp_khr_gles3_vulkan_gtests',
      'gpu_angle_end2end_gtests',
      'gpu_angle_unit_gtests',
      'gpu_angle_white_box_gtests',
    ],

    'gpu_chromeos_telemetry_tests': [
      'gpu_webgl_conformance_telemetry_tests',
    ],

    'gpu_common_gl_passthrough_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
    ],

    'gpu_common_linux_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webgl_conformance_telemetry_tests',
    ],

    'gpu_common_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_validating_telemetry_tests',
      'gpu_webgl_conformance_telemetry_tests',
    ],

    'gpu_common_win_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
    ],

    'gpu_dawn_asan_isolated_scripts': [
      'gpu_dawn_perf_smoke_isolated_scripts',
      'gpu_webgpu_integration_isolated_scripts',
    ],

    'gpu_dawn_integration_asan_gtests_passthrough': [
      'gpu_dawn_gtests',
      'gpu_common_gtests_passthrough',
    ],

    # GPU gtests that test Dawn and integration with Chromium
    # These tests are run both on the CI and trybots which test DEPS Dawn.
    'gpu_dawn_integration_gtests_passthrough': [
      'gpu_dawn_gtests',
      'gpu_dawn_gtests_with_validation',
      'gpu_common_gtests_passthrough',
    ],

    # GPU gtests that test Dawn and integration with Chromium
    # These tests are run both on the CI and trybots which test DEPS Dawn.
    'gpu_dawn_integration_gtests_passthrough_win_intel': [
      'gpu_dawn_gtests',
      'gpu_dawn_gtests_with_partial_validation',
      'gpu_common_gtests_passthrough',
    ],

    'gpu_dawn_integration_gtests_validating': [
      'gpu_dawn_gtests',
      'gpu_dawn_gtests_with_validation',
      'gpu_common_gtests_validating',
    ],

    'gpu_dawn_isolated_scripts': [
      'gpu_dawn_perf_smoke_isolated_scripts',
      'gpu_webgpu_integration_isolated_scripts',
      'gpu_webgpu_integration_backend_validation_isolated_scripts',
    ],

    'gpu_dawn_isolated_scripts_win': [
      'gpu_dawn_perf_smoke_isolated_scripts',
      'gpu_webgpu_integration_isolated_scripts',
      'gpu_webgpu_integration_partial_backend_validation_isolated_scripts',
    ],

    'gpu_dawn_telemetry_cts_regular_and_partial_validation': [
      'gpu_dawn_telemetry_cts_tests',
      'gpu_dawn_telemetry_cts_tests_with_partial_validation',
    ],

    'gpu_dawn_telemetry_cts_regular_and_validation': [
      'gpu_dawn_telemetry_cts_tests',
      'gpu_dawn_telemetry_cts_tests_with_validation',
    ],

    'gpu_desktop_mac_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_common_gtests_validating',
      'gpu_desktop_specific_gtests',
    ],

    'gpu_desktop_passthrough_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_desktop_specific_gtests',
    ],

    'gpu_desktop_representative_perf_fyi_isolated_scripts': [
      'rendering_desktop_representative_perf_tests_isolated_scripts',
    ],

    'gpu_fuchsia_telemetry_experimental_tests': [
      'gpu_fuchsia_common_telemetry_tests',
      'gpu_mediapipe_validating_telemetry_tests',
    ],

    'gpu_fuchsia_telemetry_tests': [
      'gpu_validating_telemetry_tests',
    ],

    'gpu_fyi_android_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_validating',
      'gpu_fyi_and_optional_non_linux_gtests',
    ],

    'gpu_fyi_android_shieldtv_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_validating',
      'gpu_fyi_and_optional_non_linux_gtests',
    ],

    'gpu_fyi_android_webgl2_and_gold_telemetry_tests': [
      'gpu_validating_telemetry_tests',
      'gpu_webgl2_conformance_gles_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_validating_telemetry_tests',
    ],

    # TODO(crbug.com/1080424): Merge with an existing set of tests such as
    # gpu_fyi_linux_release_gtests once all CrOS tests have been enabled.
    'gpu_fyi_chromeos_release_gtests': [
      # TODO(crbug.com/1135720): Missing cros wrapper script.
      # 'gpu_angle_unit_gtests',
      # TODO(crbug.com/1087567, crbug.com/1087590): Enable once there are tests
      # that actually pass.
      # 'gpu_common_gtests',
      # TODO(crbug.com/1087563): Enable once tab_capture_end2end_tests passes
      # on CrOS.
      # 'gpu_desktop_specific_gtests',
      # CrOS should always have GL, and thus not fall back to SwiftShader. It's
      # currently unclear if we want to bother running any SwiftShader tests on
      # CrOS since it should never actually get used.
      # 'gpu_swiftshader_gtests',
    ],

    # TODO(crbug.com/1080424): Merge with an existing set of tests such as
    # gpu_fyi_linux_release_telemetry_tests once all CrOS tests
    # have been enabled.
    'gpu_fyi_chromeos_release_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_validating_telemetry_tests',
      'gpu_validating_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl_conformance_validating_telemetry_tests',
      'gpu_gl_renderer_full_telemetry_tests',
      # Large amounts of WebGL/WebGL2 tests are failing due to issues that are
      # possibly related to other CrOS issues that are already reported.
      # TODO(crbug.com/1080424): Try enabling these again once some of the
      # existing CrOS WebGL issues are resolved.
      'gpu_webgl2_conformance_gles_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_validating_telemetry_tests',
      # 'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
    ],

    'gpu_fyi_linux_debug_gtests': [
      'gpu_common_gtests_passthrough',
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
    ],

    'gpu_fyi_linux_debug_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
    ],

    'gpu_fyi_linux_optional_gtests': [
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
    ],

    'gpu_fyi_linux_release_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_desktop_specific_gtests',
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
    ],

    'gpu_fyi_linux_release_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
    ],

    # TODO(jonross): remove this once Vulkan Swiftshader and Vulkan GL interop
    # paths are merged. This should mirror
    # `gpu_fyi_linux_release_telemetry_tests` but with additional
    # `gpu_skia_renderer_vulkan_passthrough_telemetry_tests`
    'gpu_fyi_linux_release_vulkan_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_skia_renderer_vulkan_passthrough_telemetry_tests',
    ],

    'gpu_fyi_mac_debug_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_common_gtests_validating',
      'gpu_fyi_and_optional_non_linux_gtests',
      'gpu_fyi_mac_specific_gtests',
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
    ],

    'gpu_fyi_mac_debug_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_validating_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_validating_telemetry_tests',
    ],

    'gpu_fyi_mac_optional_gtests': [
      'gpu_fyi_and_optional_non_linux_gtests',
      'gpu_fyi_mac_specific_gtests',
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
    ],

    'gpu_fyi_mac_pro_release_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_validating_telemetry_tests',
      'gpu_webgl2_conformance_validating_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
    ],

    'gpu_fyi_mac_release_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_common_gtests_validating',
      'gpu_desktop_specific_gtests',
      'gpu_fyi_and_optional_non_linux_gtests',
      'gpu_fyi_mac_specific_gtests',
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
    ],

    'gpu_fyi_mac_release_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_mediapipe_validating_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_validating_telemetry_tests',
      'gpu_webgl2_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_metal_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_validating_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_metal_passthrough_telemetry_tests',
      'gpu_webgl_conformance_validating_telemetry_tests',
      'gpu_webgl_conformance_swangle_passthrough_representative_telemetry_tests',
    ],

    'gpu_fyi_optional_linux_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl2_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
    ],

    'gpu_fyi_optional_mac_passthrough_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl2_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_metal_passthrough_telemetry_tests',
      'gpu_webgl_conformance_swangle_passthrough_representative_telemetry_tests',
    ],

    'gpu_fyi_optional_mac_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_mediapipe_validating_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl2_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_validating_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_metal_passthrough_telemetry_tests',
      'gpu_webgl_conformance_swangle_passthrough_representative_telemetry_tests',
    ],

    'gpu_fyi_optional_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_mediapipe_validating_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl2_conformance_validating_telemetry_tests',
    ],

    'gpu_fyi_win7_amd_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_desktop_specific_gtests',
      'gpu_fyi_and_optional_non_linux_gtests',
      'gpu_fyi_and_optional_win_specific_gtests',
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
    ],

    'gpu_fyi_win7_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_desktop_specific_gtests',
      'gpu_fyi_and_optional_non_linux_gtests',
      'gpu_fyi_and_optional_win_specific_gtests',
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
    ],

    'gpu_fyi_win7_nvidia_amd_release_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl2_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
    ],

    'gpu_fyi_win_amd_release_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl2_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests',
    ],

    'gpu_fyi_win_debug_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_vulkan_passthrough_telemetry_tests',
    ],

    'gpu_fyi_win_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_default_and_optional_win_specific_gtests',
      'gpu_desktop_specific_gtests',
      'gpu_fyi_and_optional_non_linux_gtests',
      'gpu_fyi_and_optional_win_specific_gtests',
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
      'gpu_vulkan_gtests',
    ],

    'gpu_fyi_win_intel_release_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl2_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_vulkan_passthrough_telemetry_tests',
      'gpu_win_intel_specific_telemetry_tests',
    ],

    'gpu_fyi_win_optional_and_representative_perf_isolated_scripts': [
      'gpu_command_buffer_perf_passthrough_isolated_scripts',
      'rendering_desktop_representative_perf_tests_isolated_scripts',
    ],

    'gpu_fyi_win_optional_gtests': [
      'gpu_default_and_optional_win_specific_gtests',
      'gpu_fyi_and_optional_non_linux_gtests',
      'gpu_fyi_and_optional_win_specific_gtests',
      'gpu_gles2_conform_gtests',
      'gpu_swiftshader_gtests',
    ],

    'gpu_fyi_win_optional_isolated_scripts': [
      'gpu_command_buffer_perf_passthrough_isolated_scripts',
    ],

    'gpu_fyi_win_release_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests',
      'gpu_webgl_conformance_fast_call_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_vulkan_passthrough_telemetry_tests',
    ],

    'gpu_mobile_representative_perf_fyi_isolated_scripts': [
      'rendering_mobile_representative_perf_tests_isolated_scripts',
    ],

    'gpu_nexus5x_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_mediapipe_validating_telemetry_tests',
      'gpu_validating_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl_conformance_gles_passthrough_telemetry_tests',
      'gpu_webgl_conformance_validating_telemetry_tests',
    ],

    'gpu_nexus5x_telemetry_tests_v8': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_validating_telemetry_tests',
      'gpu_webgl_conformance_gles_passthrough_telemetry_tests',
      'gpu_webgl_conformance_validating_telemetry_tests',
    ],

    'gpu_optional_win_intel_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl2_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_vulkan_passthrough_telemetry_tests',
      'gpu_win_intel_specific_telemetry_tests',
    ],

    'gpu_optional_win_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl2_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests',
      'gpu_webgl_conformance_fast_call_passthrough_telemetry_tests',
      'gpu_webgl_conformance_gl_passthrough_telemetry_tests',
      'gpu_webgl_conformance_vulkan_passthrough_telemetry_tests',
    ],

    'gpu_pixel_4_and_6_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_mediapipe_passthrough_telemetry_tests',
      'gpu_mediapipe_validating_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_validating_telemetry_tests',
      'gpu_webcodecs_telemetry_test',
      'gpu_webgl_conformance_gles_passthrough_telemetry_tests',
      'gpu_webgl_conformance_validating_telemetry_tests',
      'gpu_webgl2_conformance_gles_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_validating_telemetry_tests',
    ],

    'gpu_swangle_telemetry_tests': [
      'gpu_webgl_conformance_swangle_passthrough_telemetry_tests',
    ],

    'gpu_test_buildbucket_api_gpu_use_cases': [
      'test_buildbucket_api_gpu_use_cases',
    ],

    'gpu_v8_desktop_passthrough_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_passthrough_telemetry_tests',
      'gpu_webgl2_conformance_telemetry_tests',
      'gpu_webgl_conformance_telemetry_tests',
    ],

    'gpu_v8_desktop_validating_telemetry_tests': [
      'gpu_common_and_optional_telemetry_tests',
      'gpu_validating_telemetry_tests',
      'gpu_webgl2_conformance_telemetry_tests',
      'gpu_webgl_conformance_telemetry_tests',
    ],

    'gpu_win_angle_amd_telemetry_tests': [
      'gpu_webgl_conformance_d3d11_passthrough_telemetry_tests',
      'gpu_webgl_conformance_d3d9_passthrough_telemetry_tests',
    ],

    'gpu_win_gtests': [
      'gpu_angle_unit_gtests',
      'gpu_common_gtests_passthrough',
      'gpu_default_and_optional_win_specific_gtests',
      'gpu_desktop_specific_gtests',
    ],

    # END composition test suites used by the GPU bots

    'linux_chromeos_gtests': [
      # This is:
      #   linux_chromium_gtests
      #   - non_android_and_cast_and_chromeos_chromium_gtests
      #   + linux_chromeos_lacros_gtests
      #   + linux_chromeos_specific_gtests
      'aura_gtests',
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_linux_and_chromeos_only',
      'chromium_gtests_for_win_and_linux_only',
      'linux_chromeos_lacros_gtests',
      'linux_chromeos_skia_renderer_specific_gtests',
      'linux_chromeos_specific_gtests',
      'linux_flavor_specific_chromium_gtests',
      'non_android_chromium_gtests',
    ],

    'linux_chromeos_gtests_oobe': [
      'aura_gtests',
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_linux_and_chromeos_only',
      'chromium_gtests_for_win_and_linux_only',
      'linux_chromeos_lacros_gtests',
      'linux_chromeos_oobe_specific_tests',
      'linux_chromeos_skia_renderer_specific_gtests',
      'linux_chromeos_specific_gtests',
      'linux_flavor_specific_chromium_gtests',
      'non_android_chromium_gtests',
    ],

    'linux_chromeos_specific_and_lacros_dependent_gtests': [
      # This is:
      #   linux_chromeos_gtests
      #   + 'linux_chromeos_browser_tests_require_lacros'
      'aura_gtests',
      'chromium_gtests',
      'chromium_gtests_for_devices_with_graphical_output',
      'chromium_gtests_for_linux_and_chromeos_only',
      'chromium_gtests_for_win_and_linux_only',
      'linux_chromeos_lacros_gtests',
      'linux_chromeos_skia_renderer_specific_gtests',
      'linux_chromeos_specific_gtests',
      'linux_chromeos_browser_tests_require_lacros',
      'linux_flavor_specific_chromium_gtests',
      'non_android_chromium_gtests',
    ],

    'linux_viz_gtests': [
      'gpu_fyi_vulkan_swiftshader_gtests',
    ],

    'marshmallow_nougat_pie_isolated_scripts_with_proguard': [
      'android_isolated_scripts',
      'components_perftests_isolated_scripts',
      'telemetry_android_minidump_unittests_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts_android',
    ],

    'marshmallow_pie_isolated_scripts': [
      'android_isolated_scripts',
      'components_perftests_isolated_scripts',
      'telemetry_android_minidump_unittests_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts_android',
    ],

    'mojo_android_gtests': [
    ],

    'mojo_chromiumos_fyi_gtests': [
      'aura_gtests',
      'mojo_chromiumos_specific_gtests',
    ],

    'mojo_linux_gtests': [
    ],

    'mojo_windows_gtests': [
      'mojo_windows_specific_gtests',
      'network_service_fyi_gtests',
    ],

    'monochrome_public_apk_checker_isolated_script_and_sizes': [
      'chrome_sizes_android',
      'monochrome_public_apk_checker_isolated_script',
    ],

    'network_service_extra_gtests': [
      'network_service_fyi_gtests',
    ],

    'nougat_isolated_scripts': [
      'android_isolated_scripts',
      'components_perftests_isolated_scripts',
      'monochrome_public_apk_checker_isolated_script',
      'telemetry_android_minidump_unittests_isolated_scripts',
      'telemetry_perf_unittests_isolated_scripts_android',
    ],

    'paeverywhere_mac_gtests': [
      'chromium_gtests_for_linux_and_mac_only',
      'mac_specific_chromium_gtests',
      'paeverywhere_common_tests',
    ],

    'sandboxed_chromium_memory_linux_gtests': [
      'chromium_browser_tests',
    ],

    'webrtc_android_tests_with_baremetal_tests': [
      'webrtc_chromium_simple_baremetal_gtests',
      'webrtc_chromium_simple_gtests',
    ],

    'webrtc_chromium_tests_with_baremetal_tests': [
      'webrtc_chromium_baremetal_gtests',
      'webrtc_chromium_gtests',
      'webrtc_chromium_simple_baremetal_gtests',
      'webrtc_chromium_simple_gtests',
    ],

    'webview_bot_all_gtests': [
      'system_webview_shell_instrumentation_tests',
      'webview_bot_instrumentation_test_apk_gtest',
      'webview_bot_instrumentation_test_apk_no_field_trial_gtest',
      'webview_bot_unittests_gtest',
      'webview_cts_tests_gtest',
      'webview_cts_tests_gtest_no_field_trial',
      'webview_ui_instrumentation_tests',
      'webview_ui_instrumentation_tests_no_field_trial',
    ],

    'webview_bot_system_gtests': [
      'system_webview_shell_instrumentation_tests',
      'webview_cts_tests_gtest',
      'webview_cts_tests_gtest_no_field_trial',
      'webview_ui_instrumentation_tests',
      'webview_ui_instrumentation_tests_no_field_trial',
    ],

    'win_specific_isolated_scripts_and_sizes': [
      'chrome_sizes',
      'win_specific_isolated_scripts',
    ],
  },

  ##############################################################################
  # Matrix compound test suites.                                               #
  ##############################################################################

  'matrix_compound_suites': {

    'android_weblayer_x86_10_gtests': {
      'weblayer_instrumentation_tests': {
        'variants': [
          {'identifier': 'ToT_Tests'}
        ]
      },
      'weblayer_skew_tests': {
        'variants': [
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_ONE_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_TWO_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_THREE_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_FOUR_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_FIVE_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_ONE_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_TWO_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_THREE_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_FOUR_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_FIVE_MILESTONE',
        ]
      }
    },

    'android_weblayer_x86_marshmallow_gtests': {
      'weblayer_skew_tests_with_chrome': {
        'variants': [
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_ONE_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_TWO_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_THREE_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_FOUR_MILESTONE',
          'WEBLAYER_10_AND_M_IMPL_SKEW_TESTS_NTH_MINUS_FIVE_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_ONE_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_TWO_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_THREE_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_FOUR_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_FIVE_MILESTONE',
        ]
      }
    },

    'android_weblayer_x86_pie_oreo_gtests': {
      'weblayer_instrumentation_tests': {
        'variants': [
          {'identifier': 'ToT_Tests'}
        ]
      },
      'weblayer_skew_tests': {
        'variants': [
          'WEBLAYER_IMPL_SKEW_TESTS_NTH_MILESTONE',
          'WEBLAYER_IMPL_SKEW_TESTS_NTH_MINUS_ONE_MILESTONE',
          'WEBLAYER_IMPL_SKEW_TESTS_NTH_MINUS_TWO_MILESTONE',
          'WEBLAYER_IMPL_SKEW_TESTS_NTH_MINUS_THREE_MILESTONE',
          'WEBLAYER_IMPL_SKEW_TESTS_NTH_MINUS_FOUR_MILESTONE',
          'WEBLAYER_IMPL_SKEW_TESTS_NTH_MINUS_FIVE_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_ONE_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_TWO_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_THREE_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_FOUR_MILESTONE',
          'WEBLAYER_CLIENT_SKEW_TESTS_NTH_MINUS_FIVE_MILESTONE',
        ]
      }
    },

    'gpu_angle_ios_gtests': {
      'gpu_angle_end2end_gtests': {
        'variants': [
          'SIM_IPHONE_X_14_4',
        ],
      },
      'gpu_angle_white_box_gtests': {
        'variants': [
          'SIM_IPHONE_X_14_4',
        ],
      },
    },

    'ios14_beta_simulator_tests': {
      'ios_common_tests': {
        'variants': [
          'SIM_IPHONE_X_14_5',
        ],
      },
      'ios_crash_unittests': {
        'variants': [
          'SIM_IPHONE_X_14_5',
        ],
      },
      'ios_eg2_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_X_14_5',
          'SIM_IPHONE_7_14_5',
          'SIM_IPAD_AIR_3RD_GEN_14_5',
          'SIM_IPAD_6_GEN_14_5',
        ]
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_7_14_5',
          'SIM_IPHONE_X_14_5',
          'SIM_IPAD_PRO_2ND_GEN_14_5',
          'SIM_IPAD_6_GEN_14_5',
        ]
      },
      'ios_screen_size_dependent_tests': {
        'variants': [
          'SIM_IPHONE_6S_PLUS_14_5',
          'SIM_IPHONE_X_14_5',
          'SIM_IPAD_AIR_2_14_5',
        ],
      },
    },

    'ios14_sdk_simulator_tests': {
      'ios_common_tests': {
        'variants': [
          # Latest beta iOS version Sims
          'SIM_IPHONE_6S_14_5',
        ],
      },
      'ios_crash_unittests': {
        'variants': [
          # Latest beta iOS version Sims
          'SIM_IPHONE_6S_14_5',
        ],
      },
      'ios_eg2_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          # Latest beta iOS version Sims
          'SIM_IPHONE_7_14_5',
          'SIM_IPAD_AIR_2_14_5',
          'SIM_IPHONE_X_14_5',
        ]
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          # Latest beta iOS version Sims
          'SIM_IPHONE_X_14_5',
          'SIM_IPAD_AIR_2_14_5',
          'SIM_IPAD_PRO_2ND_GEN_14_5',
        ]
      },
      'ios_screen_size_dependent_tests': {
        'variants': [
          # Latest beta iOS version Sims
          'SIM_IPHONE_6S_PLUS_14_5',
          'SIM_IPHONE_6S_14_5',
          'SIM_IPHONE_SE_1ST_GEN_14_5',
          'SIM_IPAD_AIR_2_14_5',
        ],
      },
    },

    'ios15_beta_simulator_tests': {
      'ios_common_tests': {
        'variants': [
          'SIM_IPHONE_6S_15_4',
          'SIM_IPHONE_6S_14_5',
        ],
      },
      'ios_crash_unittests': {
        'variants': [
          'SIM_IPHONE_6S_15_4',
          'SIM_IPHONE_6S_14_5',
        ],
      },
      'ios_eg2_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_7_15_4',
          'SIM_IPAD_AIR_2_15_4',
          'SIM_IPHONE_X_15_4',
          'SIM_IPHONE_7_14_5',
          'SIM_IPAD_AIR_2_14_5',
          'SIM_IPHONE_X_14_5',
        ]
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_7_15_4',
          'SIM_IPAD_AIR_2_15_4',
          'SIM_IPHONE_X_15_4',
          'SIM_IPHONE_7_14_5',
          'SIM_IPAD_AIR_2_14_5',
          'SIM_IPHONE_X_14_5',
        ]
      },
      'ios_screen_size_dependent_tests': {
        'variants': [
          'SIM_IPHONE_6S_PLUS_14_5',
          'SIM_IPHONE_6S_14_5',
          'SIM_IPHONE_SE_1ST_GEN_14_5',
          'SIM_IPAD_AIR_2_14_5',
          'SIM_IPHONE_6S_PLUS_15_4',
          'SIM_IPHONE_6S_15_4',
          'SIM_IPHONE_SE_1ST_GEN_15_4',
          'SIM_IPAD_AIR_2_15_4',
        ],
      },
      'ios_swift_interop_xcuitests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_X_15_4',
          'SIM_IPHONE_X_14_5',
        ],
      },
    },

    'ios15_sdk_simulator_tests': {
      'ios_common_tests': {
        'variants': [
          'SIM_IPHONE_6S_15_4',
          'SIM_IPHONE_6S_14_5',
        ],
      },
      'ios_crash_unittests': {
        'variants': [
          'SIM_IPHONE_6S_15_4',
          'SIM_IPHONE_6S_14_5',
        ],
      },
      'ios_eg2_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_7_15_4',
          'SIM_IPAD_AIR_2_15_4',
          'SIM_IPHONE_X_15_4',
          'SIM_IPHONE_7_14_5',
          'SIM_IPAD_AIR_2_14_5',
          'SIM_IPHONE_X_14_5',
        ]
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_7_15_4',
          'SIM_IPAD_AIR_2_15_4',
          'SIM_IPHONE_X_15_4',
          'SIM_IPHONE_7_14_5',
          'SIM_IPAD_AIR_2_14_5',
          'SIM_IPHONE_X_14_5',
        ]
      },
      'ios_screen_size_dependent_tests': {
        'variants': [
          'SIM_IPHONE_6S_PLUS_14_5',
          'SIM_IPHONE_6S_14_5',
          'SIM_IPHONE_SE_1ST_GEN_14_5',
          'SIM_IPAD_AIR_2_14_5',
          'SIM_IPHONE_6S_PLUS_15_4',
          'SIM_IPHONE_6S_15_4',
          'SIM_IPHONE_SE_1ST_GEN_15_4',
          'SIM_IPAD_AIR_2_15_4',
        ],
      },
    },

    'ios_asan_tests': {
      'ios_common_tests': {
        'variants': [
          'SIM_IPHONE_X_15_2',
          'SIM_IPAD_AIR_2_15_2',
        ]
      },
      'ios_crash_unittests': {
        'variants': [
          'SIM_IPHONE_X_15_2',
          'SIM_IPAD_AIR_2_15_2',
        ]
      },
      'ios_screen_size_dependent_tests': {
        'variants': [
          'SIM_IPHONE_X_15_2',
          'SIM_IPAD_AIR_2_15_2',
        ]
      }
    },

    'ios_clang_tot_device_tests': {
      'ios_clang_tests': {
        'variants': [
          'IPHONE_6S_12_3_1',
        ],
      }
    },

    'ios_clang_tot_sim_tests': {
      'ios_clang_tests': {
        'variants': [
          'SIM_IPHONE_6S_15_2',
        ]
      }
    },

    # This suite is a union of ios_simulator_tests and
    # ios_simulator_full_configs_tests.
    'ios_code_coverage_tests': {
      'ios_common_tests': {
        'variants': [
          'SIM_IPHONE_6S_15_2',
          'SIM_IPHONE_6S_14_4',
        ],
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_6S_15_2',
          'SIM_IPHONE_7_15_2',
          'SIM_IPAD_AIR_2_15_2',
          'SIM_IPHONE_6S_14_4',
          'SIM_IPHONE_7_14_4',
          'SIM_IPAD_AIR_2_14_4',
        ],
      },
      'ios_eg2_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_7_15_2',
          'SIM_IPAD_AIR_2_15_2',
          'SIM_IPHONE_X_15_2',
          'SIM_IPHONE_7_14_4',
          'SIM_IPAD_AIR_2_14_4',
          'SIM_IPHONE_X_14_4',
        ],
      },
      'ios_screen_size_dependent_tests': {
        'variants': [
          'SIM_IPHONE_6S_PLUS_15_2',
          'SIM_IPHONE_6S_15_2',
          'SIM_IPHONE_SE_1ST_GEN_15_2',
          'SIM_IPAD_AIR_2_15_2',
          'SIM_IPHONE_6S_PLUS_14_4',
          'SIM_IPHONE_6S_14_4',
          'SIM_IPHONE_SE_1ST_GEN_14_4',
          'SIM_IPAD_AIR_2_14_4',
        ],
      },
    },

    'ios_simulator_cronet_tests': {
      'ios_cronet_tests': {
        'variants': [
          'SIM_IPHONE_X_15_2',
        ]
      }
    },

    # Please also change ios_code_coverage_tests for any change in this suite.
    'ios_simulator_full_configs_tests': {
      'ios_eg2_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_7_15_2',
          'SIM_IPAD_AIR_2_15_2',
          'SIM_IPHONE_X_15_2',
          'SIM_IPHONE_7_14_4',
          'SIM_IPAD_AIR_2_14_4',
          'SIM_IPHONE_X_14_4',
        ]
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_7_15_2',
          'SIM_IPAD_AIR_2_15_2',
          'SIM_IPHONE_7_14_4',
          'SIM_IPAD_AIR_2_14_4',
        ]
      }
    },

    'ios_simulator_multi_window_tests': {
      'ios_common_tests': {
        'variants': [
          'SIM_IPAD_AIR_2_15_2',
        ]
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPAD_AIR_2_15_2',
        ]
      },
      'ios_eg2_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPAD_AIR_2_15_2',
        ]
      },
      'ios_screen_size_dependent_tests': {
        'variants': [
          'SIM_IPAD_AIR_2_15_2',
        ]
      }
    },

    'ios_simulator_noncq_tests': {
      'ios_common_tests': {
        'variants': [
          'SIM_IPHONE_6S_14_4',
        ]
      },
      'ios_eg2_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_6S_14_4',
        ]
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_6S_PLUS_14_4',
          'SIM_IPHONE_6S_14_4',
          'SIM_IPHONE_SE_1ST_GEN_14_4',
          'SIM_IPAD_AIR_2_14_4',
        ]
      },
      'ios_crash_xcuitests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_7_15_2',
          'SIM_IPHONE_7_14_4',
        ]
      },
    },

    # Please also change ios_code_coverage_tests for any change in this suite.
    'ios_simulator_tests': {
      'ios_common_tests': {
        'variants': [
          'SIM_IPHONE_6S_14_4',
          'SIM_IPHONE_6S_15_2',
        ]
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_6S_14_4',
          'SIM_IPHONE_6S_15_2',
        ]
      },
      'ios_screen_size_dependent_tests': {
        'variants': [
          'SIM_IPHONE_6S_PLUS_15_2',
          'SIM_IPHONE_6S_15_2',
          'SIM_IPHONE_SE_1ST_GEN_15_2',
          'SIM_IPAD_AIR_2_15_2',
          'SIM_IPHONE_6S_PLUS_14_4',
          'SIM_IPHONE_6S_14_4',
          'SIM_IPHONE_SE_1ST_GEN_14_4',
          'SIM_IPAD_AIR_2_14_4'
        ]
      }
    },

    'ios_webkit_tot_tests': {
      'ios_common_tests': {
        'variants': [
          'SIM_IPHONE_X_15_0',
          'SIM_IPAD_AIR_2_15_0',
        ]
      },
      'ios_eg2_cq_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_X_15_0',
          'SIM_IPAD_AIR_2_15_0',
        ]
      },
      'ios_eg2_tests': {
        'mixins': ['xcode_parallelization'],
        'variants': [
          'SIM_IPHONE_X_15_0',
          'SIM_IPAD_AIR_2_15_0',
        ]
      },
      'ios_screen_size_dependent_tests': {
        'variants': [
          'SIM_IPHONE_X_15_0',
          'SIM_IPAD_AIR_2_15_0',
        ]
      },
    },

    'ios_webrtc_fyi_tests': {
      'ios_remoting_fyi_unittests': {
        'variants': [
          'SIM_IPHONE_X_14_5',
          'SIM_IPAD_AIR_3RD_GEN_14_5',
        ]
      },
    },

    'lacros_all_tast_tests_eve': {
      'lacros_all_tast_tests': {
        'variants': [
          'LACROS_EVE',
        ]
      },
    },

    'lacros_amd64_generic_rel_skylab_fyi': {
      'lacros_skylab_poc': {
        'variants': [
          'CROS_OCTOPUS_FULL',
          'CROS_EVE_FULL',
        ]
      },
    },

    'lacros_device_or_vm_tests': {
      'lacros_all_tast_tests': {
        'variants': [
          'LACROS_AMD64_GENERIC',
          'LACROS_EVE',
        ]
      },
      'lacros_device_or_vm_gtests': {
        'variants': [
          'LACROS_AMD64_GENERIC',
          'LACROS_EVE',
        ]
      },
    },

    'lacros_device_or_vm_tests_fyi': {
      'lacros_all_tast_tests_informational': {
        'variants': [
          'LACROS_AMD64_GENERIC',
          'LACROS_EVE',
        ]
      },
      'lacros_device_or_vm_gtests': {
        'variants': [
          'LACROS_AMD64_GENERIC',
          'LACROS_EVE',
        ]
      },
      'lacros_fyi_tast_tests': {
        'variants': [
          'LACROS_AMD64_GENERIC',
          'LACROS_EVE',
        ]
      },
    },

    # Check go/lacros-on-skylab for details of Skylab configurations.
    'lacros_skylab_arm': {
      'lacros_skylab_arm_tests': {
        'variants': [
          'CROS_KEVIN_RELEASE_LKGM',
          'CROS_HANA_RELEASE_LKGM',
        ]
      },
    },

    # Check go/lacros-on-skylab for details of Skylab configurations.
    'lacros_skylab_arm_fyi': {
      'lacros_skylab_arm_tests_fyi': {
        'variants': [
          'CROS_KEVIN_RELEASE_LKGM',
          'CROS_HANA_RELEASE_LKGM',
        ]
      },
    },

    # Check go/lacros-on-skylab for details of Skylab configurations.
    'lacros_skylab_tests_amd64_generic': {
      'lacros_skylab_tests': {
        'variants': [
          'CROS_ATLAS_RELEASE_LKGM',
          'CROS_ATLAS_RELEASE_DEV',
          'CROS_ATLAS_RELEASE_BETA',
          'CROS_ATLAS_RELEASE_STABLE',
          'CROS_EVE_RELEASE_LKGM',
          'CROS_EVE_RELEASE_DEV',
          'CROS_EVE_RELEASE_BETA',
          'CROS_EVE_RELEASE_STABLE',
        ]
      },
    },

    'lacros_skylab_tests_amd64_generic_fyi': {
      'lacros_skylab_poc': {
        'variants': [
          'CROS_OCTOPUS_RELEASE_LKGM',
          'CROS_OCTOPUS_RELEASE_DEV',
          'CROS_OCTOPUS_RELEASE_BETA',
          'CROS_OCTOPUS_RELEASE_STABLE',
        ]
      },
    },

    'linux_lacros_gtests': {
      # This is:
      #   linux_chromeos_gtests
      #   - linux_chromeos_specific_gtests
      #   + linux_chromeos_lacros_gtests
      #   + linux_lacros_chrome_browsertests_version_skew
      #   + linux_lacros_specific_gtests
      'aura_gtests': {},
      'chromium_gtests': {},
      'chromium_gtests_for_devices_with_graphical_output': {},
      'chromium_gtests_for_linux_and_chromeos_only': {},
      'chromium_gtests_for_win_and_linux_only': {},
      'linux_chromeos_lacros_gtests': { },
      'linux_flavor_specific_chromium_gtests': {  },
      'linux_lacros_specific_gtests': {  },
      'non_android_chromium_gtests': {
      },
      'linux_lacros_chrome_browsertests_version_skew': {
        'variants': [
          'LACROS_TOT',
          'LACROS_VERSION_SKEW_CANARY',
          'LACROS_VERSION_SKEW_DEV',
          'LACROS_VERSION_SKEW_BETA',
          'LACROS_VERSION_SKEW_STABLE',
        ]
      },
    },

    'linux_lacros_version_skew_tests': {
      'linux_lacros_chrome_browsertests_version_skew': {
        'variants': [
          'LACROS_VERSION_SKEW_CANARY',
          'LACROS_VERSION_SKEW_DEV',
          'LACROS_VERSION_SKEW_BETA',
          'LACROS_VERSION_SKEW_STABLE',
        ]
      },
    },
  }
}