Add support in test scripts backend for simple HTML tests.

tools/testing/dart/browser_controller.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 library browser;
 
 import "dart:async";
-import "dart:convert" show LineSplitter, UTF8;
+import "dart:convert" show LineSplitter, UTF8, JSON;
 import "dart:core";
 import "dart:io";
 
 import 'android.dart';
 import 'http_server.dart';
 import 'utils.dart';
 
 class BrowserOutput {
   final StringBuffer stdout = new StringBuffer();
   final StringBuffer stderr = new StringBuffer();
@@ skipping 758 matching lines @@
   Timer timeoutTimer;
 
   // Used for debugging, this is simply a unique identifier assigned to each
   // test.
   int id;
   static int _idCounter = 0;
 
   BrowserTest(this.url, this.doneCallback, this.timeout) {
     id = _idCounter++;
   }
+
+  String toJSON() => JSON.encode({'url': url,
+                                  'id': id,
+                                  'isSimpleHtmlTest': false});
 }
 
+
+/**
+ * Describes a test with a custom HTML page to be run in the browser.
+ */
+class HtmlTest extends BrowserTest {
+  List<String> expectedMessages;
+
+  HtmlTest(url, doneCallback, timeout, this.expectedMessages)
+      : super(url, doneCallback, timeout) { }
+
+  String toJSON() => JSON.encode({'url': url,
+                                  'id': id,
+                                  'isSimpleHtmlTest': true,
+                                  'expectedMessages': expectedMessages});
+}
+
+
 /* Describes the output of running the test in a browser */
 class BrowserTestOutput {
   final Duration delayUntilTestStarted;
   final Duration duration;
 
   final String lastKnownMessage;
 
   final BrowserOutput browserOutput;
   final bool didTimeout;
 
@@ skipping 497 matching lines @@
     errorReportingServer.listen(errorReportingHandler, onError: errorHandler);
   }
 
   void setupDispatchingServer(_) {
     DispatchingServer server = configuration['_servers_'].server;
     void noCache(request) {
         request.response.headers.set("Cache-Control",
                                      "no-cache, no-store, must-revalidate");
     }
     int testId(request) =>
-        int.parse(request.uri.queryParameters["id"].split("=")[1]);
+        int.parse(request.uri.queryParameters["id"]);
     String browserId(request, prefix) =>
         request.uri.path.substring(prefix.length + 1);
 
 
     server.addHandler(reportPath, (HttpRequest request) {
       noCache(request);
       handleReport(request, browserId(request, reportPath),
                    testId(request), isStatusUpdate: false);
     });
     server.addHandler(statusUpdatePath, (HttpRequest request) {
@@ skipping 62 matching lines @@
       testStartedCallBack(browserId, back, testId);
     }, onError: (error) { DebugLogger.error("$error"); });
   }
 
   String getNextTest(String browserId) {
     var nextTest = nextTestCallBack(browserId);
     if (underTermination) {
       // Browsers will be killed shortly, send them a terminate signal so
       // that they stop pulling.
       return terminateSignal;
-    } else if (nextTest == null) {
-      // We don't currently have any tests ready for consumption, wait.
-      return waitSignal;
     } else {
-      return "${nextTest.url}#id=${nextTest.id}";
+      return nextTest == null ? waitSignal : nextTest.toJSON();
     }
   }
 
   String getDriverUrl(String browserId) {
     if (errorReportingServer == null) {
       print("Bad browser testing server, you are not started yet. Can't "
             "produce driver url");
       exit(1);
       // This should never happen - exit immediately;
     }
     var port = configuration['_servers_'].port;
     return "http://$localIp:$port/driver/$browserId";
   }
 
 
   String getDriverPage(String browserId) {
     var errorReportingUrl =
         "http://$localIp:${errorReportingServer.port}/$browserId";
     String driverContent = """
 <!DOCTYPE html><html>
 <head>
   <title>Driving page</title>
   <script type='text/javascript'>
+    var STATUS_UPDATE_INTERVAL = 10000;
+
     function startTesting() {
       var number_of_tests = 0;
       var current_id;
       var next_id;
       // Describes a state where we are currently fetching the next test
       // from the server. We use this to never double request tasks.
       var test_completed = true;
       var testing_window;
 
       var embedded_iframe = document.getElementById('embedded_iframe');
       var number_div = document.getElementById('number');
       var executing_div = document.getElementById('currently_executing');
       var error_div = document.getElementById('unhandled_error');
       var use_iframe = ${useIframe};
       var start = new Date();
 
+      // Object that holds the state of an HTML test
+      var html_test;
+  
       function newTaskHandler() {
         if (this.readyState == this.DONE) {
           if (this.status == 200) {
             if (this.responseText == '$waitSignal') {
               setTimeout(getNextTask, 500);
             } else if (this.responseText == '$terminateSignal') {
               // Don't do anything, we will be killed shortly.
             } else {
               var elapsed = new Date() - start;
-              // The task is send to us as:
-              // URL#ID
-              var split = this.responseText.split('#');
-              var nextTask = split[0];
-              next_id = split[1];
-              run(nextTask);
+              var nextTask = JSON.parse(this.responseText);
+              var url = nextTask.url;
+              next_id = nextTask.id;
+              if (nextTask.isHtmlTest) {
+                html_test = {
+                  expected_messages: nextTask.expectedMessages,
+                  found_message_count: 0,
+                  double_received_messages: [],
+                  unexpected_messages: [],
+                  found_messages: {}
+                };
+                for (var i = 0; i < html_test.expected_messages.length; ++i) {
+                  html_test.found_messages[html_test.expected_messages[i]] = 0;
+                }
+              } else {
+                html_test = null;
+              }               
+              run(url);
             }
           } else {
             reportError('Could not contact the server and get a new task');
           }
         }
       }
 
       function contactBrowserController(method,
                                         path,
                                         callback,
                                         msg,
                                         isUrlEncoded) {
         var client = new XMLHttpRequest();
         client.onreadystatechange = callback;
         client.open(method, path);
         if (isUrlEncoded) {
           client.setRequestHeader('Content-type',
                                   'application/x-www-form-urlencoded');
         }
         client.send(msg);
       }
 
       function getNextTask() {
         // Until we have the next task we set the current_id to a specific
         // negative value.
         contactBrowserController(
             'GET', '$nextTestPath/$browserId', newTaskHandler, "", false);
       }
 
+      function childError(message, filename, lineno, colno, error) {
+        sendStatusUpdate();
+        if (error) {
+          reportMessage('FAIL:' + filename + ':' + lineno + 
+               ':' + colno + ':' + message + '\\n' + error.stack, false, false);
+        } else if (filename) {
+          reportMessage('FAIL:' + filename + ':' + lineno + 
+               ':' + colno + ':' + message, false, false);
+        } else {
+          reportMessage('FAIL: ' + message, false, false);
+        }
+        return true;
+      }
+
+      function setChildHandlers(e) {
+        embedded_iframe.contentWindow.addEventListener('message',
+                                                       childMessageHandler,
+                                                       false);
+        embedded_iframe.contentWindow.onerror = childError;
+        reportMessage("First message from html test", true, false);
+        html_test.handlers_installed = true;
+        sendRepeatingStatusUpdate();
+      }
+
+      function checkChildHandlersInstalled() {
+        if (!html_test.handlers_installed) {
+          reportMessage("First message from html test", true, false);
+          reportMessage(
+              'FAIL: Html test did not call ' +
+              'window.parent.dispatchEvent(new Event("detect_errors")) ' +
+              'as its first action', false, false);
+        }
+      }
+
       function run(url) {
         number_of_tests++;
         number_div.innerHTML = number_of_tests;
         executing_div.innerHTML = url;
         if (use_iframe) {
+          if (html_test) {
+            window.addEventListener('detect_errors', setChildHandlers, false);
+            embedded_iframe.onload = checkChildHandlersInstalled;
+          } else {
+            embedded_iframe.onload = null;
+          }
           embedded_iframe.src = url;
         } else {
           if (typeof testing_window != 'undefined') {
             testing_window.close();
           }
           testing_window = window.open(url);
         }
       }
 
       window.onerror = function (message, url, lineNumber) {
@@ skipping 60 matching lines @@
       }
 
       function parseResult(result) {
         var parsedData = null;
         try {
           parsedData = JSON.parse(result);
         } catch(error) { }
         return parsedData;
       }
 
+      // Browser tests send JSON messages to the driver window, handled here.
       function messageHandler(e) {
         var msg = e.data;
         if (typeof msg != 'string') return;
 
         var parsedData = parseResult(msg);
         if (parsedData) {
           // Only if the JSON message contains all required parameters,
           // will we handle it and post it back to the test controller.
           if ('message' in parsedData &&
               'is_first_message' in parsedData &&
               'is_status_update' in parsedData &&
               'is_done' in parsedData) {
             var message = parsedData['message'];
             var isFirstMessage = parsedData['is_first_message'];
             var isStatusUpdate = parsedData['is_status_update'];
             var isDone = parsedData['is_done'];
             if (!isFirstMessage && !isStatusUpdate) {
               if (!isDone) {
                 alert("Bug in test_controller.js: " +
                       "isFirstMessage/isStatusUpdate/isDone were all false");
               }
             }
             reportMessage(message, isFirstMessage, isStatusUpdate);
           }
         }
       }
 
-      window.addEventListener('message', messageHandler, false);
-      waitForDone = false;
+      function sendStatusUpdate () {
+        var dom =
+            embedded_iframe.contentWindow.document.documentElement.innerHTML;
+        reportMessage('Status:\\n  Messages received multiple times:\\n    ' +
+                      html_test.double_received_messages +
+                      '\\n  Unexpected messages:\\n    ' +
+                      html_test.unexpected_messages +
+                      '\\n  DOM:\\n    ' + dom, false, true);
+      }
 
+      function sendRepeatingStatusUpdate() {
+        sendStatusUpdate();
+        setTimeout(sendRepeatingStatusUpdate, STATUS_UPDATE_INTERVAL);
+      }
+
+      // HTML tests post messages to their own window, handled by this handler.
+      // This handler is installed on the child window when it sends the
+      // 'detect_errors' event.  Every HTML test must send 'detect_errors' to
+      // its parent window as its first action, so all errors will be caught.
+      function childMessageHandler(e) {
+        var msg = e.data;
+        if (typeof msg != 'string') return;
+        if (msg in html_test.found_messages) {
+          html_test.found_messages[msg]++;
+          if (html_test.found_messages[msg] == 1) {
+            html_test.found_message_count++;
+          } else {  
+            html_test.double_received_messages.push(msg);
+            sendStatusUpdate();
+          }
+        } else {
+          html_test.unexpected_messages.push(msg);
+          sendStatusUpdate();
+        }
+        if (html_test.found_message_count ==
+            html_test.expected_messages.length) {
+          reportMessage('Test done: PASS', false, false);
+        }
+      }
+
+      if (!html_test) {
+        window.addEventListener('message', messageHandler, false);
+        waitForDone = false;
+      }
       getNextTask();
     }
-
   </script>
 </head>
   <body onload="startTesting()">
     Dart test driver, number of tests: <div id="number"></div><br>
     Currently executing: <div id="currently_executing"></div><br>
     Unhandled error: <div id="unhandled_error"></div>
     <iframe id="embedded_iframe"></iframe>
   </body>
 </html>
 """;
     return driverContent;
   }
 }