pkg/unittest: fixed deprecations in alt configs

pkg/unittest/lib/html_layout_config.dart

 // Copyright (c) 2012, 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.
 
 /**
  * A configuration for running layoutr tests with testrunner.
  * This configuration is similar to the interactive_html_config
  * as it runs each test in its own IFrame. However, where the former
  * recreated the IFrame for each test, here the IFrames are preserved.
  * Furthermore we post a message on completion.
  */
 library html_layout_config;
 
+import 'dart:async';
 import 'dart:html';
 import 'dart:math';
 import 'unittest.dart';
 
 /** The messages exchanged between parent and child. */
 // TODO(gram) At some point postMessage was supposed to support
 // sending arrays and maps. When it does we can get rid of the encoding/
 // decoding of messages as string.
 class _Message {
   static final START = 'start';
@@ skipping 33 matching lines @@
 }
 
 /**
  * The child configuration that is used to run individual tests in
  * an IFrame and post the results back to the parent. In principle
  * this can run more than one test in the IFrame but currently only
  * one is used.
  */
 class ChildHtmlConfiguration extends Configuration {
   get name => 'ChildHtmlConfiguration';
-  // TODO(rnystrom): Get rid of this if we get canonical closures for methods.
-  EventListener _onErrorClosure;
+
+  StreamSubscription _errorSubscription;
 
   /** The window to which results must be posted. */
   Window parentWindow;
 
   /** The time at which tests start. */
   Map<int,DateTime> _testStarts;
 
   ChildHtmlConfiguration() :
       _testStarts = new Map<int,DateTime>();
 
   /** Don't start running tests automatically. */
   get autoStart => false;
 
   void onInit() {
-    _onErrorClosure =
-        (e) => handleExternalError(e, '(DOM callback has errors)');
-
     /**
      *  The parent posts a 'start' message to kick things off,
      *  which is handled by this handler. It saves the parent
      *  window, gets the test ID from the query parameter in the
      *  IFrame URL, sets that as a solo test and starts test execution.
      */
-    window.on.message.add((MessageEvent e) {
+    window.onMessage.listen((MessageEvent e) {
       var m = new _Message.fromString(e.data);
       if (m.messageType == _Message.START) {
         parentWindow = e.source;
         String search = window.location.search;
         int pos = search.indexOf('t=');
         String ids = search.substring(pos+2);
         int id = int.parse(ids);
         setSoloTest(id);
         runTests();
       }
     });
   }
 
   void onStart() {
-    // Listen for uncaught errors.
-    window.on.error.add(_onErrorClosure);
+    _errorSubscription = window.onError.listen((e) {
+      handleExternalError(e, '(DOM callback has errors)');
+    });
   }
 
   /** Record the start time of the test. */
   void onTestStart(TestCase testCase) {
     super.onTestStart(testCase);
     _testStarts[testCase.id]= new DateTime.now();
   }
 
   /**
    * Tests can call [log] for diagnostic output. These log
@@ skipping 27 matching lines @@
     }
     parentWindow.postMessage(
         _Message.text(testCase.result, elapsed, testCase.message), '*');
   }
 
   void onSummary(int passed, int failed, int errors, List<TestCase> results,
       String uncaughtError) {
   }
 
   void onDone(bool success) {
-    window.on.error.remove(_onErrorClosure);
+    assert(_errorSubscription != null);
+    _errorSubscription.cancel();
+    _errorSubscription = null;
   }
 }
 
 /**
  * The parent configuration runs in the top-level window; it wraps the tests
  * in new functions that create child IFrames and run the real tests.
  */
 class ParentHtmlConfiguration extends Configuration {
   get autoStart => false;
   get name => 'ParentHtmlConfiguration';
   Map<int,DateTime> _testStarts;
-  // TODO(rnystrom): Get rid of this if we get canonical closures for methods.
-  EventListener _onErrorClosure;
 
   /** The stack that was posted back from the child, if any. */
   String _stack;
 
   int _testTime;
   /**
    * Whether or not we have already wrapped the TestCase test functions
    * in new closures that instead create an IFrame and get it to run the
    * test.
    */
   bool _doneWrap = false;
 
-  /**
-   * We use this to make a single closure from _handleMessage so we
-   * can remove the handler later.
-   */
-  Function _messageHandler;
+  StreamSubscription _messageSubscription, _errorSubscription;
 
   ParentHtmlConfiguration() :
       _testStarts = new Map<int,DateTime>();
 
   // We need to block until the test is done, so we make a
   // dummy async callback that we will use to flag completion.
   Function completeTest = null;
 
   wrapTest(TestCase testCase) {
     String baseUrl = window.location.toString();
     String url = '${baseUrl}?t=${testCase.id}';
     return () {
       // Add the child IFrame.
       Element childDiv = document.query('#child');
       var label = new Element.html(
           "<pre id='result${testCase.id}'>${testCase.description}</pre>");
       IFrameElement child = new Element.html("""
           <iframe id='childFrame${testCase.id}' src='$url'>
           </iframe>""");
       childDiv.nodes.add(label);
       childDiv.nodes.add(child);
       completeTest = expectAsync0((){ });
       // Kick off the test when the IFrame is loaded.
-      child.on.load.add((e) {
+      child.onLoad.listen((e) {
         child.contentWindow.postMessage(_Message.text(_Message.START), '*');
       });
     };
   }
 
   void _handleMessage(MessageEvent e) {
     // Get the result, do any logging, then do a pass/fail.
     var msg = new _Message.fromString(e.data);
     if (msg.messageType == _Message.LOG) {
       logMessage(e.data);
     } else if (msg.messageType == _Message.STACK) {
       _stack = msg.body;
     } else {
       _testTime = msg.elapsed;
       if (msg.messageType == _Message.PASS) {
         currentTestCase.pass();
       } else if (msg.messageType == _Message.FAIL) {
         currentTestCase.fail(msg.body, _stack);
       } else if (msg.messageType == _Message.ERROR) {
         currentTestCase.error(msg.body, _stack);
       }
       completeTest();
     }
   }
 
   void onInit() {
-    _messageHandler = _handleMessage; // We need to make just one closure.
-    _onErrorClosure =
-        (e) => handleExternalError(e, '(DOM callback has errors)');
   }
 
   void onStart() {
     // Listen for uncaught errors.
-    window.on.error.add(_onErrorClosure);
+    assert(_errorSubscription == null);
+    _errorSubscription = window.onError.listen((e) {
+      handleExternalError(e, '(DOM callback has errors)');
+    });
+
     if (!_doneWrap) {
       _doneWrap = true;
       for (int i = 0; i < testCases.length; i++) {
         testCases[i].test = wrapTest(testCases[i]);
         testCases[i].setUp = null;
         testCases[i].tearDown = null;
       }
     }
-    window.on.message.add(_messageHandler);
+
+    _messageSubscription = window.onMessage.listen(_handleMessage);
   }
 
   void onTestStart(TestCase testCase) {
     var id = testCase.id;
     _testStarts[testCase.id]= new DateTime.now();
     super.onTestStart(testCase);
     _stack = null;
   }
 
   // Actually test logging is handled by the child, then posted
@@ skipping 10 matching lines @@
     super.onTestResult(testCase);
     document.query('#result${testCase.id}').text =
         '${testCase.result}:${testCase.runningTime.inMilliseconds}:'
         '${testCase.description}//${testCase.message}';
   }
 
   void onSummary(int passed, int failed, int errors, List<TestCase> results,
       String uncaughtError) {
   }
   void onDone(bool success) {
-    window.on.message.remove(_messageHandler);
-    window.on.error.remove(_onErrorClosure);
+    _messageSubscription.cancel();
+    _messageSubscription = null;
+
+    _errorSubscription.cancel();
+    _errorSubscription = null;
+
     window.postMessage('done', '*'); // Unblock DRT
   }
 }
 
 /**
  * Add the divs to the DOM if they are not present.
  */
 void _prepareDom() {
   if (document.query('#otherlogs') == null) {
     document.body.nodes.add(new Element.html(
@@ skipping 11 matching lines @@
 void useHtmlLayoutConfiguration() {
   if (config != null) return;
   if (window.location.search == '') { // This is the parent.
     _prepareDom();
     configure(new ParentHtmlConfiguration());
   } else {
     configure(new ChildHtmlConfiguration());
   }
 }