add ui for mutli-rebaselining

tools/skpdiff/skpdiff_server.py

 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 
 from __future__ import print_function
 import argparse
 import BaseHTTPServer
 import json
 import os
 import os.path
 import re
@@ skipping 81 matching lines @@
         writer.write(reader.read())
 
 
 def download_gm_image(image_name, image_path, hash_val):
     """Download the gm result into the given path.
 
     @param image_name The GM file name, for example imageblur_gpu.png.
     @param image_path Path to place the image.
     @param hash_val   The hash value of the image.
     """
+    if hash_val is None:
+        return
 
     # Separate the test name from a image name
     image_match = IMAGE_FILENAME_RE.match(image_name)
     test_name = image_match.group(1)
 
     # Calculate the URL of the requested image
     image_url = gm_json.CreateGmActualUrl(
         test_name, gm_json.JSONKEY_HASHTYPE_BITMAP_64BITMD5, hash_val)
 
     # Download the image as requested
@@ skipping 55 matching lines @@
     git_version_content, _ = git_show_proc.communicate()
     return git_version_content
 
 
 class GMInstance:
     """Information about a GM test result on a specific device:
      - device_name = the name of the device that rendered it
      - image_name = the GM test name and config
      - expected_hash = the current expected hash value
      - actual_hash = the actual hash value
+     - is_rebaselined = True if actual_hash is what is currently in the expected
+                        results file, False otherwise.
     """
     def __init__(self,
                  device_name, image_name,
-                 expected_hash, actual_hash):
+                 expected_hash, actual_hash,
+                 is_rebaselined):
         self.device_name = device_name
         self.image_name = image_name
         self.expected_hash = expected_hash
         self.actual_hash = actual_hash
