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

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/port/android.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 284 matching lines @@
             command_version = path_version
 
         assert command_path, 'Unable to locate the "adb" command. Are you using an Android checkout of Chromium?'
 
         AndroidCommands._adb_command_path = command_path
         return command_path
 
     # Local private methods.
 
     def _log_error(self, message):
-        _log.error('[%s] %s' % (self._device_serial, message))
+        _log.error('[%s] %s', self._device_serial, message)
 
     def _log_info(self, message):
-        _log.info('[%s] %s' % (self._device_serial, message))
+        _log.info('[%s] %s', self._device_serial, message)
 
     def _log_debug(self, message):
         if self._debug_logging:
-            _log.debug('[%s] %s' % (self._device_serial, message))
+            _log.debug('[%s] %s', self._device_serial, message)
 
     @staticmethod
     def _determine_adb_version(adb_command_path, executive, debug_logging):
         re_version = re.compile('^.*version ([\d\.]+)')
         try:
             output = executive.run_command([adb_command_path, 'version'], error_handler=executive.ignore_error,
                                            debug_logging=debug_logging)
         except OSError:
             return None
 
@@ skipping 37 matching lines @@
 
         result = executive.run_command([AndroidCommands.adb_command_path(executive, debug_logging=self._debug_logging), 'devices'],
                                        error_handler=executive.ignore_error, debug_logging=self._debug_logging)
         devices = re_device.findall(result)
         if not devices:
             return []
 
         for device_serial in sorted(devices):
             commands = AndroidCommands(executive, device_serial, self._debug_logging)
             if self._battery_level_for_device(commands) < AndroidDevices.MINIMUM_BATTERY_PERCENTAGE:
-                _log.warning('Device with serial "%s" skipped because it has less than %d percent battery.'
-                             % (commands.get_serial(), AndroidDevices.MINIMUM_BATTERY_PERCENTAGE))
+                _log.warning('Device with serial "%s" skipped because it has less than %d percent battery.',
+                             commands.get_serial(), AndroidDevices.MINIMUM_BATTERY_PERCENTAGE)
                 continue
 
             if not self._is_device_screen_on(commands):
-                _log.warning('Device with serial "%s" skipped because the screen must be on.' % commands.get_serial())
+                _log.warning('Device with serial "%s" skipped because the screen must be on.', commands.get_serial())
                 continue
 
             self._usable_devices.append(commands)
 
         return self._usable_devices
 
     def get_device(self, executive, device_index):
         devices = self.usable_devices(executive)
         if device_index >= len(devices):
             raise AssertionError('Device index exceeds number of usable devices.')
 
         return devices[device_index]
 
     def is_device_prepared(self, device_serial):
         return device_serial in self._prepared_devices
 
     def set_device_prepared(self, device_serial):
         self._prepared_devices.append(device_serial)
 
     # Private methods
     def _battery_level_for_device(self, commands):
         battery_status = commands.run(['shell', 'dumpsys', 'battery'])
         if 'Error' in battery_status or "Can't find service: battery" in battery_status:
-            _log.warning('Unable to read the battery level from device with serial "%s".' % commands.get_serial())
+            _log.warning('Unable to read the battery level from device with serial "%s".', commands.get_serial())
             return 0
 
         return int(re.findall('level: (\d+)', battery_status)[0])
 
     def _is_device_screen_on(self, commands):
         power_status = commands.run(['shell', 'dumpsys', 'power'])
         return 'mScreenOn=true' in power_status or 'mScreenOn=SCREEN_ON_BIT' in power_status or 'Display Power: state=ON' in power_status
 
 
 class AndroidPort(base.Port):
@@ skipping 142 matching lines @@
                     callback("[%s] %s" % (serial, msg))
                 finally:
                     lock.release()
 
             log_safely("preparing device", throttled=False)
             try:
                 d._setup_test(log_safely)
                 log_safely("device prepared", throttled=False)
             except (ScriptError, driver.DeviceFailure) as e:
                 lock.acquire()
