Added support for running dart2js tests on android devices

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';
 
 /** Class describing the interface for communicating with browsers. */
-class Browser {
+abstract class Browser {
   // Browsers actually takes a while to cleanup after itself when closing
   // Give it sufficient time to do that.
   static final Duration killRepeatInternal = const Duration(seconds: 10);
   static final int killRetries = 5;
   StringBuffer _stdout = new StringBuffer();
   StringBuffer _stderr = new StringBuffer();
   StringBuffer _usageLog = new StringBuffer();
   // This function is called when the process is closed.
   // This is extracted to an external function so that we can do additional
   // functionality when the process closes (cleanup and call onExit)
@@ skipping 131 matching lines @@
       });
 
       process.exitCode.then((exitCode) {
         _logEvent("Browser closed with exitcode $exitCode");
         if (_processClosed != null) _processClosed();
         if (_cleanup != null) _cleanup();
         if (onClose != null) onClose(exitCode);
       });
       return true;
     }).catchError((error) {
-      _logEvent("Running $binary $arguments failed with $error");
+      _logEvent("Running $command $arguments failed with $error");
       return false;
     });
   }
 
   /**
    * Get any stdout that the browser wrote during execution.
    */
   String get stdout => _stdout.toString();
   String get stderr => _stderr.toString();
   String get usageLog => _usageLog.toString();
 
   String toString();
   /** Starts the browser loading the given url */
   Future<bool> start(String url);
 }
 
-
 class Chrome extends Browser {
   /**
    * The binary used to run chrome - changing this can be nececcary for
    * testing or using non standard chrome installation.
    */
   const String binary = "google-chrome";
 
   Future<bool> start(String url) {
     _logEvent("Starting chrome browser on: $url");
     // Get the version and log that.
@@ skipping 16 matching lines @@
       });
     }).catchError((e) {
       _logEvent("Running $binary --version failed with $e");
       return false;
     });
   }
 
   String toString() => "Chrome";
 }
 
+class AndroidChrome extends Browser {
+  const String viewAction = 'android.intent.action.VIEW';
+  const String mainAction = 'android.intent.action.MAIN';
+  const String chromePackage = 'com.android.chrome';
+  const String browserPackage = 'com.android.browser';
+  const String firefoxPackage = 'org.mozilla.firefox';
+  const String turnScreenOnPackage = 'com.google.dart.turnscreenon';
+
+  AndroidEmulator _emulator;
+  AdbDevice _adbDevice;
+
+  AndroidChrome(this._adbDevice);
+
+  Future<bool> start(String url) {
+    var browserIntent = new Intent(
+        viewAction, browserPackage, '.BrowserActivity', url);
+    var chromeIntent = new Intent(viewAction, chromePackage, '.Main', url);
+    var firefoxIntent = new Intent(viewAction, firefoxPackage, '.App', url);
+    var turnScreenOnIntent =
+        new Intent(mainAction, turnScreenOnPackage, '.Main');
+
+    var chromeAPK = new Path(
+        'third_party/android_testing_resources/com.android.chrome-1.apk');
+    var turnScreenOnAPK = new Path(
+        'third_party/android_testing_resources/TurnScreenOn.apk');
+    var chromeConfDir = new Path(
+        'third_party/android_testing_resources/chrome_configuration');
+    var chromeConfDirRemote = new Path(
+        '/data/user/0/com.android.chrome/');
+
+    return _adbDevice.waitForBootCompleted().then((_) {
+      return _adbDevice.forceStop(chromeIntent.package);
+    }).then((_) {
+      return _adbDevice.killAll();
+    }).then((_) {
+      return _adbDevice.adbRoot();
+    }).then((_) {
+      return _adbDevice.installApk(turnScreenOnAPK);
+    }).then((_) {
+      return _adbDevice.installApk(chromeAPK);
+    }).then((_) {
+      return _adbDevice.pushData(chromeConfDir, chromeConfDirRemote);
+    }).then((_) {
+      return _adbDevice.chmod('777', chromeConfDirRemote);
+    }).then((_) {
+      return _adbDevice.startActivity(turnScreenOnIntent).then((_) => true);
+    }).then((_) {
+      return _adbDevice.startActivity(chromeIntent).then((_) => true);
+    });
+  }
+
+  Future<bool> close() {
+    if (_adbDevice != null) {
+      return _adbDevice.forceStop(chromePackage).then((_) {
+        return _adbDevice.killAll().then((_) => true);
+      });
+    }
+    return new Future.immediate(true);
+  }
+
+  String toString() => "chromeOnAndroid";
+}
+
 class Firefox extends Browser {
   /**
    * The binary used to run firefox - changing this can be nececcary for
    * testing or using non standard firefox installation.
    */
   const String binary = "firefox";
 
   const String enablePopUp =
       "user_pref(\"dom.disable_open_during_load\", false);";
 
@@ skipping 35 matching lines @@
 }
 
 
 /**
  * Describes the current state of a browser used for testing.
  */
 class BrowserTestingStatus {
 // TODO(ricow): Add prefetching to the browsers. We spend a lot of time waiting
 // for the next test. Handling timeouts is the hard part of this!
 
-
   Browser browser;
   BrowserTest currentTest;
   // This is currently not used for anything except for error reporting.
   // Given the usefulness of this in debugging issues this should not be
   // removed even when we have really stable system.
   BrowserTest lastTest;
   bool timeout = false;
   BrowserTestingStatus(Browser this.browser);
 }
 
