Get rid of WebSocketChannel.pingInterval.

lib/src/channel.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:async';
 
 import 'package:async/async.dart';
 import 'package:crypto/crypto.dart';
 import 'package:stream_channel/stream_channel.dart';
 
 import 'copy/web_socket_impl.dart';
 
 /// A [StreamChannel] that communicates over a WebSocket.
 ///
 /// This is implemented by classes that use `dart:io` and `dart:html`. The [new
 /// WebSocketChannel] constructor can also be used on any platform to connect to
 /// use the WebSocket protocol over a pre-existing channel.
 ///
 /// All implementations emit [WebSocketChannelException]s. These exceptions wrap
 /// the native exception types where possible.
 class WebSocketChannel extends StreamChannelMixin {
   /// The underlying web socket.
   ///
   /// This is essentially a copy of `dart:io`'s WebSocket implementation, with
   /// the IO-specific pieces factored out.
   final WebSocketImpl _webSocket;
 
-  /// The interval for sending ping signals.
-  ///
-  /// If a ping message is not answered by a pong message from the peer, the
-  /// `WebSocket` is assumed disconnected and the connection is closed with a
-  /// [WebSocketStatus.GOING_AWAY] close code. When a ping signal is sent, the
-  /// pong message must be received within [pingInterval].
-  ///
-  /// There are never two outstanding pings at any given time, and the next ping
-  /// timer starts when the pong is received.
-  ///
-  /// By default, the [pingInterval] is `null`, indicating that ping messages
-  /// are disabled. Some implementations may not support setting it.
-  Duration get pingInterval => _webSocket.pingInterval;
-  set pingInterval(Duration value) => _webSocket.pingInterval = value;
-
   /// The subprotocol selected by the server.
   ///
   /// For a client socket, this is initially `null`. After the WebSocket
   /// connection is established the value is set to the subprotocol selected by
   /// the server. If no subprotocol is negotiated the value will remain `null`.
   String get protocol => _webSocket.protocol;
 
   /// The [close code][] set when the WebSocket connection is closed.
   ///
   /// [close code]: https://tools.ietf.org/html/rfc6455#section-7.1.5
@@ skipping 33 matching lines @@
 
   /// Creates a new WebSocket handling messaging across an existing [channel].
   ///
   /// This is a cross-platform constructor; it doesn't use either `dart:io` or
   /// `dart:html`. It's also HTTP-API-agnostic, which means that the initial
   /// [WebSocket handshake][] must have already been completed on the socket
   /// before this is called.
   ///
   /// [protocol] should be the protocol negotiated by this handshake, if any.
   ///
+  /// [pingInterval] controls the interval for sending ping signals. If a ping
+  /// message is not answered by a pong message from the peer, the WebSocket is
+  /// assumed disconnected and the connection is closed with a
+  /// [WebSocketStatus.GOING_AWAY] close code. When a ping signal is sent, the
+  /// pong message must be received within [pingInterval]. It defaults to
+  /// `null`, indicating that ping messages are disabled.
+  ///
   /// If this is a WebSocket server, [serverSide] should be `true` (the
   /// default); if it's a client, [serverSide] should be `false`.
   ///
   /// [WebSocket handshake]: https://tools.ietf.org/html/rfc6455#section-4
   WebSocketChannel(StreamChannel<List<int>> channel,
-        {String protocol, bool serverSide: true})
+        {String protocol, Duration pingInterval, bool serverSide: true})
       : _webSocket = new WebSocketImpl.fromSocket(
-          channel.stream, channel.sink, protocol, serverSide);
+            channel.stream, channel.sink, protocol, serverSide)
+          ..pingInterval = pingInterval;
 }
 
 /// The sink exposed by a [WebSocketChannel].
 ///
 /// This is like a normal [StreamSink], except that it supports extra arguments
 /// to [close].
 class WebSocketSink extends DelegatingStreamSink {
   final WebSocketImpl _webSocket;
 
   WebSocketSink._(WebSocketImpl webSocket)
       : super(webSocket),
         _webSocket = webSocket;
 
   /// Closes the web socket connection.
   ///
   /// [closeCode] and [closeReason] are the [close code][] and [reason][] sent
   /// to the remote peer, respectively. If they are omitted, the peer will see
   /// a "no status received" code with no reason.
   ///
   /// [close code]: https://tools.ietf.org/html/rfc6455#section-7.1.5
   /// [reason]: https://tools.ietf.org/html/rfc6455#section-7.1.6
   Future close([int closeCode, String closeReason]) =>
       _webSocket.close(closeCode, closeReason);
 }