Change logging statements to not use the "%" operator.

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 131 matching lines @@
                  for baseline in self._immediate_predecessors_in_fallback(baseline_directory)]
 
         old_baselines = []
         new_baselines = []
 
         # Need to gather all the baseline paths before modifying the filesystem since
         # the modifications can affect the results of port.expected_filename.
         for port in ports:
             old_baseline = port.expected_filename(test_name, "." + suffix)
             if not self._tool.filesystem.exists(old_baseline):
-                _log.debug("No existing baseline for %s." % test_name)
+                _log.debug("No existing baseline for %s.", test_name)
                 continue
 
             new_baseline = self._tool.filesystem.join(port.baseline_path(), self._file_name_for_expected_result(test_name, suffix))
             if self._tool.filesystem.exists(new_baseline):
-                _log.debug("Existing baseline at %s, not copying over it." % new_baseline)
+                _log.debug("Existing baseline at %s, not copying over it.", new_baseline)
                 continue
 
             expectations = TestExpectations(port, [test_name])
             if SKIP in expectations.get_expectations(test_name):
-                _log.debug("%s is skipped on %s." % (test_name, port.name()))
+                _log.debug("%s is skipped on %s.", test_name, port.name())
                 continue
 
             old_baselines.append(old_baseline)
             new_baselines.append(new_baseline)
 
         for i in range(len(old_baselines)):
             old_baseline = old_baselines[i]
             new_baseline = new_baselines[i]
 
-            _log.debug("Copying baseline from %s to %s." % (old_baseline, new_baseline))
+            _log.debug("Copying baseline from %s to %s.", old_baseline, new_baseline)
             self._tool.filesystem.maybe_make_directory(self._tool.filesystem.dirname(new_baseline))
             self._tool.filesystem.copyfile(old_baseline, new_baseline)
             if not self._tool.scm().exists(new_baseline):
                 self._add_to_scm_later(new_baseline)
 
     def execute(self, options, args, tool):
         for suffix in options.suffixes.split(','):
             self._copy_existing_baseline(options.builder, options.test, suffix)
         self._print_scm_changes()
 
@@ skipping 12 matching lines @@
         filesystem.write_binary_file(target_baseline, data)
         if not self._tool.scm().exists(target_baseline):
             self._add_to_scm_later(target_baseline)
 
     def _rebaseline_test(self, builder_name, test_name, suffix, results_url):
         baseline_directory = self._baseline_directory(builder_name)
 
         source_baseline = "%s/%s" % (results_url, self._file_name_for_actual_result(test_name, suffix))
         target_baseline = self._tool.filesystem.join(baseline_directory, self._file_name_for_expected_result(test_name, suffix))
 
-        _log.debug("Retrieving source %s for target %s." % (source_baseline, target_baseline))
+        _log.debug("Retrieving source %s for target %s.", source_baseline, target_baseline)
         self._save_baseline(self._tool.web.get_binary(source_baseline, convert_404_to_None=True),
                             target_baseline)
 
     def _rebaseline_test_and_update_expectations(self, options):
         self._baseline_suffix_list = options.suffixes.split(',')
 
         port = self._tool.port_factory.get_from_builder_name(options.builder)
         if port.reference_files(options.test):
             if 'png' in self._baseline_suffix_list:
                 _log.warning("Cannot rebaseline image result for reftest: %s", options.test)
@@ skipping 196 matching lines @@
                             files_to_delete.update(parsed_line['delete'])
                         if 'remove-lines' in parsed_line:
                             for line_to_remove in parsed_line['remove-lines']:
                                 test = line_to_remove['test']
                                 builder = line_to_remove['builder']
                                 if test not in lines_to_remove:
                                     lines_to_remove[test] = []
                                 lines_to_remove[test].append(builder)
                         file_added = True
                 except ValueError:
-                    _log.debug('"%s" is not a JSON object, ignoring' % line)
+                    _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)
+                _log.debug('Could not add file based off output "%s"', output)
 
         return list(files_to_add), list(files_to_delete), lines_to_remove
 
     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:
@@ skipping 92 matching lines @@
                 (build 100), and new text baselines should be downloaded for
                 "some/other.html" but only from builder-1.
                 TODO(qyearsley): Replace test_prefix_list everywhere with some
                 sort of class that contains the same data.
             skip_checking_actual_results: If True, then the lists of suffixes
                 to rebaseline from |test_prefix_list| will be used directly;
                 if False, then the list of suffixes will filtered to include
                 suffixes with mismatches in actual results.
         """
         for test, builds_to_check in sorted(test_prefix_list.items()):
-            _log.info("Rebaselining %s" % test)
+            _log.info("Rebaselining %s", test)
             for build, suffixes in sorted(builds_to_check.items()):
-                _log.debug("  %s: %s" % (build, ",".join(suffixes)))
+                _log.debug("  %s: %s", build, ",".join(suffixes))
 
         copy_baseline_commands, rebaseline_commands, extra_lines_to_remove = self._rebaseline_commands(
             test_prefix_list, options, skip_checking_actual_results)
         lines_to_remove = {}
 
         self._run_in_parallel_and_update_scm(copy_baseline_commands)
         lines_to_remove = self._run_in_parallel_and_update_scm(rebaseline_commands)
 
         for test in extra_lines_to_remove:
             if test in lines_to_remove:
@@ skipping 63 matching lines @@
                 tests_to_rebaseline[test] = suffixes or BASELINE_SUFFIX_LIST
         return tests_to_rebaseline
 
     def _add_tests_to_rebaseline_for_port(self, port_name):
         builder_name = self._tool.builders.builder_name_for_port_name(port_name)
         if not builder_name:
             return
         tests = self._tests_to_rebaseline(self._tool.port_factory.get(port_name)).items()
 
         if tests:
-            _log.info("Retrieving results for %s from %s." % (port_name, builder_name))
+            _log.info("Retrieving results for %s from %s.", port_name, builder_name)
 
         for test_name, suffixes in tests:
-            _log.info("    %s (%s)" % (test_name, ','.join(suffixes)))
+            _log.info("    %s (%s)", test_name, ','.join(suffixes))
             if test_name not in self._test_prefix_list:
                 self._test_prefix_list[test_name] = {}
             self._test_prefix_list[test_name][Build(builder_name)] = suffixes
 
     def execute(self, options, args, tool):
         options.results_directory = None
         self._test_prefix_list = {}
         port_names = tool.port_factory.all_port_names(options.platform)
         for port_name in port_names:
             self._add_tests_to_rebaseline_for_port(port_name)
@@ skipping 86 matching lines @@
                 )
                 .*?([^ ]*)  # Test file name
                 \ \[        # Single space followed by opening [ for expectation specifier
                 [^[]*$      # Prevents matching previous [ for version specifiers instead of expectation specifiers
             """, re.VERBOSE)
 
     def bot_revision_data(self, scm):
         revisions = []
         for result in self.build_data().values():
             if result.run_was_interrupted():
