Rebaseline the actual missing results only

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/views/buildbot_results.py

 # Copyright (C) 2012 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 11 matching lines @@
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 from webkitpy.layout_tests.models import test_expectations
 
-from webkitpy.common.net import layouttestresults
+from webkitpy.common.net.layouttestresults import LayoutTestResults
 
 
 TestExpectations = test_expectations.TestExpectations
 TestExpectationParser = test_expectations.TestExpectationParser
 
 
 class BuildBotPrinter(object):
     # This output is parsed by buildbots and must only be changed in coordination with buildbot scripts (see webkit.org's
     # Tools/BuildSlaveSupport/build.webkit.org-config/master.cfg: RunWebKitTests._parseNewRunWebKitTestsOutput
     # and chromium.org's buildbot/master.chromium/scripts/master/log_parser/webkit_test_command.py).
@@ skipping 45 matching lines @@
                 self._print("  %5d %-24s (%4.1f%%)" % (len(results), desc, pct))
 
     def print_unexpected_results(self, summarized_results, enabled_pixel_tests_in_retry=False):
         passes = {}
         flaky = {}
         regressions = {}
 
         def add_to_dict_of_lists(dict, key, value):
             dict.setdefault(key, []).append(value)
 
-        def add_result(test, results, passes=passes, flaky=flaky, regressions=regressions):
-            actual = results['actual'].split(" ")
-            expected = results['expected'].split(" ")
+        def add_result(result):
+            test = result.test_name()
+            actual = result.actual_results().split(" ")
+            expected = result.expected_results().split(" ")
 
-            if 'is_unexpected' not in results or not results['is_unexpected']:
+            if result.did_run_as_expected():
                 # Don't print anything for tests that ran as expected.
                 return
 
             if actual == ['PASS']:
                 if 'CRASH' in expected:
                     add_to_dict_of_lists(passes, 'Expected to crash, but passed', test)
                 elif 'TIMEOUT' in expected:
                     add_to_dict_of_lists(passes, 'Expected to timeout, but passed', test)
                 else:
                     add_to_dict_of_lists(passes, 'Expected to fail, but passed', test)
             elif enabled_pixel_tests_in_retry and actual == ['TEXT', 'IMAGE+TEXT']:
                 add_to_dict_of_lists(regressions, actual[0], test)
             elif len(actual) > 1 and bool(set(actual[1:]) & set(expected)):
                 # We group flaky tests by the first actual result we got.
                 add_to_dict_of_lists(flaky, actual[0], test)
             else:
                 add_to_dict_of_lists(regressions, actual[0], test)
 
-        layouttestresults.for_each_test(summarized_results['tests'], add_result)
+        test_results = LayoutTestResults(summarized_results)
+        test_results.for_each_test(add_result)
 
         if len(passes) or len(flaky) or len(regressions):
             self._print("")
         if len(passes):
             for key, tests in passes.iteritems():
                 self._print("%s: (%d)" % (key, len(tests)))
                 tests.sort()
                 for test in tests:
                     self._print("  %s" % test)
                 self._print("")
             self._print("")
 
         if len(flaky):
             descriptions = TestExpectations.EXPECTATION_DESCRIPTIONS
             for key, tests in flaky.iteritems():
                 result_type = TestExpectations.EXPECTATIONS[key.lower()]
                 self._print("Unexpected flakiness: %s (%d)" % (descriptions[result_type], len(tests)))
                 tests.sort()
 
                 for test in tests:
-                    result = layouttestresults.result_for_test(summarized_results['tests'], test)
-                    actual = result['actual'].split(" ")
-                    expected = result['expected'].split(" ")
+                    result = test_results.result_for_test(test)
+                    actual = result.actual_results().split(" ")
+                    expected = result.expected_results().split(" ")
                     # FIXME: clean this up once the old syntax is gone
                     new_expectations_list = [TestExpectationParser._inverted_expectation_tokens[exp]
                                              for exp in list(set(actual) | set(expected))]
                     self._print("  %s [ %s ]" % (test, " ".join(new_expectations_list)))
                 self._print("")
             self._print("")
 
         if len(regressions):
             descriptions = TestExpectations.EXPECTATION_DESCRIPTIONS
             for key, tests in regressions.iteritems():
                 result_type = TestExpectations.EXPECTATIONS[key.lower()]
                 self._print("Regressions: Unexpected %s (%d)" % (descriptions[result_type], len(tests)))
                 tests.sort()
                 for test in tests:
-                    result = layouttestresults.result_for_test(summarized_results['tests'], test)
-                    actual = result['actual'].split(" ")
-                    expected = result['expected'].split(" ")
+                    result = test_results.result_for_test(test)
+                    actual = result.actual_results().split(" ")
+                    expected = result.expected_results().split(" ")
                     new_expectations_list = [TestExpectationParser._inverted_expectation_tokens[exp] for exp in actual]
                     self._print("  %s [ %s ]" % (test, " ".join(new_expectations_list)))
                 self._print("")
 
         if len(summarized_results['tests']) and self.debug_logging:
             self._print("%s" % ("-" * 78))