Add setNoDelay method on Socket/RawSocket.

sdk/lib/io/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;
 
 /**
  * The RawServerSocket is a server socket, providing a stream of low-level
  * [RawSocket]s.
  *
@@ skipping 68 matching lines @@
  */
 class SocketDirection {
   static const SocketDirection RECEIVE = const SocketDirection._(0);
   static const SocketDirection SEND = const SocketDirection._(1);
   static const SocketDirection BOTH = const SocketDirection._(2);
   const SocketDirection._(this._value);
   final _value;
 }
 
 /**
+ * The [SocketOption] is used as a parameter to [Socket.setOption] and
+ * [RawSocket.setOption] to set customize the behaviour of the underlying
+ * socket.
+ */
+class SocketOption {
+  /**
+   * Enable or disable no-delay on the socket. If TCP_NODELAY is enabled, the
+   * socket will not buffer data internally, but instead write each data chunk
+   * as an invidual TCP packet.
+   *
+   * TCP_NODELAY is disabled by default.
+   */
+  static const SocketOption TCP_NODELAY = const SocketOption._(0);
+  const SocketOption._(this._value);
+  final _value;
+}
+
+/**
  * Events for the [RawSocket].
  */
 class RawSocketEvent {
   static const RawSocketEvent READ = const RawSocketEvent._(0);
   static const RawSocketEvent WRITE = const RawSocketEvent._(1);
   static const RawSocketEvent READ_CLOSED = const RawSocketEvent._(2);
   const RawSocketEvent._(this._value);
   final int _value;
   String toString() {
     return ['RawSocketEvent:READ',
@@ skipping 73 matching lines @@
    */
   bool readEventsEnabled;
 
   /**
    * Set or get, if the [RawSocket] should listen for [RawSocketEvent.WRITE]
    * events. Default is [true].
    * This is a one-shot listener, and writeEventsEnabled must be set
    * to true again to receive another write event.
    */
   bool writeEventsEnabled;
+
+  /**
+   * Use [setOption] to customize the [RawSocket]. See [SocketOption] for
+   * available options.
+   *
+   * Returns [true] if the option was set successfully, false otherwise.
+   */
+  bool setOption(SocketOption option, bool enabled);
 }
 
 /**
  * A high-level class for communicating over a TCP socket. The [Socket] exposes
  * both a [Stream] and a [IOSink] interface, making it ideal for
  * using together with other [Stream]s.
  */
 abstract class Socket implements Stream<List<int>>,
                                  IOSink<Socket> {
   /**
    * Creats a new socket connection to the host and port and returns a [Future]
    * that will complete with either a [RawSocket] once connected or an error
    * if the host-lookup or connection failed.
    */
   external static Future<Socket> connect(String host, int port);
 
   /**
    * Destroy the socket in both directions. Calling [destroy] will make the
    * send a close event on the stream and will no longer react on data being
    * piped to it.
    *
    * Call [close](inherited from [IOSink]) to only close the [Socket]
    * for sending data.
    */
   void destroy();
 
+  /**
+   * Enable or disable no-delay on the socket. If no-delay is enabled, the
+   * socket will not buffer data internally, but instead write each data chunk
+   * as an invidual TCP packet.
+   *
+   * No-delay is disabled by default.
+   */
+  bool setNoDelay([bool enabled = true]);
+
   int get port;
   String get remoteHost;
   int get remotePort;
 }
 
 
 class SocketIOException implements Exception {
   const SocketIOException([String this.message = "",
                            OSError this.osError = null]);
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write("SocketIOException");
     if (!message.isEmpty) {
       sb.write(": $message");
       if (osError != null) {
         sb.write(" ($osError)");
       }
     } else if (osError != null) {
       sb.write(": $osError");
     }
     return sb.toString();
   }
   final String message;
   final OSError osError;
 }