Refactoring: Replace test_prefix_list variables with TestBaselineSet objects.

third_party/WebKit/Tools/Scripts/webkitpy/tool/commands/auto_rebaseline.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """A command to download new baselines for NeedsRebaseline tests.
 
 This command checks the list of tests with NeedsRebaseline expectations,
 and downloads the latest baselines for those tests from the results archived
 by the continuous builders.
 """
 
 import logging
 import optparse
 import re
 import sys
 import time
 import traceback
 import urllib2
 
 from webkitpy.common.net.buildbot import Build, current_build_link
 from webkitpy.layout_tests.models.test_expectations import TestExpectations, BASELINE_SUFFIX_LIST
-from webkitpy.tool.commands.rebaseline import AbstractParallelRebaselineCommand
+from webkitpy.tool.commands.rebaseline import AbstractParallelRebaselineCommand, TestBaselineSet
 
 
 _log = logging.getLogger(__name__)
 
 
 class AutoRebaseline(AbstractParallelRebaselineCommand):
     name = 'auto-rebaseline'
     help_text = 'Rebaselines any NeedsRebaseline lines in TestExpectations that have cycled through all the bots.'
     AUTO_REBASELINE_BRANCH_NAME = 'auto-rebaseline-temporary-branch'
     AUTO_REBASELINE_ALT_BRANCH_NAME = 'auto-rebaseline-alt-temporary-branch'
@@ skipping 110 matching lines @@
         message += '%s\n\n' % self.link_to_patch(commit)
         if bugs:
             message += 'BUG=%s\n' % ','.join(bugs)
         message += 'TBR=%s\n' % author
         return message
 
     @staticmethod
     def link_to_patch(commit):
         return 'https://chromium.googlesource.com/chromium/src/+/' + commit
 
-    def get_test_prefix_list(self, tests):
-        test_prefix_list = {}
-        lines_to_remove = {}
-
+    def _make_test_baseline_set(self, tests):
+        test_baseline_set = TestBaselineSet(self._tool)
         for builder_name in self._release_builders():
             port_name = self._tool.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 test_prefix_list:
-                    lines_to_remove[test] = []
-                    test_prefix_list[test] = {}
-                lines_to_remove[test].append(builder_name)
-                test_prefix_list[test][Build(builder_name)] = BASELINE_SUFFIX_LIST
-
-        return test_prefix_list, lines_to_remove
+                test_baseline_set.add(test, Build(builder_name))
+        return test_baseline_set
 
     def _run_git_cl_command(self, options, command):
         subprocess_command = ['git', 'cl'] + command
         if options.verbose:
             subprocess_command.append('--verbose')
         if options.auth_refresh_token_json:
             subprocess_command.append('--auth-refresh-token-json')
             subprocess_command.append(options.auth_refresh_token_json)
 
         process = self._tool.executive.popen(subprocess_command, stdout=self._tool.executive.PIPE,
@@ skipping 52 matching lines @@
         if not tests:
             _log.debug('No tests to rebaseline.')
             return
 
         if self.tree_status() == 'closed':
             _log.info('Cannot proceed. Tree is closed.')
             return
 
         _log.info('Rebaselining %s for r%s by %s.', list(tests), revision, author)
 
-        test_prefix_list, _ = self.get_test_prefix_list(tests)
+        test_baseline_set = self._make_test_baseline_set(tests)
 
         did_switch_branches = False
         did_finish = False
         old_branch_name_or_ref = ''
         rebaseline_branch_name = self.AUTO_REBASELINE_BRANCH_NAME
         try:
             # Save the current branch name and check out a clean branch for the patch.
             old_branch_name_or_ref = tool.git().current_branch_or_ref()
             if old_branch_name_or_ref == self.AUTO_REBASELINE_BRANCH_NAME:
                 rebaseline_branch_name = self.AUTO_REBASELINE_ALT_BRANCH_NAME
             if not options.dry_run:
                 tool.git().delete_branch(rebaseline_branch_name)
                 tool.git().create_clean_branch(rebaseline_branch_name)
                 did_switch_branches = True
 
-            if test_prefix_list:
-                self.rebaseline(options, test_prefix_list)
+            if test_baseline_set:
+                self.rebaseline(options, test_baseline_set)
 
             if options.dry_run:
                 return
 
             tool.git().commit_locally_with_message(
                 self.commit_message(author, revision, commit, bugs))
 
             # FIXME: It would be nice if we could dcommit the patch without uploading, but still
             # go through all the precommit hooks. For rebaselines with lots of files, uploading
             # takes a long time and sometimes fails, but we don't want to commit if, e.g. the
@@ skipping 16 matching lines @@
                     issue_already_closed = tool.executive.run_command(
                         ['git', 'config', 'branch.%s.rietveldissue' % rebaseline_branch_name],
                         return_exit_code=True)
                     if not issue_already_closed:
                         self._run_git_cl_command(options, ['set_close'])
 
                 tool.git().ensure_cleanly_tracking_remote_master()
                 if old_branch_name_or_ref:
                     tool.git().checkout_branch(old_branch_name_or_ref)
                 tool.git().delete_branch(rebaseline_branch_name)