-                _log.error("Can't rebaseline because the latest run on %s exited early." % result.builder_name())
+                _log.error("Can't rebaseline because the latest run on %s exited early.", result.builder_name())
                 return []
             revisions.append({
                 "builder": result.builder_name(),
                 "revision": result.chromium_revision(scm),
             })
         return revisions
 
     def _strip_comments(self, line):
         comment_index = line.find("#")
         if comment_index == -1:
@@ skipping 16 matching lines @@
             if "NeedsRebaseline" not in line:
                 continue
 
             has_any_needs_rebaseline_lines = True
 
             parsed_line = self._blame_regex.match(line)
             if not parsed_line:
                 # Deal gracefully with inability to parse blame info for a line in TestExpectations.
                 # Parsing could fail if for example during local debugging the developer modifies
                 # TestExpectations and does not commit.
-                _log.info("Couldn't find blame info for expectations line, skipping [line=%s]." % line)
+                _log.info("Couldn't find blame info for expectations line, skipping [line=%s].", line)
                 continue
 
             commit_hash = parsed_line.group(1)
             commit_position = tool.scm().commit_position_from_git_commit(commit_hash)
 
             test = parsed_line.group(3)
             if print_revisions:
-                _log.info("%s is waiting for r%s" % (test, commit_position))
+                _log.info("%s is waiting for r%s", test, commit_position)
 
             if not commit_position or commit_position > min_revision:
                 continue
 
             if revision and commit_position != revision:
                 continue
 
             if not revision:
                 revision = commit_position
                 commit = commit_hash
                 author = parsed_line.group(2)
 
             bugs.update(re.findall(r"crbug\.com\/(\d+)", line))
             tests.add(test)
 
             if len(tests) >= self.MAX_LINES_TO_REBASELINE:
-                _log.info("Too many tests to rebaseline in one patch. Doing the first %d." % self.MAX_LINES_TO_REBASELINE)
+                _log.info("Too many tests to rebaseline in one patch. Doing the first %d.", self.MAX_LINES_TO_REBASELINE)
                 break
 
         return tests, revision, commit, author, bugs, has_any_needs_rebaseline_lines
 
     def link_to_patch(self, commit):
         return "https://chromium.googlesource.com/chromium/src/+/" + commit
 
     def commit_message(self, author, revision, commit, bugs):
         bug_string = ""
         if bugs:
@@ skipping 42 matching lines @@
         while process.poll() is None and time.time() < last_output_time + self.SECONDS_BEFORE_GIVING_UP:
             # FIXME: This doesn't make any sense. readline blocks, so all this code to
             # try and bail is useless. Instead, we should do the readline calls on a
             # subthread. Then the rest of this code would make sense.
             out = process.stdout.readline().rstrip('\n')
             if out:
                 last_output_time = time.time()
                 _log.info(out)
 
         if process.poll() is None:
-            _log.error('Command hung: %s' % subprocess_command)
+            _log.error('Command hung: %s', subprocess_command)
             return False
         return True
 
     # FIXME: Move this somewhere more general.
     def tree_status(self):
         blink_tree_status_url = "http://chromium-status.appspot.com/status"
         status = urllib2.urlopen(blink_tree_status_url).read().lower()
         if 'closed' in status or status == "0":
             return 'closed'
         elif 'open' in status or status == "1":
@@ skipping 11 matching lines @@
 
         revision_data = self.bot_revision_data(tool.scm())
         if not revision_data:
             return
 
         min_revision = int(min([item["revision"] for item in revision_data]))
         tests, revision, commit, author, bugs, _ = self.tests_to_rebaseline(
             tool, min_revision, print_revisions=options.verbose)
 
         if options.verbose:
-            _log.info("Min revision across all bots is %s." % min_revision)
+            _log.info("Min revision across all bots is %s.", min_revision)
             for item in revision_data:
-                _log.info("%s: r%s" % (item["builder"], item["revision"]))
+                _log.info("%s: r%s", item["builder"], item["revision"])
 
         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))
+        _log.info('Rebaselining %s for r%s by %s.', list(tests), revision, author)
 
         test_prefix_list, _ = self.get_test_prefix_list(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.scm().current_branch_or_ref()
@@ skipping 35 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.scm().ensure_cleanly_tracking_remote_master()
                 if old_branch_name_or_ref:
                     tool.scm().checkout_branch(old_branch_name_or_ref)
                 tool.scm().delete_branch(rebaseline_branch_name)