Added Base64 support in TextEncoder and TextDecoder.

Source/wtf/text/TextCodecBase64.cpp

 /*
- * Copyright (C) 2003, 2006 Apple Computer, Inc.  All rights reserved.
- * Copyright (C) 2005 Nokia.  All rights reserved.
+ * Copyright (C) 2004, 2006, 2008, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
-#include "platform/geometry/FloatSize.h"
+#include "wtf/text/TextCodecBase64.h"
 
-#include "platform/FloatConversion.h"
-#include "platform/geometry/IntSize.h"
-#include "platform/geometry/LayoutSize.h"
-#include <limits>
-#include <math.h>
+#include "wtf/text/Base64.h"
+#include "wtf/text/CString.h"
+#include "wtf/text/StringBuffer.h"

[jsbell, 2014/01/24 22:15:05]

Is this include needed?

+#include "wtf/unicode/CharacterNames.h"

[jsbell, 2014/01/24 22:15:05]

Is this include needed?

 
+using namespace WTF;
 using namespace std;
 
-namespace WebCore {
+namespace WTF {
 
-FloatSize::FloatSize(const IntSize& size) : m_width(size.width()), m_height(size.height())
+PassOwnPtr<TextCodec> TextCodecBase64::create(const TextEncoding&, const void*)
 {
+    return adoptPtr(new TextCodecBase64);
 }
 
-FloatSize::FloatSize(const LayoutSize& size) : m_width(size.width()), m_height(size.height())
+void TextCodecBase64::registerEncodingNames(EncodingNameRegistrar registrar)

[jsbell, 2014/01/24 22:15:05]

Does this registration cause base64 to show up in the set of encodings used
elsewhere in Blink, e.g. in the loader? We should have a explicit tests that it
does NOT.

That should cover page loading, XHR (both the request body and response), and
form submissions. Look in LayoutTests/fast/encoding - hopefully there are
examples.

(Correct behavior should be to fall back to the default encoding, which is
probably windows-1252/latin-1 in the tests.) 

 {
+    registrar("Base64", "Base64");
+    registrar("base64", "Base64");
 }
 
-float FloatSize::diagonalLength() const
+void TextCodecBase64::registerCodecs(TextCodecRegistrar registrar)
 {
-    return sqrtf(diagonalLengthSquared());
+    registrar("Base64", create, 0);
 }
 
-bool FloatSize::isZero() const
+String TextCodecBase64::decode(const char* bytes, size_t length, bool flush, bool stopOnError, bool& sawError)

[jsbell, 2014/01/24 22:15:05]

Is streaming handled here? It looks like flush is ignored. Do the
wtf/text/Base64.h APIs handle it?

 {
-    return fabs(m_width) < numeric_limits<float>::epsilon() && fabs(m_height) < numeric_limits<float>::epsilon();
+    return base64Encode(bytes, length);
 }
 
-bool FloatSize::isExpressibleAsIntSize() const
+CString TextCodecBase64::encode(const UChar* characters, size_t length, UnencodableHandling)

[jsbell, 2014/01/24 22:15:05]

It doesn't look like the Codec API handles flushing for encode (i.e. string to
binary). For base64 you can imagine this being needed for:

encoder.encode("ZWFzd", {stream:true});
encoder.encode("XJlLg==");

This isn't normally necessary in normal text encoders since a single UChar maps
to a zero or more whole octets, but for base64 a single UChar may map fractions
of an octet.

(Uh.... actually, lone UTF16 surrogates probably have the same issue when
transcoding from JS UTF-16 strings to something else e.g. UTF-8. So this may be
a pre-existing issue where a surrogate pair is split across encode() calls...)

 {
-    return isWithinIntRange(m_width) && isWithinIntRange(m_height);
+    Vector<char> output;
+    base64Decode(characters, length, output);
+    return CString(output.data(), output.size());
 }
 
-FloatSize FloatSize::narrowPrecision(double width, double height)
+CString TextCodecBase64::encode(const LChar* characters, size_t length, UnencodableHandling)
 {
-    return FloatSize(narrowPrecisionToFloat(width), narrowPrecisionToFloat(height));
+    Vector<char> output;
+    base64Decode(reinterpret_cast<const char*>(characters), length, output);
+    return CString(output.data(), output.size());
 }
 
-}
+} // namespace WTF