Reland of In rebaseline, include build number information with "test_prefix_list" dicts.

third_party/WebKit/Tools/Scripts/webkitpy/tool/commands/rebaseline_unittest.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.
 
 import unittest
 
 from webkitpy.common.net.buildbot_mock import MockBuilder
 from webkitpy.common.net.layouttestresults import LayoutTestResults
 from webkitpy.common.system.executive_mock import MockExecutive
 from webkitpy.common.system.executive_mock import MockExecutive2
@@ skipping 34 matching lines @@
         self.tool.filesystem.write_text_file(
             self.tool.filesystem.join(self.mac_port.layout_tests_dir(), "VirtualTestSuites"), '[]')
 
         # In AbstractParallelRebaselineCommand._rebaseline_commands, a default port
         # object is gotten using self.tool.port_factory.get(), which is used to get
         # test paths -- and the layout tests directory may be different for the "test"
         # ports and real ports. Since only "test" ports are used in this class,
         # we can make the default port also a "test" port.
         self.original_port_factory_get = self.tool.port_factory.get
         test_port = self.tool.port_factory.get('test')
-        self._builder_data = {}
+        self._build_data = {}
 
         def get_test_port(port_name=None, options=None, **kwargs):
             if not port_name:
                 return test_port
             return self.original_port_factory_get(port_name, options, **kwargs)
 
         self.tool.port_factory.get = get_test_port
 
     def tearDown(self):
         self.tool.port_factory.get = self.original_port_factory_get
 
     def _expand(self, path):
         if self.tool.filesystem.isabs(path):
             return path
         return self.tool.filesystem.join(self.mac_port.layout_tests_dir(), path)
 
     def _read(self, path):
         return self.tool.filesystem.read_text_file(self._expand(path))
 
     def _write(self, path, contents):
         self.tool.filesystem.write_text_file(self._expand(path), contents)
 
     def _zero_out_test_expectations(self):
         for port_name in self.tool.port_factory.all_port_names():
             port = self.tool.port_factory.get(port_name)
             for path in port.expectations_files():
                 self._write(path, '')
         self.tool.filesystem.written_files = {}
 
-    def _setup_mock_builder_data(self):
+    def _setup_mock_build_data(self):
         data = LayoutTestResults({
             "tests": {
                 "userscripts": {
                     "first-test.html": {
                         "expected": "PASS",
                         "actual": "IMAGE+TEXT"
                     },
                     "second-test.html": {
                         "expected": "FAIL",
                         "actual": "IMAGE+TEXT"
                     }
                 }
             }
         })
 
-        def builder_data():
-            self._builder_data = {}
+        def build_data():
+            self._build_data = {}
             for builder in ['MOCK Win7', 'MOCK Win7 (dbg)', 'MOCK Mac10.11']:
-                self._builder_data[builder] = data
-            return self._builder_data
+                self._build_data[Build(builder)] = data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
 class TestCopyExistingBaselinesInternal(BaseTestCase):
     command_constructor = CopyExistingBaselinesInternal
 
     def setUp(self):
         super(TestCopyExistingBaselinesInternal, self).setUp()
 
     def test_copying_overwritten_baseline(self):
         self.tool.executive = MockExecutive2()
 
