Switch webgl2_conformance_tests to new harness, and shard them.

content/test/gpu/generate_buildbot_json.py

 #!/usr/bin/env python
 # Copyright 2016 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.
 
 """Script to generate chromium.gpu.json and chromium.gpu.fyi.json in
 the src/testing/buildbot directory. Maintaining these files by hand is
 too unwieldy.
 """
 
@@ skipping 867 matching lines @@
       {
         'fyi_only': True,
         'os_types': ['linux']
       }
     ],
     'target_name': 'webgl_conformance',
     'extra_browser_args': [
       '--use-gl=angle',
     ],
   },
+}
+
+# These tests use Telemetry's new, simpler, browser_test_runner.
+# Eventually all of the Telemetry based tests above will be ported to
+# this harness, and the old harness will be deleted.
+TELEMETRY_GPU_INTEGRATION_TESTS = {
   'webgl2_conformance_tests': {
     'tester_configs': [
       {
          # The WebGL 2.0 conformance tests take over an hour to run on
          # the Debug bots, which is too long.
         'build_configs': ['Release', 'Release_x64'],
         'fyi_only': True,
         'run_on_optional': True,
       },
     ],
     'disabled_tester_configs': [
       {
         'names': [
           # http://crbug.com/599451: this test is currently too slow
           # to run on x64 in Debug mode. Need to shard the tests.
           'Win7 x64 Debug (NVIDIA)',
           # http://crbug.com/540543: Linux Intel driver is GL 3.0 and
           # doesn't support features needed for ES3
           'Linux Release (New Intel)',
           'Linux Debug (New Intel)',
         ],
       },
     ],
     'target_name': 'webgl_conformance',
     'args': [
       '--webgl-conformance-version=2.0.0',
       '--webgl2-only=true',
     ],
+    'swarming': {
+      # These tests currently take about an hour to run. Split them
+      # into roughly 5-minute shards.
+      'shards': 12,
+    },
   },
   'webgl2_conformance_angle_tests': {
     'tester_configs': [
       {
          # The WebGL 2.0 conformance tests take over an hour to run on
          # the Debug bots, which is too long.
         'build_configs': ['Release'],
         'fyi_only': True,
         'run_on_optional': False,
         # Only run on the NVIDIA Release and New Intel Release Linux bots
@@ skipping 10 matching lines @@
       },
     ],
     'target_name': 'webgl_conformance',
     'extra_browser_args': [
       '--use-gl=angle',
     ],
     'args': [
       '--webgl-conformance-version=2.0.0',
       '--webgl2-only=true',
     ],
+    'swarming': {
+      # These tests currently take about an hour to run. Split them
+      # into roughly 5-minute shards.
+      'shards': 12,
+    },
   },
 }
 
 def substitute_args(tester_config, args):
   """Substitutes the ${os_type} variable in |args| from the
      tester_config's "os_type" property.
   """
   substitutions = {
     'os_type': tester_config['os_type']
   }
@@ skipping 97 matching lines @@
     result.pop('desktop_args')
 
   # This flag only has an effect on the Linux bots that run tests
   # locally (as opposed to via Swarming), which are only those couple
   # on the chromium.gpu.fyi waterfall. Still, there is no harm in
   # specifying it everywhere.
   result['use_xvfb'] = False
   return result
 
 def generate_telemetry_test(tester_name, tester_config,
-                            test, test_config, is_fyi):
+                            test, test_config, is_fyi,
+                            use_gpu_integration_test_harness):
   if not should_run_on_tester(tester_name, tester_config, test_config, is_fyi):
     return None
   test_args = ['-v']
   # --expose-gc allows the WebGL conformance tests to more reliably
   # reproduce GC-related bugs in the V8 bindings.
   extra_browser_args_string = (
       '--enable-logging=stderr --js-flags=--expose-gc')
   if 'extra_browser_args' in test_config:
     extra_browser_args_string += ' ' + ' '.join(
         test_config['extra_browser_args'])
@@ skipping 10 matching lines @@
   step_name = test
   if not (step_name.endswith('test') or step_name.endswith('tests')):
     step_name = '%s_tests' % step_name
   # Prepend Telemetry GPU-specific flags.
   benchmark_name = test_config.get('target_name') or test
   prefix_args = [
     benchmark_name,
     '--show-stdout',
     '--browser=%s' % tester_config['build_config'].lower()
   ]
