Convert Coverage flavor and bot to Swarming

scripts/slave/recipe_modules/skia/api.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 os
 import re
 import sys
 
@@ skipping 181 matching lines @@
     if self.running_in_swarming:
       self.swarming_out_dir = self.m.properties['swarm_out_dir']
       self.out_dir = self.slave_dir.join('out')
       self.local_skp_dir = self.slave_dir.join('skps')
     else:
       self.out_dir = self.m.path['checkout'].join('out', self.builder_name)
       self.local_skp_dir = self.slave_dir.join('playback', 'skps')
     self.tmp_dir = self.m.path['slave_build'].join('tmp')
 
     self.gsutil_env_chromium_skia_gm = self.gsutil_env(BOTO_CHROMIUM_SKIA_GM)
-    # TODO(borenet): This works on GCE instance because we fall back on
-    # service account auth. What about our local bots?
-    self.gsutil_env_skia_infra = self.gsutil_env(None)
 
     self.device_dirs = None
     self._ccache = None
     self._checked_for_ccache = False
     self.configuration = self.builder_spec['configuration']
     self.default_env.update({'SKIA_OUT': self.out_dir,
                              'BUILDTYPE': self.configuration})
     self.default_env.update(self.builder_spec['env'])
     self.build_targets = [str(t) for t in self.builder_spec['build_targets']]
     if 'Android' in self.builder_name and self.running_in_swarming:
       # TODO(borenet): Make the app build work on Swarming and remove this.
       self.build_targets = ['dm', 'nanobench']
+    self.do_compile_steps = self.builder_spec.get('do_compile_steps', True)
     self.do_test_steps = self.builder_spec['do_test_steps']
     self.do_perf_steps = self.builder_spec['do_perf_steps']
     self.is_trybot = self.builder_cfg['is_trybot']
     self.upload_dm_results = self.builder_spec['upload_dm_results']
     self.upload_perf_results = self.builder_spec['upload_perf_results']
     if self.running_in_swarming:
       self.dm_dir = self.m.path.join(
           self.swarming_out_dir, 'dm')
       self.perf_data_dir = self.m.path.join(self.swarming_out_dir,
           'perfdata', self.builder_name, 'data')
     else:
       self.dm_dir = self.slave_dir.join('dm')
       self.perf_data_dir = self.slave_dir.join('perfdata', self.builder_name,
                                                'data')
     self.dm_flags = self.builder_spec['dm_flags']
     self.nanobench_flags = self.builder_spec['nanobench_flags']
 
     self.flavor = self.get_flavor(self.builder_cfg)
 
   def run_steps(self):
     """Compile, run tests, perf, etc."""
-    self.compile_steps()
+    if self.do_compile_steps:
+      self.compile_steps()
     if self.do_test_steps:
       self.test_steps()
     if self.do_perf_steps:
       self.perf_steps()
 
     if self.do_test_steps or self.do_perf_steps:
       self.cleanup_steps()
 
     if self.failed:
       raise self.m.step.StepFailure('Failed build steps: %s' %
@@ skipping 139 matching lines @@
     env = dict(env or {})
     env.update(self.default_env)
     try:
       return steptype(name=name, env=env, **kwargs)
     except self.m.step.StepFailure as e:
       if abort_on_failure:
         raise  # pragma: no cover
       if fail_build_on_failure:
         self.failed.append(e)
 
-  def gsutil_upload(self, name, source, bucket, dest):
-    """Upload to Google Storage without using a .boto file."""
-    self.run(
-        self.m.gsutil.upload,
-        name,
-        source=source,
-        bucket=bucket,
-        dest=dest,
-        args=['-R'],
-        env=self.gsutil_env_skia_infra,
-        abort_on_failure=False)
-
   def download_dir(self, version_file, gs_path_tmpl, tmp_dir, host_path,
                    test_expected_version, test_actual_version,
                    running_in_swarming):
     """Download the given directory from Google Storage if necessary.
 
     Return the downloaded version.
     """
     actual_version_file = self.m.path.join(tmp_dir, version_file)
     # If we're running as a Swarming task, we should've received the test inputs
     # via the isolate server. Only download if we're not running in Swarming.
@@ skipping 449 matching lines @@
     # Don't bother to include role, which is always Test.
     # TryBots are uploaded elsewhere so they can use the same key.
     blacklist = ['role', 'is_trybot']
 
     flat = []
     for k in sorted(self.builder_cfg.keys()):
       if k not in blacklist:
         flat.append(k)
         flat.append(self.builder_cfg[k])
     return flat