Run auto-formatter on files in webkitpy/layout_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 128 matching lines @@
     'compositing/resources/video.mp4',
 ]
 
 MD5SUM_DEVICE_FILE_NAME = 'md5sum_bin'
 MD5SUM_HOST_FILE_NAME = 'md5sum_bin_host'
 MD5SUM_DEVICE_PATH = '/data/local/tmp/' + MD5SUM_DEVICE_FILE_NAME
 
 
 # Information required when running layout tests using content_shell as the test runner.
 class ContentShellDriverDetails():
+
     def device_cache_directory(self):
         return self.device_directory() + 'cache/'
 
     def device_fonts_directory(self):
         return self.device_directory() + 'fonts/'
 
     def device_forwarder_path(self):
         return self.device_directory() + 'forwarder'
 
     def device_fifo_directory(self):
@@ skipping 88 matching lines @@
                 pass
         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, debug_logging=self._debug_logging)
+        result = self._executive.run_command(self.adb_command() + command,
+                                             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])
         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]
@@ skipping 86 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))
+                             % (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())
                 continue
 
             self._usable_devices.append(commands)
 
         return self._usable_devices
 
@@ skipping 59 matching lines @@
         # Initialize the AndroidDevices class which tracks available devices.
         default_device = None
         if hasattr(self._options, 'adb_device') and len(self._options.adb_device):
             default_device = self._options.adb_device
 
         self._debug_logging = self.get_option('android_logging')
         self._devices = AndroidDevices(self._executive, default_device, self._debug_logging)
 
         # Tell AndroidCommands where to search for the "adb" command.
         AndroidCommands.set_adb_command_path_options(['adb',
-            self.path_from_chromium_base('third_party', 'android_tools', 'sdk', 'platform-tools', 'adb')])
+                                                      self.path_from_chromium_base('third_party', 'android_tools', 'sdk', 'platform-tools', 'adb')])
 
         prepared_devices = self.get_option('prepared_devices', [])
         for serial in prepared_devices:
             self._devices.set_device_prepared(serial)
 
     def default_smoke_test_only(self):
         return True
 
     # Local public methods.
     def path_to_forwarder(self):
@@ skipping 14 matching lines @@
         # marked as slow tests on desktop platforms.
         return 10 * 1000
 
     def driver_stop_timeout(self):
         # The driver doesn't respond to closing stdin, so we might as well stop the driver immediately.
         return 0.0
 
     def default_child_processes(self):
         usable_devices = self._devices.usable_devices(self._executive)
         if not usable_devices:
-            raise test_run_results.TestRunException(test_run_results.NO_DEVICES_EXIT_STATUS, "Unable to find any attached Android devices.")
+            raise test_run_results.TestRunException(test_run_results.NO_DEVICES_EXIT_STATUS,
+                                                    "Unable to find any attached Android devices.")
         return len(usable_devices)
 
     def max_drivers_per_process(self):
         # Android falls over when we try to run multiple content_shells per worker.
         # See https://codereview.chromium.org/1158323009/
         return 1
 
     def check_wdiff(self, logging=True):
         return self._host_port.check_wdiff(logging)
 
@@ skipping 102 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, '', 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 201 matching lines @@
         self._device_failed = False
 
         # FIXME: If we taught ProfileFactory about "target" devices we could
         # just use the logic in Driver instead of duplicating it here.
         if self._port.get_option("profile"):
             # FIXME: This should be done once, instead of per-driver!
             symfs_path = self._find_or_create_symfs()
             kallsyms_path = self._update_kallsyms_cache(symfs_path)
             # FIXME: We should pass this some sort of "Bridge" object abstraction around ADB instead of a path/device pair.
             self._profiler = AndroidPerf(self._port.host, self._port._path_to_driver(), self._port.results_directory(),
-                self._android_commands, symfs_path, kallsyms_path)
+                                         self._android_commands, symfs_path, kallsyms_path)
             # FIXME: This is a layering violation and should be moved to Port.check_sys_deps
             # once we have an abstraction around an adb_path/device_serial pair to make it
             # easy to make these class methods on AndroidPerf.
             if not self._profiler.check_configuration():
                 self._profiler.print_setup_instructions()
                 sys.exit(1)
         else:
             self._profiler = None
 
     def __del__(self):