+  swarming = {
+    # Always say this is true regardless of whether the tester
+    # supports swarming. It doesn't hurt.
+    'can_use_on_swarming_builders': True,
+    'dimension_sets': [
+      tester_config['swarming_dimensions']
+    ]
+  }
+  if 'swarming' in test_config:
+    swarming.update(test_config['swarming'])
   result = {
     'args': prefix_args + test_args,
-    'isolate_name': 'telemetry_gpu_test',
+    'isolate_name': (
+      'telemetry_gpu_integration_test' if use_gpu_integration_test_harness
+      else 'telemetry_gpu_test'),
     'name': step_name,
     'override_compile_targets': [
-      'telemetry_gpu_test_run'
+      ('telemetry_gpu_integration_test_run' if use_gpu_integration_test_harness
+       else 'telemetry_gpu_test_run')
     ],
-    'swarming': {
-      # Always say this is true regardless of whether the tester
-      # supports swarming. It doesn't hurt.
-      'can_use_on_swarming_builders': True,
-      'dimension_sets': [
-        tester_config['swarming_dimensions']
-      ]
-    },
+    'swarming': swarming,
   }
   if 'non_precommit_args' in test_config:
     result['non_precommit_args'] = test_config['non_precommit_args']
   if 'precommit_args' in test_config:
     result['precommit_args'] = test_config['precommit_args']
   return result
 
 def generate_gtests(tester_name, tester_config, test_dictionary, is_fyi):
   # The relative ordering of some of the tests is important to
   # minimize differences compared to the handwritten JSON files, since
   # Python's sorts are stable and there are some tests with the same
   # key (see gles2_conform_d3d9_test and similar variants). Avoid
   # losing the order by avoiding coalescing the dictionaries into one.
   gtests = []
   for test_name, test_config in sorted(test_dictionary.iteritems()):
     test = generate_gtest(tester_name, tester_config,
                           test_name, test_config, is_fyi)
     if test:
       # generate_gtest may veto the test generation on this platform.
       gtests.append(test)
   return gtests
 
 def generate_telemetry_tests(tester_name, tester_config,
-                             test_dictionary, is_fyi):
+                             test_dictionary, is_fyi,
+                             use_gpu_integration_test_harness):
   isolated_scripts = []
   for test_name, test_config in sorted(test_dictionary.iteritems()):
     test = generate_telemetry_test(
-        tester_name, tester_config, test_name, test_config, is_fyi)
+      tester_name, tester_config, test_name, test_config, is_fyi,
+      use_gpu_integration_test_harness)
     if test:
       isolated_scripts.append(test)
   return isolated_scripts
 
 def generate_all_tests(waterfall, is_fyi):
   tests = {}
   for builder in waterfall['builders']:
     tests[builder] = {}
   for name, config in waterfall['testers'].iteritems():
     gtests = generate_gtests(name, config, COMMON_GTESTS, is_fyi)
     isolated_scripts = \
-        generate_telemetry_tests(name, config, TELEMETRY_TESTS, is_fyi)
+      generate_telemetry_tests(name, config, TELEMETRY_TESTS, is_fyi, False) + \
+      generate_telemetry_tests(name, config, TELEMETRY_GPU_INTEGRATION_TESTS,
+                               is_fyi, True)
     tests[name] = {
       'gtest_tests': sorted(gtests, key=lambda x: x['test']),
       'isolated_scripts': sorted(isolated_scripts, key=lambda x: x['name'])
     }
   tests['AAAAA1 AUTOGENERATED FILE DO NOT EDIT'] = {}
   tests['AAAAA2 See generate_buildbot_json.py to make changes'] = {}
   filename = 'chromium.gpu.fyi.json' if is_fyi else 'chromium.gpu.json'
   with open(os.path.join(SRC_DIR, 'testing', 'buildbot', filename), 'w') as fp:
     json.dump(tests, fp, indent=2, separators=(',', ': '), sort_keys=True)
     fp.write('\n')
 
 def main():
   generate_all_tests(FYI_WATERFALL, True)
   generate_all_tests(WATERFALL, False)
   return 0
 
 if __name__ == "__main__":
   sys.exit(main())