Bug fix: Get the leak log not from error strings but from the line

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 160 matching lines @@
             # We call stop() even if we crashed or timed out in order to get any remaining stdout/stderr output.
             # In the timeout case, we kill the hung process as well.
             out, err = self._server_process.stop(self._port.driver_stop_timeout() if stop_when_done else 0.0)
             if out:
                 text += out
             if err:
                 self.error_from_test += err
             self._server_process = None
 
         crash_log = None
-        leak_log = None
         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'
 
                 # 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)
-        elif leaked:
-            self.error_from_test, leak_log = self._get_leak_log(text, self.error_from_test, newer_than=start_time)
 
         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,
-            leak=leaked, leak_log=leak_log,
+            leak=leaked, leak_log=self._leak_log,
             pid=pid)
 
     def _get_crash_log(self, stdout, stderr, newer_than):
         return self._port._get_crash_log(self._crashed_process_name, self._crashed_pid, stdout, stderr, newer_than)
 
-    def _get_leak_log(self, stdout, stderr, newer_than):
-        return self._port._get_leak_log(self._crashed_process_name, self._crashed_pid, stdout, stderr, newer_than)
-
     # FIXME: Seems this could just be inlined into callers.
     @classmethod
     def _command_wrapper(cls, wrapper_option):
         # Hook for injecting valgrind or other runtime instrumentation,
         # used by e.g. tools/valgrind/valgrind_tests.py.
         return shlex.split(wrapper_option) if wrapper_option else []
 
     HTTP_DIR = "http/tests/"
     HTTP_LOCAL_DIR = "http/tests/local/"
 
@@ skipping 55 matching lines @@
 
     def _start(self, pixel_tests, per_test_args, wait_for_ready=True):
         self.stop()
         self._driver_tempdir = self._port._filesystem.mkdtemp(prefix='%s-' % self._port.driver_name())
         server_name = self._port.driver_name()
         environment = self._port.setup_environ_for_server(server_name)
         environment = self._setup_environ_for_driver(environment)
         self._crashed_process_name = None
         self._crashed_pid = None
         self._leaked = False
+        self._leak_log = None
         cmd_line = self.cmd_line(pixel_tests, per_test_args)
         self._server_process = self._port._server_process_constructor(self._port, server_name, cmd_line, environment, logging=self._port.get_option("driver_logging"))
         self._server_process.start()
         self._current_cmd_line = cmd_line
 
         if wait_for_ready:
             deadline = time.time() + DRIVER_START_TIMEOUT_SECS
             if not self._wait_for_server_process_output(self._server_process, deadline, '#READY'):
                 _log.error("content_shell took too long to startup.")
 
@@ skipping 65 matching lines @@
                 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
             return True
         return self.has_crashed()
 
     def _check_for_leak(self, error_line):
         if error_line.startswith("#LEAK - "):
             self._leaked = True
+            match = re.match('#LEAK - (\S+) pid (\d+) (.+)\n', error_line)
+            self._leak_log = match.group(3)
         return self._leaked
 
     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:
             command = self._port.abspath_for_test(driver_input.test_name)
@@ skipping 95 matching lines @@
                 if content_length_before_header_check != block._content_length:
                     if block._content_length > 0:
                         block.content = self._server_process.read_stdout(deadline, block._content_length)
                     else:
                         _log.error("Received content of type %s with Content-Length of 0!  This indicates a bug in %s.",
                                    block.content_type, self._server_process.name())
 
             if err_line:
                 if self._check_for_driver_crash(err_line):
                     break
-                self._check_for_leak(err_line)
+                if self._check_for_leak(err_line):
+                    break
                 self.error_from_test += err_line
 
         block.decode_content()
         return block
 
 
 class ContentBlock(object):
     def __init__(self):
         self.content_type = None
         self.encoding = None
         self.content_hash = None
         self._content_length = None
         # Content is treated as binary data even though the text output is usually UTF-8.
         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