@@ skipping 23 matching lines @@
         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)
 
         # 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()))
+        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).
+        # 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))
         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):
@@ skipping 46 matching lines @@
         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]
 
     def _files_match(self, host_file, device_file):
         assert self._port.host.filesystem.exists(host_file)
         device_hashes = self._extract_hashes_from_md5sum_output(
-                self._port.host.executive.popen(self._android_commands.adb_command() + ['shell', MD5SUM_DEVICE_PATH, device_file],
-                                                stdout=subprocess.PIPE).stdout)
+            self._port.host.executive.popen(self._android_commands.adb_command() + ['shell', MD5SUM_DEVICE_PATH, device_file],
+                                            stdout=subprocess.PIPE).stdout)
         host_hashes = self._extract_hashes_from_md5sum_output(
-                self._port.host.executive.popen(args=['%s_host' % self._md5sum_path, host_file],
-                                                stdout=subprocess.PIPE).stdout)
+            self._port.host.executive.popen(args=['%s_host' % self._md5sum_path, host_file],
+                                            stdout=subprocess.PIPE).stdout)
         return host_hashes and device_hashes == host_hashes
 
     def _push_file_if_needed(self, host_file, device_file, log_callback):
         basename = self._port.host.filesystem.basename(host_file)
         log_callback("checking %s" % basename)
         if not self._files_match(host_file, device_file):
             log_callback("pushing %s" % basename)
             self._android_commands.push(host_file, device_file)
 
     def _push_executable(self, log_callback):
         self._push_file_if_needed(self._port.path_to_forwarder(), self._driver_details.device_forwarder_path(), log_callback)
         for resource in self._driver_details.additional_resources():
-            self._push_file_if_needed(self._port._build_path(resource), self._driver_details.device_directory() + resource, log_callback)
+            self._push_file_if_needed(self._port._build_path(
+                resource), self._driver_details.device_directory() + resource, log_callback)
 
-        self._push_file_if_needed(self._port._build_path('android_main_fonts.xml'), self._driver_details.device_directory() + 'android_main_fonts.xml', log_callback)
-        self._push_file_if_needed(self._port._build_path('android_fallback_fonts.xml'), self._driver_details.device_directory() + 'android_fallback_fonts.xml', log_callback)
+        self._push_file_if_needed(self._port._build_path('android_main_fonts.xml'),
+                                  self._driver_details.device_directory() + 'android_main_fonts.xml', log_callback)
+        self._push_file_if_needed(self._port._build_path('android_fallback_fonts.xml'),
+                                  self._driver_details.device_directory() + 'android_fallback_fonts.xml', log_callback)
 
         log_callback("checking apk")
         if self._files_match(self._port._build_path('apks', 'ContentShell.apk'),
                              '/data/app/org.chromium.content_shell_apk-1.apk'):
             return
 
         log_callback("uninstalling apk")
         self._android_commands.run(['uninstall', self._driver_details.package_name()])
         driver_host_path = self._port._path_to_driver()
         log_callback("installing apk")
         install_result = self._android_commands.run(['install', driver_host_path])
         if install_result.find('Success') == -1:
             self._abort('Failed to install %s onto device: %s' % (driver_host_path, install_result))
 
     def _push_fonts(self, log_callback):
         path_to_ahem_font = self._port._build_path('AHEM____.TTF')
         self._push_file_if_needed(path_to_ahem_font, self._driver_details.device_fonts_directory() + 'AHEM____.TTF', log_callback)
         for (host_dirs, font_file, package) in HOST_FONT_FILES:
             for host_dir in host_dirs:
                 host_font_path = host_dir + font_file
                 if self._port._check_file_exists(host_font_path, '', logging=False):
-                    self._push_file_if_needed(host_font_path, self._driver_details.device_fonts_directory() + font_file, log_callback)
+                    self._push_file_if_needed(
+                        host_font_path, self._driver_details.device_fonts_directory() + font_file, log_callback)
 
     def _push_test_resources(self, log_callback):
         for resource in TEST_RESOURCES_TO_PUSH:
