DOM-object leak detection at run_webkit_tests.py

Tools/Scripts/webkitpy/layout_tests/port/driver.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 95 matching lines @@
         # "#CRASHED - PROCESSNAME".  Since those can happen at any time
         # and ServerProcess won't be aware of them (since the actual tool
         # didn't crash, just a subprocess) we record the crashed subprocess name here.
         self._crashed_process_name = None
         self._crashed_pid = None
 
         # WebKitTestRunner can report back subprocesses that became unresponsive
         # This could mean they crashed.
         self._subprocess_was_unresponsive = False
 
+        # WebKitTestRunenr can report back subprocess DOM-object leaks by printing

[Dirk Pranke, 2014/01/28 20:11:46]

WebKitTestRunner doesn't exist in Blink :) I'd probably change this to
"content_shell can report back DOM object leaks by printing".

[hajimehoshi, 2014/02/14 10:18:59]

Done.

+        # "#LEAK". This leak detection is enabled only when the flag
+        # --enable-leak-detection is passed to content_shell.
+        self._leaked = False
+
         # stderr reading is scoped on a per-test (not per-block) basis, so we store the accumulated
         # stderr output, as well as if we've seen #EOF on this driver instance.
         # FIXME: We should probably remove _read_first_block and _read_optional_image_block and
         # instead scope these locally in run_test.
         self.error_from_test = str()
         self.err_seen_eof = False
         self._server_process = None
         self._current_cmd_line = None
 
         self._measurements = {}
@@ skipping 47 matching lines @@
         if crashed:
             self.error_from_test, crash_log = self._get_crash_log(text, self.error_from_test, newer_than=start_time)
 
             # If we don't find a crash log use a placeholder error message instead.
             if not crash_log:
                 pid_str = str(self._crashed_pid) if self._crashed_pid else "unknown pid"
                 crash_log = 'No crash log found for %s:%s.\n' % (self._crashed_process_name, pid_str)
                 # If we were unresponsive append a message informing there may not have been a crash.
                 if self._subprocess_was_unresponsive:
                     crash_log += 'Process failed to become responsive before timing out.\n'
+                if self._leaked:
+                    crash_log += 'DOM-object leaking was detected.\n'

[Dirk Pranke, 2014/01/30 01:43:21]

Given that the process isn't actually crashing, it is probably wrong to be
making any changes to _check_for_driver_crash() or inside the if block that
starts on line 178.

I suggest that you add lines before line 167 that parses the stderr output, and
if it finds the '# LEAK - ' line, marks something to tell the driver code to
restart content_shell (assuming that's what you want to have happen) and
propagate the right information back up in the DriverOutput.

Let me know if the approach I describe turns out to have problems.

[hajimehoshi, 2014/02/14 10:18:59]

Done.

 
                 # Print stdout and stderr to the placeholder crash log; we want as much context as possible.
                 if self.error_from_test:
                     crash_log += '\nstdout:\n%s\nstderr:\n%s\n' % (text, self.error_from_test)
 
         return DriverOutput(text, image, actual_image_hash, audio,
             crash=crashed, test_time=time.time() - test_begin_time, measurements=self._measurements,
             timeout=timed_out, error=self.error_from_test,
             crashed_process_name=self._crashed_process_name,
             crashed_pid=self._crashed_pid, crash_log=crash_log, pid=pid)
@@ skipping 120 matching lines @@
 
         self._current_cmd_line = None
 
     def cmd_line(self, pixel_tests, per_test_args):
         cmd = self._command_wrapper(self._port.get_option('wrapper'))
         cmd.append(self._port._path_to_driver())
         if self._no_timeout:
             cmd.append('--no-timeout')
         cmd.extend(self._port.get_option('additional_drt_flag', []))
         cmd.extend(self._port.additional_drt_flag())
+        if self._port.get_option('enable_leak_detection'):
+            cmd.append('--enable-leak-detection')
         cmd.extend(per_test_args)
         cmd.append('-')
         return cmd
 
     def _check_for_driver_crash(self, error_line):
         if error_line == "#CRASHED\n":
             # This is used on Windows to report that the process has crashed
             # See http://trac.webkit.org/changeset/65537.
             self._crashed_process_name = self._server_process.name()
             self._crashed_pid = self._server_process.pid()
         elif (error_line.startswith("#CRASHED - ")
-            or error_line.startswith("#PROCESS UNRESPONSIVE - ")):
+            or error_line.startswith("#PROCESS UNRESPONSIVE - ")
+            or error_line.startswith("#LEAK - ")):

[Dirk Pranke, 2014/01/30 01:43:21]

See comments above.

[hajimehoshi, 2014/02/14 10:18:59]

Done.

             # WebKitTestRunner uses this to report that the WebProcess subprocess crashed.
-            match = re.match('#(?:CRASHED|PROCESS UNRESPONSIVE) - (\S+)', error_line)
+            match = re.match('#(?:CRASHED|PROCESS UNRESPONSIVE|LEAK) - (\S+)', error_line)
             self._crashed_process_name = match.group(1) if match else 'WebProcess'
             match = re.search('pid (\d+)', error_line)
             pid = int(match.group(1)) if match else None
             self._crashed_pid = pid
             # FIXME: delete this after we're sure this code is working :)
             _log.debug('%s crash, pid = %s, error_line = %s' % (self._crashed_process_name, str(pid), error_line))
             if error_line.startswith("#PROCESS UNRESPONSIVE - "):
                 self._subprocess_was_unresponsive = True
                 self._port.sample_process(self._crashed_process_name, self._crashed_pid)
                 # We want to show this since it's not a regular crash and probably we don't have a crash log.
                 self.error_from_test += error_line
+            elif error_line.startswith("#LEAK - "):
+                self._leaked = True
+                self.error_from_test += error_line
             return True
         return self.has_crashed()
 
     def _command_from_driver_input(self, driver_input):
         # FIXME: performance tests pass in full URLs instead of test names.
         if driver_input.test_name.startswith('http://') or driver_input.test_name.startswith('https://')  or driver_input.test_name == ('about:blank'):
             command = driver_input.test_name
         elif self.is_http_test(driver_input.test_name):
             command = self.test_to_uri(driver_input.test_name)
         else:
@@ skipping 119 matching lines @@
         self.content = str()  # FIXME: Should be bytearray() once we require Python 2.6.
         self.decoded_content = None
         self.malloc = None
         self.js_heap = None
 
     def decode_content(self):
         if self.encoding == 'base64' and self.content is not None:
             self.decoded_content = base64.b64decode(self.content)
         else:
             self.decoded_content = self.content