+        self.is_rebaselined = is_rebaselined
 
 
 class ExpectationsManager:
     def __init__(self, expectations_dir, expected_name, updated_name,
                  skpdiff_path):
         """
         @param expectations_dir   The directory to traverse for results files.
                This should resemble expectations/gm in the Skia trunk.
         @param expected_name      The name of the expected result files. These
                are in the format of expected-results.json.
@@ skipping 26 matching lines @@
         actual_image_dir = os.path.join(image_output_dir, 'actual')
         os.mkdir(expected_image_dir)
         os.mkdir(actual_image_dir)
 
         # Download expected and actual images that differed into the temporary
         # file tree.
         self._download_expectation_images(expected_image_dir, actual_image_dir)
 
         # Invoke skpdiff with our downloaded images and place its results in the
         # temporary directory.
-        self.skpdiff_output_path = os.path.join(image_output_dir,
+        self._skpdiff_output_path = os.path.join(image_output_dir,
                                                 'skpdiff_output.json')
         skpdiff_cmd = SKPDIFF_INVOKE_FORMAT.format(self._skpdiff_path,
-                                                   self.skpdiff_output_path,
+                                                   self._skpdiff_output_path,
                                                    expected_image_dir,
                                                    actual_image_dir)
         os.system(skpdiff_cmd)
+        self._load_skpdiff_output()
 
 
     def _get_expectations(self):
         """Fills self._expectations with GMInstance objects for each test whose
         expectation is different between the following two files:
          - the local filesystem's updated results file
          - git's head version of the expected results file
         """
         differ = jsondiff.GMDiffer()
         self._expectations = []
@@ skipping 12 matching lines @@
                 if not os.path.isfile(updated_file_path):
                     continue
 
                 # Always get the expected results from git because we may have
                 # changed them in a previous instance of the server.
                 expected_contents = get_head_version(expected_file_path)
                 updated_contents = None
                 with open(updated_file_path, 'rb') as updated_file:
                     updated_contents = updated_file.read()
 
+                # Read the expected results on disk to determine what we've
+                # already rebaselined.
+                commited_contents = None
+                with open(expected_file_path, 'rb') as expected_file:
+                    commited_contents = expected_file.read()
+
                 # Find all expectations that did not match.
                 expected_diff = differ.GenerateDiffDictFromStrings(
                     expected_contents,
                     updated_contents)
 
+                # Generate a set of images that have already been rebaselined
+                # onto disk.
+                rebaselined_diff = differ.GenerateDiffDictFromStrings(
+                    expected_contents,
+                    commited_contents)
+
+                rebaselined_set = set(rebaselined_diff.keys())
+
                 # The name of the device corresponds to the name of the folder
                 # we are in.
                 device_name = os.path.basename(root)
 
                 # Store old and new versions of the expectation for each GM
                 for image_name, hashes in expected_diff.iteritems():
                     self._expectations.append(
                         GMInstance(device_name, image_name,
-                                   hashes['old'], hashes['new']))
+                                   hashes['old'], hashes['new'],
+                                   image_name in rebaselined_set))
+
+    def _load_skpdiff_output(self):
+        """Loads the results of skpdiff and annotates them with whether they
+        have already been rebaselined or not. The resulting data is store in
+        self.skpdiff_records."""
+        self.skpdiff_records = None
+        with open(self._skpdiff_output_path, 'rb') as skpdiff_output_file:
+            self.skpdiff_records = json.load(skpdiff_output_file)['records']
+            for record in self.skpdiff_records:
+                record['isRebaselined'] = self.image_map[record['baselinePath']][1].is_rebaselined
 
 
     def _download_expectation_images(self, expected_image_dir, actual_image_dir):
         """Download the expected and actual images for the _expectations array.
 
         @param expected_image_dir The directory to download expected images
                into.
         @param actual_image_dir   The directory to download actual images into.
         """
         image_map = {}
@@ skipping 45 matching lines @@
         json_path = os.path.join(self._expectations_dir, device_name,
                                  self._expected_name)
         expectations = gm_json.LoadFromFile(json_path)
 
         # Set the specified hash.
         set_expected_hash_in_json(expectations, image_name, hash_value)
 
         # Write it out to disk using gm_json to keep the formatting consistent.
         gm_json.WriteToFile(expectations, json_path)
 
-    def use_hash_of(self, image_path):
-        """Determine the hash of the image at the path using the records, and
-        set it as the expected hash for its device and image config.
+    def commit_rebaselines(self, rebaselines):
+        """Resets all expectations to their defaults and uses the hashes for the
+        images in the given list.
 
-        @param image_path The path of the image as it was stored in the output
-               of skpdiff_path
+        @param rebaselines A list of image paths to use the hash of.
         """
+        # Reset all expectations to their old hashes

[epoger, 2013/08/07 16:51:55]

I don't understand why you have to reset all the expectations.  I guess some of
the expectations (other than the ones that the user wants to actually commit)
will be "dirty" and need to be cleaned before the commit?  Please add a bit more
description of this to the comment.

+        for expectation in self._expectations:
+            expectation.is_rebaselined = False
+            self._set_expected_hash(expectation.device_name,
+                                    expectation.image_name,
+                                    expectation.expected_hash)
 
-        # Get the metadata about the image at the path.
-        is_actual, expectation = self.image_map[image_path]
+        # Take all the images to rebaseline
+        for image_path in rebaselines:
+            # Get the metadata about the image at the path.
+            is_actual, expectation = self.image_map[image_path]
 
-        expectation_hash = expectation.actual_hash if is_actual else\
-                           expectation.expected_hash
+            expectation.is_rebaselined = is_actual
+            expectation_hash = expectation.actual_hash if is_actual else\
+                               expectation.expected_hash
 
-        # Write out that image's hash directly to the expected results file.
-        self._set_expected_hash(expectation.device_name, expectation.image_name,
-                                expectation_hash)
+            # Write out that image's hash directly to the expected results file.
+            self._set_expected_hash(expectation.device_name,
+                                    expectation.image_name,
+                                    expectation_hash)
+
+        self._load_skpdiff_output()
 
 
 class SkPDiffHandler(BaseHTTPServer.BaseHTTPRequestHandler):
     def send_file(self, file_path):
         # Grab the extension if there is one
         extension = os.path.splitext(file_path)[1]
         if len(extension) >= 1:
             extension = extension[1:]
 
         # Determine the MIME type of the file from its extension
