Change StreamController constructor.

sdk/lib/async/stream.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.
 
 part of dart.async;
 
 // -------------------------------------------------------------------
 // Core Stream types
 // -------------------------------------------------------------------
 
@@ skipping 97 matching lines @@
     }
 
     void startPeriodicTimer() {
       assert(timer == null);
       timer = new Timer.periodic(period, (Timer timer) {
         sendEvent();
       });
     }
 
     controller = new StreamController<T>(
-        onPauseStateChange: () {
-          if (controller.isPaused) {
-            timer.cancel();
+        onListen: () {
+          watch.start();
+          startPeriodicTimer();
+        },
+        onPause: () {
+          timer.cancel();
+          timer = null;
+          watch.stop();
+        },
+        onResume: () {
+          assert(timer == null);
+          Duration elapsed = watch.elapsed;
+          watch.start();
+          timer = new Timer(period - elapsed, () {
             timer = null;
-            watch.stop();
-          } else {
-            assert(timer == null);
-            Duration elapsed = watch.elapsed;
-            watch.start();
-            timer = new Timer(period - elapsed, () {
-              timer = null;
-              startPeriodicTimer();
-              sendEvent();
-            });
-          }
+            startPeriodicTimer();
+            sendEvent();
+          });
         },
-        onSubscriptionStateChange: () {
-          if (controller.hasListener) {
-            watch.start();
-            startPeriodicTimer();
-          } else {
-            if (timer != null) timer.cancel();
-            timer = null;
-          }
+        onCancel: () {
+          if (timer != null) timer.cancel();
+          timer = null;
         });
     return controller.stream;
   }
 
   /**
    * Reports whether this stream is a broadcast stream.
    */
   bool get isBroadcast => false;
 
   /**
@@ skipping 814 matching lines @@
 abstract class StreamEventTransformer<S, T> implements StreamTransformer<S, T> {
   const StreamEventTransformer();
 
   Stream<T> bind(Stream<S> source) {
     // Hackish way of buffering data that goes out of the event-transformer.
     // TODO(floitsch): replace this with a correct solution.
     Stream transformingStream = new EventTransformStream<S, T>(source, this);
     StreamController controller;
     StreamSubscription subscription;
     controller = new StreamController<T>(
-        onPauseStateChange: () {
-          if (controller.isPaused) {
-            subscription.pause();
-          } else {
-            subscription.resume();
-          }
+        onListen: () {
+          subscription = transformingStream.listen(
+              controller.add,
+              onError: controller.addError,
+              onDone: controller.close);
         },
-        onSubscriptionStateChange: () {
-          if (controller.hasListener) {
-            subscription = transformingStream.listen(
-                controller.add,
-                onError: controller.addError,
-                onDone: controller.close);
-          } else {
-            subscription.cancel();
-          }
-        });
+        onPause: () => subscription.pause(),
+        onResume: () => subscription.resume(),
+        onCancel: () => subscription.cancel());
     return controller.stream;
   }
 
   /**
    * Act on incoming data event.
    *
    * The method may generate any number of events on the sink, but should
    * not throw.
    */
   void handleData(S event, EventSink<T> sink) {
@@ skipping 147 matching lines @@
 }
 
 class _EventOutputSinkWrapper<T> extends EventSink<T> {
   _EventOutputSink _sink;
   _EventOutputSinkWrapper(this._sink);
 
   void add(T data) { _sink._sendData(data); }
   void addError(AsyncError error) { _sink._sendError(error); }
   void close() { _sink._sendDone(); }
 }