Have all the rebaseline commands only rebaseline failures that are actually happening on the bots.

Tools/Scripts/webkitpy/tool/commands/rebaseline.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 270 matching lines @@
 
         self._baseline_optimizer = self._optimizer_class(tool, port_names)
         self._port = tool.port_factory.get(port_names[0])
         for test_name in self._port.tests(args):
             self._analyze_baseline(options, test_name)
 
 
 class AbstractParallelRebaselineCommand(AbstractRebaseliningCommand):
     # not overriding execute() - pylint: disable=W0223
 
+    def __init__(self, options=None):
+        super(AbstractParallelRebaselineCommand, self).__init__(options=options)
+        self._builder_data = {}
+
+    def builder_data(self):
+        if not self._builder_data:
+            for builder_name in self._release_builders():
+                builder = self._tool.buildbot_for_builder_name(builder_name).builder_with_name(builder_name)
+                self._builder_data[builder_name] = builder.latest_layout_test_results()
+        return self._builder_data
+
     # The release builders cycle much faster than the debug ones and cover all the platforms.
     def _release_builders(self):
         release_builders = []
         for builder_name in builders.all_builder_names():
             port = self._tool.port_factory.get_from_builder_name(builder_name)
             if port.test_configuration().build_type == 'release':
                 release_builders.append(builder_name)
         return release_builders
 
     def _run_webkit_patch(self, args, verbose):
@@ skipping 29 matching lines @@
     def _rebaseline_commands(self, test_prefix_list, options):
         path_to_webkit_patch = self._tool.path()
         cwd = self._tool.scm().checkout_root
         copy_baseline_commands = []
         rebaseline_commands = []
         port = self._tool.port_factory.get()
 
         for test_prefix in test_prefix_list:
             for test in port.tests([test_prefix]):
                 for builder in self._builders_to_fetch_from(test_prefix_list[test_prefix]):
-                    suffixes = ','.join(test_prefix_list[test_prefix][builder])
+                    actual_failures_suffixes = self._suffixes_for_actual_failures(test, builder, test_prefix_list[test_prefix][builder])
+                    if not actual_failures_suffixes:
+                        continue
+
+                    suffixes = ','.join(actual_failures_suffixes)
                     cmd_line = ['--suffixes', suffixes, '--builder', builder, '--test', test]
                     if options.results_directory:
                         cmd_line.extend(['--results-directory', options.results_directory])
                     if options.verbose:
                         cmd_line.append('--verbose')
                     copy_baseline_commands.append(tuple([[path_to_webkit_patch, 'copy-existing-baselines-internal'] + cmd_line, cwd]))
                     rebaseline_commands.append(tuple([[path_to_webkit_patch, 'rebaseline-test-internal'] + cmd_line, cwd]))
         return copy_baseline_commands, rebaseline_commands
 
     def _files_to_add(self, command_results):
@@ skipping 21 matching lines @@
             if not file_added:
                 _log.debug('Could not add file based off output "%s"' % output)
 
         return list(files_to_add), lines_to_remove
 
     def _optimize_baselines(self, test_prefix_list, verbose=False):
         # We don't run this in parallel because modifying the SCM in parallel is unreliable.
         for test in test_prefix_list:
             all_suffixes = set()
             for builder in self._builders_to_fetch_from(test_prefix_list[test]):
-                all_suffixes.update(test_prefix_list[test][builder])
+                all_suffixes.update(self._suffixes_for_actual_failures(test, builder, test_prefix_list[test][builder]))
             # FIXME: We should propagate the platform options as well.
             self._run_webkit_patch(['optimize-baselines', '--suffixes', ','.join(all_suffixes), test], verbose)
 
     def _update_expectations_files(self, lines_to_remove):
         for test in lines_to_remove:
             for builder in lines_to_remove[test]:
                 port = self._tool.port_factory.get_from_builder_name(builder)
                 path = port.path_to_generic_test_expectations_file()
                 expectations = TestExpectations(port, include_overrides=False)
                 for test_configuration in port.all_test_configurations():
