dart:io | Rename optional carryOverData argument to SecureSocket.secureServer to bufferedData.

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 85 matching lines @@
    * future completes the [SecureSocket] has completed the TLS
    * handshake. Using this function requires that the other end of the
    * connection is going to start the TLS handshake.
    *
    * If the [socket] already has a subscription, this subscription
    * will no longer receive and events. In most cases calling
    * [:pause:] on this subscription before starting TLS handshake is
    * the right thing to do.
    *
    * If some of the data of the TLS handshake has already been read
-   * from the socket this data can be passed in the [carryOverData]
+   * from the socket this data can be passed in the [bufferedData]
    * parameter. This data will be processed before any other data
    * available on the socket.
    *
    * See [SecureServerSocket.bind] for more information on the
    * arguments.
    *
    */
   static Future<SecureSocket> secureServer(
       Socket socket,
       String certificateName,
-      {List<int> carryOverData,
+      {List<int> bufferedData,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false}) {
     var completer = new Completer();
     (socket as dynamic)._detachRaw()
         .then((detachedRaw) {
           return RawSecureSocket.secureServer(
             detachedRaw[0],
             certificateName,
             subscription: detachedRaw[1],
-            carryOverData: carryOverData,
+            bufferedData: bufferedData,
             requestClientCertificate: requestClientCertificate,
             requireClientCertificate: requireClientCertificate);
           })
         .then((raw) {
           completer.complete(new SecureSocket._(raw));
         });
     return completer.future;
   }
 
   /**
@@ skipping 139 matching lines @@
    * future completes the [RawSecureSocket] has completed the TLS
    * handshake. Using this function requires that the other end of the
    * connection is going to start the TLS handshake.
    *
    * If the [socket] already has a subscription, pass the existing
    * subscription in the [subscription] parameter. The secure socket
    * will take over the subscription and process any subsequent
    * events.
    *
    * If some of the data of the TLS handshake has already been read
-   * from the socket this data can be passed in the [carryOverData]
+   * from the socket this data can be passed in the [bufferedData]
    * parameter. This data will be processed before any other data
    * available on the socket.
    *
    * See [RawSecureServerSocket.bind] for more information on the
    * arguments.
    *
    */
   static Future<RawSecureSocket> secureServer(
       RawSocket socket,
       String certificateName,
       {StreamSubscription subscription,
-       List<int> carryOverData,
+       List<int> bufferedData,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false}) {
     socket.readEventsEnabled = false;
     socket.writeEventsEnabled = false;
     return _RawSecureSocket.connect(
         socket.address,
         socket.remotePort,
         certificateName,
         is_server: true,
         socket: socket,
         subscription: subscription,
-        carryOverData: carryOverData,
+        bufferedData: bufferedData,
         requestClientCertificate: requestClientCertificate,
         requireClientCertificate: requireClientCertificate);
   }
 
   /**
    * Get the peer certificate for a connected RawSecureSocket.  If this
    * RawSecureSocket is the server end of a secure socket connection,
    * [peerCertificate] will return the client certificate, or null, if no
    * client certificate was received.  If it is the client end,
    * [peerCertificate] will return the server's certificate.
@@ skipping 33 matching lines @@
   static final int READ_ENCRYPTED = 2;
   static final int WRITE_ENCRYPTED = 3;
   static final int NUM_BUFFERS = 4;
 
   RawSocket _socket;
   final Completer<_RawSecureSocket> _handshakeComplete =
       new Completer<_RawSecureSocket>();
   StreamController<RawSocketEvent> _controller;
   Stream<RawSocketEvent> _stream;
   StreamSubscription<RawSocketEvent> _socketSubscription;
-  List<int> _carryOverData;
-  int _carryOverDataIndex = 0;
+  List<int> _bufferedData;
+  int _bufferedDataIndex = 0;
   final InternetAddress address;
   final bool is_server;
   final String certificateName;
   final bool requestClientCertificate;
   final bool requireClientCertificate;
   final bool sendClientCertificate;
   final Function onBadCertificate;
 
   var _status = NOT_CONNECTED;
   bool _writeEventsEnabled = true;
   bool _readEventsEnabled = true;
   bool _socketClosedRead = false;  // The network socket is closed for reading.
   bool _socketClosedWrite = false;  // The network socket is closed for writing.
   bool _closedRead = false;  // The secure socket has fired an onClosed event.
   bool _closedWrite = false;  // The secure socket has been closed for writing.
   bool _filterReadEmpty = true;  // There is no buffered data to read.
   bool _filterWriteEmpty = true;  // There is no buffered data to be written.
   bool _connectPending = false;
   _SecureFilter _secureFilter = new _SecureFilter();
 
   static Future<_RawSecureSocket> connect(
       host,
       int requestedPort,
       String certificateName,
       {bool is_server,
        RawSocket socket,
        StreamSubscription subscription,
-       List<int> carryOverData,
+       List<int> bufferedData,
        bool requestClientCertificate: false,
        bool requireClientCertificate: false,
        bool sendClientCertificate: false,
        bool onBadCertificate(X509Certificate certificate)}) {
     var future;
     if (host is String) {
       future = InternetAddress.lookup(host).then((addrs) => addrs.first);
     } else {
       future = new Future.value(host);
     }
     return future.then((addr) {
      return new _RawSecureSocket(addr,
                                  requestedPort,
                                  certificateName,
                                  is_server,
                                  socket,
                                  subscription,
-                                 carryOverData,
+                                 bufferedData,
                                  requestClientCertificate,
                                  requireClientCertificate,
                                  sendClientCertificate,
                                  onBadCertificate)
          ._handshakeComplete.future;
     });
   }
 
   _RawSecureSocket(
       InternetAddress this.address,
       int requestedPort,
       String this.certificateName,
       bool this.is_server,
       RawSocket socket,
       StreamSubscription this._socketSubscription,
-      List<int> this._carryOverData,
+      List<int> this._bufferedData,
       bool this.requestClientCertificate,
       bool this.requireClientCertificate,
       bool this.sendClientCertificate,
       bool this.onBadCertificate(X509Certificate certificate)) {
     _controller = new StreamController<RawSocketEvent>(
         sync: true,
         onListen: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange,
         onCancel: _onSubscriptionStateChange);
     _stream = _controller.stream;
     // Throw an ArgumentError if any field is invalid.  After this, all
     // errors will be reported through the future or the stream.
     _verifyFields();
     _secureFilter.init();
-    if (_carryOverData != null) _readFromCarryOver();
+    if (_bufferedData != null) _readFromBuffered();
     _secureFilter.registerHandshakeCompleteCallback(
         _secureHandshakeCompleteHandler);
     if (onBadCertificate != null) {
       _secureFilter.registerBadCertificateCallback(onBadCertificate);
     }
     var futureSocket;
     if (socket == null) {
       futureSocket = RawSocket.connect(address, requestedPort);
     } else {
       futureSocket = new Future.value(socket);
@@ skipping 261 matching lines @@
   void _eventDispatcher(RawSocketEvent event) {
     if (event == RawSocketEvent.READ) {
       _readHandler();
     } else if (event == RawSocketEvent.WRITE) {
       _writeHandler();
     } else if (event == RawSocketEvent.READ_CLOSED) {
       _closeHandler();
     }
   }
 
-  void _readFromCarryOver() {
-    assert(_carryOverData != null);
+  void _readFromBuffered() {
+    assert(_bufferedData != null);
     var encrypted = _secureFilter.buffers[READ_ENCRYPTED];
-    var bytes = _carryOverData.length - _carryOverDataIndex;
+    var bytes = _bufferedData.length - _bufferedDataIndex;
     int startIndex = encrypted.start + encrypted.length;
     encrypted.data.setRange(startIndex,
                             startIndex + bytes,
-                            _carryOverData,
-                            _carryOverDataIndex);
+                            _bufferedData,
+                            _bufferedDataIndex);
     encrypted.length += bytes;
-    _carryOverDataIndex += bytes;
-    if (_carryOverData.length == _carryOverDataIndex) {
-      _carryOverData = null;
+    _bufferedDataIndex += bytes;
+    if (_bufferedData.length == _bufferedDataIndex) {
+      _bufferedData = null;
     }
   }
 
   void _readHandler() {
     if (_status == CLOSED) {
       return;
     } else if (_status == HANDSHAKE) {
       try {
         _secureHandshake();
         if (_status != HANDSHAKE) _readHandler();
@@ skipping 117 matching lines @@
         }
       }
       if (encrypted.length > 0) {
         int bytes = _secureFilter.processBuffer(READ_ENCRYPTED);
         if (bytes > 0) {
           encrypted.advanceStart(bytes);
           progress = true;
         }
       }
       if (!_socketClosedRead && encrypted.free > 0) {
-        if (_carryOverData != null) {
+        if (_bufferedData != null) {
           _readFromCarryOver();
           progress = true;
         } else {
           List<int> data = _socket.read(encrypted.free);
           if (data != null) {
             int bytes = data.length;
             int startIndex = encrypted.start + encrypted.length;
             encrypted.data.setRange(startIndex, startIndex + bytes, data);
             encrypted.length += bytes;
             progress = true;
@@ skipping 86 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;
 }