@@ skipping 216 matching lines @@
     command_constructor = RebaselineJson
 
     def setUp(self):
         super(TestRebaselineJson, self).setUp()
         self.tool.executive = MockExecutive2()
 
     def tearDown(self):
         super(TestRebaselineJson, self).tearDown()
 
     def test_rebaseline_test_passes_on_all_builders(self):
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
-        def builder_data():
-            self._builder_data['MOCK Win7'] = LayoutTestResults({
+        def build_data():
+            self._build_data[Build('MOCK Win7')] = LayoutTestResults({
                 "tests": {
                     "userscripts": {
                         "first-test.html": {
                             "expected": "NEEDSREBASELINE",
                             "actual": "PASS"
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         options = MockOptions(optimize=True, verbose=True, results_directory=None)
 
         self._write(self.mac_expectations_path, "Bug(x) userscripts/first-test.html [ Failure ]\n")
         self._write("userscripts/first-test.html", "Dummy test contents")
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Win7": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
 
         self.assertEqual(self.tool.executive.calls, [])
 
     def test_rebaseline_all(self):
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
         options = MockOptions(optimize=True, verbose=True, results_directory=None)
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Win7": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
 
         # Note that we have one run_in_parallel() call followed by a run_command()
         self.assertEqual(self.tool.executive.calls,
                          [
                              [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
                                '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
                              [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png',
                                '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
                              [['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt,png',
                                'userscripts/first-test.html', '--verbose']]
                          ])
 
     def test_rebaseline_debug(self):
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
         options = MockOptions(optimize=True, verbose=True, results_directory=None)
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Win7 (dbg)": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Win7 (dbg)"): ["txt", "png"]}})
 
         # Note that we have one run_in_parallel() call followed by a run_command()
         self.assertEqual(self.tool.executive.calls,
                          [
                              [['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
                                '--builder', 'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']],
                              [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder',
                                'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']],
                              [['python', 'echo', 'optimize-baselines', '--no-modify-scm', '--suffixes', 'txt,png',
                                'userscripts/first-test.html', '--verbose']]
                          ])
 
     def test_no_optimize(self):
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
         options = MockOptions(optimize=False, verbose=True, results_directory=None)
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Win7 (dbg)": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Win7 (dbg)"): ["txt", "png"]}})
 
         # Note that we have only one run_in_parallel() call
         self.assertEqual(self.tool.executive.calls,
                          [[['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png', '--builder', 'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']],
                           [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK Win7 (dbg)', '--test', 'userscripts/first-test.html', '--verbose']]])
 
     def test_results_directory(self):
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
         options = MockOptions(optimize=False, verbose=True, results_directory='/tmp')
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Win7": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Win7"): ["txt", "png"]}})
 
         # Note that we have only one run_in_parallel() call
         self.assertEqual(self.tool.executive.calls,
                          [[['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png', '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--results-directory', '/tmp', '--verbose']],
                           [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--results-directory', '/tmp', '--verbose']]])
 
 
 class TestRebaselineJsonUpdatesExpectationsFiles(BaseTestCase):
     command_constructor = RebaselineJson
 
     def setUp(self):
         super(TestRebaselineJsonUpdatesExpectationsFiles, self).setUp()
         self.tool.executive = MockExecutive2()
 
         def mock_run_command(*args, **kwargs):  # pylint: disable=unused-argument
             return '{"add": [], "remove-lines": [{"test": "userscripts/first-test.html", "builder": "MOCK Mac10.11"}]}\n'
         self.tool.executive.run_command = mock_run_command
 
     def test_rebaseline_updates_expectations_file(self):
         options = MockOptions(optimize=False, verbose=True, results_directory=None)
 
         self._write(self.mac_expectations_path,
                     "Bug(x) [ Mac ] userscripts/first-test.html [ Failure ]\nbug(z) [ Linux ] userscripts/first-test.html [ Failure ]\n")
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Mac10.11": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations, "Bug(x) [ Mac10.10 ] userscripts/first-test.html [ Failure ]\nbug(z) [ Linux ] userscripts/first-test.html [ Failure ]\n")
 
     def test_rebaseline_updates_expectations_file_all_platforms(self):
         options = MockOptions(optimize=False, verbose=True, results_directory=None)
 
         self._write(self.mac_expectations_path, "Bug(x) userscripts/first-test.html [ Failure ]\n")
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Mac10.11": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations, "Bug(x) [ Linux Mac10.10 Win ] userscripts/first-test.html [ Failure ]\n")
 
     def test_rebaseline_handles_platform_skips(self):
         # This test is just like test_rebaseline_updates_expectations_file_all_platforms(),
         # except that if a particular port happens to SKIP a test in an overrides file,
         # we count that as passing, and do not think that we still need to rebaseline it.
         options = MockOptions(optimize=False, verbose=True, results_directory=None)
 
         self._write(self.mac_expectations_path, "Bug(x) userscripts/first-test.html [ Failure ]\n")
         self._write("NeverFixTests", "Bug(y) [ Android ] userscripts [ WontFix ]\n")
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Mac10.11": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations, "Bug(x) [ Linux Mac10.10 Win ] userscripts/first-test.html [ Failure ]\n")
 
     def test_rebaseline_handles_skips_in_file(self):
         # This test is like test_Rebaseline_handles_platform_skips, except that the
         # Skip is in the same (generic) file rather than a platform file. In this case,
         # the Skip line should be left unmodified. Note that the first line is now
         # qualified as "[Linux Mac Win]"; if it was unqualified, it would conflict with
         # the second line.
         options = MockOptions(optimize=False, verbose=True, results_directory=None)
 
         self._write(self.mac_expectations_path,
                     ("Bug(x) [ Linux Mac Win ] userscripts/first-test.html [ Failure ]\n"
                      "Bug(y) [ Android ] userscripts/first-test.html [ Skip ]\n"))
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Mac10.11": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations,
             ("Bug(x) [ Linux Mac10.10 Win ] userscripts/first-test.html [ Failure ]\n"
              "Bug(y) [ Android ] userscripts/first-test.html [ Skip ]\n"))
 
     def test_rebaseline_handles_smoke_tests(self):
         # This test is just like test_rebaseline_handles_platform_skips, except that we check for
         # a test not being in the SmokeTests file, instead of using overrides files.
         # If a test is not part of the smoke tests, we count that as passing on ports that only
         # run smoke tests, and do not think that we still need to rebaseline it.
         options = MockOptions(optimize=False, verbose=True, results_directory=None)
 
         self._write(self.mac_expectations_path, "Bug(x) userscripts/first-test.html [ Failure ]\n")
         self._write("SmokeTests", "fast/html/article-element.html")
         self._write("userscripts/first-test.html", "Dummy test contents")
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
-        self.command._rebaseline(options, {"userscripts/first-test.html": {"MOCK Mac10.11": ["txt", "png"]}})
+        self.command._rebaseline(options, {"userscripts/first-test.html": {Build("MOCK Mac10.11"): ["txt", "png"]}})
 
         new_expectations = self._read(self.mac_expectations_path)
         self.assertMultiLineEqual(
             new_expectations, "Bug(x) [ Linux Mac10.10 Win ] userscripts/first-test.html [ Failure ]\n")
 
 
 class TestRebaseline(BaseTestCase):
     # This command shares most of its logic with RebaselineJson, so these tests just test what is different.
 
     command_constructor = Rebaseline  # AKA webkit-patch rebaseline
 
     def test_rebaseline(self):
         self.command._builders_to_pull_from = lambda: [MockBuilder('MOCK Win7')]
 
         self._write("userscripts/first-test.html", "test data")
 
         self._zero_out_test_expectations()
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
         self.command.execute(MockOptions(results_directory=False, optimize=False, builders=None,
                                          suffixes="txt,png", verbose=True), ['userscripts/first-test.html'], self.tool)
 
         self.assertEqual(self.tool.executive.calls,
                          [[['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png', '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']],
                           [['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'txt,png', '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose']]])
 
     def test_rebaseline_directory(self):
         self.command._builders_to_pull_from = lambda: [MockBuilder('MOCK Win7')]
 
         self._write("userscripts/first-test.html", "test data")
         self._write("userscripts/second-test.html", "test data")
 
-        self._setup_mock_builder_data()
+        self._setup_mock_build_data()
 
         self.command.execute(MockOptions(results_directory=False, optimize=False, builders=None,
                                          suffixes="txt,png", verbose=True), ['userscripts'], self.tool)
 
         self.assertEqual(self.tool.executive.calls,
                          [
                              [
                                  ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
                                   '--builder', 'MOCK Win7', '--test', 'userscripts/first-test.html', '--verbose'],
                                  ['python', 'echo', 'copy-existing-baselines-internal', '--suffixes', 'txt,png',
@@ skipping 37 matching lines @@
 
     def _write_test_file(self, port, path, contents):
         abs_path = self.tool.filesystem.join(port.layout_tests_dir(), path)
         self.tool.filesystem.write_text_file(abs_path, contents)
 
     def test_rebaseline_expectations(self):
         self._zero_out_test_expectations()
 
         self.tool.executive = MockExecutive2()
 
-        def builder_data():
-            self._builder_data['MOCK Mac10.11'] = self._builder_data['MOCK Mac10.10'] = LayoutTestResults({
+        def build_data():
+            self._build_data[Build('MOCK Mac10.11')] = self._build_data[Build('MOCK Mac10.10')] = LayoutTestResults({
                 "tests": {
                     "userscripts": {
                         "another-test.html": {
                             "expected": "PASS",
                             "actual": "PASS TEXT"
                         },
                         "images.svg": {
                             "expected": "FAIL",
                             "actual": "IMAGE+TEXT"
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self._write("userscripts/another-test.html", "Dummy test contents")
         self._write("userscripts/images.svg", "Dummy test contents")
         self.command._tests_to_rebaseline = lambda port: {
             'userscripts/another-test.html': set(['txt']),
             'userscripts/images.svg': set(['png']),
             'userscripts/not-actually-failing.html': set(['txt', 'png', 'wav']),
         }
 
         self.command.execute(self.options, [], self.tool)
@@ skipping 19 matching lines @@
                 ['python', 'echo', 'rebaseline-test-internal', '--suffixes', 'png',
                  '--builder', 'MOCK Mac10.11', '--test', 'userscripts/images.svg'],
             ],
         ])
 
     def test_rebaseline_expectations_reftests(self):
         self._zero_out_test_expectations()
 
         self.tool.executive = MockExecutive2()
 
-        def builder_data():
-            self._builder_data['MOCK Mac10.10'] = self._builder_data['MOCK Mac10.11'] = LayoutTestResults({
+        def build_data():
+            self._build_data[Build('MOCK Mac10.10')] = self._build_data[Build('MOCK Mac10.11')] = LayoutTestResults({
                 "tests": {
                     "userscripts": {
                         "reftest-text.html": {
                             "expected": "PASS",
                             "actual": "TEXT"
                         },
                         "reftest-image.html": {
                             "expected": "FAIL",
                             "actual": "IMAGE"
                         },
                         "reftest-image-text.html": {
                             "expected": "FAIL",
                             "actual": "IMAGE+TEXT"
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self._write("userscripts/reftest-text.html", "Dummy test contents")
         self._write("userscripts/reftest-text-expected.html", "Dummy test contents")
         self._write("userscripts/reftest-text-expected.html", "Dummy test contents")
         self.command._tests_to_rebaseline = lambda port: {
             'userscripts/reftest-text.html': set(['txt']),
             'userscripts/reftest-image.html': set(['png']),
             'userscripts/reftest-image-text.html': set(['png', 'txt']),
         }
 
@@ skipping 44 matching lines @@
 
     def test_rebaseline_without_other_expectations(self):
         self._write("userscripts/another-test.html", "Dummy test contents")
         self._write(self.mac_expectations_path, "Bug(x) userscripts/another-test.html [ Rebaseline ]\n")
         self.assertDictEqual(self.command._tests_to_rebaseline(self.mac_port),
                              {'userscripts/another-test.html': ('png', 'wav', 'txt')})
 
     def test_rebaseline_test_passes_everywhere(self):
         test_port = self.tool.port_factory.get('test')
 
-        def builder_data():
-            self._builder_data['MOCK Mac10.10'] = self._builder_data['MOCK Mac10.11'] = LayoutTestResults({
+        def build_data():
+            self._build_data[Build('MOCK Mac10.10')] = self._build_data[Build('MOCK Mac10.11')] = LayoutTestResults({
                 "tests": {
                     "fast": {
                         "dom": {
                             "prototype-taco.html": {
                                 "expected": "FAIL",
                                 "actual": "PASS",
                                 "is_unexpected": True
                             }
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ Rebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
         self.tool.builders = BuilderList({
             "MOCK Mac10.10": {"port_name": "test-mac-mac10.10", "specifiers": ["Mac10.10", "Release"]},
             "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": ["Mac10.11", "Release"]},
         })
 
         self.command.execute(self.options, [], self.tool)
         self.assertEqual(self.tool.executive.calls, [])
 
         # The mac ports should both be removed since they're the only ones in the builder list.
         self.assertEqual(self.tool.filesystem.read_text_file(test_port.path_to_generic_test_expectations_file()), """
 Bug(foo) [ Linux Win ] fast/dom/prototype-taco.html [ Rebaseline ]
 """)
 
     def test_rebaseline_missing(self):
-        def builder_data():
-            self._builder_data['MOCK Mac10.10'] = LayoutTestResults({
+        def build_data():
+            self._build_data[Build('MOCK Mac10.10')] = LayoutTestResults({
                 "tests": {
                     "fast": {
                         "dom": {
                             "missing-text.html": {
                                 "expected": "PASS",
                                 "actual": "MISSING",
                                 "is_unexpected": True,
                                 "is_missing_text": True
                             },
                             "missing-text-and-image.html": {
                                 "expected": "PASS",
                                 "actual": "MISSING",
                                 "is_unexpected": True,
                                 "is_missing_text": True,
                                 "is_missing_image": True
                             },
                             "missing-image.html": {
                                 "expected": "PASS",
                                 "actual": "MISSING",
                                 "is_unexpected": True,
                                 "is_missing_image": True
                             }
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self._write('fast/dom/missing-text.html', "Dummy test contents")
         self._write('fast/dom/missing-text-and-image.html', "Dummy test contents")
         self._write('fast/dom/missing-image.html', "Dummy test contents")
 
         self.command._tests_to_rebaseline = lambda port: {
             'fast/dom/missing-text.html': set(['txt', 'png']),
             'fast/dom/missing-text-and-image.html': set(['txt', 'png']),
             'fast/dom/missing-image.html': set(['txt', 'png']),
         }
@@ skipping 214 matching lines @@
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-06-14 20:18:46 +0000   11) crbug.com/24182 [ Mac10.11 ] fast/dom/prototype-strawberry.html [ NeedsRebaseline ]
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   12) crbug.com/24182 fast/dom/prototype-chocolate.html [ NeedsRebaseline ]
 624caaaaaa path/to/TestExpectations                   (<foo@chromium.org>        2013-04-28 04:52:41 +0000   12) crbug.com/24182 path/to/not-cycled-through-bots.html [ NeedsRebaseline ]
 0000000000 path/to/TestExpectations                   (<foo@chromium.org>        2013-04-28 04:52:41 +0000   12) crbug.com/24182 path/to/locally-changed-lined.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self.tool.port_factory.get('test')
 
-        def builder_data():
+        def build_data():
             # Have prototype-chocolate only fail on "MOCK Mac10.11".
-            self._builder_data['MOCK Mac10.11'] = LayoutTestResults({
+            self._build_data[Build('MOCK Mac10.11')] = LayoutTestResults({
                 "tests": {
                     "fast": {
                         "dom": {
                             "prototype-taco.html": {
                                 "expected": "PASS",
                                 "actual": "PASS TEXT",
                                 "is_unexpected": True
                             },
                             "prototype-chocolate.html": {
                                 "expected": "FAIL",
                                 "actual": "PASS"
                             },
                             "prototype-strawberry.html": {
                                 "expected": "PASS",
                                 "actual": "IMAGE PASS",
                                 "is_unexpected": True
                             }
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 crbug.com/24182 [ Debug ] path/to/norebaseline.html [ Rebaseline ]
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 crbug.com/24182 [ Mac10.11 ] fast/dom/prototype-strawberry.html [ NeedsRebaseline ]
 crbug.com/24182 fast/dom/prototype-chocolate.html [ NeedsRebaseline ]
 crbug.com/24182 path/to/not-cycled-through-bots.html [ NeedsRebaseline ]
 crbug.com/24182 path/to/locally-changed-lined.html [ NeedsRebaseline ]
 """)
 
@@ skipping 52 matching lines @@
 
     def test_execute_git_cl_hangs(self):
         def blame(_):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self.tool.port_factory.get('test')
 
-        original_builder_data = self.command.builder_data
-        def builder_data():
-            original_builder_data()
+        original_build_data = self.command.build_data
+
+        def build_data():
+            original_build_data()
             # Have prototype-chocolate only fail on "MOCK Mac10.11".
-            self._builder_data['MOCK Mac10.11'] = LayoutTestResults({
+            self._build_data[Build('MOCK Mac10.11')] = LayoutTestResults({
                 "tests": {
                     "fast": {
                         "dom": {
                             "prototype-taco.html": {
                                 "expected": "PASS",
                                 "actual": "PASS TEXT",
                                 "is_unexpected": True
                             }
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.builders = BuilderList({
             "MOCK Mac10.11": {"port_name": "test-mac-mac10.11", "specifiers": ["Mac10.11", "Release"]},
         })
@@ skipping 19 matching lines @@
 
     def test_execute_test_passes_everywhere(self):
         def blame(_):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self.tool.port_factory.get('test')
 
-        def builder_data():
-            self._builder_data['MOCK Mac10.10'] = self._builder_data['MOCK Mac10.11'] = LayoutTestResults({
+        def build_data():
+            self._build_data[Build('MOCK Mac10.10')] = self._build_data[Build('MOCK Mac10.11')] = LayoutTestResults({
                 "tests": {
                     "fast": {
                         "dom": {
                             "prototype-taco.html": {
                                 "expected": "FAIL",
                                 "actual": "PASS",
                                 "is_unexpected": True
                             }
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
         self.tool.builders = BuilderList({
@@ skipping 17 matching lines @@
 
     def test_execute_use_alternate_rebaseline_branch(self):
         def blame(_):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self.tool.port_factory.get('test')
 
-        def builder_data():
-            self._builder_data['MOCK Win'] = LayoutTestResults({
+        def build_data():
+            self._build_data[Build('MOCK Win')] = LayoutTestResults({
                 "tests": {
                     "fast": {
                         "dom": {
                             "prototype-taco.html": {
                                 "expected": "FAIL",
                                 "actual": "PASS",
                                 "is_unexpected": True
                             }
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
         self.tool.builders = BuilderList({
@@ skipping 19 matching lines @@
 
     def test_execute_stuck_on_alternate_rebaseline_branch(self):
         def blame(_):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self.tool.port_factory.get('test')
 
-        def builder_data():
-            self._builder_data['MOCK Win'] = LayoutTestResults({
+        def build_data():
+            self._build_data[Build('MOCK Win')] = LayoutTestResults({
                 "tests": {
                     "fast": {
                         "dom": {
                             "prototype-taco.html": {
                                 "expected": "FAIL",
                                 "actual": "PASS",
                                 "is_unexpected": True
                             }
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
         self.tool.builders = BuilderList({
@@ skipping 20 matching lines @@
 
     def _basic_execute_test(self, expected_executive_calls, auth_refresh_token_json=None, commit_author=None, dry_run=False):
         def blame(_):
             return """
 6469e754a1 path/to/TestExpectations                   (<foobarbaz1@chromium.org> 2013-04-28 04:52:41 +0000   13) Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """
         self.tool.scm().blame = blame
 
         test_port = self.tool.port_factory.get('test')
 
-        def builder_data():
-            self._builder_data['MOCK Mac10.10'] = self._builder_data['MOCK Mac10.11'] = LayoutTestResults({
+        def build_data():
+            self._build_data[Build('MOCK Mac10.10')] = self._build_data[Build('MOCK Mac10.11')] = LayoutTestResults({
                 "tests": {
                     "fast": {
                         "dom": {
                             "prototype-taco.html": {
                                 "expected": "FAIL",
                                 "actual": "PASS",
                                 "is_unexpected": True
                             }
                         }
                     }
                 }
             })
-            return self._builder_data
+            return self._build_data
 
-        self.command.builder_data = builder_data
+        self.command.build_data = build_data
 
         self.tool.filesystem.write_text_file(test_port.path_to_generic_test_expectations_file(), """
 Bug(foo) fast/dom/prototype-taco.html [ NeedsRebaseline ]
 """)
 
         self._write_test_file(test_port, 'fast/dom/prototype-taco.html', "Dummy test contents")
 
         self.tool.executive = MockLineRemovingExecutive()
 
         self.tool.builders = BuilderList({
@@ skipping 18 matching lines @@
                 ['git', 'cl', 'upload', '-f', '--auth-refresh-token-json', RIETVELD_REFRESH_TOKEN],
                 ['git', 'pull'],
                 ['git', 'cl', 'land', '-f', '-v', '--auth-refresh-token-json', RIETVELD_REFRESH_TOKEN],
                 ['git', 'config', 'branch.auto-rebaseline-temporary-branch.rietveldissue'],
             ],
             auth_refresh_token_json=RIETVELD_REFRESH_TOKEN)
 
     def test_execute_with_dry_run(self):
         self._basic_execute_test([], dry_run=True)
         self.assertEqual(self.tool.scm().local_commits(), [])