Run skimage on the bots.

slave/skia_slave_scripts/build_step.py

 # Copyright (c) 2013 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.
 
 """Base class for all slave-side build steps. """
 
 import config
 import multiprocessing
 import os
 import shlex
@@ skipping 66 matching lines @@
   def write(self, data):
     build_step_stdout_has_written.value = INT_TRUE
     self.stdout.write(data)
 
   def flush(self):
     self.stdout.flush()
 
 
 class DeviceDirs(object):
   def __init__(self, perf_data_dir, gm_actual_dir, gm_expected_dir,
-               resource_dir, skp_dir, skp_perf_dir, skp_out_dir, tmp_dir):
+               resource_dir, skimage_in_dir, skimage_expected_dir,
+               skimage_out_dir, skp_dir, skp_perf_dir, skp_out_dir, tmp_dir):
     self._perf_data_dir = perf_data_dir
     self._gm_actual_dir = gm_actual_dir
     self._gm_expected_dir = gm_expected_dir
     self._resource_dir = resource_dir
+    self._skimage_in_dir = skimage_in_dir
+    self._skimage_expected_dir = skimage_expected_dir
+    self._skimage_out_dir = skimage_out_dir
     self._skp_dir = skp_dir
     self._skp_perf_dir = skp_perf_dir
     self._skp_out_dir = skp_out_dir
     self._tmp_dir = tmp_dir
 
   def GMActualDir(self):
     return  self._gm_actual_dir
 
   def GMExpectedDir(self):
     return self._gm_expected_dir
 
   def PerfDir(self):
     return self._perf_data_dir
 
   def ResourceDir(self):
     return self._resource_dir
 
+  def SKImageInDir(self):
+    return self._skimage_in_dir
+
+  def SKImageExpectedDir(self):
+    return self._skimage_expected_dir
+
+  def SKImageOutDir(self):
+    return self._skimage_out_dir
+
   def SKPDir(self):
     return self._skp_dir
 
   def SKPPerfDir(self):
     return self._skp_perf_dir
 
   def SKPOutDir(self):
     return self._skp_out_dir
 
   def TmpDir(self):
@@ skipping 21 matching lines @@
                        'from host to device is undefined and only allowed if '
                        'host_dir and device_dir are the same.')
 
   def PushFileToDevice(self, src, dst):
     """ Copy the a single file from path "src" on the host to path "dst" on
     the device.  If the host IS the device we are testing, it's just a filecopy.
     Subclasses should override this method with one appropriate for
     pushing the file to the device. """
     shutil.copy(src, dst)
 
+  def DeviceListDir(self, directory):
+    """ List the contents of a directory on the connected device. """
+    return os.listdir(directory)
+
+  def DevicePathExists(self, path):
+    """ Like os.path.exists(), but for a path on the connected device. """
+    return os.path.exists(path)
+
   def DevicePathJoin(self, *args):
     """ Like os.path.join(), but for paths that will target the connected
     device. """
     return os.sep.join(args)
 
   def CreateCleanDirectory(self, directory):
     file_utils.CreateCleanLocalDir(directory)
 
   def __init__(self, args, attempts=1, timeout=DEFAULT_TIMEOUT,
                no_output_timeout=DEFAULT_NO_OUTPUT_TIMEOUT):
@@ skipping 65 matching lines @@
     # Figure out where we are going to store performance output.
     if args['perf_output_basedir'] != 'None':
       self._perf_data_dir = os.path.join(args['perf_output_basedir'],
                                          self._builder_name, 'data')
       self._perf_graphs_dir = os.path.join(args['perf_output_basedir'],
                                            self._builder_name, 'graphs')
     else:
       self._perf_data_dir = None
       self._perf_graphs_dir = None
 
+    self._skimage_in_dir = os.path.join(os.pardir, 'skimage_in')
+
+    self._skimage_expected_dir = os.path.join('expectations', 'skimage')
+
+    self._skimage_out_dir = os.path.join('out', self._configuration,
+                                         'skimage_out')
+
     # Note that DeviceDirs.GMExpectedDir() is being set up to point at a
     # DIFFERENT directory than self._gm_expected.
     # self._gm_expected : The SVN-managed directory on the buildbot host
     #                     where canonical expectations are stored.
     #                     Currently, they are stored there as
     #                     individual image files.
     # DeviceDirs.GMExpectedDir(): A temporary directory on the device we are
     #                             testing, where the PreRender step will put
     #                             an expected-results.json file that describes
     #                             all GM results expectations.
     # TODO(epoger): Update the above description as we move through the steps in
     # https://goto.google.com/ChecksumTransitionDetail
     self._device_dirs = DeviceDirs(
         perf_data_dir=self._perf_data_dir,
         gm_actual_dir=os.path.join(os.pardir, os.pardir, 'gm', 'actual'),
         gm_expected_dir=os.path.join(os.pardir, os.pardir, 'gm', 'expected'),
         resource_dir=self._resource_dir,
+        skimage_in_dir=self._skimage_in_dir,
+        skimage_expected_dir=self._skimage_expected_dir,
+        skimage_out_dir=self._skimage_out_dir,
         skp_dir=self._local_playback_dirs.PlaybackSkpDir(),
         skp_perf_dir=self._perf_data_dir,
         skp_out_dir=self._local_playback_dirs.PlaybackGmActualDir(),
         tmp_dir=os.path.join(os.pardir, 'tmp'))
 
   def RunFlavoredCmd(self, app, args):
     """ Override this in new BuildStep flavors. """
     shell_utils.Bash([self._PathToBinary(app)] + args)
 
   def _PreRun(self):
@@ skipping 103 matching lines @@
         else:
           raise BuildStepFailure('Build step failed.')
       except Exception:
         print traceback.format_exc()
         if attempt + 1 >= step.attempts:
           raise
       # pylint: disable=W0212
       step._WaitFunc(attempt)
       attempt += 1
       print '**** %s, attempt %d ****' % (StepType.__name__, attempt + 1)