-            self._push_file_if_needed(self._port.layout_tests_dir() + '/' + resource, DEVICE_LAYOUT_TESTS_DIR + resource, log_callback)
+            self._push_file_if_needed(self._port.layout_tests_dir() + '/' + resource,
+                                      DEVICE_LAYOUT_TESTS_DIR + resource, log_callback)
 
     def _get_last_stacktrace(self):
         tombstones = self._android_commands.run(['shell', 'ls', '-n', '/data/tombstones/tombstone_*'])
         if not tombstones or tombstones.startswith('/data/tombstones/tombstone_*: No such file or directory'):
             self._log_error('The driver crashed, but no tombstone found!')
             return ''
 
         if tombstones.startswith('/data/tombstones/tombstone_*: Permission denied'):
             # FIXME: crbug.com/321489 ... figure out why this happens.
             self._log_error('The driver crashed, but we could not read the tombstones!')
@@ skipping 47 matching lines @@
         if not stdout:
             stdout = ''
         stdout += '********* [%s] Logcat:\n%s' % (self._android_commands.get_serial(), self._get_logcat())
         if not stderr:
             stderr = ''
         stderr += '********* [%s] Tombstone file:\n%s' % (self._android_commands.get_serial(), self._get_last_stacktrace())
 
         if not self._port.get_option('disable_breakpad'):
             crashes = self._pull_crash_dumps_from_device()
             for crash in crashes:
-                stderr += '********* [%s] breakpad minidump %s:\n%s' % (self._port.host.filesystem.basename(crash), self._android_commands.get_serial(), self._port._dump_reader._get_stack_from_dump(crash))
+                stderr += '********* [%s] breakpad minidump %s:\n%s' % (self._port.host.filesystem.basename(
+                    crash), self._android_commands.get_serial(), self._port._dump_reader._get_stack_from_dump(crash))
 
         # The parent method expects stdout and stderr to be byte streams, but
         # since adb shell does newline conversion, we used universal_newlines
         # when launching the processes, and hence our stdout and stderr are
         # text objects that need to be encoded back into bytes.
         return super(ChromiumAndroidDriver, self)._get_crash_log(
             stdout.encode('utf8', 'replace'),
             stderr.encode('utf8', 'replace'),
             newer_than)
 
@@ skipping 72 matching lines @@
         self._android_commands.run(['logcat', '-c'])
 
         cmd_line_file_path = self._driver_details.command_line_file()
         original_cmd_line_file_path = cmd_line_file_path + '.orig'
         if self._android_commands.file_exists(cmd_line_file_path) and not self._android_commands.file_exists(original_cmd_line_file_path):
             # We check for both the normal path and the backup because we do not want to step
             # on the backup. Otherwise, we'd clobber the backup whenever we changed the
             # command line during the run.
             self._android_commands.run(['shell', 'mv', cmd_line_file_path, original_cmd_line_file_path])
 
-        self._android_commands.run(['shell', 'echo'] + self._android_driver_cmd_line(pixel_tests, per_test_args) + ['>', self._driver_details.command_line_file()])
+        self._android_commands.run(['shell', 'echo'] + self._android_driver_cmd_line(pixel_tests,
+                                                                                     per_test_args) + ['>', self._driver_details.command_line_file()])
         self._created_cmd_line = True
 
         self._android_commands.run(['shell', 'rm', '-rf', self._driver_details.device_crash_dumps_directory()])
         self._android_commands.mkdir(self._driver_details.device_crash_dumps_directory(), chmod='777')
 
-        start_result = self._android_commands.run(['shell', 'am', 'start', '-e', 'RunInSubThread', '-n', self._driver_details.activity_name()])
+        start_result = self._android_commands.run(
+            ['shell', 'am', 'start', '-e', 'RunInSubThread', '-n', self._driver_details.activity_name()])
         if start_result.find('Exception') != -1:
             self._log_error('Failed to start the content_shell application. Exception:\n' + start_result)
             return False
 
         if not ChromiumAndroidDriver._loop_with_timeout(self._all_pipes_created, DRIVER_START_STOP_TIMEOUT_SECS):
             return False
 
         # Read back the shell prompt to ensure adb shell ready.
         deadline = time.time() + DRIVER_START_STOP_TIMEOUT_SECS
         self._server_process.start()
@@ skipping 124 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