rebaseline_server: allow users to generate SKP diff patches on a shared instance

gm/rebaseline_server/compare_rendered_pictures.py

 #!/usr/bin/python
 
 """
 Copyright 2014 Google Inc.
 
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 
 Compare results of two render_pictures runs.
 
@@ skipping 33 matching lines @@
 
 # Column descriptors, and display preferences for them.
 COLUMN__RESULT_TYPE = results.KEY__EXTRACOLUMNS__RESULT_TYPE
 COLUMN__SOURCE_SKP = 'sourceSkpFile'
 COLUMN__TILED_OR_WHOLE = 'tiledOrWhole'
 COLUMN__TILENUM = 'tilenum'
 COLUMN__BUILDER_A = 'builderA'
 COLUMN__RENDER_MODE_A = 'renderModeA'
 COLUMN__BUILDER_B = 'builderB'
 COLUMN__RENDER_MODE_B = 'renderModeB'
+# Known values for some of those columns.
+COLUMN__TILED_OR_WHOLE__TILED = 'tiled'
+COLUMN__TILED_OR_WHOLE__WHOLE = 'whole'
 
 FREEFORM_COLUMN_IDS = [
     COLUMN__SOURCE_SKP,
     COLUMN__TILENUM,
 ]
 ORDERED_COLUMN_IDS = [
     COLUMN__RESULT_TYPE,
     COLUMN__SOURCE_SKP,
     COLUMN__TILED_OR_WHOLE,
     COLUMN__TILENUM,
@@ skipping 142 matching lines @@
       setA_section: which section (gm_json.JSONKEY_ACTUALRESULTS or
           gm_json.JSONKEY_EXPECTEDRESULTS) to load from the summaries in setA
       setB_section: which section (gm_json.JSONKEY_ACTUALRESULTS or
           gm_json.JSONKEY_EXPECTEDRESULTS) to load from the summaries in setB
 
     Returns the summary of all image diff results (or None, depending on
     self._prefetch_only).
     """
     logging.info('Reading JSON image summaries from dirs %s and %s...' % (
         setA_root, setB_root))
-    setA_dicts = self._read_dicts_from_root(setA_root)
-    setB_dicts = self._read_dicts_from_root(setB_root)
+    setA_dicts = self.read_dicts_from_root(setA_root)
+    setB_dicts = self.read_dicts_from_root(setB_root)
     logging.info('Comparing summary dicts...')
 
     all_image_pairs = imagepairset.ImagePairSet(
         descriptions=(self._setA_label, self._setB_label),
         diff_base_url=self._diff_base_url)
     failing_image_pairs = imagepairset.ImagePairSet(
         descriptions=(self._setA_label, self._setB_label),
         diff_base_url=self._diff_base_url)
 
     # Override settings for columns that should be filtered using freeform text.
@@ skipping 61 matching lines @@
         whole_image_A = self.get_default(
             dictA_results, None,
             skp_name, gm_json.JSONKEY_SOURCE_WHOLEIMAGE)
         whole_image_B = self.get_default(
             dictB_results, None,
             skp_name, gm_json.JSONKEY_SOURCE_WHOLEIMAGE)
         imagepairs_for_this_skp.append(self._create_image_pair(
             image_dict_A=whole_image_A, image_dict_B=whole_image_B,
             builder_A=builder_A, render_mode_A=render_mode_A,
             builder_B=builder_B, render_mode_B=render_mode_B,
+            source_json_file=dict_path,
             source_skp_name=skp_name, tilenum=None))
 
         tiled_images_A = self.get_default(
             dictA_results, [],
             skp_name, gm_json.JSONKEY_SOURCE_TILEDIMAGES)
         tiled_images_B = self.get_default(
             dictB_results, [],
             skp_name, gm_json.JSONKEY_SOURCE_TILEDIMAGES)
         if tiled_images_A or tiled_images_B:
           num_tiles_A = len(tiled_images_A)
           num_tiles_B = len(tiled_images_B)
           num_tiles = max(num_tiles_A, num_tiles_B)
           for tile_num in range(num_tiles):
             imagepairs_for_this_skp.append(self._create_image_pair(
                 image_dict_A=(tiled_images_A[tile_num]
                               if tile_num < num_tiles_A else None),
                 image_dict_B=(tiled_images_B[tile_num]
                               if tile_num < num_tiles_B else None),
                 builder_A=builder_A, render_mode_A=render_mode_A,
                 builder_B=builder_B, render_mode_B=render_mode_B,
+                source_json_file=dict_path,
                 source_skp_name=skp_name, tilenum=tile_num))
 
         for one_imagepair in imagepairs_for_this_skp:
           if one_imagepair:
             all_image_pairs.add_image_pair(one_imagepair)
             result_type = one_imagepair.extra_columns_dict\
                 [COLUMN__RESULT_TYPE]
             if result_type != results.KEY__RESULT_TYPE__SUCCEEDED:
               failing_image_pairs.add_image_pair(one_imagepair)
 
