Clean up dart:io exceptions.

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 596 matching lines @@
         ((_secureFilter != null &&
           _secureFilter.buffers[READ_PLAINTEXT].length > 0) ||
          _socketClosedRead)) {
       // We might not have no underlying socket to set off read events.
       Timer.run(_readHandler);
     }
   }
 
   List<int> read([int len]) {
     if (_closedRead) {
-      throw new SocketIOException("Reading from a closed socket");
+      throw new SocketException("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(
@@ skipping 28 matching lines @@
     }
 
     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]) {
     if (_closedWrite) {
-      _controller.addError(new SocketIOException("Writing to a closed socket"));
+      _controller.addError(new SocketException("Writing to a closed socket"));
       return 0;
     }
     if (_status != CONNECTED) return 0;
 
     if (offset == null) offset = 0;
     if (bytes == null) bytes = data.length - offset;
 
     var buffer = _secureFilter.buffers[WRITE_PLAINTEXT];
     if (bytes > buffer.free) {
       bytes = buffer.free;
@@ skipping 66 matching lines @@
     if (_status == CLOSED) {
       return;
     } else if (_status == HANDSHAKE) {
       try {
         _secureHandshake();
         if (_status != HANDSHAKE) _readHandler();
       } catch (e) { _reportError(e, "RawSecureSocket error"); }
     } else {
       if (_status != CONNECTED) {
         // Cannot happen.
-        throw new SocketIOException("Internal SocketIO Error");
+        throw new SocketException("Internal SocketIO Error");
       }
       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) {
@@ skipping 12 matching lines @@
       _close();
     }
   }
 
   void _errorHandler(e) {
     _reportError(e, 'Error on underlying RawSocket');
   }
 
   void _reportError(e, String message) {
     // TODO(whesse): Call _reportError from all internal functions that throw.
-    if (e is SocketIOException) {
-      e = new SocketIOException('$message (${e.message})', e.osError);
+    if (e is SocketException) {
+      e = new SocketException('$message (${e.message})', e.osError);
     } else if (e is OSError) {
-      e = new SocketIOException(message, e);
+      e = new SocketException(message, e);
     } else {
-      e = new SocketIOException('$message (${e.toString()})', null);
+      e = new SocketException('$message (${e.toString()})', null);
     }
     if (_connectPending) {
       _handshakeComplete.completeError(e);
     } else {
       _controller.addError(e);
     }
     _close();
   }
 
   void _closeHandler() {
     if  (_status == CONNECTED) {
       if (_closedRead) return;
       _socketClosedRead = true;
       if (_filterReadEmpty) {
         _closedRead = true;
         _controller.add(RawSocketEvent.READ_CLOSED);
         if (_socketClosedWrite) {
           _close();
         }
       }
     } else if (_status == HANDSHAKE) {
       _reportError(
-          new SocketIOException('Connection terminated during handshake'),
+          new SocketException('Connection terminated during handshake'),
           'handshake error');
     }
   }
 
   void _secureHandshake() {
     _readEncryptedData();
     _secureFilter.handshake();
     _writeEncryptedData();
   }
 
@@ skipping 148 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;
 }