Add support for ie in the browser controller

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:core";
 import "dart:io";
 
 import 'android.dart';
@@ skipping 36 matching lines @@
 
   Browser();
 
   factory Browser.byName(String name) {
     if (name == 'ff' || name == 'firefox') {
       return new Firefox();
     } else if (name == 'chrome') {
       return new Chrome();
     } else if (name == 'safari') {
       return new Safari();
+    } else if (name.startsWith('ie')) {
+      return new IE();
     } else {
       throw "Non supported browser";
     }
   }
 
   static const List<String> SUPPORTED_BROWSERS =
-      const ['safari', 'ff', 'firefox', 'chrome'];
+    const ['safari', 'ff', 'firefox', 'chrome', 'ie9', 'ie10'];
 
   static const List<String> BROWSERS_WITH_WINDOW_SUPPORT =
       const ['safari', 'ff', 'firefox', 'chrome'];
 
   // TODO(kustermann): add standard support for chrome on android
   static bool supportedBrowser(String name) {
     return SUPPORTED_BROWSERS.contains(name);
   }
 
   void _logEvent(String event) {
@@ skipping 63 matching lines @@
         stderrDone.complete(true);
       });
 
       process.exitCode.then((exitCode) {
         _logEvent("Browser closed with exitcode $exitCode");
         Future.wait([stdoutDone.future, stderrDone.future]).then((_) {
           process = null;
           if (_cleanup != null) {
             _cleanup();
           }
-          doneCompleter.complete(exitCode);
+          doneCompleter.complete(true);
+        }).catchError((error) {
+          _logEvent("Error closing browsers: $error");
         });
       });
       return true;
     }).catchError((error) {
       _logEvent("Running $command $arguments failed with $error");
       return false;
     });
   }
 
   /**
@@ skipping 182 matching lines @@
       });
     }).catchError((e) {
       _logEvent("Running $binary --version failed with $e");
       return false;
     });
   }
 
   String toString() => "Chrome";
 }
 
+class IE extends Browser {
+
+  static const String binary =
+      "c:\\Program Files\\Internet Explorer\\iexplore.exe";

[kustermann, 2013/08/14 11:06:16]

Check if the path is the same for ie9/ie10.

[ricow1, 2013/08/14 11:29:48]

It is

+
+  Future<String> getVersion() {
+    var args = ["query",
+                "HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Internet Explorer",
+                "/v",
+                "version"];
+    return Process.run("reg", args).then((result) {
+      if (result.exitCode == 0) {
+        // The string we get back looks like this:
+        // HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Explorer
+        //    version    REG_SZ    9.0.8112.16421
+        var findString = "REG_SZ";
+        var index = result.stdout.indexOf(findString);
+        if (index > 0) {
+          return result.stdout.substring(index + findString.length).trim();
+        }
+      }
+      return "Could not get the version of internet explorer";
+    });
+  }
+

[kustermann, 2013/08/14 11:06:16]

extra line

[ricow1, 2013/08/14 11:29:48]

done

+
+  Future<bool> start(String url) {
+    _logEvent("Starting ie browser on: $url");
+    return getVersion().then((version) {
+      _logEvent("Got version: $version");
+      return startBrowser(binary, [url]);
+    });
+  }
+  String toString() => "IE";
+}
+
+
 class AndroidChrome extends Browser {
   static const String viewAction = 'android.intent.action.VIEW';
   static const String mainAction = 'android.intent.action.MAIN';
   static const String chromePackage = 'com.android.chrome';
   static const String browserPackage = 'com.android.browser';
   static const String firefoxPackage = 'org.mozilla.firefox';
   static const String turnScreenOnPackage = 'com.google.dart.turnscreenon';
 
   AndroidEmulator _emulator;
   AdbDevice _adbDevice;
@@ skipping 242 matching lines @@
       }
       browsersCompleter.complete(browsers);
     }
     return browsersCompleter.future;
   }
 
   var timedOut = [];
 
   void handleResults(String browserId, String output, int testId) {
     var status = browserStatus[browserId];
-    DebugLogger.info("Handling result for browser ${browserId}");
     if (testCache.containsKey(testId)) {
       doubleReportingTests.add(testId);
       return;
     }
 
     if (status.timeout) {
       // We don't do anything, this browser is currently being killed and
       // replaced.
     } else if (status.currentTest != null) {
       status.currentTest.timeoutTimer.cancel();
       status.currentTest.stopwatch.stop();
 
       if (status.currentTest.id != testId) {
         print("Expected test id ${status.currentTest.id} for"
               "${status.currentTest.url}");
         print("Got test id ${testId}");
         print("Last test id was ${status.lastTest.id} for "
               "${status.currentTest.url}");
         throw("This should never happen, wrong test id");
       }
       testCache[testId] = status.currentTest.url;
-      DebugLogger.info("Size of output for test $testId : ${output.length}");
       Stopwatch watch = new Stopwatch()..start();
       status.currentTest.doneCallback(output,
                                       status.currentTest.stopwatch.elapsed);
       watch.stop();
-      DebugLogger.info("Handling of test $testId took : ${watch.elapsed}");
       status.lastTest = status.currentTest;
       status.currentTest = null;
     } else {
       print("\nThis is bad, should never happen, handleResult no test");
       print("URL: ${status.lastTest.url}");
       print(output);
       terminate().then((_) {
         exit(1);
       });
     }
   }
 
   void handleTimeout(BrowserTestingStatus status) {
     // We simply kill the browser and starts up a new one!
     // We could be smarter here, but it does not seems like it is worth it.
-    DebugLogger.info("Handling timeout for browser ${status.browser.id}");
     status.timeout = true;
     timedOut.add(status.currentTest.url);
     var id = status.browser.id;
     status.browser.close().then((_) {
       // We don't want to start a new browser if we are terminating.
       if (underTermination) return;
       var browser;
       var new_id = id;
       if (browserName == 'chromeOnAndroid') {
         browser = new AndroidChrome(adbDeviceMapping[id]);
@@ skipping 28 matching lines @@
     status.currentTest.stopwatch.stop();
     status.currentTest.doneCallback("TIMEOUT",
                                     status.currentTest.stopwatch.elapsed);
     status.currentTest = null;
   }
 
   BrowserTest getNextTest(String browserId) {
     if (testQueue.isEmpty) return null;
     var status = browserStatus[browserId];
     if (status == null) return null;
-    DebugLogger.info("Handling getNext for browser "
-                     "${browserId} timeout status: ${status.timeout}");
 
     // We are currently terminating this browser, don't start a new test.
     if (status.timeout) return null;
     BrowserTest test = testQueue.removeLast();
     if (status.currentTest == null) {
       status.currentTest = test;
     } else {
       // TODO(ricow): Handle this better.
       print("This is bad, should never happen, getNextTest all full");
       print("This happened for browser $browserId");
@@ skipping 78 matching lines @@
 
   Function testDoneCallBack;
   Function nextTestCallBack;
 
   BrowserTestingServer(this.local_ip, this.useIframe);
 
   Future start() {
     return HttpServer.bind(local_ip, 0).then((createdServer) {
       httpServer = createdServer;
       void handler(HttpRequest request) {
-        DebugLogger.info("Handling request to: ${request.uri.path}");
+        // Don't allow caching of resources from the browser controller, i.e.,
+        // we don't want the browser to cache the result of getNextTest.
+        request.response.headers.set("Cache-Control",
+                                     "no-cache, no-store, must-revalidate");
         if (request.uri.path.startsWith(reportPath)) {
           var browserId = request.uri.path.substring(reportPath.length + 1);
-          var testId = 
+          var testId =
               int.parse(request.uri.queryParameters["id"].split("=")[1]);
           handleReport(request, browserId, testId);
           // handleReport will asynchroniously fetch the data and will handle
           // the closing of the streams.
           return;
         }
         var textResponse = "";
         if (request.uri.path.startsWith(driverPath)) {
           var browserId = request.uri.path.substring(driverPath.length + 1);
           textResponse = getDriverPage(browserId);
         } else if (request.uri.path.startsWith(nextTestPath)) {
           var browserId = request.uri.path.substring(nextTestPath.length + 1);
           textResponse = getNextTest(browserId);
         } else {
-          DebugLogger.info("Handling non standard request to: "
-                           "${request.uri.path}");
+          // /favicon.ico requests
         }
         request.response.write(textResponse);
         request.listen((_) {}, onDone: request.response.close);
-        request.response.done.then((_) {
-          DebugLogger.info("Done handling request to: ${request.uri.path}");
-        }).catchError((error) {
+        request.response.done.catchError((error) {
           if (!underTermination) {
             print("URI ${request.uri}");
             print("Textresponse $textResponse");
             throw "Error returning content to browser: $error";
           }
       });
       }
       void errorHandler(e) {
         if (!underTermination) print("Error occured in httpserver: $e");
       };
 
       httpServer.listen(handler, onError: errorHandler);
 
       // Set up the error reporting server that enables us to send back
       // errors from the browser.
       return HttpServer.bind(local_ip, 0).then((createdReportServer) {
         errorReportingServer = createdReportServer;
         void errorReportingHandler(HttpRequest request) {
           StringBuffer buffer = new StringBuffer();
           request.transform(new StringDecoder()).listen((data) {
             buffer.write(data);
           }, onDone: () {
               String back = buffer.toString();
               request.response.headers.set("Access-Control-Allow-Origin", "*");
-
               request.response.done.catchError((error) {
                 DebugLogger.error("Error getting error from browser"
                                   "on uri ${request.uri.path}: $error");
               });
               request.response.close();
               DebugLogger.error("Error from browser on : "
                                "${request.uri.path}, data:  $back");
           }, onError: (error) { print(error); });
         }
         errorReportingServer.listen(errorReportingHandler,
                                     onError: errorHandler);
         return true;
       });
     });
   }
 
   void handleReport(HttpRequest request, String browserId, var testId) {
     StringBuffer buffer = new StringBuffer();
     request.transform(new StringDecoder()).listen((data) {
       buffer.write(data);
       }, onDone: () {
         String back = buffer.toString();
         request.response.close();
         testDoneCallBack(browserId, back, testId);
-        DebugLogger.info("Done handling request to: ${request.uri.path}");
       }, onError: (error) { print(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) {
@@ skipping 21 matching lines @@
     String driverContent = """
 <!DOCTYPE html><html>
 <head>
   <title>Driving page</title>
   <script type='text/javascript'>
 
     function startTesting() {
       var number_of_tests = 0;
       var current_id;
       var last_reported_id;
+      // Describes a state where we are currently fetching the next test
+      // from the server. We use this to never double request tasks.
+      var instantiating_next_test = false;

[kustermann, 2013/08/14 11:06:16]

I'd rename this to 'var old_test_finished', set it to false when we get
'STARTING' and set it to true after we've received the DOM the first time.

       var testing_window;
-      // We use this to determine if we did actually get back a start event
-      // from the test we just loaded.
-      var did_start = false;
 
       var embedded_iframe = document.getElementById('embedded_iframe');
       var use_iframe = ${useIframe};
       var start = new Date();
 
       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;
-              // TODO(ricow): Do something more clever here.
-              if (nextTask != undefined) alert('This is really bad');
               // The task is send to us as:
               // URL#ID
               var split = this.responseText.split('#');
               var nextTask = split[0];
               current_id = split[1];
-              reportError('Done getting task : ' + elapsed);
-              did_start = false;
               run(nextTask);
             }
           } else {
             reportError('Could not contact the server and get a new task');
           }
         }
       }
 
       function getNextTask() {
-        var elapsed = new Date() - start;
-        reportError('Getting task at: ' + elapsed);
+        // Until we have the next task we set the current_id to a specific
+        // negative value.
+        instantiating_next_test = true;
         var client = new XMLHttpRequest();
         client.onreadystatechange = newTaskHandler;
         client.open('GET', '$nextTestPath/$browserId');
         client.send();
       }
 
       function run(url) {
         number_of_tests++;
         document.getElementById('number').innerHTML = number_of_tests;
         if (use_iframe) {
@@ skipping 25 matching lines @@
         }
         client.onreadystatechange = handleReady;
         client.open('POST', '$errorReportingUrl?test=1');
         client.setRequestHeader('Content-type',
                                 'application/x-www-form-urlencoded');
         client.send(msg);
       }
 
       function reportMessage(msg) {
         if (msg == 'STARTING') {
-          did_start = true;
+          instantiating_next_test = false;
           return;
         }
-        var client = new XMLHttpRequest();
+
+        // We define this here to capture the value of the posting id.
+        // That way we can make sure to never ask for a new task if the
+        // reported id is not the currently running id. If we just use
+        // current_id and last_reported_id, current_id may have been changed
+        // by the next test.
+        var posting_id =
+            instantiating_next_test ? last_reported_id : current_id;

[kustermann, 2013/08/14 11:06:16]

I'd add a variable here (so it's captured by the closure):
var isDoubleReport = ...;

and 5 lines down, I'd use that variable int he condition whether we call
'getNextTask()' or not.

[ricow1, 2013/08/14 11:29:48]

Changed it _again_ :-)

         function handleReady() {
           if (this.readyState == this.DONE) {
             if (this.status == 200) {
-              if (last_reported_id != current_id && did_start) {
-                var elapsed = new Date() - start;
-                reportError('Done sending results at: ' + elapsed);
+              if (posting_id == current_id && !instantiating_next_test) {
+                last_reported_id = current_id;
                 getNextTask();
-                last_reported_id = current_id;
               }
             } else {
               reportError('Error sending result to server');
             }
           }
         }
+        var client = new XMLHttpRequest();
         client.onreadystatechange = handleReady;
-        // If did_start is false it means that we did actually set the url on
-        // the testing_window, but this is a report left in the event loop or
-        // a callback because the page did not load yet.
-        // In both cases this is a double report from the last test.
-        var posting_id = did_start ? current_id : last_reported_id;
         client.open('POST', '$reportPath/${browserId}?id=' + posting_id);
         client.setRequestHeader('Content-type',
                                 'application/x-www-form-urlencoded');
         client.send(msg);
-        var elapsed = new Date() - start;
-        reportError('Sending results at: ' + elapsed);
       }
 
       function messageHandler(e) {
         var msg = e.data;
         if (typeof msg != 'string') return;
         reportMessage(msg);
       }
 
       window.addEventListener('message', messageHandler, false);
       waitForDone = false;
 
       getNextTask();
     }
 
   </script>
 </head>
   <body onload="startTesting()">
     Dart test driver, number of tests: <div id="number"></div>
     <iframe id="embedded_iframe"></iframe>
   </body>
 </html>
 """;
     return driverContent;
   }
 }