Clean up dart:io exceptions.

sdk/lib/io/http_parser.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;
 
 // Global constants.
 class _Const {
   // Bytes for "HTTP".
   static const HTTP = const [72, 84, 84, 80];
@@ skipping 255 matching lines @@
   //                   CRLF
   //                   [ message-body ]
   // start-line      = Request-Line | Status-Line
   // Request-Line    = Method SP Request-URI SP HTTP-Version CRLF
   // Status-Line     = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
   // message-header  = field-name ":" [ field-value ]
   void _doParse() {
     assert(!_parserCalled);
     _parserCalled = true;
     if (_state == _State.CLOSED) {
-      throw new HttpParserException("Data on closed connection");
+      throw new HttpException("Data on closed connection");
     }
     if (_state == _State.FAILURE) {
-      throw new HttpParserException("Data on failed connection");
+      throw new HttpException("Data on failed connection");
     }
     while (_buffer != null &&
            _index < _buffer.length &&
            _state != _State.FAILURE &&
            _state != _State.UPGRADED) {
       // Depending on _incoming, we either break on _bodyPaused or _paused.
       if ((_incoming != null && _bodyPaused) ||
           (_incoming == null && _paused)) {
         _parserCalled = false;
         return;
       }
       int byte = _buffer[_index++];
       switch (_state) {
         case _State.START:
           if (byte == _Const.HTTP[0]) {
             // Start parsing method or HTTP version.
             _httpVersionIndex = 1;
             _state = _State.METHOD_OR_RESPONSE_HTTP_VERSION;
           } else {
             // Start parsing method.
             if (!_isTokenChar(byte)) {
-              throw new HttpParserException("Invalid request method");
+              throw new HttpException("Invalid request method");
             }
             _method_or_status_code.add(byte);
             if (!_requestParser) {
-              throw new HttpParserException("Invalid response line");
+              throw new HttpException("Invalid response line");
             }
             _state = _State.REQUEST_LINE_METHOD;
           }
           break;
 
         case _State.METHOD_OR_RESPONSE_HTTP_VERSION:
           if (_httpVersionIndex < _Const.HTTP.length &&
               byte == _Const.HTTP[_httpVersionIndex]) {
             // Continue parsing HTTP version.
             _httpVersionIndex++;
           } else if (_httpVersionIndex == _Const.HTTP.length &&
                      byte == _CharCode.SLASH) {
             // HTTP/ parsed. As method is a token this cannot be a
             // method anymore.
             _httpVersionIndex++;
             if (_requestParser) {
-              throw new HttpParserException("Invalid request line");
+              throw new HttpException("Invalid request line");
             }
             _state = _State.RESPONSE_HTTP_VERSION;
           } else {
             // Did not parse HTTP version. Expect method instead.
             for (int i = 0; i < _httpVersionIndex; i++) {
               _method_or_status_code.add(_Const.HTTP[i]);
             }
             if (byte == _CharCode.SP) {
               _state = _State.REQUEST_LINE_URI;
             } else {
               _method_or_status_code.add(byte);
               _httpVersion = _HttpVersion.UNDETERMINED;
               if (!_requestParser) {
-                throw new HttpParserException("Invalid response line");
+                throw new HttpException("Invalid response line");
               }
               _state = _State.REQUEST_LINE_METHOD;
             }
           }
           break;
 
         case _State.RESPONSE_HTTP_VERSION:
           if (_httpVersionIndex < _Const.HTTP1DOT.length) {
             // Continue parsing HTTP version.
             _expect(byte, _Const.HTTP1DOT[_httpVersionIndex]);
             _httpVersionIndex++;
           } else if (_httpVersionIndex == _Const.HTTP1DOT.length &&
                      byte == _CharCode.ONE) {
             // HTTP/1.1 parsed.
             _httpVersion = _HttpVersion.HTTP11;
             _persistentConnection = true;
             _httpVersionIndex++;
           } else if (_httpVersionIndex == _Const.HTTP1DOT.length &&
                      byte == _CharCode.ZERO) {
             // HTTP/1.0 parsed.
             _httpVersion = _HttpVersion.HTTP10;
             _persistentConnection = false;
             _httpVersionIndex++;
           } else if (_httpVersionIndex == _Const.HTTP1DOT.length + 1) {
             _expect(byte, _CharCode.SP);
             // HTTP version parsed.
             _state = _State.RESPONSE_LINE_STATUS_CODE;
           } else {
-            throw new HttpParserException("Invalid response line");
+            throw new HttpException("Invalid response line");
           }
           break;
 
         case _State.REQUEST_LINE_METHOD:
           if (byte == _CharCode.SP) {
             _state = _State.REQUEST_LINE_URI;
           } else {
             if (_Const.SEPARATORS_AND_CR_LF.indexOf(byte) != -1) {
-              throw new HttpParserException("Invalid request method");
+              throw new HttpException("Invalid request method");
             }
             _method_or_status_code.add(byte);
           }
           break;
 
         case _State.REQUEST_LINE_URI:
           if (byte == _CharCode.SP) {
             if (_uri_or_reason_phrase.length == 0) {
-              throw new HttpParserException("Invalid request URI");
+              throw new HttpException("Invalid request URI");
             }
             _state = _State.REQUEST_LINE_HTTP_VERSION;
             _httpVersionIndex = 0;
           } else {
             if (byte == _CharCode.CR || byte == _CharCode.LF) {
-              throw new HttpParserException("Invalid request URI");
+              throw new HttpException("Invalid request URI");
             }
             _uri_or_reason_phrase.add(byte);
           }
           break;
 
         case _State.REQUEST_LINE_HTTP_VERSION:
           if (_httpVersionIndex < _Const.HTTP1DOT.length) {
             _expect(byte, _Const.HTTP11[_httpVersionIndex]);
             _httpVersionIndex++;
           } else if (_httpVersionIndex == _Const.HTTP1DOT.length) {
             if (byte == _CharCode.ONE) {
               // HTTP/1.1 parsed.
               _httpVersion = _HttpVersion.HTTP11;
               _persistentConnection = true;
               _httpVersionIndex++;
             } else if (byte == _CharCode.ZERO) {
               // HTTP/1.0 parsed.
               _httpVersion = _HttpVersion.HTTP10;
               _persistentConnection = false;
               _httpVersionIndex++;
             } else {
-              throw new HttpParserException("Invalid response line");
+              throw new HttpException("Invalid response line");
             }
           } else {
             _expect(byte, _CharCode.CR);
             _state = _State.REQUEST_LINE_ENDING;
           }
           break;
 
         case _State.REQUEST_LINE_ENDING:
           _expect(byte, _CharCode.LF);
           _messageType = _MessageType.REQUEST;
           _state = _State.HEADER_START;
           break;
 
         case _State.RESPONSE_LINE_STATUS_CODE:
           if (byte == _CharCode.SP) {
             if (_method_or_status_code.length != 3) {
-              throw new HttpParserException("Invalid response status code");
+              throw new HttpException("Invalid response status code");
             }
             _state = _State.RESPONSE_LINE_REASON_PHRASE;
           } else {
             if (byte < 0x30 && 0x39 < byte) {
-              throw new HttpParserException("Invalid response status code");
+              throw new HttpException("Invalid response status code");
             } else {
               _method_or_status_code.add(byte);
             }
           }
           break;
 
         case _State.RESPONSE_LINE_REASON_PHRASE:
           if (byte == _CharCode.CR) {
             _state = _State.RESPONSE_LINE_ENDING;
           } else {
             if (byte == _CharCode.CR || byte == _CharCode.LF) {
-              throw new HttpParserException("Invalid response reason phrase");
+              throw new HttpException("Invalid response reason phrase");
             }
             _uri_or_reason_phrase.add(byte);
           }
           break;
 
         case _State.RESPONSE_LINE_ENDING:
           _expect(byte, _CharCode.LF);
           _messageType == _MessageType.RESPONSE;
           _statusCode = int.parse(
               new String.fromCharCodes(_method_or_status_code));
           if (_statusCode < 100 || _statusCode > 599) {
-            throw new HttpParserException("Invalid response status code");
+            throw new HttpException("Invalid response status code");
           } else {
             // Check whether this response will never have a body.
             _noMessageBody = _statusCode <= 199 || _statusCode == 204 ||
                 _statusCode == 304;
           }
           _state = _State.HEADER_START;
           break;
 
         case _State.HEADER_START:
           _headers = new _HttpHeaders(version);
           if (byte == _CharCode.CR) {
             _state = _State.HEADER_ENDING;
           } else {
             // Start of new header field.
             _headerField.add(_toLowerCase(byte));
             _state = _State.HEADER_FIELD;
           }
           break;
 
         case _State.HEADER_FIELD:
           if (byte == _CharCode.COLON) {
             _state = _State.HEADER_VALUE_START;
           } else {
             if (!_isTokenChar(byte)) {
-              throw new HttpParserException("Invalid header field name");
+              throw new HttpException("Invalid header field name");
             }
             _headerField.add(_toLowerCase(byte));
           }
           break;
 
         case _State.HEADER_VALUE_START:
           if (byte == _CharCode.CR) {
             _state = _State.HEADER_VALUE_FOLDING_OR_ENDING;
           } else if (byte != _CharCode.SP && byte != _CharCode.HT) {
             // Start of new header value.
@@ skipping 228 matching lines @@
   void _onDone() {
     // onDone cancles the subscription.
     _socketSubscription = null;
     if (_state == _State.CLOSED || _state == _State.FAILURE) return;
 
     if (_incoming != null) {
       if (_state != _State.UPGRADED &&
           !(_state == _State.START && !_requestParser) &&
           !(_state == _State.BODY && !_chunked && _transferLength == -1)) {
         _bodyController.addError(
-              new HttpParserException(
-                  "Connection closed while receiving data"));
+              new HttpException("Connection closed while receiving data"));
       }
       _closeIncoming(true);
       _controller.close();
       return;
     }
     // If the connection is idle the HTTP stream is closed.
     if (_state == _State.START) {
       if (!_requestParser) {
-        error(new HttpParserException(
+        error(new HttpException(
                     "Connection closed before full header was received"));
       }
       _controller.close();
       return;
     }
 
     if (_state == _State.UPGRADED) {
       _controller.close();
       return;
     }
 
     if (_state < _State.FIRST_BODY_STATE) {
       _state = _State.FAILURE;
       // Report the error through the error callback if any. Otherwise
       // throw the error.
-      error(new HttpParserException(
+      error(new HttpException(
                   "Connection closed before full header was received"));
       _controller.close();
       return;
     }
 
     if (!_chunked && _transferLength == -1) {
       _state = _State.CLOSED;
     } else {
       _state = _State.FAILURE;
       // Report the error through the error callback if any. Otherwise
       // throw the error.
-      error(new HttpParserException(
+      error(new HttpException(
                   "Connection closed before full body was received"));
     }
     _controller.close();
   }
 
   void _onError(e) {
     _controller.addError(e);
   }
 
   String get version {
@@ skipping 76 matching lines @@
 
   int _toLowerCase(int byte) {
     final int aCode = "A".codeUnitAt(0);
     final int zCode = "Z".codeUnitAt(0);
     final int delta = "a".codeUnitAt(0) - aCode;
     return (aCode <= byte && byte <= zCode) ? byte + delta : byte;
   }
 
   int _expect(int val1, int val2) {
     if (val1 != val2) {
-      throw new HttpParserException("Failed to parse HTTP");
+      throw new HttpException("Failed to parse HTTP");
     }
   }
 
   int _expectHexDigit(int byte) {
     if (0x30 <= byte && byte <= 0x39) {
       return byte - 0x30;  // 0 - 9
     } else if (0x41 <= byte && byte <= 0x46) {
       return byte - 0x41 + 10;  // A - F
     } else if (0x61 <= byte && byte <= 0x66) {
       return byte - 0x61 + 10;  // a - f
     } else {
-      throw new HttpParserException("Failed to parse HTTP");
+      throw new HttpException("Failed to parse HTTP");
     }
   }
 
   void _createIncoming(int transferLength) {
     assert(_incoming == null);
     assert(_bodyController == null);
     assert(!_bodyPaused);
     var incoming;
     _bodyController = new StreamController<List<int>>(
         sync: true,
@@ skipping 92 matching lines @@
   _HttpHeaders _headers;
 
   // The current incoming connection.
   _HttpIncoming _incoming;
   StreamSubscription _socketSubscription;
   bool _paused = true;
   bool _bodyPaused = false;
   StreamController<_HttpIncoming> _controller;
   StreamController<List<int>> _bodyController;
 }
-
-
-class HttpParserException implements Exception {
-  const HttpParserException([String this.message = ""]);
-  String toString() => "HttpParserException: $message";
-  final String message;
-}