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
 import shutil
 import signal
 import subprocess
 import sys
 import time
 import traceback
 
+from get_subdir import GetSubDirFromBuilderName
 from playback_dirs import LocalSkpPlaybackDirs
 from playback_dirs import StorageSkpPlaybackDirs
 from utils import file_utils
 from utils import misc
 from utils import shell_utils
 
 
 # Add important directories to the PYTHONPATH
 buildbot_root = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                              os.pardir, os.pardir)
@@ skipping 49 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 106 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
 
+    skimage_subdir = GetSubDirFromBuilderName(self._builder_name)

[borenet, 2013/06/25 18:19:12]

Would it be equivalent to use self._gm_image_subdir?

[scroggo, 2013/06/25 19:28:56]

Yes. Thanks!

+    if None == skimage_subdir:
+      raise BuildStepFailure("Could not find subdir for " + self._builder_name)
+
+    self._skimage_in_dir = os.path.join(os.pardir, 'skimage_in')
+
+    self._skimage_expected_dir = os.path.join(os.pardir, 'expectations',
+                                              'skimage', skimage_subdir)
+    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)