dart:io: Prevent initial WRITE event on RawSecureSocket when writeEventsEnabled is set to false.

sdk/lib/io/secure_socket.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.io;
 
 /**
  * A high-level class for communicating securely over a TCP socket, using
  * TLS and SSL. The [SecureSocket] exposes both a [Stream] and an
  * [IOSink] interface, making it ideal for using together with
@@ skipping 368 matching lines @@
       if (_socketClosedWrite) {
         close();
       }
     }
   }
 
   bool get writeEventsEnabled => _writeEventsEnabled;
 
   void set writeEventsEnabled(bool value) {
     if (value &&
+        _controller.hasSubscribers &&

[Søren Gjesse, 2013/02/25 07:20:44]

What about paused?

[Bill Hesse, 2013/02/25 07:32:36]

It should be legal to enqueue a WRITE event if they are enabled while the
subscription is paused.  The main thing is to stop events being queued before
the first .listen.

Since we only send an initial WRITE event on a .listen call when they are
enabled, not on a pauseChange, we cannot handle the case that a WRITE event from
the base socket comes during a pause, unless we enqueue it at the time it
arrives.

[Søren Gjesse, 2013/02/25 14:50:54]

I agree that it is not an error to send WRITE events when paused. However I
still think we should avoid doing that so that we handle pause/resume and only
send events when not paused.

When unpausing shouldn't just send a WRITE event if there is room in the
plaintext write buffer?

         _secureFilter != null &&
         _secureFilter.buffers[WRITE_PLAINTEXT].free > 0) {
       new Timer(0, (_) => _controller.add(RawSocketEvent.WRITE));
     } else {
       _writeEventsEnabled = value;
     }
   }
 
   bool get readEventsEnabled => _readEventsEnabled;
 
@@ skipping 83 matching lines @@
     if (_filterWriteEmpty && _closedWrite && !_socketClosedWrite) {
       // Close _socket for write, by calling shutdown(), to avoid cloning the
       // socket closing code in shutdown().
       shutdown(SocketDirection.SEND);
     }
     if (_status == HANDSHAKE) {
       try {
         _secureHandshake();
       } catch (e) { _reportError(e, "RawSecureSocket error"); }
     } else if (_status == CONNECTED &&
+               _controller.hasSubscribers &&

[Søren Gjesse, 2013/02/25 07:20:44]

Ditto.

                _writeEventsEnabled &&
                _secureFilter.buffers[WRITE_PLAINTEXT].free > 0) {
       // Reset the one-shot handler.
       _writeEventsEnabled = false;
       _controller.add(RawSocketEvent.WRITE);
     }
   }
 
   void _eventDispatcher(RawSocketEvent event) {
     if (event == RawSocketEvent.READ) {
@@ skipping 238 matching lines @@
   void destroy();
   void handshake();
   void init();
   X509Certificate get peerCertificate;
   int processBuffer(int bufferIndex);
   void registerBadCertificateCallback(Function callback);
   void registerHandshakeCompleteCallback(Function handshakeCompleteHandler);
 
   List<_ExternalBuffer> get buffers;
 }