Revert of Fix more android logging crashes in run-webkit-tests.

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 239 matching lines @@
         return pids
 
     def run(self, command, ignore_error=False):
         self._log_debug('Run adb command: ' + str(command))
         if ignore_error:
             error_handler = self._executive.ignore_error
         else:
             error_handler = None
 
         result = self._executive.run_command(self.adb_command() + command,
-                                             error_handler=error_handler,
-                                             decode_output=False,
-                                             debug_logging=self._debug_logging)
+                                             error_handler=error_handler, debug_logging=self._debug_logging)
 
         # We limit the length to avoid outputting too verbose commands, such as "adb logcat".
-        self._log_debug('Run adb result: ' + result[:80].decode('ascii', errors='replace'))
+        self._log_debug('Run adb result: ' + result[:80])
         return result
 
     def get_serial(self):
         return self._device_serial
 
     def adb_command(self):
         return [AndroidCommands.adb_command_path(self._executive, self._debug_logging), '-s', self._device_serial]
 
     @staticmethod
     def set_adb_command_path_options(paths):
@@ skipping 32 matching lines @@
         _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))
 
     @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,
-                                           decode_output=False,
+            output = executive.run_command([adb_command_path, 'version'], error_handler=executive.ignore_error,
                                            debug_logging=debug_logging)
         except OSError:
             return None
 
-        result = re_version.match(output.decode('ascii', errors='replace'))
+        result = re_version.match(output)
         if not output or not result:
             return None
 
         return [int(n) for n in result.group(1).split('.')]
 
 
 # A class to encapsulate device status and information, such as the AndroidCommands
 # instances and whether the device has been set up.
 class AndroidDevices(object):
     # Percentage of battery a device needs to have in order for it to be considered
@@ skipping 16 matching lines @@
         if self._default_device:
             self._usable_devices = [AndroidCommands(executive, self._default_device, self._debug_logging)]
             return self._usable_devices
 
         # Example "adb devices" command output:
         #   List of devices attached
         #   0123456789ABCDEF        device
         re_device = re.compile('^([a-zA-Z0-9_:.-]+)\tdevice$', re.MULTILINE)
 
         result = executive.run_command([AndroidCommands.adb_command_path(executive, debug_logging=self._debug_logging), 'devices'],
-                                       error_handler=executive.ignore_error,
-                                       decode_output=False,
-                                       debug_logging=self._debug_logging)
-        devices = re_device.findall(result.decode('ascii', errors='replace'))
+                                       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))
                 continue
 
@@ skipping 131 matching lines @@
         result = self._check_file_exists(self.path_to_forwarder(), 'forwarder utility') and result
 
         if not result:
             # There is a race condition in adb at least <= 4.3 on Linux that causes it to go offline periodically
             # We set the processor affinity for any running adb process to attempt to work around this.
             # See crbug.com/268450
             if self.host.platform.is_linux():
                 pids = self._executive.running_pids(lambda name: 'adb' in name)
                 if not pids:
                     # Apparently adb is not running, which is unusual. Running any adb command should start it.
-                    self._executive.run_command(['adb', 'devices'],
-                                                decode_output=False)
+                    self._executive.run_command(['adb', 'devices'])
                     pids = self._executive.running_pids(lambda name: 'adb' in name)
                 if not pids:
                     _log.error("The adb daemon does not appear to be running.")
                     return False
 
                 for pid in pids:
-                    self._executive.run_command(['taskset', '-p', '-c', '0', str(pid)],
-                                                decode_output=False)
+                    self._executive.run_command(['taskset', '-p', '-c', '0', str(pid)])
 
         if not result:
             _log.error('For complete Android build requirements, please see:')
             _log.error('')
             _log.error('    https://www.chromium.org/developers/how-tos/android-build-instructions')
             return test_run_results.UNEXPECTED_ERROR_EXIT_STATUS
 
         return self._check_devices(printer)
 
     def _check_devices(self, printer):
@@ skipping 198 matching lines @@
 
     def attach_to_pid(self, pid):
         assert(pid)
         assert(self._perf_process == None)
         # FIXME: This can't be a fixed timeout!
         cmd = self._android_commands.adb_command() + ['shell', 'perf', 'record', '-g', '-p', pid, 'sleep', 30]
         self._perf_process = self._host.executive.popen(cmd)
 
     def _perf_version_string(self, perf_path):
         try:
-            return self._host.executive.run_command([perf_path, '--version'],
-                                                    decode_output=False)
+            return self._host.executive.run_command([perf_path, '--version'])
         except:
             return None
 
     def _find_perfhost_binary(self):
         perfhost_version = self._perf_version_string('perfhost_linux')
         if perfhost_version:
             return 'perfhost_linux'
         perf_version = self._perf_version_string('perf')
         if perf_version:
             return 'perf'
@@ skipping 20 matching lines @@
 
         perfhost_path = self._perfhost_path()
         perfhost_report_command = [
             'report',
             '--input', self._output_path,
             '--symfs', self._symfs_path,
             '--kallsyms', self._kallsyms_path,
         ]
         if perfhost_path:
             perfhost_args = [perfhost_path] + perfhost_report_command + ['--call-graph', 'none']
-            perf_output = self._host.executive.run_command(perfhost_args,
-                                                           decode_output=False)
+            perf_output = self._host.executive.run_command(perfhost_args)
             # We could save off the full -g report to a file if users found that useful.
-            _log.debug(self._first_ten_lines_of_profile(perf_output).decode('ascii', errors='replace'))
+            _log.debug(self._first_ten_lines_of_profile(perf_output))
         else:
             _log.debug("""
 Failed to find perfhost_linux binary, can't process samples from the device.
 
 perfhost_linux can be built from:
 https://android.googlesource.com/platform/external/linux-tools-perf/
 also, modern versions of perf (available from apt-get install goobuntu-kernel-tools-common)
 may also be able to process the perf.data files from the device.
 
 Googlers should read:
@@ skipping 511 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