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

third_party/WebKit/Tools/Scripts/webkitpy/w3c/test_importer.py

 # Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # 1. Redistributions of source code must retain the above
 #    copyright notice, this list of conditions and the following
 #    disclaimer.
 # 2. Redistributions in binary form must reproduce the above
@@ skipping 175 matching lines @@
                     if d in dirs:
                         dirs.remove(d)
 
                 for path in paths_to_skip:
                     path_base = path.replace(self.options.destination + '/', '')
                     path_base = path_base.replace(cur_dir, '')
                     path_full = self.filesystem.join(root, path_base)
                     if path_base in dirs:
                         dirs.remove(path_base)
                         if not self.options.dry_run and self.import_in_place:
-                            _log.info("  pruning %s" % path_base)
+                            _log.info("  pruning %s", path_base)
                             self.filesystem.rmtree(path_full)
                         else:
-                            _log.info("  skipping %s" % path_base)
+                            _log.info("  skipping %s", path_base)
 
             copy_list = []
 
             for filename in files:
                 path_full = self.filesystem.join(root, filename)
                 path_base = path_full.replace(self.source_repo_path + '/', '')
                 path_base = self.destination_directory.replace(self.layout_tests_dir + '/', '') + '/' + path_base
                 if path_base in paths_to_skip:
                     if not self.options.dry_run and self.import_in_place:
-                        _log.info("  pruning %s" % path_base)
+                        _log.info("  pruning %s", path_base)
                         self.filesystem.remove(path_full)
                         continue
                     else:
                         continue
                 # FIXME: This block should really be a separate function, but the early-continues make that difficult.
 
                 if filename.startswith('.') or filename.endswith('.pl'):
                     continue  # For some reason the w3c repo contains random perl scripts we don't care about.
                 if filename == 'OWNERS' or filename == 'reftest.list':
                     continue  # These files fail our presubmits.
@@ skipping 69 matching lines @@
 
         paths_to_skip = set()
         port = self.host.port_factory.get()
         w3c_import_expectations_path = self.webkit_finder.path_from_webkit_base('LayoutTests', 'W3CImportExpectations')
         w3c_import_expectations = self.filesystem.read_text_file(w3c_import_expectations_path)
         parser = TestExpectationParser(port, all_tests=(), is_lint_mode=False)
         expectation_lines = parser.parse(w3c_import_expectations_path, w3c_import_expectations)
         for line in expectation_lines:
             if 'SKIP' in line.expectations:
                 if line.specifiers:
-                    _log.warning("W3CImportExpectations:%s should not have any specifiers" % line.line_numbers)
+                    _log.warning("W3CImportExpectations:%s should not have any specifiers", line.line_numbers)
                     continue
                 paths_to_skip.add(line.name)
         return paths_to_skip
 
     def import_tests(self):
         """Reads |self.import_list|, and converts and copies files to their destination."""
         total_imported_tests = 0
         total_imported_reftests = 0
         total_imported_jstests = 0
         total_prefixed_properties = {}
@@ skipping 17 matching lines @@
                 self.filesystem.maybe_make_directory(new_path)
 
             copied_files = []
 
             for file_to_copy in dir_to_copy['copy_list']:
                 # FIXME: Split this block into a separate function.
                 orig_filepath = self.filesystem.normpath(file_to_copy['src'])
 
                 if self.filesystem.isdir(orig_filepath):
                     # FIXME: Figure out what is triggering this and what to do about it.
-                    _log.error('%s refers to a directory' % orig_filepath)
+                    _log.error('%s refers to a directory', orig_filepath)
                     continue
 
                 if not self.filesystem.exists(orig_filepath):
                     _log.warning('%s not found. Possible error in the test.', orig_filepath)
                     continue
 
                 new_filepath = self.filesystem.join(new_path, file_to_copy['dest'])
                 if 'reference_support_info' in file_to_copy.keys() and file_to_copy['reference_support_info'] != {}:
                     reference_support_info = file_to_copy['reference_support_info']
                 else:
                     reference_support_info = None
 
                 if not self.filesystem.exists(self.filesystem.dirname(new_filepath)):
                     if not self.import_in_place and not self.options.dry_run:
                         self.filesystem.maybe_make_directory(self.filesystem.dirname(new_filepath))
 
                 relpath = self.filesystem.relpath(new_filepath, self.layout_tests_dir)
                 if not self.options.overwrite and self.filesystem.exists(new_filepath):
-                    _log.info('  skipping %s' % relpath)
+                    _log.info('  skipping %s', relpath)
                 else:
                     # FIXME: Maybe doing a file diff is in order here for existing files?
                     # In other words, there's no sense in overwriting identical files, but
                     # there's no harm in copying the identical thing.
-                    _log.info('  %s' % relpath)
+                    _log.info('  %s', relpath)
 
                 # Only HTML, XML, or CSS should be converted.
                 # FIXME: Eventually, so should JS when support is added for this type of conversion.
                 mimetype = mimetypes.guess_type(orig_filepath)
                 if 'is_jstest' not in file_to_copy and (
                         'html' in str(mimetype[0]) or 'xml' in str(mimetype[0]) or 'css' in str(mimetype[0])):
                     converted_file = convert_for_webkit(new_path, filename=orig_filepath,
                                                         reference_support_info=reference_support_info)
 
                     if not converted_file:
@@ skipping 32 matching lines @@
                 _log.info('  %s: %s', prefixed_property, total_prefixed_properties[prefixed_property])
 
     def path_too_long(self, source_path):
         """Checks whether a source path is too long to import.
 
         Args:
           Absolute path of file to be imported.
         """
         path_from_repo_base = os.path.relpath(source_path, self.source_repo_path)
         return len(path_from_repo_base) > MAX_PATH_LENGTH