Refactor List.setRange function.

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 444 matching lines @@
         Timer.run(_closeHandler);
       }
     }
 
     return result;
   }
 
   // Write the data to the socket, and flush it as much as possible
   // until it would block.  If the write would block, _writeEncryptedData sets
   // up handlers to flush the pipeline when possible.
   int write(List<int> data, [int offset, int bytes]) {

[Lasse Reichstein Nielsen, 2013/04/11 06:11:55]

This code doesn't seem to handle the case where offset and bytes are null
because they were not passed, even though they are optional. I'd expect offset
to default to zero, and bytes  to data.length - offset.

[floitsch, 2013/04/12 23:35:42]

Done.

     if (_closedWrite) {
       _controller.addError(new AsyncError(new SocketIOException(
           "Writing to a closed socket")));
       return 0;
     }
     if (_status != CONNECTED) return 0;
     var buffer = _secureFilter.buffers[WRITE_PLAINTEXT];
     if (bytes > buffer.free) {
       bytes = buffer.free;
     }
     if (bytes > 0) {
-      buffer.data.setRange(buffer.start + buffer.length, bytes, data, offset);
+      int startIndex = buffer.start + buffer.length;
+      buffer.data.setRange(startIndex, startIndex + bytes, data, offset);
       buffer.length += bytes;
     }
     _writeEncryptedData();  // Tries to flush all pipeline stages.
     return bytes;
   }
 
   X509Certificate get peerCertificate => _secureFilter.peerCertificate;
 
   bool setOption(SocketOption option, bool enabled) {
     if (_socket == null) return false;
@@ skipping 165 matching lines @@
         int bytes = _secureFilter.processBuffer(READ_ENCRYPTED);
         if (bytes > 0) {
           encrypted.advanceStart(bytes);
           progress = true;
         }
       }
       if (!_socketClosedRead && encrypted.free > 0) {
         List<int> data = _socket.read(encrypted.free);
         if (data != null) {
           int bytes = data.length;
-          encrypted.data.setRange(encrypted.start + encrypted.length,
-                                  bytes,
-                                  data);
+          int startIndex = encrypted.start + encrypted.length;
+          encrypted.data.setRange(startIndex, startIndex + bytes, data);
           encrypted.length += bytes;
           progress = true;
         }
       }
     }
     // If there is any data in any stages of the filter, there should
     // be data in the plaintext buffer after this process.
     // TODO(whesse): Verify that this is true, and there can be no
     // partial encrypted block stuck in the secureFilter.
     _filterReadEmpty = (plaintext.length == 0);
@@ skipping 77 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;
 }