Do follow-up refactoring in rebaseline.py in _run_in_parallel and _serial_commands.

third_party/WebKit/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 66 matching lines @@
      (1) files that have been added or removed.
      (2) lines to remove from TestExpectations.
 
     The reason for keeping track of these changes together is that after rebaselining
     many tests in parallel by subprocesses, we can update the git staged files list
     and the TestExpectations all at once at the end.
 
     Each subprocess can communicate some set of changes by outputting JSON lines,
     and another process can aggregate the changes.
 
-    TODO(qyearsley): Refactor this so that:
-     - lines to remove are only tracked in one format.
-     - files to add and delete are always disjoint sets.
+    TODO(qyearsley): Refactor this so that lines to remove are only tracked in one format.
     """
     def __init__(self, files_to_add=None, files_to_delete=None, lines_to_remove=None):
         self._files_to_add = set(files_to_add or [])
         self._files_to_delete = set(files_to_delete or [])
         lines_to_remove = lines_to_remove or {}
         self._lines_to_remove = {t: set(builders) for t, builders in lines_to_remove.iteritems()}
 
     def add_file(self, path):
         self._files_to_add.add(path)
 
@@ skipping 308 matching lines @@
                         cmd_line.extend(['--results-directory', options.results_directory])
                     if options.verbose:
                         cmd_line.append('--verbose')
                     copy_baseline_commands.append(
                         tuple([[self._tool.executable, path_to_webkit_patch, 'copy-existing-baselines-internal'] + cmd_line, cwd]))
                     rebaseline_commands.append(
                         tuple([[self._tool.executable, path_to_webkit_patch, 'rebaseline-test-internal'] + cmd_line, cwd]))
         return copy_baseline_commands, rebaseline_commands, lines_to_remove
 
     @staticmethod
-    def _serial_commands(command_results):
-        """Parses the JSON lines from command output to extract SCM changes.
-
-        TODO(qyearsley): Refactor and rename this function.
-        """
+    def _extract_scm_changes(command_results):
+        """Parses the JSON lines from sub-command output and returns the result as a ChangeSet."""
         change_set = ChangeSet()
-        for output in [result[1].split('\n') for result in command_results]:
-            file_added = False
-            for line in output:
+        for _, stdout, _ in command_results:
+            updated = False
+            for line in filter(None, stdout.splitlines()):
                 try:
-                    if line:
-                        parsed_line = json.loads(line)
-                        change_set.update(ChangeSet.from_dict(parsed_line))
-                        file_added = True
+                    parsed_line = json.loads(line)
+                    change_set.update(ChangeSet.from_dict(parsed_line))
+                    updated = True
                 except ValueError:
                     _log.debug('"%s" is not a JSON object, ignoring', line)
-
-            if not file_added:
-                _log.debug('Could not add file based off output "%s"', output)
-
+            if not updated:
+                # TODO(qyearsley): This probably should be an error. See http://crbug.com/649412.
+                _log.debug('Could not add file based off output "%s"', stdout)
         return change_set
 
     def _optimize_baselines(self, test_prefix_list, verbose=False):
         optimize_commands = []
         for test in test_prefix_list:
             all_suffixes = set()
             builders_to_fetch_from = self._builders_to_fetch_from(self._builder_names(test_prefix_list[test]))
             for build in sorted(test_prefix_list[test]):
                 if build.builder_name not in builders_to_fetch_from:
                     break
@@ skipping 55 matching lines @@
             if fs.exists(smoke_test_filename) and test not in fs.read_text_file(smoke_test_filename):
                 return True
 
         return (SKIP in full_expectations.get_expectations(test) and
                 SKIP not in generic_expectations.get_expectations(test))
 
     def _run_in_parallel(self, commands):
         if not commands:
             return ChangeSet()
 
-        # TODO(qyearsley): Refactor this block.
         command_results = self._tool.executive.run_in_parallel(commands)
-        log_output = '\n'.join(result[2] for result in command_results).replace('\n\n', '\n')
-        for line in log_output.split('\n'):
-            if line:
-                _log.error(line)
+        for _, _, stderr in command_results:
+            if stderr:
+                _log.error(stderr)
 
-        return self._serial_commands(command_results)
+        return self._extract_scm_changes(command_results)
 
     def _rebaseline(self, options, test_prefix_list):
         """Downloads new baselines in parallel, then updates expectations files
         and optimizes baselines.
 
         Args:
             options: An object with the options passed to the current command.
             test_prefix_list: A map of test names to Build objects to file suffixes
                 for new baselines. For example:
                 {
@@ skipping 162 matching lines @@
             for test in args:
                 if test not in test_prefix_list:
                     test_prefix_list[test] = {}
                 build = Build(builder)
                 test_prefix_list[test][build] = suffixes_to_update
 
         if options.verbose:
             _log.debug("rebaseline-json: " + str(test_prefix_list))
 
         self._rebaseline(options, test_prefix_list)