Revert of Updating swarming api to check for chartjson results from a finished

scripts/slave/recipe_modules/test_utils/test_api.py

 import json
 
 from recipe_engine import recipe_test_api
 
 from .util import GTestResults, TestResults
 
 class TestUtilsTestApi(recipe_test_api.RecipeTestApi):
   @recipe_test_api.placeholder_step_data
   def test_results(self, test_results, retcode=None):
     return self.m.json.output(test_results.as_jsonish(), retcode)
@@ skipping 98 matching lines @@
   def raw_gtest_output(self, jsonish, retcode):
     t = GTestResults(jsonish)
     ret = self.gtest_results(t)
     ret.retcode = retcode
     return ret
 
   def canned_isolated_script_output(self, passing, is_win, swarming=False,
                                     shards=1, swarming_internal_failure=False,
                                     isolated_script_passing=True, valid=True,
                                     missing_shards=[],
-                                    empty_shards=[],
-                                    output_chartjson=False):
+                                    empty_shards=[]):
     """Produces a test results' compatible json for isolated script tests. """
     per_shard_results = []
-    per_shard_chartjson_results = []
     for i in xrange(shards):
       jsonish_results = {}
-      chartjsonish_results = {}
       jsonish_results['valid'] = valid
       # Keep shard 0's results equivalent to the old code to minimize
       # expectation diffs.
       idx = 1 + (2 * i)
       tests_run = ['test%d.Test%d' % (idx, idx),
                    'test%d.Test%d' % (idx + 1, idx + 1)]
       if isolated_script_passing:
         jsonish_results['failures'] = []
         jsonish_results['successes'] = tests_run
       else:
         jsonish_results['failures'] = tests_run
         jsonish_results['successes'] = []
       jsonish_results['times'] = {t : 0.1 for t in tests_run}
-      chartjsonish_results['dummy'] =  'dummy%d' % i
-      chartjsonish_results['charts'] = {'entry%d' % idx: 'chart%d' % idx,
-        'entry%d' % (idx + 1): 'chart%d' % (idx + 1)}
       per_shard_results.append(jsonish_results)
-      per_shard_chartjson_results.append(chartjsonish_results)
     if swarming:
       jsonish_shards = []
       files_dict = {}
       for i in xrange(shards):
         jsonish_shards.append({
           'failure': not passing,
           'internal_failure': swarming_internal_failure
         })
-        swarming_path = str(i)
-        swarming_path += '\\output.json' if is_win else '/output.json'
-
-        chartjson_swarming_path = str(i)
-        chartjson_swarming_path += \
-          '\\chartjson-output.json' \
-            if is_win else '/chartjson-output.json'
-
-        # Determine what output we are writing and if it is empty or not
-        output_missing = i in missing_shards and not output_chartjson
-        chartjson_output_missing = i in missing_shards and output_chartjson
-        output_empty = i in empty_shards and not output_chartjson
-        chartjson_output_empty = i in empty_shards and output_chartjson
-
-        if not output_missing:
-          files_dict[swarming_path] = \
-            '' if output_empty else json.dumps(per_shard_results[i])
-        if not chartjson_output_missing and output_chartjson:
-          files_dict[chartjson_swarming_path] = \
-            '' if chartjson_output_empty \
-              else json.dumps(per_shard_chartjson_results[i])
-
+        if i not in missing_shards:
+          swarming_path = str(i)
+          swarming_path += '\\output.json' if is_win else '/output.json'
+          if i not in empty_shards:
+            files_dict[swarming_path] = json.dumps(per_shard_results[i])
+          else:
+            # Simulate a complete harness failure.
+            files_dict[swarming_path] = ''
       jsonish_summary = {'shards': jsonish_shards}
       files_dict['summary.json'] = json.dumps(jsonish_summary)
       return self.m.raw_io.output_dir(files_dict)
     else:
       return self.m.json.output(per_shard_results[0])