Rebaseline the actual missing results only

third_party/WebKit/Tools/Scripts/webkitpy/common/net/layouttestresults.py

 # Copyright (c) 2010, Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 19 matching lines @@
 import logging
 
 from webkitpy.common.memoized import memoized
 from webkitpy.layout_tests.layout_package import json_results_generator
 from webkitpy.layout_tests.models import test_expectations
 from webkitpy.layout_tests.models.test_expectations import TestExpectations
 
 _log = logging.getLogger(__name__)
 
 
-# These are helper functions for navigating the results json structure.
-def for_each_test(tree, handler, prefix=''):
-    for key in tree:
-        new_prefix = (prefix + '/' + key) if prefix else key
-        if 'actual' not in tree[key]:
-            for_each_test(tree[key], handler, new_prefix)
-        else:
-            handler(new_prefix, tree[key])
-
-
-def result_for_test(tree, test):
-    parts = test.split('/')
-    for part in parts:
-        if part not in tree:
-            return None
-        tree = tree[part]
-    return tree
-
-
-class JSONTestResult(object):
+class LayoutTestResult(object):
 
     def __init__(self, test_name, result_dict):
         self._test_name = test_name
         self._result_dict = result_dict
 
+    def result_dict(self):
+        return self._result_dict
+
+    def test_name(self):
+        return self._test_name
+
     def did_pass_or_run_as_expected(self):
         return self.did_pass() or self.did_run_as_expected()
 
     def did_pass(self):
-        return test_expectations.PASS in self._actual_as_tokens()
+        return 'PASS' in self.actual_results()
 
     def did_run_as_expected(self):
         return 'is_unexpected' not in self._result_dict
 
-    def _tokenize(self, results_string):
-        tokens = map(TestExpectations.expectation_from_string, results_string.split(' '))
-        if None in tokens:
-            _log.warning("Unrecognized result in %s" % results_string)
-        return set(tokens)
+    def is_missing_image(self):
+        return 'is_missing_image' in self._result_dict
 
-    @memoized
-    def _actual_as_tokens(self):
-        actual_results = self._result_dict['actual']
-        return self._tokenize(actual_results)
+    def is_missing_text(self):
+        return 'is_missing_text' in self._result_dict
+
+    def is_missing_audio(self):
+        return 'is_missing_audio' in self._result_dict
+
+    def actual_results(self):
+        return self._result_dict['actual']
+
+    def expected_results(self):
+        return self._result_dict['expected']
 
 
 # FIXME: This should be unified with ResultsSummary or other NRWT layout tests code
 # in the layout_tests package.
 # This doesn't belong in common.net, but we don't have a better place for it yet.
 class LayoutTestResults(object):
 
     @classmethod
     def results_from_string(cls, string):
         if not string:
             return None
 
         content_string = json_results_generator.strip_json_wrapper(string)
         json_dict = json.loads(content_string)
         if not json_dict:
             return None
+
         return cls(json_dict)
 
     def __init__(self, parsed_json):
         self._results = parsed_json
 
     def run_was_interrupted(self):
         return self._results["interrupted"]
 
     def builder_name(self):
         return self._results["builder_name"]
 
     def chromium_revision(self):
         return int(self._results["chromium_revision"])
 
-    def actual_results(self, test):
-        result = result_for_test(self._results["tests"], test)
-        if result:
-            return result["actual"]
-        return ""
+    def result_for_test(self, test):
+        parts = test.split("/")
+        tree = self._test_result_tree()
+        for part in parts:
+            if part not in tree:
+                return None
+            tree = tree[part]
+        return LayoutTestResult(test, tree)
+
+    def for_each_test(self, handler):
+        LayoutTestResults._for_each_test(self._test_result_tree(), handler, '')
+
+    @staticmethod
+    def _for_each_test(tree, handler, prefix=''):
+        for key in tree:
+            new_prefix = (prefix + '/' + key) if prefix else key
+            if 'actual' not in tree[key]:
+                LayoutTestResults._for_each_test(tree[key], handler, new_prefix)
+            else:
+                handler(LayoutTestResult(new_prefix, tree[key]))
+
+    def _test_result_tree(self):
+        return self._results['tests']