Modifications to layout test framework so that it can work with browser_tests.

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 132 matching lines @@
     def run_test(self, driver_input, stop_when_done):
         """Run a single test and return the results.
 
         Note that it is okay if a test times out or crashes and leaves
         the driver in an indeterminate state. The upper layers of the program
         are responsible for cleaning up and ensuring things are okay.
 
         Returns a DriverOutput object.
         """
         start_time = time.time()
-        self.start(driver_input.should_run_pixel_test, driver_input.args)
+        self.start(driver_input.should_run_pixel_test, driver_input.args, int(driver_input.timeout))
         test_begin_time = time.time()
         self.error_from_test = str()
         self.err_seen_eof = False
 
         command = self._command_from_driver_input(driver_input)
         deadline = test_begin_time + int(driver_input.timeout) / 1000.0
 
         self._server_process.write(command)
         text, audio = self._read_first_block(deadline)  # First block is either text or audio
         image, actual_image_hash = self._read_optional_image_block(deadline)  # The second (optional) block is image data.
@@ skipping 94 matching lines @@
         if self._server_process is None:
             return False
         if self._crashed_process_name:
             return True
         if self._server_process.has_crashed():
             self._crashed_process_name = self._server_process.name()
             self._crashed_pid = self._server_process.pid()
             return True
         return False
 
-    def start(self, pixel_tests, per_test_args):
+    def start(self, pixel_tests, per_test_args, deadline=0):
         new_cmd_line = self.cmd_line(pixel_tests, per_test_args)
         if not self._server_process or new_cmd_line != self._current_cmd_line:
             self._start(pixel_tests, per_test_args)
             self._run_post_start_tasks()
 
     def _setup_environ_for_driver(self, environment):
         if self._profiler:
             environment = self._profiler.adjusted_environment(environment)
         return environment
 
@@ skipping 129 matching lines @@
             return (None, block.decoded_content)
         return (block.decoded_content, None)
 
     def _read_optional_image_block(self, deadline):
         # returns (image, actual_image_hash)
         block = self._read_block(deadline, wait_for_stderr_eof=True)
         if block.content and block.content_type == 'image/png':
             return (block.decoded_content, block.content_hash)
         return (None, block.content_hash)
 
+    def _read_stdin_path(self, deadline):
+        # returns (stdin_path, bool)
+        block = self._read_block(deadline)
+        if block.stdin_path:
+            return (block.stdin_path, True)
+        return (None, False)
+
     def _read_header(self, block, line, header_text, header_attr, header_filter=None):
         if line.startswith(header_text) and getattr(block, header_attr) is None:
             value = line.split()[1]
             if header_filter:
                 value = header_filter(value)
             setattr(block, header_attr, value)
             return True
         return False
 
     def _process_stdout_line(self, block, line):
         if (self._read_header(block, line, 'Content-Type: ', 'content_type')
             or self._read_header(block, line, 'Content-Transfer-Encoding: ', 'encoding')
             or self._read_header(block, line, 'Content-Length: ', '_content_length', int)
             or self._read_header(block, line, 'ActualHash: ', 'content_hash')
             or self._read_header(block, line, 'DumpMalloc: ', 'malloc')
-            or self._read_header(block, line, 'DumpJSHeap: ', 'js_heap')):
+            or self._read_header(block, line, 'DumpJSHeap: ', 'js_heap')
+            or self._read_header(block, line, 'StdinPath', 'stdin_path')):
             return
         # Note, we're not reading ExpectedHash: here, but we could.
         # If the line wasn't a header, we just append it to the content.
         block.content += line
 
     def _strip_eof(self, line):
         if line and line.endswith("#EOF\n"):
             return line[:-5], True
         if line and line.endswith("#EOF\r\n"):
             _log.error("Got a CRLF-terminated #EOF - this is a driver bug.")
@@ skipping 56 matching lines @@
     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
+        self.stdin_path = 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