rebaseline-cl: Enable filling in missing results if no results could be fetched.

third_party/WebKit/Tools/Scripts/webkitpy/tool/commands/rebaseline_cl.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 fetch new baselines from try jobs for the current CL."""
 
 import json
 import logging
 import optparse
 
@@ skipping 59 matching lines @@
             for builder in sorted(builders_with_pending_builds):
                 _log.info('  %s', builder)
         builders_with_no_results = self.builders_with_no_results(builds)
 
         if options.trigger_jobs and builders_with_no_results:
             self.trigger_builds(builders_with_no_results)
             _log.info('Please re-run webkit-patch rebaseline-cl once all pending try jobs have finished.')
             return 1
 
         if builders_with_no_results and not options.fill_missing:
-            # TODO(qyearsley): Support trying to continue as long as there are
-            # some results from some builder; see http://crbug.com/673966.
             _log.error('The following builders have no results:')
             for builder in builders_with_no_results:
                 _log.error('  %s', builder)
             return 1
 
         _log.debug('Getting results for issue %d.', issue_number)
         builds_to_results = self._fetch_results(builds)
-        if builds_to_results is None:
+        if not options.fill_missing and len(builds_to_results) < len(builds):
             return 1
 
         test_baseline_set = TestBaselineSet(tool)
         if args:
             for test in args:
                 for build in builds:
+                    if not builds_to_results.get(build):
+                        continue
                     test_baseline_set.add(test, build)
         else:
             test_baseline_set = self._make_test_baseline_set(
                 builds_to_results,
                 only_changed_tests=options.only_changed_tests)
 
         if options.fill_missing:
             self.fill_in_missing_results(test_baseline_set)
 
         _log.debug('Rebaselining: %s', test_baseline_set)
@@ skipping 47 matching lines @@
         Returns:
             A dict mapping Build to LayoutTestResults, or None if any results
             were not available.
         """
         buildbot = self._tool.buildbot
         results = {}
         for build in builds:
             results_url = buildbot.results_url(build.builder_name, build.build_number)
             layout_test_results = buildbot.fetch_results(build)
             if layout_test_results is None:
-                _log.error('Failed to fetch results for: %s', build)
-                _log.error('Results were expected to exist at:\n%s/results.html', results_url)
-                _log.error('If the job failed, you could retry by running:\ngit cl try -b %s', build.builder_name)
-                return None
+                _log.info('Failed to fetch results for %s', build)
+                _log.info('Results URL: %s/results.html', results_url)
+                _log.info('Retry job by running: git cl try -b %s', build.builder_name)
+                continue
             results[build] = layout_test_results
         return results
 
     def _make_test_baseline_set(self, builds_to_results, only_changed_tests):
         """Returns a dict which lists the set of baselines to fetch.
 
         The dict that is returned is a dict of tests to Build objects
         to baseline file extensions.
 
         Args:
@@ skipping 54 matching lines @@
         """Modifies test_baseline_set to guarantee that there are entries for
         all ports for all tests to rebaseline.
 
         For each test prefix, if there is an entry missing for some port,
         then an entry should be added for that port using a build that is
         available. For example, if there's no entry for the port "win-win7",
         then an entry might be added for "win-win7" using a build on
         a Win10 builder which does have results.
         """
         all_ports = {self._tool.builders.port_name_for_builder_name(b) for b in self._try_bots()}
+        print test_baseline_set

[wkorman, 2017/04/13 16:45:53]

debugging?

         for test_prefix in test_baseline_set.test_prefixes():
             build_port_pairs = test_baseline_set.build_port_pairs(test_prefix)
             missing_ports = all_ports - {p for _, p in build_port_pairs}
             if not missing_ports:
                 continue
             _log.info('For %s:', test_prefix)
             for port in missing_ports:
                 build = self._choose_fill_in_build(port, build_port_pairs)
                 _log.info('Using %s to supply results for %s.', build, port)
                 test_baseline_set.add(test_prefix, build, port)
         return test_baseline_set
 
     def _choose_fill_in_build(self, _, build_port_pairs):
         """Returns a Build to use to supply results for the given port.
 
         Ideally, this should return a build for a similar port so that the
         results from the selected build may also be correct for the target port.
         """
         # TODO(qyearsley): Decide what build to use for a given port
         # in a more sophisticated way, such that a build with a
         # "similar" port will be used when available.
         return build_port_pairs[0][0]