-                _log.warning("[%s] failed to prepare_device: %s" % (serial, str(e)))
+                _log.warning("[%s] failed to prepare_device: %s", serial, str(e))
                 lock.release()
             except KeyboardInterrupt:
                 if pool:
                     pool.terminate()
 
         # FIXME: It would be nice if we knew how many workers we needed.
         num_workers = self.default_child_processes()
         num_child_processes = int(self.get_option('child_processes'))
         if num_child_processes:
             num_workers = min(num_workers, num_child_processes)
@@ skipping 28 matching lines @@
 
     def check_sys_deps(self, needs_http):
         for (font_dirs, font_file, package) in HOST_FONT_FILES:
             exists = False
             for font_dir in font_dirs:
                 font_path = font_dir + font_file
                 if self._check_file_exists(font_path, '', more_logging=False):
                     exists = True
                     break
             if not exists:
-                _log.error('You are missing %s under %s. Try installing %s. See build instructions.' %
-                           (font_file, font_dirs, package))
+                _log.error('You are missing %s under %s. Try installing %s. See build instructions.',
+                           font_file, font_dirs, package)
                 return test_run_results.SYS_DEPS_EXIT_STATUS
         return test_run_results.OK_EXIT_STATUS
 
     def requires_http_server(self):
         """Chromium Android runs tests on devices, and uses the HTTP server to
         serve the actual layout tests to the test driver."""
         return True
 
     def start_http_server(self, additional_dirs, number_of_drivers):
         additional_dirs[PERF_TEST_PATH_PREFIX] = self.perf_tests_dir()
@@ skipping 68 matching lines @@
     def __init__(self, host, executable_path, output_dir, android_commands, symfs_path, kallsyms_path, identifier=None):
         super(AndroidPerf, self).__init__(host, executable_path, output_dir, "data", identifier)
         self._android_commands = android_commands
         self._perf_process = None
         self._symfs_path = symfs_path
         self._kallsyms_path = kallsyms_path
 
     def check_configuration(self):
         # Check that perf is installed
         if not self._android_commands.file_exists('/system/bin/perf'):
-            _log.error("Cannot find /system/bin/perf on device %s" % self._android_commands.get_serial())
+            _log.error("Cannot find /system/bin/perf on device %s", self._android_commands.get_serial())
             return False
 
         # Check that the device is a userdebug build (or at least has the necessary libraries).
         if self._android_commands.run(['shell', 'getprop', 'ro.build.type']).strip() != 'userdebug':
