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

third_party/WebKit/Tools/Scripts/webkitpy/common/message_pool.py

 # Copyright (C) 2011 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 227 matching lines @@
         if not self._running_inline:
             super(_Worker, self).start()
 
     def run(self):
         if not self.host:
             self.host = Host()
         if not self._running_inline:
             self._set_up_logging()
 
         worker = self._worker
-        _log.debug("%s starting" % self.name)
+        _log.debug("%s starting", self.name)
         self._running = True
 
         try:
             if hasattr(worker, 'start'):
                 worker.start()
             while self._running:
                 message = self._messages_to_worker.get()
                 if message.from_user:
                     worker.handle(message.name, message.src, *message.args)
                     self._yield_to_manager()
                 else:
                     assert message.name == 'stop', 'bad message %s' % repr(message)
                     break
 
-            _log.debug("%s exiting" % self.name)
+            _log.debug("%s exiting", self.name)
         except Queue.Empty:
             assert False, '%s: ran out of messages in worker queue.' % self.name
         except KeyboardInterrupt:
             self._raise(sys.exc_info())
         except Exception:
             self._raise(sys.exc_info())
         finally:
             try:
                 if hasattr(worker, 'stop'):
                     worker.stop()
@@ skipping 16 matching lines @@
         log_messages = self.log_messages
         self.log_messages = []
         self._messages_to_manager.put(_Message(self.name, name, args, from_user, log_messages))
 
     def _raise(self, exc_info):
         exception_type, exception_value, exception_traceback = exc_info
         if self._running_inline:
             raise exception_type, exception_value, exception_traceback
 
         if exception_type == KeyboardInterrupt:
-            _log.debug("%s: interrupted, exiting" % self.name)
+            _log.debug("%s: interrupted, exiting", self.name)
             stack_utils.log_traceback(_log.debug, exception_traceback)
         else:
-            _log.error("%s: %s('%s') raised:" % (self.name, exception_value.__class__.__name__, str(exception_value)))
+            _log.error("%s: %s('%s') raised:", self.name, exception_value.__class__.__name__, str(exception_value))
             stack_utils.log_traceback(_log.error, exception_traceback)
         # Since tracebacks aren't picklable, send the extracted stack instead.
         stack = traceback.extract_tb(exception_traceback)
         self._post(name='worker_exception', args=(exception_type, exception_value, stack), from_user=False)
 
     def _set_up_logging(self):
         self._logger = logging.getLogger()
 
         # The unix multiprocessing implementation clones any log handlers into the child process,
         # so we remove them to avoid duplicate logging.
         for h in self._logger.handlers:
             self._logger.removeHandler(h)
 
         self._log_handler = _WorkerLogHandler(self)
         self._logger.addHandler(self._log_handler)
         self._logger.setLevel(self.log_level)
 
 
 class _WorkerLogHandler(logging.Handler):
 
     def __init__(self, worker):
         logging.Handler.__init__(self)
         self._worker = worker
         self.setLevel(worker.log_level)
 
     def emit(self, record):
         self._worker.log_messages.append(record)