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

third_party/WebKit/Tools/Scripts/webkitpy/performance_tests/perftestsrunner.py

 # Copyright (C) 2012 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 134 matching lines @@
 
         paths = []
         for arg in self._args:
             if filesystem.exists(filesystem.join(self._base_path, arg)):
                 paths.append(arg)
             else:
                 relpath = filesystem.relpath(arg, self._base_path)
                 if filesystem.exists(filesystem.join(self._base_path, relpath)):
                     paths.append(filesystem.normpath(relpath))
                 else:
-                    _log.warn('Path was not found:' + arg)
+                    _log.warning('Path was not found:' + arg)
 
         skipped_directories = set(['.svn', 'resources'])
         test_files = find_files.find(filesystem, self._base_path, paths, skipped_directories, _is_test_file)
         tests = []
         for path in test_files:
             relative_path = filesystem.relpath(path, self._base_path).replace('\\', '/')
             if self._options.use_skipped_list and self._port.skips_perf_test(
                     relative_path) and filesystem.normpath(relative_path) not in paths:
                 continue
             test = PerfTestFactory.create_perf_test(self._port, relative_path, path,
@@ skipping 25 matching lines @@
             _log.error("Build not up to date for %s" % self._port._path_to_driver())
             return self.EXIT_CODE_BAD_BUILD
 
         run_count = 0
         repeat = self._options.repeat
         while run_count < repeat:
             run_count += 1
 
             tests = self._collect_tests()
             runs = ' (Run %d of %d)' % (run_count, repeat) if repeat > 1 else ''
-            _log.info("Running %d tests%s" % (len(tests), runs))
+            _log.info("Running %d tests%s", len(tests), runs)
 
             for test in tests:
                 if not test.prepare(self._options.time_out_ms):
                     return self.EXIT_CODE_BAD_PREPARATION
 
             try:
                 if needs_http:
                     self._start_http_servers()
                 unexpected = self._run_tests_set(sorted(list(tests), key=lambda test: test.test_name()))
 
@@ skipping 94 matching lines @@
                         tests = current_test['tests']
 
         return contents
 
     @staticmethod
     def _datetime_in_ES5_compatible_iso_format(datetime):
         return datetime.strftime('%Y-%m-%dT%H:%M:%S.%f')
 
     def _merge_slave_config_json(self, slave_config_json_path, contents):
         if not self._host.filesystem.isfile(slave_config_json_path):
-            _log.error("Missing slave configuration JSON file: %s" % slave_config_json_path)
+            _log.error("Missing slave configuration JSON file: %s", slave_config_json_path)
             return None
 
         try:
             slave_config_json = self._host.filesystem.open_text_file_for_reading(slave_config_json_path)
             slave_config = json.load(slave_config_json)
             for key in slave_config:
                 contents['builder' + key.capitalize()] = slave_config[key]
             return contents
         except Exception as error:
-            _log.error("Failed to merge slave configuration JSON file %s: %s" % (slave_config_json_path, error))
+            _log.error("Failed to merge slave configuration JSON file %s: %s", slave_config_json_path, error)
         return None
 
     def _merge_outputs_if_needed(self, output_json_path, output):
         if self._options.reset_results or not self._host.filesystem.isfile(output_json_path):
             return [output]
         try:
             existing_outputs = json.loads(self._host.filesystem.read_text_file(output_json_path))
             return existing_outputs + [output]
         except Exception as error:
-            _log.error("Failed to merge output JSON file %s: %s" % (output_json_path, error))
+            _log.error("Failed to merge output JSON file %s: %s", output_json_path, error)
         return None
 
     def _upload_json(self, test_results_server, json_path, host_path="/api/report", file_uploader=FileUploader):
         url = "https://%s%s" % (test_results_server, host_path)
         uploader = file_uploader(url, 120)
         try:
             response = uploader.upload_single_text_file(self._host.filesystem, 'application/json', json_path)
         except Exception as error:
-            _log.error("Failed to upload JSON file to %s in 120s: %s" % (url, error))
+            _log.error("Failed to upload JSON file to %s in 120s: %s", url, error)
             return False
 
         response_body = [line.strip('\n') for line in response]
         if response_body != ['OK']:
             try:
                 parsed_response = json.loads('\n'.join(response_body))
             except:
-                _log.error("Uploaded JSON to %s but got a bad response:" % url)
+                _log.error("Uploaded JSON to %s but got a bad response:", url)
                 for line in response_body:
                     _log.error(line)
                 return False
             if parsed_response.get('status') != 'OK':
-                _log.error("Uploaded JSON to %s but got an error:" % url)
+                _log.error("Uploaded JSON to %s but got an error:", url)
                 _log.error(json.dumps(parsed_response, indent=4))
                 return False
 
-        _log.info("JSON file uploaded to %s." % url)
+        _log.info("JSON file uploaded to %s.", url)
         return True
 
     def _run_tests_set(self, tests):
         failures = 0
         self._results = []
 
         for i, test in enumerate(tests):
-            _log.info('Running %s (%d of %d)' % (test.test_name(), i + 1, len(tests)))
+            _log.info('Running %s (%d of %d)', test.test_name(), i + 1, len(tests))
             start_time = time.time()
             metrics = test.run(self._options.time_out_ms)
             if metrics:
                 self._results.append((test, metrics))
             else:
                 failures += 1
                 _log.error('FAILED')
 
-            _log.info('Finished: %f s' % (time.time() - start_time))
+            _log.info('Finished: %f s', time.time() - start_time)
             _log.info('')
 
         return failures