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

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py

 # Copyright (C) 2010 Google Inc. All rights reserved.
 # Copyright (C) 2010 Gabor Rapcsanyi (rgabor@inf.u-szeged.hu), University of Szeged
 #
 # 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
@@ skipping 131 matching lines @@
             tests_to_retry = self._tests_to_retry(initial_results)
             all_retry_results = []
             if should_retry_failures and tests_to_retry:
                 enabled_pixel_tests_in_retry = self._force_pixel_tests_if_needed()
 
                 for retry_attempt in xrange(1, self._options.num_retries + 1):
                     if not tests_to_retry:
                         break
 
                     _log.info('')
-                    _log.info('Retrying %s, attempt %d of %d...' %
-                              (grammar.pluralize('unexpected failure', len(tests_to_retry)),
-                               retry_attempt, self._options.num_retries))
+                    _log.info('Retrying %s, attempt %d of %d...',
+                              grammar.pluralize('unexpected failure', len(tests_to_retry)),
+                              retry_attempt, self._options.num_retries)
 
                     retry_results = self._run_tests(tests_to_retry,
                                                     tests_to_skip=set(),
                                                     repeat_each=1,
                                                     iterations=1,
                                                     num_workers=num_workers,
                                                     retry_attempt=retry_attempt)
                     all_retry_results.append(retry_results)
 
                     tests_to_retry = self._tests_to_retry(retry_results)
@@ skipping 14 matching lines @@
         _log.debug("summarizing results")
         summarized_full_results = test_run_results.summarize_results(
             self._port, self._expectations, initial_results, all_retry_results,
             enabled_pixel_tests_in_retry)
         summarized_failing_results = test_run_results.summarize_results(
             self._port, self._expectations, initial_results, all_retry_results,
             enabled_pixel_tests_in_retry, only_include_failing=True)
 
         exit_code = summarized_failing_results['num_regressions']
         if exit_code > test_run_results.MAX_FAILURES_EXIT_STATUS:
-            _log.warning('num regressions (%d) exceeds max exit status (%d)' %
-                         (exit_code, test_run_results.MAX_FAILURES_EXIT_STATUS))
+            _log.warning('num regressions (%d) exceeds max exit status (%d)',
+                         exit_code, test_run_results.MAX_FAILURES_EXIT_STATUS)
             exit_code = test_run_results.MAX_FAILURES_EXIT_STATUS
 
         if not self._options.dry_run:
             self._write_json_files(summarized_full_results, summarized_failing_results, initial_results, running_all_tests)
 
             if self._options.write_full_results_to:
                 self._filesystem.copyfile(self._filesystem.join(self._results_directory, "full_results.json"),
                                           self._options.write_full_results_to)
 
             self._upload_json_files()
@@ skipping 269 matching lines @@
         # Port specific clean-up.
         self._port.clobber_old_port_specific_results()
 
     def _tests_to_retry(self, run_results):
         # TODO(ojan): This should also check that result.type != test_expectations.MISSING since retrying missing expectations is silly.
         # But that's a bit tricky since we only consider the last retry attempt for the count of unexpected regressions.
         return [result.test_name for result in run_results.unexpected_results_by_name.values(
         ) if result.type != test_expectations.PASS]
 
     def _write_json_files(self, summarized_full_results, summarized_failing_results, initial_results, running_all_tests):
-        _log.debug("Writing JSON files in %s." % self._results_directory)
+        _log.debug("Writing JSON files in %s.", self._results_directory)
 
         # FIXME: Upload stats.json to the server and delete times_ms.
         times_trie = json_results_generator.test_timings_trie(initial_results.results_by_name.values())
         times_json_path = self._filesystem.join(self._results_directory, "times_ms.json")
         json_results_generator.write_json(self._filesystem, times_trie, times_json_path)
 
         # Save out the times data so we can use it for --fastest in the future.
         if running_all_tests:
             bot_test_times_path = self._port.bot_test_times_path()
             self._filesystem.maybe_make_directory(self._filesystem.dirname(bot_test_times_path))
@@ skipping 35 matching lines @@
         url = "http://%s/testfile/upload" % self._options.test_results_server
         # Set uploading timeout in case appengine server is having problems.
         # 120 seconds are more than enough to upload test results.
         uploader = FileUploader(url, 120)
         try:
             response = uploader.upload_as_multipart_form_data(self._filesystem, files, attrs)
             if response:
                 if response.code == 200:
                     _log.debug("JSON uploaded.")
                 else:
-                    _log.debug("JSON upload failed, %d: '%s'" % (response.code, response.read()))
+                    _log.debug("JSON upload failed, %d: '%s'", response.code, response.read())
             else:
                 _log.error("JSON upload failed; no response returned")
         except Exception as err:
-            _log.error("Upload failed: %s" % err)
+            _log.error("Upload failed: %s", err)
 
     def _copy_results_html_file(self, destination_path):
         base_dir = self._port.path_from_webkit_base('LayoutTests', 'fast', 'harness')
         results_file = self._filesystem.join(base_dir, 'results.html')
         # Note that the results.html template file won't exist when we're using a MockFileSystem during unit tests,
         # so make sure it exists before we try to copy it.
         if self._filesystem.exists(results_file):
             self._filesystem.copyfile(results_file, destination_path)
 
     def _stats_trie(self, initial_results):
         def _worker_number(worker_name):
             return int(worker_name.split('/')[1]) if worker_name else -1
 
         stats = {}
         for result in initial_results.results_by_name.values():
             if result.type != test_expectations.SKIP:
                 stats[result.test_name] = {'results': (_worker_number(result.worker_name), result.test_number, result.pid, int(
                     result.test_run_time * 1000), int(result.total_run_time * 1000))}
         stats_trie = {}
         for name, value in stats.iteritems():
             json_results_generator.add_path_to_trie(name, value, stats_trie)
         return stats_trie