Remove deprecated ms arguments for Timer and Future.

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 371 matching lines @@
     }
   }
 
   bool get writeEventsEnabled => _writeEventsEnabled;
 
   void set writeEventsEnabled(bool value) {
     if (value &&
         _controller.hasSubscribers &&
         _secureFilter != null &&
         _secureFilter.buffers[WRITE_PLAINTEXT].free > 0) {
-      new Timer(0, (_) => _controller.add(RawSocketEvent.WRITE));
+      Timer.run(() => _controller.add(RawSocketEvent.WRITE));
     } else {
       _writeEventsEnabled = value;
     }
   }
 
   bool get readEventsEnabled => _readEventsEnabled;
 
   void set readEventsEnabled(bool value) {
     _readEventsEnabled = value;
     if (_socketClosedRead) {
       if (value) {
         // We have no underlying socket to set off read events.
-        new Timer(0, (_) => _readHandler());
+        Timer.run(_readHandler);
       }
     }
   }
 
   List<int> read([int len]) {
     if (_closedRead) {
       throw new SocketIOException("Reading from a closed socket");
     }
     if (_status != CONNECTED) {
       return null;
     }
     var buffer = _secureFilter.buffers[READ_PLAINTEXT];
     _readEncryptedData();
     int toRead = buffer.length;
     if (len != null) {
       if (len is! int || len < 0) {
         throw new ArgumentError(
             "Invalid len parameter in SecureSocket.read (len: $len)");
       }
       if (len < toRead) {
         toRead = len;
       }
     }
     List<int> result = (toRead == 0) ? null :
         buffer.data.getRange(buffer.start, toRead);
     buffer.advanceStart(toRead);
 
     // Set up a read event if the filter still has data.
     if (!_filterReadEmpty) {
-      new Timer(0, (_) => _readHandler());
+      Timer.run(_readHandler);
     }
 
     if (_socketClosedRead) {  // An onClose event is pending.
       // _closedRead is false, since we are in a read  call.
       if (!_filterReadEmpty) {
         // _filterReadEmpty may be out of date since read empties
         // the plaintext buffer after calling _readEncryptedData.
         // TODO(whesse): Fix this as part of fixing read.
         _readEncryptedData();
       }
       if (_filterReadEmpty) {
         // This can't be an else clause: the value of _filterReadEmpty changes.
         // This must be asynchronous, because we are in a read call.
-        new Timer(0, (_) => _closeHandler());
+        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]) {
@@ skipping 65 matching lines @@
       try {
         _readEncryptedData();
       } catch (e) { _reportError(e, "RawSecureSocket error"); }
       if (!_filterReadEmpty) {
         if (_readEventsEnabled) {
           if (_secureFilter.buffers[READ_PLAINTEXT].length > 0) {
             _controller.add(RawSocketEvent.READ);
           }
           if (_socketClosedRead) {
             // Keep firing read events until we are paused or buffer is empty.
-            new Timer(0, (_) => _readHandler());
+            Timer.run(_readHandler);
           }
         }
       } else if (_socketClosedRead) {
         _closeHandler();
       }
     }
   }
 
   void _doneHandler() {
     if (_filterReadEmpty) {
@@ skipping 49 matching lines @@
     _writeEncryptedData();
   }
 
   void _secureHandshakeCompleteHandler() {
     _status = CONNECTED;
     if (_connectPending) {
       _connectPending = false;
       // If we complete the future synchronously, user code will run here,
       // and modify the state of the RawSecureSocket.  For example, it
       // could close the socket, and set _filter to null.
-      new Timer(0, (_) => _handshakeComplete.complete(this));
+      Timer.run(() => _handshakeComplete.complete(this));
     }
   }
 
   void _onPauseStateChange() {
     if (!_socketClosedRead || !_socketClosedWrite) {
       if (_controller.isPaused) {
         _socketSubscription.pause();
       } else {
         _socketSubscription.resume();
       }
@@ skipping 126 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;
 }