@@ skipping 27 matching lines @@
 
         # The [1:] chops off the leading '/'
         file_path = self.path[1:]
 
         # Handle skpdiff_output.json manually because it is was processed by the
         # server when it was started and does not exist as a file.
         if file_path == 'skpdiff_output.json':
             self.send_response(200)
             self.send_header('Content-type', MIME_TYPE_MAP['json'])
             self.end_headers()
-            self.wfile.write(self.server.skpdiff_output_json)
+
+            # Add JSONP padding to the JSON because the web page expects it. It
+            # expects it because it was designed to run with or without a web
+            # server. Without a web server, the only way to load JSON is with
+            # JSONP.
+            skpdiff_records = self.server.expectations_manager.skpdiff_records
+            self.wfile.write('var SkPDiffRecords = ')
+            json.dump({'records': skpdiff_records}, self.wfile)
+            self.wfile.write(';')
             return
 
         # Attempt to send static asset files first.
         if self.serve_if_in_dir(SCRIPT_DIR, file_path):
             return
 
         # WARNING: Serving any file the user wants is incredibly insecure. Its
         # redeeming quality is that we only serve gm files on a white list.
         if self.path in self.server.image_set:
             self.send_file(self.path)
             return
 
         # If no file to send was found, just give the standard 404
         self.send_error(404)
 
     def do_POST(self):
-        if self.path == '/set_hash':
+        if self.path == '/commit_rebaselines':
             content_length = int(self.headers['Content-length'])
             request_data = json.loads(self.rfile.read(content_length))
-            self.server.expectations_manager.use_hash_of(request_data['path'])
+            rebaselines = request_data['rebaselines']
+            self.server.expectations_manager.commit_rebaselines(rebaselines)
             self.send_response(200)
             self.send_header('Content-type', 'application/json')
             self.end_headers()
             self.wfile.write('{"success":true}')
             return
 
         # If the we have no handler for this path, give em' the 404
         self.send_error(404)
 
 
 def run_server(expectations_manager, port=8080):
-    # Preload the skpdiff results file. This is so we can perform some
-    # processing on it.
-    skpdiff_output_json = ''
-    with open(expectations_manager.skpdiff_output_path, 'rb') as records_file:
-        skpdiff_output_json = records_file.read()
-
     # It's important to parse the results file so that we can make a set of
     # images that the web page might request.
-    skpdiff_records = json.loads(skpdiff_output_json)['records']
+    skpdiff_records = expectations_manager.skpdiff_records
     image_set = get_image_set_from_skpdiff(skpdiff_records)
 
-    # Add JSONP padding to the JSON because the web page expects it. It expects
-    # it because it was designed to run with or without a web server. Without a
-    # web server, the only way to load JSON is with JSONP.
-    skpdiff_output_json = ('var SkPDiffRecords = ' +
-                           json.dumps({'records': skpdiff_records}) + ';')
-
     # Do not bind to interfaces other than localhost because the server will
     # attempt to serve files relative to the root directory as a last resort
     # before 404ing. This means all of your files can be accessed from this
     # server, so DO NOT let this server listen to anything but localhost.
     server_address = ('127.0.0.1', port)
     http_server = BaseHTTPServer.HTTPServer(server_address, SkPDiffHandler)
     http_server.image_set = image_set
-    http_server.skpdiff_output_json = skpdiff_output_json
     http_server.expectations_manager = expectations_manager
     print('Navigate thine browser to: http://{}:{}/'.format(*server_address))
     http_server.serve_forever()
 
 
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--port', '-p', metavar='PORT',
                         type=int,
                         default=8080,
@@ skipping 43 matching lines @@
 
     expectations_manager = ExpectationsManager(args['expectations_dir'],
                                                args['expected'],
                                                args['updated'],
                                                skpdiff_path)
 
     run_server(expectations_manager, port=args['port'])
 
 if __name__ == '__main__':
     main()