minor fixes

com.unity.uiwidgets/Runtime/async/async_cast.cs

             this._source = _source;
         }
 
-        bool isBroadcast {
+        public override bool isBroadcast {
             get { return _source.isBroadcast; }
         }
 
         public override void onDone(Action handleDone) {
             _source.onDone(handleDone);
         }
-
         void _onData(S data) {
             if (_handleData == null) return;
             T targetData;
             _source.resume();
         }
 
-        bool isPaused {
+        public override bool isPaused {
-
 
     class CastStreamTransformer<SS, ST, TS, TT>
         : StreamTransformerBase<TS, TT> where TT : class where ST : class {

com.unity.uiwidgets/Runtime/async/broadcast_stream_controller.cs

             : base(controller) {
         }
 
-        bool isBroadcast {
+        public override bool isBroadcast {
             get { return true; }
         }
     }
 
         // The controller._recordPause doesn't do anything for a broadcast controller,
         // so we don't bother calling it.
-        void _onPause() {
+        protected override void _onPause() {
-        void _onResume() {
+        protected override void _onResume() {
         }
 
         // _onCancel is inherited.
         protected const int _STATE_CLOSED = 4;
         const int _STATE_ADDSTREAM = 8;
 
-        _stream.ControllerCallback onListen;
-        _stream.ControllerCancelCallback onCancel;
+        public override _stream.ControllerCallback onListen { get; set; }
+        public override _stream.ControllerCancelCallback onCancel { get; set; }
 
         // State of the controller.
         internal int _state;
             _state = _STATE_INITIAL;
         }
 
-        _stream.ControllerCallback onPause {
+        public override _stream.ControllerCallback onPause {
             get {
                 throw new Exception(
                     "Broadcast stream controllers do not support pause callbacks");
             }
         }
 
-        _stream.ControllerCallback onResume {
+        public override _stream.ControllerCallback onResume {
             get {
                 throw new Exception(
                     "Broadcast stream controllers do not support pause callbacks");
         }
 
         /** Whether an event is being fired (sent to some, but not all, listeners). */
-        internal bool _isFiring {
+        internal virtual bool _isFiring {
-        bool _isAddingStream {
+        internal bool _isAddingStream {
-        internal bool _mayAddEvent {
+        internal virtual bool _mayAddEvent {
             get => (_state < _STATE_CLOSED);
         }
 
 
         // Linked list helpers
 
-        internal bool _isEmpty {
+        internal virtual bool _isEmpty {
             get { return _firstSubscription == null; }
         }
 
             return subscription;
         }
 
-        Future _recordCancel(StreamSubscription<T> sub) {
+        public override Future _recordCancel(StreamSubscription<T> sub) {
             _BroadcastSubscription<T> subscription = (_BroadcastSubscription<T>) sub;
             // If already removed by the stream, don't remove it again.
             if (Equals(subscription._next, subscription)) return null;
             return null;
         }
 
-        void _recordPause(StreamSubscription<T> subscription) {
+        public override void _recordPause(StreamSubscription<T> subscription) {
-        void _recordResume(StreamSubscription<T> subscription) {
+        public override void _recordResume(StreamSubscription<T> subscription) {
         }
 
         // EventSink interface.
             return doneFuture;
         }
 
-        Future done {
+        public override Future done {
             get { return _ensureDoneFuture(); }
         }
 
             }
         }
 
-        internal void _callOnCancel() {
+        internal virtual void _callOnCancel() {
             D.assert(_isEmpty);
             if (isClosed && _doneFuture._mayComplete) {
                 // When closed, _doneFuture is not null.
 
         // EventDispatch interface.
 
-        bool _mayAddEvent {
+        internal override bool _mayAddEvent {
             get { return base._mayAddEvent && !_isFiring; }
         }
 
             _pending.add(evt);
         }
 
-        void add(T data) {
+        public override void add(T data) {
             if (!isClosed && _isFiring) {
                 _addPendingEvent(new _DelayedData<T>(data));
                 return;
             }
         }
 
-        void addError(object error, string stackTrace) {
+        public override void addError(object error, string stackTrace) {
             // ArgumentError.checkNotNull(error, "error");
             stackTrace = stackTrace ?? AsyncError.defaultStackTrace(error);
             if (!isClosed && _isFiring) {
             }
         }
 
-        Future close() {
+        public override Future close() {
             if (!isClosed && _isFiring) {
                 _addPendingEvent(new _DelayedDone<T>());
                 _state |= _BroadcastStreamController<T>._STATE_CLOSED;
             return result;
         }
 
-        void _callOnCancel() {
+        internal override void _callOnCancel() {
             if (_hasPending) {
                 _pending.clear();
                 _pending = null;

com.unity.uiwidgets/Runtime/async/stream.cs

-//part of dart.async;
-
-
-using System.Diagnostics;
-using System.IO;
-using Unity.UIWidgets.async;
 using Unity.UIWidgets.core;
 using Unity.UIWidgets.foundation;
 using Stopwatch = Unity.UIWidgets.core.Stopwatch;
         public delegate void _TimerCallback();
     }
 
-    public abstract class Foo<T> {
-        public Foo() {
-        }
-    }
-
-
-
-
+        
-
 
         // @Since("2.5")
         public static Stream<T> value(T value) {
         static Stream<T> castFrom<S, T>(Stream<S> source) =>
             new CastStream<S, T>(source);
 
-        public bool isBroadcast {
+        public virtual bool isBroadcast {
-        public Stream<T> asBroadcastStream(
+        public virtual Stream<T> asBroadcastStream(
             Action<StreamSubscription<T>> onListen = null,
             Action<StreamSubscription<T>> onCancel = null) {
             return new _AsBroadcastStream<T>(this, onListen, onCancel);
 
         public abstract void resume();
 
-        public bool isPaused { get; }
+        public virtual bool isPaused { get; }
 
         public abstract Future<E> asFuture<E>(E futureValue);
     }
     public abstract class StreamSink<S> : EventSink<S>, StreamConsumer<S> {
         // Future close();
 
-        public Future done { get; }
+        public virtual Future done { get; }
-        public Future addStream(Stream<S> stream) {
+        public virtual Future addStream(Stream<S> stream) {
             throw new System.NotImplementedException();
         }
 

com.unity.uiwidgets/Runtime/async/stream_controller.cs

 using System;
-using System.Diagnostics;
-using Unity.UIWidgets.async;
-using UnityEditor.PackageManager;
 
 namespace Unity.UIWidgets.async {
     static partial class _stream {
                 });
         }
 
-        public _stream.ControllerCallback onListen { get; set; }
+        public virtual _stream.ControllerCallback onListen { get; set; }
-        public _stream.ControllerCallback onPause { get; set; }
+        public virtual _stream.ControllerCallback onPause { get; set; }
-        public _stream.ControllerCallback onResume { get; set; }
+        public virtual _stream.ControllerCallback onResume { get; set; }
-        public _stream.ControllerCancelCallback onCancel { get; set; }
+        public virtual _stream.ControllerCancelCallback onCancel { get; set; }
 
         // void set onCancel(onCancelHandler());
 
             Action onDone, bool cancelOnError);
 
 
-        public void _recordPause(StreamSubscription<T> subscription) {
+        public virtual void _recordPause(StreamSubscription<T> subscription) {
-        public void _recordResume(StreamSubscription<T> subscription) {
+        public virtual void _recordResume(StreamSubscription<T> subscription) {
         }
 
         public virtual Future _recordCancel(StreamSubscription<T> subscription) => null;
         // accessed earlier, or if close is called before subscribing.
         _Future _doneFuture;
 
-        _stream.ControllerCallback onListen;
-        _stream.ControllerCallback onPause;
-        _stream.ControllerCallback onResume;
-        _stream.ControllerCancelCallback onCancel;
+        public override _stream.ControllerCallback onListen { get; set; }
+        public override _stream.ControllerCallback onPause  { get; set; }
+        public override _stream.ControllerCallback onResume  { get; set; }
+        public override _stream.ControllerCancelCallback onCancel  { get; set; }
 
         internal _StreamController(_stream.ControllerCallback onListen, _stream.ControllerCallback onPause,
             _stream.ControllerCallback onResume, _stream.ControllerCancelCallback onCancel) {
                 (_state & _STATE_SUBSCRIPTION_MASK) == _STATE_INITIAL;
         }
 
-        bool isClosed {
+        public override bool isClosed {
-        bool isPaused {
+        public override bool isPaused {
             get =>
                 hasListener ? _subscription._isInputPaused : !_isCanceled;
         }
         }
 
         /** New events may not be added after close, or during addStream. */
-        bool _mayAddEvent {
+        internal bool _mayAddEvent {
             get => (_state < _STATE_CLOSED);
         }
 
             return addState.addStreamFuture;
         }
 
-        Future done {
+        public override Future done {
             get { return _ensureDoneFuture(); }
         }
 
             return result;
         }
 
-        void _recordPause(StreamSubscription<T> subscription) {
+        public override void _recordPause(StreamSubscription<T> subscription) {
             if (_isAddingStream) {
                 _StreamControllerAddStreamState<T> addState = (_StreamControllerAddStreamState<T>) _varData;
                 addState.pause();
         }
 
-        void _recordResume(StreamSubscription<T> subscription) {
+        public override void _recordResume(StreamSubscription<T> subscription) {
             if (_isAddingStream) {
                 _StreamControllerAddStreamState<T> addState = (_StreamControllerAddStreamState<T>) _varData;
                 addState.resume();
             this._controller = _controller;
         }
 
-        Future _onCancel() {
+        protected override Future _onCancel() {
-        void _onPause() {
+        protected override void _onPause() {
-        void _onResume() {
+        protected override void _onResume() {
             _controller._recordResume(this);
         }
     }
 
         public override Future close() => _target.close();
 
-        Future addStream(Stream<T> source) => _target.addStream(source);
+        public override Future addStream(Stream<T> source) => _target.addStream(source);
-        Future done {
+        public override Future done {
             get { return _target.done; }
         }
     }

com.unity.uiwidgets/Runtime/async/stream_impl.cs

             _iterator = data.GetEnumerator();
         }
 
-        bool isEmpty {
+        public override bool isEmpty {
             get { return _iterator == null; }
         }
 
 
     abstract class _DelayedEvent<T> {
         /** Added as a linked list on the [StreamController]. */
-        internal _DelayedEvent<T> next;
+        internal virtual _DelayedEvent<T> next { get; set; }
 
         /** Execute the delayed event on the [StreamController]. */
         public abstract void perform(_EventDispatch<T> dispatch);
             dispatch._sendDone();
         }
 
-        _DelayedEvent<object> next {
+        internal override _DelayedEvent<T> next {
             get { return null; }
             set { throw new Exception("No events after a done."); }
         }
             get => (_state & _STATE_CANCEL_ON_ERROR) != 0;
         }
 
-        internal bool isPaused {
+        public override bool isPaused {
             get => _isPaused;
         }
 
 
         // _EventSink interface.
 
-        public void _add(T data) {
+        public virtual void _add(T data) {
             D.assert(!_isClosed);
             if (_isCanceled) return;
             if (_canFire) {
             }
         }
 
-        public void _addError(object error, string stackTrace) {
+        public virtual void _addError(object error, string stackTrace) {
             if (_isCanceled) return;
             if (_canFire) {
                 _sendError(error, stackTrace); // Reports cancel after sending.
             }
         }
 
-        public void _close() {
+        public virtual void _close() {
             D.assert(!_isClosed);
             if (_isCanceled) return;
             _state |= _STATE_CLOSED;
         // These must not throw. If overwritten to call user code, include suitable
         // try/catch wrapping and send any errors to
         // [_Zone.current.handleUncaughtError].
-        void _onPause() {
+        protected virtual void _onPause() {
-        void _onResume() {
+        protected virtual void _onResume() {
-        Future _onCancel() {
+        protected virtual Future _onCancel() {
             D.assert(_isCanceled);
             return null;
         }
             }
         }
 
-        public void _sendData(T data) {
+        public virtual void _sendData(T data) {
             D.assert(!_isCanceled);
             D.assert(!_isPaused);
             D.assert(!_inCallback);
             _checkState(wasInputPaused);
         }
 
-        public void _sendError(object error, string stackTrace) {
+        public virtual void _sendError(object error, string stackTrace) {
             D.assert(!_isCanceled);
             D.assert(!_isPaused);
             D.assert(!_inCallback);
    */
         int _state = _STATE_UNSCHEDULED;
 
-        public bool isEmpty { get; }
+        public virtual bool isEmpty { get; }
 
         public bool isScheduled {
             get => _state == _STATE_SCHEDULED;
         /// Last element in the list of pending events. New events are added after it.
         _DelayedEvent<T> lastPendingEvent;
 
-        bool isEmpty {
+        public override bool isEmpty {
             get { return lastPendingEvent == null; }
         }
 
             get => (_state & _SCHEDULED) != 0;
         }
 
-        bool isPaused {
+        public override bool isPaused {
             get => _state >= _PAUSED;
         }
 
             _controller = new _AsBroadcastStreamController<T>(_onListen, _onCancel);
         }
 
-        bool isBroadcast {
+        public override bool isBroadcast {
             get { return true; }
         }
 
             return Future._nullFuture;
         }
 
-        bool isPaused {
+        public override bool isPaused {
             get { return _stream._isSubscriptionPaused; }
         }
 
         internal _EmptyStream() : base() {
         }
 
-        bool isBroadcast {
+        public override bool isBroadcast {
             get { return true; }
         }
 

com.unity.uiwidgets/Runtime/async/stream_pipe.cs

 using System;
-using System.Collections;
-using System.Diagnostics;
 
 namespace Unity.UIWidgets.async {
     public static partial class _stream {
             this._source = _source;
         }
 
-        bool isBroadcast {
+        public override bool isBroadcast {
             get { return _source.isBroadcast; }
         }
 
             sink._add((T) (object) data);
         }
 
-        internal virtual void _handleError(Exception error, _EventSink<T> sink) {
-            sink._addError(error, error.StackTrace);
+        internal virtual void _handleError(object error, _EventSink<T> sink) {
+            string stackTrace = error is Exception ? ((Exception) error).StackTrace : "";
+            sink._addError(error, stackTrace);
         }
 
         internal virtual void _handleDone(_EventSink<T> sink) {
         // Transformers sending more than one event have no way to know if the stream
         // is canceled or closed after the first, so we just ignore remaining events.
 
-        void _add(T data) {
+        public override void _add(T data) {
-        void _addError(object error, string stackTrace) {
+        public override void _addError(object error, string stackTrace) {
             if (_isClosed) return;
             base._addError(error, stackTrace);
         }
-        void _onPause() {
+        protected override void _onPause() {
-        void _onResume() {
+        protected override void _onResume() {
-        Future _onCancel() {
+        protected override Future _onCancel() {
             if (_subscription != null) {
                 StreamSubscription<S> subscription = _subscription;
                 _subscription = null;
         }
 
 
-        void _handleError(object error, string stackTrace, _EventSink<T> sink) {
+        internal override void _handleError(object error, _EventSink<T> sink) {
             bool matches = true;
             if (_test != null) {
                 try {
                 }
             }
 
+            string stackTrace = error is Exception ? ((Exception) error).StackTrace : "";
             if (matches) {
                 try {
                     _async._invokeErrorHandler(_transform, error, stackTrace);
                 this, onData, onError, onDone, cancelOnError, _SENTINEL);
         }
 
-        void _handleData(T inputEvent, _EventSink<T> sink) {
+        internal override void _handleData(T inputEvent, _EventSink<T> sink) {
             _StateStreamSubscription<T> subscription = (_StateStreamSubscription<T>) sink;
             var previous = subscription._value;
             if (Equals(previous, _SENTINEL)) {

com.unity.uiwidgets/Runtime/async/stream_transformers.cs

 
         // _EventSink interface.
 
-        void _add(T data) {
+        public override void _add(T data) {
             if (_isClosed) {
                 throw new Exception("Stream is already closed");
             }
 
-        void _addError(object error, string stackTrace) {
+        public override void _addError(object error, string stackTrace) {
             if (_isClosed) {
                 throw new Exception("Stream is already closed");
             }
 
-        void _close() {
+        public override void _close() {
             if (_isClosed) {
                 throw new Exception("Stream is already closed");
             }
 
         // _BufferingStreamSubscription hooks.
 
-        void _onPause() {
+        protected override void _onPause() {
-        void _onResume() {
+        protected override void _onResume() {
-        Future _onCancel() {
+        protected override Future _onCancel() {
             if (_isSubscribed) {
                 StreamSubscription<S> subscription = _subscription;
                 _subscription = null;
         readonly _async._SinkMapper<S, T> _sinkMapper;
         readonly Stream<S> _stream;
 
-        bool isBroadcast {
+        public override bool isBroadcast {
             get { return _stream.isBroadcast; }
         }
 
             }) {
         }
 
-        Stream<T> bind(Stream<S> stream) {
+        public override Stream<T> bind(Stream<S> stream) {
             return base.bind(stream);
         }
     }
         readonly _async._SubscriptionTransformer<S, T> _onListen;
         readonly Stream<S> _stream;
 
-        bool isBroadcast {
+        public override bool isBroadcast {
             get { return _stream.isBroadcast; }
         }