rebaseline_server: include setA/setB descriptions in output JSON

gm/rebaseline_server/results.py

 #!/usr/bin/python
 
 """
 Copyright 2013 Google Inc.
 
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 
 Repackage expected/actual GM results as needed by our HTML rebaseline viewer.
 """
 
 # System-level imports
 import fnmatch
 import os
 import re
 
 # Must fix up PYTHONPATH before importing from within Skia
 import fix_pythonpath  # pylint: disable=W0611
 
 # Imports from within Skia
 import gm_json
 import imagepairset
 
 # Keys used to link an image to a particular GM test.
 # NOTE: Keep these in sync with static/constants.js
-VALUE__HEADER__SCHEMA_VERSION = 4
+VALUE__HEADER__SCHEMA_VERSION = 5
 KEY__EXPECTATIONS__BUGS = gm_json.JSONKEY_EXPECTEDRESULTS_BUGS
 KEY__EXPECTATIONS__IGNOREFAILURE = gm_json.JSONKEY_EXPECTEDRESULTS_IGNOREFAILURE
 KEY__EXPECTATIONS__REVIEWED = gm_json.JSONKEY_EXPECTEDRESULTS_REVIEWED
 KEY__EXTRACOLUMNS__BUILDER = 'builder'
 KEY__EXTRACOLUMNS__CONFIG = 'config'
 KEY__EXTRACOLUMNS__RESULT_TYPE = 'resultType'
 KEY__EXTRACOLUMNS__TEST = 'test'
 KEY__HEADER__DATAHASH = 'dataHash'
 KEY__HEADER__IS_EDITABLE = 'isEditable'
 KEY__HEADER__IS_EXPORTED = 'isExported'
 KEY__HEADER__IS_STILL_LOADING = 'resultsStillLoading'
 KEY__HEADER__RESULTS_ALL = 'all'
 KEY__HEADER__RESULTS_FAILURES = 'failures'
 KEY__HEADER__SCHEMA_VERSION = 'schemaVersion'
+KEY__HEADER__SET_A_DESCRIPTIONS = 'setA'
+KEY__HEADER__SET_B_DESCRIPTIONS = 'setB'
 KEY__HEADER__TIME_NEXT_UPDATE_AVAILABLE = 'timeNextUpdateAvailable'
 KEY__HEADER__TIME_UPDATED = 'timeUpdated'
 KEY__HEADER__TYPE = 'type'
 KEY__RESULT_TYPE__FAILED = gm_json.JSONKEY_ACTUALRESULTS_FAILED
 KEY__RESULT_TYPE__FAILUREIGNORED = gm_json.JSONKEY_ACTUALRESULTS_FAILUREIGNORED
 KEY__RESULT_TYPE__NOCOMPARISON = gm_json.JSONKEY_ACTUALRESULTS_NOCOMPARISON
 KEY__RESULT_TYPE__SUCCEEDED = gm_json.JSONKEY_ACTUALRESULTS_SUCCEEDED
+KEY__SET_DESCRIPTIONS__DIR = 'dir'
+KEY__SET_DESCRIPTIONS__REPO_REVISION = 'repoRevision'
+KEY__SET_DESCRIPTIONS__SECTION = 'section'
 
 IMAGE_FILENAME_RE = re.compile(gm_json.IMAGE_FILENAME_PATTERN)
 IMAGE_FILENAME_FORMATTER = '%s_%s.png'  # pass in (testname, config)
 
 PARENT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
 DEFAULT_ACTUALS_DIR = '.gm-actuals'
 DEFAULT_GENERATED_IMAGES_ROOT = os.path.join(
     PARENT_DIRECTORY, '.generated-images')
 
 # Define the default set of builders we will process expectations/actuals for.
 # This allows us to ignore builders for which we don't maintain expectations
 # (trybots, Valgrind, ASAN, TSAN), and avoid problems like
 # https://code.google.com/p/skia/issues/detail?id=2036 ('rebaseline_server
 # produces error when trying to add baselines for ASAN/TSAN builders')
 DEFAULT_MATCH_BUILDERS_PATTERN_LIST = ['.*']
 DEFAULT_SKIP_BUILDERS_PATTERN_LIST = [
     '.*-Trybot', '.*Valgrind.*', '.*TSAN.*', '.*ASAN.*']
 
 
 class BaseComparisons(object):
   """Base class for generating summary of comparisons between two image sets.
   """
 
+  def __init__(self):
+    """Base constructor; most subclasses will override."""
+    self._setA_descriptions = None
+    self._setB_descriptions = None
+
   def get_results_of_type(self, results_type):
     """Return results of some/all tests (depending on 'results_type' parameter).
 
     Args:
       results_type: string describing which types of results to include; must
           be one of the RESULTS_* constants
 
     Results are returned in a dictionary as output by ImagePairSet.as_dict().
     """
     return self._results[results_type]
 
   def get_packaged_results_of_type(self, results_type, reload_seconds=None,
                                    is_editable=False, is_exported=True):
     """Package the results of some/all tests as a complete response_dict.
 
     Args:
       results_type: string indicating which set of results to return;
           must be one of the RESULTS_* constants
       reload_seconds: if specified, note that new results may be available once
           these results are reload_seconds old
       is_editable: whether clients are allowed to submit new baselines
       is_exported: whether these results are being made available to other
           network hosts
     """
     response_dict = self._results[results_type]
     time_updated = self.get_timestamp()
-    response_dict[imagepairset.KEY__ROOT__HEADER] = {
+    header_dict = {
         KEY__HEADER__SCHEMA_VERSION: (
             VALUE__HEADER__SCHEMA_VERSION),
 
         # Timestamps:
         # 1. when this data was last updated
         # 2. when the caller should check back for new data (if ever)
         KEY__HEADER__TIME_UPDATED: time_updated,
         KEY__HEADER__TIME_NEXT_UPDATE_AVAILABLE: (
             (time_updated+reload_seconds) if reload_seconds else None),
 
         # The type we passed to get_results_of_type()
         KEY__HEADER__TYPE: results_type,
 
         # Hash of dataset, which the client must return with any edits--
         # this ensures that the edits were made to a particular dataset.
         KEY__HEADER__DATAHASH: str(hash(repr(
             response_dict[imagepairset.KEY__ROOT__IMAGEPAIRS]))),
 
         # Whether the server will accept edits back.
         KEY__HEADER__IS_EDITABLE: is_editable,
 
         # Whether the service is accessible from other hosts.
         KEY__HEADER__IS_EXPORTED: is_exported,
     }
+    if self._setA_descriptions:
+      header_dict[KEY__HEADER__SET_A_DESCRIPTIONS] = self._setA_descriptions
+    if self._setB_descriptions:
+      header_dict[KEY__HEADER__SET_B_DESCRIPTIONS] = self._setB_descriptions
+    response_dict[imagepairset.KEY__ROOT__HEADER] = header_dict
     return response_dict
 
   def get_timestamp(self):
     """Return the time at which this object was created, in seconds past epoch
     (UTC).
     """
     return self._timestamp
 
   _match_builders_pattern_list = [
       re.compile(p) for p in DEFAULT_MATCH_BUILDERS_PATTERN_LIST]
@@ skipping 183 matching lines @@
       default_value: value to return if input_dict is None or any key cannot
           be found along the way
     """
     if input_dict == None:
       return default_value
     for key in keys:
       input_dict = input_dict.get(key, None)
       if input_dict == None:
         return default_value
     return input_dict