window.atob() returns wrong value when given a string container only white spaces

Source/wtf/text/Base64.cpp

 /*
    Copyright (C) 2000-2001 Dawit Alemayehu <adawit@kde.org>
    Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
    Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
    Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License (LGPL)
    version 2 as published by the Free Software Foundation.
 
@@ skipping 131 matching lines @@
 static inline bool base64DecodeInternal(const T* data, unsigned length, Vector<char>& out, CharacterMatchFunctionPtr shouldIgnoreCharacter, Base64DecodePolicy policy)
 {
     out.clear();
     if (!length)
         return true;
 
     out.grow(length);
 
     unsigned equalsSignCount = 0;
     unsigned outLength = 0;
+    bool hadError = false;
     for (unsigned idx = 0; idx < length; ++idx) {
         unsigned ch = data[idx];
         if (ch == '=') {
             ++equalsSignCount;
             // There should never be more than 2 padding characters.
-            if (policy == Base64ValidatePadding && equalsSignCount > 2)
-                return false;
+            if (policy == Base64ValidatePadding && equalsSignCount > 2) {
+                hadError = true;
+                break;
+            }
         } else if (('0' <= ch && ch <= '9') || ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ch == '+' || ch == '/') {
-            if (equalsSignCount)
-                return false;
+            if (equalsSignCount) {
+                hadError = true;
+                break;
+            }
             out[outLength++] = base64DecMap[ch];
         } else if (!shouldIgnoreCharacter || !shouldIgnoreCharacter(ch)) {
-            return false;
+            hadError = true;
+            break;
         }
     }
 
+    if (outLength < out.size())
+        out.shrink(outLength);
+
+    if (hadError)
+        return false;
+
     if (!outLength)
         return !equalsSignCount;
 
     // There should be no padding if length is a multiple of 4.
     // We use (outLength + equalsSignCount) instead of length because we don't want to account for ignored characters.
     if (policy == Base64ValidatePadding && equalsSignCount && (outLength + equalsSignCount) % 4)
         return false;
 
     // Valid data is (n * 4 + [0,2,3]) characters long.
     if ((outLength % 4) == 1)
@@ skipping 41 matching lines @@
 bool base64Decode(const String& in, Vector<char>& out, CharacterMatchFunctionPtr shouldIgnoreCharacter, Base64DecodePolicy policy)
 {
     if (in.isEmpty())
         return base64DecodeInternal<LChar>(0, 0, out, shouldIgnoreCharacter, policy);
     if (in.is8Bit())
         return base64DecodeInternal<LChar>(in.characters8(), in.length(), out, shouldIgnoreCharacter, policy);
     return base64DecodeInternal<UChar>(in.characters16(), in.length(), out, shouldIgnoreCharacter, policy);
 }
 
 } // namespace WTF