@@ skipping 28 matching lines @@
       raise Exception('expected header_type "%s", but got "%s"' % (
           expected_header_type, header_type))
     header_revision = header[gm_json.JSONKEY_HEADER_REVISION]
     if header_revision != expected_header_revision:
       raise Exception('expected header_revision %d, but got %d' % (
           expected_header_revision, header_revision))
 
   def _create_image_pair(self, image_dict_A, image_dict_B, 
                          builder_A, render_mode_A, 
                          builder_B, render_mode_B,
-                         source_skp_name,
-                         tilenum):
+                         source_json_file,
+                         source_skp_name, tilenum):
     """Creates an ImagePair object for this pair of images.
 
     Args:
       image_dict_A: dict with JSONKEY_IMAGE_* keys, or None if no image
       image_dict_B: dict with JSONKEY_IMAGE_* keys, or None if no image
       builder_A: builder that created image set A or None if unknow
       render_mode_A: render mode used to generate image set A or None if 
                      unknown.
       builder_B: builder that created image set A or None if unknow
       render_mode_B: render mode used to generate image set A or None if 
                      unknown.
+      source_json_file: string; relative path of the JSON file where this
+                        result came from, within setA and setB.
       source_skp_name: string; name of the source SKP file
       tilenum: which tile, or None if a wholeimage
 
     Returns:
       An ImagePair object, or None if both image_dict_A and image_dict_B are
       None.
     """
     if (not image_dict_A) and (not image_dict_B):
       return None
 
@@ skipping 21 matching lines @@
 
     extra_columns_dict = {
         COLUMN__RESULT_TYPE: result_type,
         COLUMN__SOURCE_SKP: source_skp_name,
         COLUMN__BUILDER_A: builder_A,
         COLUMN__RENDER_MODE_A: render_mode_A,
         COLUMN__BUILDER_B: builder_B,
         COLUMN__RENDER_MODE_B: render_mode_B,
     }
     if tilenum == None:
-      extra_columns_dict[COLUMN__TILED_OR_WHOLE] = 'whole'
+      extra_columns_dict[COLUMN__TILED_OR_WHOLE] = COLUMN__TILED_OR_WHOLE__WHOLE
       extra_columns_dict[COLUMN__TILENUM] = 'N/A'
     else:
-      extra_columns_dict[COLUMN__TILED_OR_WHOLE] = 'tiled'
+      extra_columns_dict[COLUMN__TILED_OR_WHOLE] = COLUMN__TILED_OR_WHOLE__TILED
       extra_columns_dict[COLUMN__TILENUM] = str(tilenum)
 
     try:
       return imagepair.ImagePair(
           image_diff_db=self._image_diff_db,
           base_url=self._image_base_gs_url,
           imageA_relative_url=imageA_relative_url,
           imageB_relative_url=imageB_relative_url,
           extra_columns=extra_columns_dict,
+          source_json_file=source_json_file,
           download_all_images=self._download_all_images)
     except (KeyError, TypeError):
       logging.exception(
           'got exception while creating ImagePair for'
           ' urlPair=("%s","%s"), source_skp_name="%s", tilenum="%s"' % (
               imageA_relative_url, imageB_relative_url, source_skp_name,
               tilenum))
       return None
 
   def _copy_dir_contents(self, source_dir, dest_dir):
@@ skipping 25 matching lines @@
       source_dir: path to source dir (GS URL, local filepath, or a special
           "repo:" URL type that points at a file within our Skia checkout;
           only the "repo:" URL type will have a commit hash.
     """
     if source_dir.lower().startswith(REPO_URL_PREFIX):
       repo_dir = os.path.join(REPO_BASEPATH, source_dir[len(REPO_URL_PREFIX):])
       return subprocess.check_output(
           args=[git_utils.GIT, 'rev-parse', 'HEAD'], cwd=repo_dir).strip()
     else:
       return None