-            _log.error("Device %s is not flashed with a userdebug build of Android" % self._android_commands.get_serial())
+            _log.error("Device %s is not flashed with a userdebug build of Android", self._android_commands.get_serial())
             return False
 
         # FIXME: Check that the binary actually is perf-able (has stackframe pointers)?
         # objdump -s a function and make sure it modifies the fp?
         # Instruct users to rebuild after export GYP_DEFINES="profiling=1 $GYP_DEFINES"
         return True
 
     def print_setup_instructions(self):
         _log.error("""
 perf on android requires a 'userdebug' build of Android, see:
@@ skipping 42 matching lines @@
         self._cached_perf_host_path = self._find_perfhost_binary()
         return self._cached_perf_host_path
 
     def _first_ten_lines_of_profile(self, perf_output):
         match = re.search("^#[^\n]*\n((?: [^\n]*\n){1,10})", perf_output, re.MULTILINE)
         return match.group(1) if match else None
 
     def profile_after_exit(self):
         perf_exitcode = self._perf_process.wait()
         if perf_exitcode != 0:
-            _log.debug("Perf failed (exit code: %i), can't process results." % perf_exitcode)
+            _log.debug("Perf failed (exit code: %i), can't process results.", perf_exitcode)
             return
 
         self._android_commands.pull('/data/perf.data', self._output_path)
 
         perfhost_path = self._perfhost_path()
         perfhost_report_command = [
             'report',
             '--input', self._output_path,
             '--symfs', self._symfs_path,
             '--kallsyms', self._kallsyms_path,
@@ skipping 68 matching lines @@
 
     def _update_kallsyms_cache(self, output_dir):
         kallsyms_name = "%s-kallsyms" % self._android_commands.get_serial()
         kallsyms_cache_path = self._port.host.filesystem.join(output_dir, kallsyms_name)
 
         self._android_commands.restart_as_root()
 
         saved_kptr_restrict = self._android_commands.run(['shell', 'cat', KPTR_RESTRICT_PATH]).strip()
         self._android_commands.run(['shell', 'echo', '0', '>', KPTR_RESTRICT_PATH])
 
-        _log.debug("Updating kallsyms file (%s) from device" % kallsyms_cache_path)
+        _log.debug("Updating kallsyms file (%s) from device", kallsyms_cache_path)
         self._android_commands.pull("/proc/kallsyms", kallsyms_cache_path)
 
         self._android_commands.run(['shell', 'echo', saved_kptr_restrict, '>', KPTR_RESTRICT_PATH])
 
         return kallsyms_cache_path
 
     def _find_or_create_symfs(self):
         env = self._port.host.environ.copy()
         fs = self._port.host.filesystem
 
         if 'ANDROID_SYMFS' in env:
             symfs_path = env['ANDROID_SYMFS']
         else:
             symfs_path = fs.join(self._port.results_directory(), 'symfs')
-            _log.debug("ANDROID_SYMFS not set, using %s" % symfs_path)
+            _log.debug("ANDROID_SYMFS not set, using %s", symfs_path)
 
         # find the installed path, and the path of the symboled built library
         # FIXME: We should get the install path from the device!
         symfs_library_path = fs.join(symfs_path, "data/app-lib/%s-1/%s" %
                                      (self._driver_details.package_name(), self._driver_details.library_name()))
         built_library_path = self._port._build_path('lib', self._driver_details.library_name())
         assert fs.exists(built_library_path)
 
         # FIXME: Ideally we'd check the sha1's first and make a soft-link instead
         # of copying (since we probably never care about windows).
-        _log.debug("Updating symfs library (%s) from built copy (%s)" % (symfs_library_path, built_library_path))
+        _log.debug("Updating symfs library (%s) from built copy (%s)", symfs_library_path, built_library_path)
         fs.maybe_make_directory(fs.dirname(symfs_library_path))
         fs.copyfile(built_library_path, symfs_library_path)
 
         return symfs_path
 
     def _setup_md5sum_and_push_data_if_needed(self, log_callback):
         self._md5sum_path = self._port.path_to_md5sum()
         if not self._android_commands.file_exists(MD5SUM_DEVICE_PATH):
             if not self._android_commands.push(self._md5sum_path, MD5SUM_DEVICE_PATH):
                 self._abort('Could not push md5sum to device')
@@ skipping 24 matching lines @@
         self._android_commands.mkdir(self._driver_details.device_directory(), chmod='777')
         self._android_commands.mkdir(self._driver_details.device_fifo_directory(), chmod='777')
 
         # Make sure that the disk cache on the device resets to a clean state.
         self._android_commands.run(['shell', 'rm', '-r', self._driver_details.device_cache_directory()])
 
         # Mark this device as having been set up.
         self._android_devices.set_device_prepared(self._android_commands.get_serial())
 
     def _log_error(self, message):
-        _log.error('[%s] %s' % (self._android_commands.get_serial(), message))
+        _log.error('[%s] %s', self._android_commands.get_serial(), message)
 
     def _log_warning(self, message):
-        _log.warning('[%s] %s' % (self._android_commands.get_serial(), message))
+        _log.warning('[%s] %s', self._android_commands.get_serial(), message)
 
     def _log_debug(self, message):
         if self._debug_logging:
-            _log.debug('[%s] %s' % (self._android_commands.get_serial(), message))
+            _log.debug('[%s] %s', self._android_commands.get_serial(), message)
 
     def _abort(self, message):
         self._device_failed = True
         raise driver.DeviceFailure('[%s] %s' % (self._android_commands.get_serial(), message))
 
     @staticmethod
     def _extract_hashes_from_md5sum_output(md5sum_output):
         assert md5sum_output
         return [line.split('  ')[0] for line in md5sum_output]
 
@@ skipping 360 matching lines @@
         return command
 
     def _read_prompt(self, deadline):
         last_char = ''
         while True:
             current_char = self._server_process.read_stdout(deadline, 1)
             if current_char == ' ':
                 if last_char in ('#', '$'):
                     return
             last_char = current_char