Removed tryserver.chromium.gpu and related references

scripts/slave/recipe_modules/chromium/steps.py

 # Copyright 2014 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.
 
-import json
 import re
 
 
 class Test(object):
   """
   Base class for tests that can be retried after deapplying a previously
   applied patch.
   """
 
   def __init__(self):
@@ skipping 247 matching lines @@
       elif self._use_isolate:
         api.isolate.runtest(self.target_name, self._revision,
                             self._webkit_revision, **kwargs)
       else:
         api.chromium.runtest(self.target_name, revision=self._revision,
                              webkit_revision=self._webkit_revision, **kwargs)
     finally:
       step_result = api.step.active_result
       self._test_runs[suffix] = step_result
 
-      r = step_result.test_utils.gtest_results
-      p = step_result.presentation
+      if hasattr(step_result, 'test_utils'):
+        r = step_result.test_utils.gtest_results
+        p = step_result.presentation
 
-      if r.valid:
-        p.step_text += api.test_utils.format_step_text([
+        if r.valid:
+          p.step_text += api.test_utils.format_step_text([
             ['failures:', r.failures]
-        ])
+          ])
 
     return step_result
 
   def has_valid_results(self, api, suffix):
     if suffix not in self._test_runs:
       return False
+    if not hasattr(self._test_runs[suffix], 'test_utils'):
+      return False
     gtest_results = self._test_runs[suffix].test_utils.gtest_results
     if not gtest_results.valid:  # pragma: no cover
       return False
     global_tags = gtest_results.raw.get('global_tags', [])
     return 'UNRELIABLE_RESULTS' not in global_tags
 
   def failures(self, api, suffix):
     return self._test_runs[suffix].test_utils.gtest_results.failures
 
 
@@ skipping 270 matching lines @@
       args.append('--gtest_filter=%s' % ':'.join(failed_tests))
 
     return api.swarming.gtest_task(
         title=self._step_name(suffix),
         isolated_hash=isolated_hash,
         shards=self._shards,
         test_launcher_summary_output=api.test_utils.gtest_results(add_json_log=False),
         extra_args=args)
 
   def validate_task_results(self, api, step_result):
+    if not hasattr(step_result, 'test_utils'):
+      return False, None
+
     gtest_results = step_result.test_utils.gtest_results
     if not gtest_results:
       return False, None
 
     global_tags = gtest_results.raw.get('global_tags', [])
     if 'UNRELIABLE_RESULTS' in global_tags:
       return False, None
 
     return True, gtest_results.failures
 
@@ skipping 70 matching lines @@
       cmd_args.extend(self.failures(api, 'with patch'))
 
     try:
       self.run_step(
           api,
           suffix,
           cmd_args,
           step_test_data=lambda: api.test_utils.test_api.canned_test_output(True))
     finally:
       step_result = api.step.active_result
-      r = step_result.test_utils.test_results
-      p = step_result.presentation
-      p.step_text += api.test_utils.format_step_text([
-        ['unexpected_failures:', r.unexpected_failures.keys()],
-      ])
       self._test_runs[suffix] = step_result
 
+      if hasattr(step_result, 'test_utils'):
+        r = step_result.test_utils.test_results
+        p = step_result.presentation
+        p.step_text += api.test_utils.format_step_text([
+          ['unexpected_failures:', r.unexpected_failures.keys()],
+        ])
+
     return step_result
 
   def has_valid_results(self, api, suffix):
     # TODO(dpranke): we should just return zero/nonzero for success/fail.
     # crbug.com/357866
     step = self._test_runs[suffix]
+    if not hasattr(step, 'test_utils'):
+      return False
     return (step.test_utils.test_results.valid and
             step.retcode <= step.test_utils.test_results.MAX_FAILURES_EXIT_STATUS and
             (step.retcode == 0) or self.failures(api, suffix))
 
   def failures(self, api, suffix):
     return self._test_runs[suffix].test_utils.test_results.unexpected_failures
 
 
 class PrintPreviewTests(PythonBasedTest):  # pylint: disable=W032
   name = 'print_preview_tests'
