Add new HttpMultipartFormData, used for parsing a MimeMultipart and extracting either text or binar…

sdk/lib/io/mime_multipart_parser.dart

 // Copyright (c) 2012, 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 Mime Multipart class representing each part parsed by
  * [MimeMultipartTransformer]. The data is streamed in as it become available.
  */
 abstract class MimeMultipart extends Stream<List<int>> {
   Map<String, String> get headers;
 }
 
-class _MimeMultipartImpl extends MimeMultipart {
+class _MimeMultipart extends MimeMultipart {
   final Map<String, String> headers;
   final Stream<List<int>> _stream;
 
-  _MimeMultipartImpl(this.headers, this._stream);
+  _MimeMultipart(this.headers, this._stream);
 
   StreamSubscription<List<int>> listen(void onData(List<int> data),
                                        {void onDone(),
                                         void onError(error),
                                         bool cancelOnError}) {
     return _stream.listen(onData,
                           onDone: onDone,
                           onError: onError,
                           cancelOnError: cancelOnError);
   }
@@ skipping 26 matching lines @@
   static const int _FAILURE = 15;
 
   StreamController _controller;
   StreamSubscription _subscription;
 
   StreamController _multipartController;
   Map<String, String> _headers;
 
   List<int> _boundary;
   int _state = _START;
-  int _boundaryIndex = 0;
+  int _boundaryIndex = 2;
 
   // Current index in the data buffer. If index is negative then it
   // is the index into the artificial prefix of the boundary string.
   int _index;
   List<int> _buffer;
 
   StringBuffer _headerField = new StringBuffer();
   StringBuffer _headerValue = new StringBuffer();
 
   /**
@@ skipping 34 matching lines @@
               (data) {
                 assert(_buffer == null);
                 _pauseStream();
                 _buffer = data;
                 _index = 0;
                 _parse();
               },
               onDone: () {
                 if (_state != _DONE) {
                   _controller.addError(
-                      new MimeParserException("Bad multipart ending"));
+                      new MimeMultipartException("Bad multipart ending"));
                 }
                 _controller.close();
               },
               onError: (error) {
                 _controller.addError(error);
               });
         },
         onCancel: () {
           _subscription.cancel();
         });
@@ skipping 47 matching lines @@
         return;
       }
       int byte;
       if (_index < 0) {
         byte = _boundary[boundaryPrefix + _index];
       } else {
         byte = _buffer[_index];
       }
       switch (_state) {
         case _START:
-          if (_toLowerCase(byte) == _toLowerCase(_boundary[_boundaryIndex])) {
+          if (byte == _boundary[_boundaryIndex]) {
             _boundaryIndex++;
             if (_boundaryIndex == _boundary.length) {
               _state = _FIRST_BOUNDARY_ENDING;
               _boundaryIndex = 0;
             }
           } else {
             // Restart matching of the boundary.
             _index = _index - _boundaryIndex;
             _boundaryIndex = 0;
           }
@@ skipping 38 matching lines @@
             _headerField.writeCharCode(_toLowerCase(byte));
             _state = _HEADER_FIELD;
           }
           break;
 
         case _HEADER_FIELD:
           if (byte == _CharCode.COLON) {
             _state = _HEADER_VALUE_START;
           } else {
             if (!_isTokenChar(byte)) {
-              throw new MimeParserException("Invalid header field name");
+              throw new MimeMultipartException("Invalid header field name");
             }
             _headerField.writeCharCode(_toLowerCase(byte));
           }
           break;
 
         case _HEADER_VALUE_START:
           if (byte == _CharCode.CR) {
             _state = _HEADER_VALUE_FOLDING_OR_ENDING;
           } else if (byte != _CharCode.SP && byte != _CharCode.HT) {
             // Start of new header value.
@@ skipping 14 matching lines @@
           _expect(byte, _CharCode.LF);
           _state = _HEADER_VALUE_FOLD_OR_END;
           break;
 
         case _HEADER_VALUE_FOLD_OR_END:
           if (byte == _CharCode.SP || byte == _CharCode.HT) {
             _state = _HEADER_VALUE_START;
           } else {
             String headerField = _headerField.toString();
             String headerValue =_headerValue.toString();
-            _headers[headerField] = headerValue;
+            _headers[headerField.toLowerCase()] = headerValue;
             _headerField = new StringBuffer();
             _headerValue = new StringBuffer();
             if (byte == _CharCode.CR) {
               _state = _HEADER_ENDING;
             } else {
               // Start of new header field.
               _headerField.writeCharCode(_toLowerCase(byte));
               _state = _HEADER_FIELD;
             }
           }
           break;
 
         case _HEADER_ENDING:
           _expect(byte, _CharCode.LF);
           _multipartController = new StreamController(
               onPause: () {
                 _pauseStream();
               },
               onResume: () {
                 _resumeStream();
                 _parse();
               });
           _controller.add(
-              new _MimeMultipartImpl(_headers, _multipartController.stream));
+              new _MimeMultipart(_headers, _multipartController.stream));
           _headers = null;
           _state = _CONTENT;
           contentStartIndex = _index + 1;
           break;
 
         case _CONTENT:
           if (byte == _boundary[_boundaryIndex]) {
             _boundaryIndex++;
             if (_boundaryIndex == _boundary.length) {
               if (contentStartIndex != null) {
@@ skipping 62 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;
   }
 
   void _expect(int val1, int val2) {
     if (val1 != val2) {
-      throw new MimeParserException("Failed to parse multipart mime 1");
+      throw new MimeMultipartException("Failed to parse multipart mime 1");
     }
   }
 
   void _expectWS(int byte) {
     if (byte != _CharCode.SP && byte != _CharCode.HT) {
-      throw new MimeParserException("Failed to parse multipart mime 2");
+      throw new MimeMultipartException("Failed to parse multipart mime 2");
     }
   }
 }
 
 
-class MimeParserException implements Exception {
-  const MimeParserException([String this.message = ""]);
-  String toString() => "MimeParserException: $message";
+class MimeMultipartException implements Exception {
+  const MimeMultipartException([String this.message = ""]);
+  String toString() => "MimeMultipartException: $message";
   final String message;
 }