@@ skipping 20 matching lines @@
             for builder, suffixes in sorted(builders_to_check.items()):
                 _log.debug("  %s: %s" % (builder, ",".join(suffixes)))
 
         copy_baseline_commands, rebaseline_commands = self._rebaseline_commands(test_prefix_list, options)
         self._run_in_parallel_and_update_scm(copy_baseline_commands)
         self._run_in_parallel_and_update_scm(rebaseline_commands)
 
         if options.optimize:
             self._optimize_baselines(test_prefix_list, options.verbose)
 
+    def _suffixes_for_actual_failures(self, test, builder_name, existing_suffixes):
+        actual_results = self.builder_data()[builder_name].actual_results(test)
+        if not actual_results:
+            return set()
+        return set(existing_suffixes) & TestExpectations.suffixes_for_actual_expectations_string(actual_results)
+
 
 class RebaselineJson(AbstractParallelRebaselineCommand):
     name = "rebaseline-json"
     help_text = "Rebaseline based off JSON passed to stdin. Intended to only be called from other scripts."
 
     def __init__(self,):
         super(RebaselineJson, self).__init__(options=[
             self.no_optimize_option,
             self.results_directory_option,
             ])
@@ skipping 106 matching lines @@
     # FIXME: http://crbug.com/263676 Obviously we should fix the uploader here.
     MAX_LINES_TO_REBASELINE = 200
 
     def __init__(self):
         super(AutoRebaseline, self).__init__(options=[
             # FIXME: Remove this option.
             self.no_optimize_option,
             # FIXME: Remove this option.
             self.results_directory_option,
             ])
-        self._builder_data = {}
-
-    def builder_data(self):
-        if not self._builder_data:
-            for builder_name in self._release_builders():
-                builder = self._tool.buildbot_for_builder_name(builder_name).builder_with_name(builder_name)
-                self._builder_data[builder_name] = builder.latest_layout_test_results()
-        return self._builder_data
 
     def latest_revision_processed_on_all_bots(self):
         revisions = []
         for result in self.builder_data().values():
             if result.run_was_interrupted():
                 _log.error("Can't rebaseline. The latest run on %s did not complete." % builder_name)
                 return 0
             revisions.append(result.blink_revision())
         return int(min(revisions))
 
@@ skipping 48 matching lines @@
         return """Auto-rebaseline for r%s
 
 %s
 
 %sTBR=%s
 """ % (revision, self.link_to_patch(revision), bug_string, author)
 
     def get_test_prefix_list(self, tests):
         test_prefix_list = {}
         lines_to_remove = {}
-        builder_data = self.builder_data()
 
         for builder_name in self._release_builders():
             port_name = builders.port_name_for_builder_name(builder_name)
             port = self._tool.port_factory.get(port_name)
             expectations = TestExpectations(port, include_overrides=True)
             for test in expectations.get_needs_rebaseline_failures():
                 if test not in tests:
                     continue
 
-                if test not in lines_to_remove:
+                if test not in test_prefix_list:
                     lines_to_remove[test] = []
+                    test_prefix_list[test] = {}
                 lines_to_remove[test].append(builder_name)
-
-                actual_results = builder_data[builder_name].actual_results(test)
-                if not actual_results:
-                    continue
-
-                suffixes = TestExpectations.suffixes_for_actual_expectations_string(actual_results)
-                if not suffixes:
-                    continue
-
-                if test not in test_prefix_list:
-                    test_prefix_list[test] = {}
-                test_prefix_list[test][builder_name] = suffixes
+                test_prefix_list[test][builder_name] = BASELINE_SUFFIX_LIST
 
         return test_prefix_list, lines_to_remove
 
     def _run_git_cl_command(self, options, command):
         subprocess_command = ['git', 'cl'] + command
         if options.verbose:
             subprocess_command.append('--verbose')
         # Use call instead of run_command so that stdout doesn't get swallowed.
         self._tool.executive.call(subprocess_command)
 
@@ skipping 76 matching lines @@
 
     def execute(self, options, args, tool):
         while True:
             tool.executive.run_command(['git', 'pull'])
             rebaseline_command = [tool.filesystem.join(tool.scm().checkout_root, 'Tools', 'Scripts', 'webkit-patch'), 'auto-rebaseline']
             if options.verbose:
                 rebaseline_command.append('--verbose')
             # Use call instead of run_command so that stdout doesn't get swallowed.
             tool.executive.call(rebaseline_command)
             time.sleep(self.SLEEP_TIME_IN_SECONDS)