@@ skipping 21 matching lines @@
 }
 
 
 /**
  * Encapsulates all the functionality for running tests in browsers.
  * The interface is rather simple. After starting the runner tests
  * are simply added to the queue and a the supplied callbacks are called
  * whenever a test completes.
  */
 class BrowserTestRunner {
+  String local_ip;
+  String browserName;
   int maxNumBrowsers;
-  String browserName;
 
   bool underTermination = false;
 
   List<BrowserTest> testQueue = new List<BrowserTest>();
   Map<String, BrowserTestingStatus> browserStatus =
       new Map<String, BrowserTestingStatus>();
+
+  var adbDeviceMapping = new Map<String, AdbDevice>();
   // This cache is used to guarantee that we never see double reporting.
   // If we do we need to provide developers with this information.
   // We don't add urls to the cache until we have run it.
   Map<int, String> testCache = new Map<int, String>();
   List<int> doubleReportingTests = new List<int>();
 
   BrowserTestingServer testingServer;
 
-  BrowserTestRunner(String this.browserName, int this.maxNumBrowsers);
+  BrowserTestRunner(this.local_ip, this.browserName, this.maxNumBrowsers);
 
   Future<bool> start() {
-    testingServer = new BrowserTestingServer();
+    testingServer = new BrowserTestingServer(local_ip);
     return testingServer.start().then((_) {
       testingServer.testDoneCallBack = handleResults;
       testingServer.nextTestCallBack = getNextTest;
-      var futures = [];
-      for (int i = 0; i < maxNumBrowsers; i++) {
-        var browser = getInstance();
-        var id = "BROWSER$i";
-        // We store this in case we need to kill the browser.
-        browser.id = id;
-        var future =
-            browser.start(testingServer.getDriverUrl(id)).then((success) {
-              if (success) {
-                browserStatus[id] = new BrowserTestingStatus(browser);
-              }
-              return success;
-            });
-        futures.add(future);
-      }
-      return Future.wait(futures).then((values) {
-        return !values.contains(false);
+      return getBrowsers().then((browsers) {
+        var futures = [];
+        for (var browser in browsers) {
+          var url = testingServer.getDriverUrl(browser.id);
+          var future = browser.start(url).then((success) {
+                if (success) {

[ricow1, 2013/05/22 13:13:37]

indentation

[kustermann, 2013/05/22 15:32:41]

Done.

+                  browserStatus[browser.id] = new BrowserTestingStatus(browser);
+                }
+                return success;
+              });
+          futures.add(future);
+        }
+        return Future.wait(futures).then((values) {
+          return !values.contains(false);
+        });
       });
     });
   }
 
+  Future<List<Browser>> getBrowsers() {

[ricow1, 2013/05/22 13:13:37]

I think this is rather hackish, how about this:
The browser class has a method that returns the max number of instances (normal
ff/chrome=unlimited). The browser constructor  takes an id (I think it should
anyway, makes sense). Now in the AdndroidChrome class we have a static Map from
id to deviceid. That way we encapsulate all browser specific stuff in the
browser classes instead of having it leak in here?

[kustermann, 2013/05/22 15:32:41]

We've to determine the number of browsers before we actually create instances of
them.
This would mean the 'maxBrowsersSupported' property has to be static ...
I've added a TODO for now and will fix it later.

+    var browsersCompleter = new Completer();
+    if (browserName == 'chromeOnAndroid') {
+      AdbHelper.listDevices().then((deviceIds) {
+        if (deviceIds.length > 0) {
+          var browsers = [];
+          for (int i = 0; i < deviceIds.length; i++) {
+            var id = "BROWSER$i";
+            var device = new AdbDevice(deviceIds[i]);
+            adbDeviceMapping[id] = device;
+            var browser = new AndroidChrome(device);
+            browsers.add(browser);
+            // We store this in case we need to kill the browser.
+            browser.id = id;
+          }
+          browsersCompleter.complete(browsers);
+        } else {
+          throw new StateError("No android devices found.");
+        }
+      });
+    } else {
+      var browsers = [];
+      for (int i = 0; i < maxNumBrowsers; i++) {
+        var id = "BROWSER$i";
+        var browser = getInstance();
+        browsers.add(browser);
+        // We store this in case we need to kill the browser.
+        browser.id = id;
+      }
+      browsersCompleter.complete(browsers);
+    }
+    return browsersCompleter.future;
+  }
+
   var timedOut = [];
 
   void handleResults(String browserId, String output, int testId) {
     var status = browserStatus[browserId];
     if (testCache.containsKey(testId)) {
       doubleReportingTests.add(testId);
       return;
     }
 
     if (status.timeout) {
@@ skipping 28 matching lines @@
     // We could be smarter here, but it does not seems like it is worth it.
     status.timeout = true;
     timedOut.add(status.currentTest.url);
     var id = status.browser.id;
     status.browser.close().then((closed) {
       if (!closed) {
         // Very bad, we could not kill the browser.
         print("could not kill browser $id");
         return;
       }
-      // Start the new browser first
-      var browser = getInstance();
+      var browser;
+      if (browserName == 'chromeOnAndroid') {
+        browser = new AndroidChrome(adbDeviceMapping[id]);
+      } else {
+        browser = getInstance();
+      }
       browser.start(testingServer.getDriverUrl(id)).then((success) {
         // We may have started terminating in the mean time.
         if (underTermination) {
           browser.close().then((success) {
             // We should never hit this, print it out.
             if (!success) {
               print("Could not kill browser ($id) started due to timeout");
             }
           });
           return;
@@ skipping 73 matching lines @@
     if (browserName == "chrome") {
       return new Chrome();
     } else if (browserName == "ff") {
       return new Firefox();
     }
     throw "Non supported browser for browser controller";
   }
 }
 
 class BrowserTestingServer {
-  const String server = "127.0.0.1";
-
   /// Interface of the testing server:
   ///
   /// GET /driver/BROWSER_ID -- This will get the driver page to fetch
   ///                           and run tests ...
   /// GET /next_test/BROWSER_ID -- returns "WAIT" "TERMINATE" or "url#id"
   /// where url is the test to run, and id is the id of the test.
   /// If there are currently no available tests the waitSignal is send
   /// back. If we are in the process of terminating the terminateSignal
   /// is send back and the browser will stop requesting new tasks.
   /// POST /report/BROWSER_ID?id=NUM -- sends back the dom of the executed
   ///                                   test
 
+  final String local_ip;
 
   const String driverPath = "/driver";
   const String nextTestPath = "/next_test";
   const String reportPath = "/report";
   const String waitSignal = "WAIT";
   const String terminateSignal = "TERMINATE";
 
   var testCount = 0;
   var httpServer;
   bool underTermination = false;
 
   Function testDoneCallBack;
   Function nextTestCallBack;
 
+  BrowserTestingServer(this.local_ip);
+
   Future start() {
-    return HttpServer.bind(server, 0).then((createdServer) {
+    return HttpServer.bind(local_ip, 0).then((createdServer) {
       httpServer = createdServer;
       void handler(HttpRequest request) {
         if (request.uri.path.startsWith(reportPath)) {
           var browserId = request.uri.path.substring(reportPath.length + 1);
           var testId = int.parse(request.queryParameters["id"].split("=")[1]);
 
           handleReport(request, browserId, testId);
           // handleReport will asynchroniously fetch the data and will handle
           // the closing of the streams.
           return;
@@ skipping 51 matching lines @@
     }
   }
 
   String getDriverUrl(String browserId) {
     if (httpServer == null) {
       print("Bad browser testing server, you are not started yet. Can't "
             "produce driver url");
       exit(1);
       // This should never happen - exit immediately;
     }
-    return "http://$server:${httpServer.port}/driver/$browserId";
+    return "http://$local_ip:${httpServer.port}/driver/$browserId";
   }
 
 
   String getDriverPage(String browserId) {
     String driverContent = """
 <!DOCTYPE html><html>
 <head>
   <title>Driving page</title>
   <script type='text/javascript'>
     var number_of_tests = 0;
+    var processed_ids = {};
     var current_id;
     var testing_window;
-    var last_reported_id;
 
     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 {
             // 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];
-            run(nextTask);
+            if (testing_window != undefined) {
+              testing_window.location = '_blank';
+            }
+            function doAfterEmptyEventLoop() {
+              current_id = split[1];
+              processed_ids[current_id] = 0;
+              run(nextTask);
+            }
+            setTimeout(doAfterEmptyEventLoop(), 0);
           }
         } else {
           // We are basically in trouble - do something clever.
         }
       }
     }
 
     function getNextTask() {
       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 (testing_window == undefined) {
         testing_window = window.open(url);
       } else {
         testing_window.location = url;
       }
     }
 
     function reportMessage(msg) {
       var client = new XMLHttpRequest();
       function handleReady() {
         if (this.readyState == this.DONE) {
-          if (current_id != last_reported_id) {
+          if (processed_ids[current_id] == 0) {
             getNextTask();
-            last_reported_id = current_id;
+            processed_ids[current_id] = 1;
           }
         }
       }
       client.onreadystatechange = handleReady;
       client.open('POST', '$reportPath/${browserId}?id=' + current_id);
       client.setRequestHeader('Content-type',
                               'application/x-www-form-urlencoded');
       client.send(msg);
       // TODO(ricow) add error handling to somehow report the fact that
       // we could not send back a result.
@@ skipping 13 matching lines @@
   </script>
 </head>
   <body>
     Dart test driver, number of tests: <div id="number"></div>
   </body>
 </html>
 """;
     return driverContent;
   }
 }