Add a test for timers in child isolates.

tools/dom/src/Timer.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.
 
 part of html;
 
 // TODO(antonm): support not DOM isolates too.
 class _Timer implements Timer {
   final canceller;
 
@@ skipping 19 matching lines @@
 };
 
 const _NEW_TIMER = 'NEW_TIMER';
 const _CANCEL_TIMER = 'CANCEL_TIMER';
 const _TIMER_PING = 'TIMER_PING';
 
 class _PureIsolateTimer implements Timer {
   final ReceivePort _port = new ReceivePort();
   SendPort _sendPort; // Effectively final.
 
+  static SendPort _SEND_PORT;
+
   _PureIsolateTimer(int milliSeconds, callback, repeating) {
     _sendPort = _port.toSendPort();
     _port.receive((msg, replyTo) {
       assert(msg == _TIMER_PING);
       assert(replyTo == _HELPER_ISOLATE_PORT);
       callback(this);
       if (!repeating) _cancel();
     });
-    _HELPER_ISOLATE_PORT.then((port) {
-      port.send([_NEW_TIMER, milliSeconds, repeating], _sendPort);
-    });
+
+    registerTimer() {
+      _SEND_PORT.send([_NEW_TIMER, milliSeconds, repeating], _sendPort);
+    }
+
+    // Tricky part: Future.then is always delayed might prevent
+    // new timer registration if many events come to this isolate.
+    // Therefore, let's resort to then only if really necessary.

[vsm, 2013/03/29 14:37:39]

I'm confused by this.  What was the problem you were hitting in the old code? 
Why wasn't the new time registering?

It doesn't seem like this change should fix anyway (beyond reducing a potential
delay).

[Anton Muhin, 2013/03/29 16:09:15]

(whatever outcome of our discuss be, I need to modify cancel code to behave
similarly).

There was an interesting corner case I found.

Imagine you spawn a timer which pings you every 10 ms and from the handler of
this timer you'd like to spawn another timer.  Alas, timer creation requires
.then which invoke Timer.run which invokes new Timer.

So I'd like to by pass timer creation while I am trying to create a new timer.

Does that sound reasonable?

I've also updates the text.

On 2013/03/29 14:37:39, vsm wrote:

[vsm, 2013/03/29 17:34:36]

I think I'm starting to get this - was the old code hitting an infinite loop on
_HELPER_ISOLATE_PORT.then?

Not entirely clear to me whether this is a bug fix or an optimization from your
comment.

On 2013/03/29 16:09:15, Anton Muhin wrote:

[Anton Muhin, 2013/04/01 14:52:57]

I've updated the comment.  May you, please, tell me if it's sufficient enough?

On 2013/03/29 17:34:36, vsm wrote:

+    if (_SEND_PORT != null) {
+      registerTimer();
+    } else {
+      _HELPER_ISOLATE_PORT.then((port) {
+        _SEND_PORT = port;
+        registerTimer();
+      });
+    }
   }
 
   void cancel() {
     _cancel();
     _HELPER_ISOLATE_PORT.then((port) {
       port.send([_CANCEL_TIMER], _sendPort);
     });
   }
 
   void _cancel() {
     _port.close();
   }
 
   static final Future<SendPort> _HELPER_ISOLATE_PORT =
       spawnDomFunction(_helperIsolateMain);
 }
 
 final _TIMER_REGISTRY = new Map<SendPort, Timer>();
 
 _helperIsolateMain() {
   port.receive((msg, replyTo) {
     final cmd = msg[0];
     if (cmd == _NEW_TIMER) {
       final duration = new Duration(milliseconds: msg[1]);
       bool periodic = msg[2];
-      final callback = () { replyTo.send(_TIMER_PING); };
+      ping() { replyTo.send(_TIMER_PING); }
       _TIMER_REGISTRY[replyTo] = periodic ?
-          new Timer.periodic(duration, callback) :
-          new Timer(duration, callback);
+          new Timer.periodic(duration, (_) { ping(); }) :
+          new Timer(duration, ping);
     } else if (cmd == _CANCEL_TIMER) {
-      _TIMER_REGISTRY.remove(replyTo).cancel();
+      Timer timer = _TIMER_REGISTRY.remove(replyTo);
+      if (timer != null) timer.cancel();
     }
   });
 }
 
 get _pureIsolateTimerFactoryClosure =>
     ((int milliSeconds, void callback(Timer time), bool repeating) =>
         new _PureIsolateTimer(milliSeconds, callback, repeating));