anchor.diff:  }
   
   /**
  + * Create a 'Timer' implementation for the services isolate that can handle
  + * 0 duration timers. If we need support for non-zero durations, we'll need to
  + * do some communications back to the main isolate and have it run the timer
  + * callbacks for us.
  + */
  +Timer _createTimer(Zone self, ZoneDelegate parent, Zone zone, Duration duration,
  +    void f()) {
  +
  +  if (duration.inMilliseconds == 0) {
  +    return new _Timer(f);
  +  } else {
  +    // UnimplementedError: Timers on background isolates are not supported in
  +    // the browser.
  +    return parent.createTimer(zone, duration, f);
  +  }
  +}
  +
  +/**
    * Print to the matching [SendPort]. Host will know it's a print because it's a
    * simple string instead of a map.
    */
   void _printToPort(String str) => _sendPort.send(str);
  +
  +class _Timer implements Timer {
  +  final Function f;
  +  bool _active = true;
  +
  +  _Timer(this.f) {
  +    scheduleMicrotask(() {
  +      if (isActive) {
  +        try {
  +          f();
  +        } finally {
  +          _active = false;
  +        }
  +      }
  +    });
  +  }
  +
  +  void cancel() { _active = false; }
  +
  +  bool get isActive => _active;
  +}
  
positive.code: Zone _createIsolateZone() {
    var specification = new ZoneSpecification(
        handleUncaughtError: _handleUncaughtError,
        print: _print);
    return Zone.current.fork(specification: specification);
  }
  
negative.code: class IsolateWorkerToHostHandler implements WorkerToHostHandler {
    final SendPort _sendPort;
    ReceivePort _receivePort;
  
    IsolateWorkerToHostHandler(this._sendPort) {
      _receivePort = new ReceivePort();
      _sendPort.send(_receivePort.sendPort);
    }
  
    @override
    void sendToHost(dynamic message) {
      _sendPort.send(message);
    }
  
    @override
    void listenFromHost(void onData(var message)) {
      _receivePort.listen(onData);
    }
  }
  
  