@@ skipping 164 matching lines @@
       step_result = api.step.active_result
       self._test_runs[suffix] = step_result
 
       try:
         res = api.json.loads(step_result.raw_io.output_dir['results.json'])
         self._failures[suffix] = [res['pages'][str(value['page_id'])]['name']
                                   for value in res['per_page_values']
                                   if value['type'] == 'failure']
 
         self._valid[suffix] = True
-      except (ValueError, KeyError):
+      except (ValueError, KeyError, AttributeError):
         self._valid[suffix] = False
 
       if self._valid[suffix]:
         step_result.presentation.step_text += api.test_utils.format_step_text([
           ['failures:', self._failures[suffix]]
         ])
 
   def has_valid_results(self, api, suffix):
     return suffix in self._valid and self._valid[suffix]
 
@@ skipping 63 matching lines @@
     self.compile_target = compile_target
 
     self.test_data = test_data
     self.adb_install_apk = adb_install_apk
     self.isolate_file_path = isolate_file_path
 
   @property
   def name(self):
     return self._name
 
-  def _get_failing_tests(self, json_results):
+  def _get_failing_tests(self, step_result):
     """Parses test results and returns a list of failed tests.
 
     Args:
-      json_results: Parsed JSON output file returned from the test runner.
+      step_result: Result returned from the test.
 
     Returns:
       None if results are invalid, a list of failures otherwise (may be empty).
     """
     try:
       # Extract test results.
+      json_results = step_result.json.output
       test_results = {test_name: test_data[0]['status']
                       for result_dict in json_results['per_iteration_data']
                       for test_name, test_data in result_dict.iteritems()}
 
       # TODO(sergiyb): Figure out how to handle status UNKNOWN.
       return [test_name for test_name, test_status in test_results.iteritems()
                         if test_status not in ['SUCCESS', 'SKIPPED']]
-    except (KeyError, IndexError, TypeError):
+    except (KeyError, IndexError, TypeError, AttributeError):
       return None
 
   def run(self, api, suffix):
     assert api.chromium.c.TARGET_PLATFORM == 'android'
     if self.adb_install_apk:
       api.chromium_android.adb_install_apk(
           self.adb_install_apk[0], self.adb_install_apk[1])
 
     mock_test_results = {
       'per_iteration_data': [{'TestA': [{'status': 'SUCCESS'}]},
                              {'TestB': [{'status': 'FAILURE'}]}]
     }
 
     try:
       api.chromium_android.run_instrumentation_suite(
           self.name, test_data=self.test_data, suffix=suffix,
           flakiness_dashboard='http://test-results.appspot.com',
           verbose=True, isolate_file_path=self.isolate_file_path,
           json_results_file=api.json.output(add_json_log=False),
           step_test_data=lambda: api.json.test_api.output(mock_test_results))
     finally:
       step_result = api.step.active_result
-      failures = self._get_failing_tests(step_result.json.output)
+      failures = self._get_failing_tests(step_result)
+
       if failures is None:
         self._test_runs[suffix] = {'valid': False}
       else:
         self._test_runs[suffix] = {'valid': True, 'failures': failures}
 
         step_result.presentation.step_text += api.test_utils.format_step_text([
           ['failures:', failures]
         ])
 
   def compile_targets(self, _):
@@ skipping 145 matching lines @@
   GTestTest('crypto_unittests'),
   GTestTest('gfx_unittests'),
   GTestTest('url_unittests'),
   GTestTest('content_unittests'),
   GTestTest('net_unittests'),
   GTestTest('ui_base_unittests'),
   GTestTest('ui_ios_unittests'),
   GTestTest('sync_unit_tests'),
   GTestTest('sql_unittests'),
 ]