Simplify base64 streaming decoder, drop decoding check.

lib/src/base64.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 crypto;
 
 const Base64Codec BASE64 = const Base64Codec();
 
 const List<int> _decodeTable =
       const [ -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -1, -2, -2,
@@ skipping 13 matching lines @@
               -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
               -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2 ];
 
 const String _encodeTableUrlSafe =
       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 
 const String _encodeTable =
       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 const List<String> _URL_SAFE_CHARACTERS = const ['+', '/'];
 const List<String> _URL_UNSAFE_CHARACTERS = const ['-', '_'];

[Søren Gjesse, 2015/08/05 07:18:33]

Remove these two constants as well.

 
 const int _LINE_LENGTH = 76;
 const int _CR = 13;  // '\r'
 const int _LF = 10;  // '\n'
 const List<int> _PAD_BYTES = const [61]; // '='
 const List<int> _ENCODED_PAD_BYTES = const [37, 51, 68]; // '%3D'
 const String _PAD = "=";
 const String _ENCODED_PAD = "%3D";
 
 class Base64Codec extends Codec<List<int>, String> {
@@ skipping 232 matching lines @@
    * Instantiates a new [Base64Decoder]
    */
   const Base64Decoder();
 
   List<int> convert(String input) {
     int length = input.length;
     if (length == 0) {
       return new List<int>(0);
     }
 
-    bool expectedSafe = false;
-    bool expectedUnsafe = false;
-
     int normalLength = 0;
     int i = 0;
     // Count '\r', '\n' and illegal characters, check if
     // '/', '+' / '-', '_' are used consistently, for illegal characters,
     // throw an exception.
 
     while (i < length) {
       int codeUnit = input.codeUnitAt(i);
       int c = _decodeTable[codeUnit];
       if (c == -2) {
         if (codeUnit == _ENCODED_PAD_BYTES[0] &&
             i < length - 2 &&
             input.codeUnitAt(i + 1) == _ENCODED_PAD_BYTES[1] &&
             input.codeUnitAt(i + 2) == _ENCODED_PAD_BYTES[2]) {
           normalLength++;
           i += 2;
         } else {
           throw new FormatException('Invalid character', input, i);
         }
-      } else if (input[i] == _URL_UNSAFE_CHARACTERS[0] ||
-                 input[i] == _URL_UNSAFE_CHARACTERS[1]) {
-
-        if (expectedSafe) {
-          throw new FormatException('Unsafe character in URL-safe string',
-                                    input, i);
-        }
-        expectedUnsafe = true;
-      } else if (input[i] == _URL_SAFE_CHARACTERS[0] ||
-                 input[i] == _URL_SAFE_CHARACTERS[1]) {
-        if (expectedUnsafe) {
-          throw new FormatException('Invalid character', input, i);
-        }
-        expectedSafe = true;
       }
       if (c >= 0) normalLength++;
       i++;
     }
 
     if (normalLength % 4 != 0) {
       throw new FormatException('''Size of Base 64 characters in Input
           must be a multiple of 4''', input, normalLength);
     }
 
@@ skipping 44 matching lines @@
     }
     return new _Base64DecoderSink(sink);
   }
 }
 
 
 class _Base64DecoderSink extends ChunkedConversionSink<String> {
 
   final Base64Decoder _decoder = new Base64Decoder();
   final ChunkedConversionSink<List<int>> _outSink;
-  String _buffer = "";
-  bool _isSafe = false;
-  bool _isUnsafe = false;
-  int _expectPaddingCount = 3;
+  String _unconverted = "";
 
   _Base64DecoderSink(this._outSink);
 
   void add(String chunk) {
     if (chunk.isEmpty) return;
-
-    int nextBufferLength = (chunk.length + _buffer.length) % 4;
-
-    if (chunk.length >= _expectPaddingCount &&
-        chunk.substring(0, _expectPaddingCount) ==
-          _ENCODED_PAD.substring(3 - _expectPaddingCount, 3)) {
-      chunk = _PAD + chunk.substring(_expectPaddingCount);
-      _expectPaddingCount = 3;
-    } else if(chunk.length < _expectPaddingCount &&
-              chunk == _ENCODED_PAD.substring(
-                         3 - _expectPaddingCount,
-                         3 - _expectPaddingCount + chunk.length)) {
-      _expectPaddingCount -= chunk.length;
-      chunk = "";
+    if (_unconverted.isNotEmpty) {
+      chunk = _unconverted + chunk;
     }
-
-    if (chunk.length > 1 &&
-        chunk[chunk.length - 2] == _ENCODED_PAD[0] &&
-        chunk[chunk.length - 1] == _ENCODED_PAD[1]) {
-      _expectPaddingCount = 1;
-      chunk = chunk.substring(0, chunk.length - 2);
-    } else if (!chunk.isEmpty && chunk[chunk.length - 1] == _ENCODED_PAD[0]) {
-      _expectPaddingCount = 2;
-      chunk = chunk.substring(0, chunk.length - 1);
+    chunk = chunk.replaceAll(_ENCODED_PAD, _PAD);
+    int decodableLength = chunk.length;
+     // If chunk ends in "%" or "%3", it may be a partial encoded pad.
+     // If chunk is smaller than 4 characters, don't bother checking.
+    if (chunk.length > 3 &&
+      chunk.contains(_ENCODED_PAD[0], chunk.length - 2)) {
+      decodableLength = chunk.lastIndexOf(_ENCODED_PAD[0]);
     }
-
-    chunk = chunk.replaceAll(_ENCODED_PAD, _PAD);
-
-    if (chunk.length + _buffer.length >= 4) {
-      int remainder = chunk.length - nextBufferLength;
-      String decodable = _buffer + chunk.substring(0, remainder);
-      _buffer = chunk.substring(remainder);
-
-      for (int i = 0;i < decodable.length; i++) {
-        if (decodable[i] == _URL_UNSAFE_CHARACTERS[0] ||
-            decodable[i] == _URL_UNSAFE_CHARACTERS[1]) {
-          if (_isSafe) {
-            throw new FormatException('Unsafe character in URL-safe string',
-                                       decodable, i);
-          }
-          _isUnsafe = true;
-        } else if (decodable[i] == _URL_SAFE_CHARACTERS[0] ||
-                   decodable[i] == _URL_SAFE_CHARACTERS[1]) {
-          if (_isUnsafe) {
-            throw new FormatException('Invalid character', decodable, i);
-          }
-          _isSafe = true;
-        }
-      }
-
-      _outSink.add(_decoder.convert(decodable));
-    } else {
-      _buffer += chunk;
+    decodableLength -= decodableLength % 4;
+    _unconverted = chunk.substring(decodableLength);
+    if (decodableLength > 0) {
+      _outSink.add(_decoder.convert(chunk.substring(0, decodableLength)));
     }
   }
 
   void close() {
-    if (_expectPaddingCount == 0 &&
-        _buffer.length == 3) {
-      _outSink.add(_buffer + _PAD);

[Bill Hesse, 2015/08/04 16:33:33]

This line was wrong, should have been .add(_decoder.convert(buffer + PAD)).

-    } else if (_expectPaddingCount < 3 &&
-               _buffer.length + 3 - _expectPaddingCount == 4) {
-      _outSink.add(_buffer + _ENCODED_PAD.substring(0, 3 - _expectPaddingCount));
-    } else if (_expectPaddingCount != 3 || !_buffer.isEmpty) {
-      throw new FormatException(
-        "Size of Base 64 input must be a multiple of 4",
-        _buffer + _PAD.substring(0, 3 - _expectPaddingCount),
-        _buffer.length + 3 - _expectPaddingCount);
+    if (_unconverted.isNotEmpty) {
+      _outSink.add(_decoder.convert(_unconverted));
     }
     _outSink.close();
   }
 }