Skia: Add --colorImages to DM

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 16 matching lines @@
 from . import ios_flavor
 from . import valgrind_flavor
 from . import xsan_flavor
 
 
 BOTO_CHROMIUM_SKIA_GM = 'chromium-skia-gm.boto'
 
 GS_SUBDIR_TMPL_SK_IMAGE = 'skimage/v%s'
 GS_SUBDIR_TMPL_SKP = 'playback_%s/skps'
 
+MIN_COLORSPACE_SKIMAGE_VERSION = 5
+
 TEST_EXPECTED_SKP_VERSION = '42'
 TEST_EXPECTED_SK_IMAGE_VERSION = '42'
 
 VERSION_FILE_SK_IMAGE = 'SK_IMAGE_VERSION'
 VERSION_FILE_SKP = 'SKP_VERSION'
 
 VERSION_NONE = -1
 
 BUILD_PRODUCTS_ISOLATE_WHITELIST = [
   'dm',
@@ skipping 224 matching lines @@
   def check_failure(self):
     """Raise an exception if any step failed."""
     if self.failed:
       raise self.m.step.StepFailure('Failed build steps: %s' %
                                     ', '.join([f.name for f in self.failed]))
 
   def _run_once(self, fn, *args, **kwargs):
     if not hasattr(self, '_already_ran'):
       self._already_ran = {}
     if not fn.__name__ in self._already_ran:
-      self._already_ran[fn.__name__] = True
-      fn(*args, **kwargs)
+      self._already_ran[fn.__name__] = fn(*args, **kwargs)
+    return self._already_ran[fn.__name__]
 
   def update_repo(self, parent_dir, repo):
     """Update an existing repo. This is safe to call without gen_steps."""
     repo_path = parent_dir.join(repo.name)
     if self.m.path.exists(repo_path):
       if self.m.platform.is_win:
         git = 'git.bat'
       else:
         git = 'git'
       self.m.step('git remote set-url',
@@ skipping 239 matching lines @@
         local_images_dir,
         test_expected_version=TEST_EXPECTED_SK_IMAGE_VERSION,
         test_actual_version=self.m.properties.get(
             'test_downloaded_sk_image_version',
             TEST_EXPECTED_SK_IMAGE_VERSION),
         running_in_swarming=running_in_swarming)
 
   def _download_and_copy_images(self):
     """Download and copy test images if needed."""
     version = self.download_images(self.tmp_dir, self.images_dir, self.running_in_swarming)
-
-    """host_version, version_file, gs_path_tmpl, tmp_dir,
-               host_path, device_path, test_expected_version,
-               test_actual_version, running_in_swarming"""
-
     self.copy_dir(
         version,
         VERSION_FILE_SK_IMAGE,
         self.tmp_dir,
         self.images_dir,
         self.device_dirs.images_dir,
         test_expected_version=TEST_EXPECTED_SK_IMAGE_VERSION,
         test_actual_version=self.m.properties.get(
             'test_downloaded_sk_image_version',
             TEST_EXPECTED_SK_IMAGE_VERSION))
+    return version
 
   def download_skps(self, tmp_dir, local_skp_dir, running_in_swarming):
     """Download SKPs if needed."""
     return self.download_dir(
         VERSION_FILE_SKP,
         GS_SUBDIR_TMPL_SKP,
         tmp_dir,
         local_skp_dir,
         test_expected_version=TEST_EXPECTED_SKP_VERSION,
         test_actual_version=self.m.properties.get(
             'test_downloaded_skp_version', TEST_EXPECTED_SKP_VERSION),
         running_in_swarming=running_in_swarming)
 
   def _download_and_copy_skps(self):
     """Download and copy the SKPs if needed."""
     version = self.download_skps(self.tmp_dir, self.local_skp_dir, self.running_in_swarming)
     self.copy_dir(
         version,
         VERSION_FILE_SKP,
         self.tmp_dir,
         self.local_skp_dir,
         self.device_dirs.skp_dir,
         test_expected_version=TEST_EXPECTED_SKP_VERSION,
         test_actual_version=self.m.properties.get(
             'test_downloaded_skp_version', TEST_EXPECTED_SKP_VERSION))
+    return version
 
   def install(self):
     """Copy the required executables and files to the device."""
     self.device_dirs = self.flavor.get_device_dirs()
 
     # Run any device-specific installation.
     self.flavor.install()
 
     # TODO(borenet): Only copy files which have changed.
     # Resources
@@ skipping 34 matching lines @@
         filename,
         args=[self.m.json.output(), builder_name],
         step_test_data=lambda: self.m.json.test_api.output(test_data),
         cwd=cwd,
         infra_step=True).json.output
 
   def test_steps(self):
     """Run the DM test."""
     self._run_once(self.install)
     self._run_once(self._download_and_copy_skps)
-    self._run_once(self._download_and_copy_images)
+    skimage_version = self._run_once(self._download_and_copy_images)
 
     use_hash_file = False
     if self.upload_dm_results:
       # This must run before we write anything into self.device_dirs.dm_dir
       # or we may end up deleting our output on machines where they're the same.
       self.flavor.create_clean_host_dir(self.dm_dir)
       if str(self.dm_dir) != str(self.device_dirs.dm_dir):
         self.flavor.create_clean_device_dir(self.device_dirs.dm_dir)
 
       # Obtain the list of already-generated hashes.
@@ skipping 69 matching lines @@
       'dm',
       '--undefok',   # This helps branches that may not know new flags.
       '--resourcePath', self.device_dirs.resource_dir,
       '--skps', self.device_dirs.skp_dir,
       '--images', self.flavor.device_path_join(
           self.device_dirs.images_dir, 'dm'),
       '--nameByHash',
       '--properties'
     ] + properties
 
+    if int(skimage_version) >= MIN_COLORSPACE_SKIMAGE_VERSION:
+      args .extend(['--colorImages',
+                    self.flavor.device_path_join(self.device_dirs.images_dir,
+                                                 'colorspace')])
+
     args.append('--key')
     args.extend(self._KeyParams())
     if use_hash_file:
       args.extend(['--uninterestingHashesFile', hashes_file])
     if self.upload_dm_results:
       args.extend(['--writePath', self.device_dirs.dm_dir])
 
     skip_flag = None
     if self.builder_cfg.get('cpu_or_gpu') == 'CPU':
       skip_flag = '--nogpu'
@@ skipping 159 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