The Tor Browser: dom/src/json/nsJSON.cpp@b8a032363ba2 (annotated)

dom/src/json/nsJSON.cpp@b8a032363ba2 (annotated)

dom/src/json/nsJSON.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 sw=2 et tw=79: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "jsapi.h"
 #include "js/CharacterEncoding.h"
 #include "js/OldDebugAPI.h"
 #include "nsJSON.h"
 #include "nsIXPConnect.h"
 #include "nsIXPCScriptable.h"
 #include "nsStreamUtils.h"
 #include "nsIInputStream.h"
 #include "nsStringStream.h"
 #include "mozilla/dom/EncodingUtils.h"
 #include "nsIUnicodeEncoder.h"
 #include "nsIUnicodeDecoder.h"
 #include "nsXPCOMStrings.h"
 #include "nsNetUtil.h"
 #include "nsContentUtils.h"
 #include "nsIScriptError.h"
 #include "nsCRTGlue.h"
 #include "nsAutoPtr.h"
 #include "nsIScriptSecurityManager.h"
 #include "mozilla/Maybe.h"
 #include <algorithm>
 using mozilla::dom::EncodingUtils;
 #define JSON_STREAM_BUFSIZE 4096
 NS_INTERFACE_MAP_BEGIN(nsJSON)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIJSON)
   NS_INTERFACE_MAP_ENTRY(nsIJSON)
 NS_INTERFACE_MAP_END
 NS_IMPL_ADDREF(nsJSON)
 NS_IMPL_RELEASE(nsJSON)
 nsJSON::nsJSON()
 {
 }
 nsJSON::~nsJSON()
 {
 }
 enum DeprecationWarning { EncodeWarning, DecodeWarning };
 static nsresult
 WarnDeprecatedMethod(DeprecationWarning warning)
 {
   return nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
                                          NS_LITERAL_CSTRING("DOM Core"), nullptr,
                                          nsContentUtils::eDOM_PROPERTIES,
                                          warning == EncodeWarning
                                          ? "nsIJSONEncodeDeprecatedWarning"
                                          : "nsIJSONDecodeDeprecatedWarning");
 }
 NS_IMETHODIMP
 nsJSON::Encode(JS::Handle<JS::Value> aValue, JSContext* cx, uint8_t aArgc,
                nsAString &aJSON)
 {
   // This function should only be called from JS.
   nsresult rv = WarnDeprecatedMethod(EncodeWarning);
   if (NS_FAILED(rv))
     return rv;
   if (aArgc == 0) {
     aJSON.Truncate();
     aJSON.SetIsVoid(true);
     return NS_OK;
   }
   nsJSONWriter writer;
   rv = EncodeInternal(cx, aValue, &writer);
   // FIXME: bug 408838. Get exception types sorted out
   if (NS_SUCCEEDED(rv) || rv == NS_ERROR_INVALID_ARG) {
     rv = NS_OK;
     // if we didn't consume anything, it's not JSON, so return null
     if (!writer.DidWrite()) {
       aJSON.Truncate();
       aJSON.SetIsVoid(true);
     } else {
       writer.FlushBuffer();
       aJSON.Append(writer.mOutputString);
     }
   }
   return rv;
 }
 static const char UTF8BOM[] = "\xEF\xBB\xBF";
 static const char UTF16LEBOM[] = "\xFF\xFE";
 static const char UTF16BEBOM[] = "\xFE\xFF";
 static nsresult CheckCharset(const char* aCharset)
 {
   // Check that the charset is permissible
   if (!(strcmp(aCharset, "UTF-8") == 0 ||
         strcmp(aCharset, "UTF-16LE") == 0 ||
         strcmp(aCharset, "UTF-16BE") == 0)) {
     return NS_ERROR_INVALID_ARG;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsJSON::EncodeToStream(nsIOutputStream *aStream,
                        const char* aCharset,
                        const bool aWriteBOM,
                        JS::Handle<JS::Value> val,
                        JSContext* cx,
                        uint8_t aArgc)
 {
   // This function should only be called from JS.
   NS_ENSURE_ARG(aStream);
   nsresult rv;
   rv = CheckCharset(aCharset);
   NS_ENSURE_SUCCESS(rv, rv);
   // Check to see if we have a buffered stream
   nsCOMPtr<nsIOutputStream> bufferedStream;
   // FIXME: bug 408514.
   // NS_OutputStreamIsBuffered(aStream) asserts on file streams...
   //if (!NS_OutputStreamIsBuffered(aStream)) {
     rv = NS_NewBufferedOutputStream(getter_AddRefs(bufferedStream),
                                     aStream, 4096);
     NS_ENSURE_SUCCESS(rv, rv);
   //  aStream = bufferedStream;
   //}
   uint32_t ignored;
   if (aWriteBOM) {
     if (strcmp(aCharset, "UTF-8") == 0)
       rv = aStream->Write(UTF8BOM, 3, &ignored);
     else if (strcmp(aCharset, "UTF-16LE") == 0)
       rv = aStream->Write(UTF16LEBOM, 2, &ignored);
     else if (strcmp(aCharset, "UTF-16BE") == 0)
       rv = aStream->Write(UTF16BEBOM, 2, &ignored);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   nsJSONWriter writer(bufferedStream);
   rv = writer.SetCharset(aCharset);
   NS_ENSURE_SUCCESS(rv, rv);
   if (aArgc == 0) {
     return NS_OK;
   }
   rv = EncodeInternal(cx, val, &writer);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = bufferedStream->Flush();
   return rv;
 }
 static bool
 WriteCallback(const jschar *buf, uint32_t len, void *data)
 {
   nsJSONWriter *writer = static_cast<nsJSONWriter*>(data);
   nsresult rv =  writer->Write((const char16_t*)buf, (uint32_t)len);
   if (NS_FAILED(rv))
     return false;
   return true;
 }
 NS_IMETHODIMP
 nsJSON::EncodeFromJSVal(JS::Value *value, JSContext *cx, nsAString &result)
 {
   result.Truncate();
   mozilla::Maybe<JSAutoCompartment> ac;
   if (value->isObject()) {
     JS::Rooted<JSObject*> obj(cx, &value->toObject());
     ac.construct(cx, obj);
   }
   nsJSONWriter writer;
   JS::Rooted<JS::Value> vp(cx, *value);
   if (!JS_Stringify(cx, &vp, JS::NullPtr(), JS::NullHandleValue, WriteCallback, &writer)) {
     return NS_ERROR_XPC_BAD_CONVERT_JS;
   }
   *value = vp;
   NS_ENSURE_TRUE(writer.DidWrite(), NS_ERROR_UNEXPECTED);
   writer.FlushBuffer();
   result.Assign(writer.mOutputString);
   return NS_OK;
 }
 nsresult
 nsJSON::EncodeInternal(JSContext* cx, const JS::Value& aValue,
                        nsJSONWriter* writer)
 {
   // Backward compatibility:
   // nsIJSON does not allow to serialize anything other than objects
   if (!aValue.isObject()) {
     return NS_ERROR_INVALID_ARG;
   }
   JS::Rooted<JSObject*> obj(cx, &aValue.toObject());
   /* Backward compatibility:
    * Manually call toJSON if implemented by the object and check that
    * the result is still an object
    * Note: It is perfectly fine to not implement toJSON, so it is
    * perfectly fine for GetMethod to fail
    */
   JS::Rooted<JS::Value> val(cx, aValue);
   JS::Rooted<JS::Value> toJSON(cx);
   if (JS_GetProperty(cx, obj, "toJSON", &toJSON) &&
       toJSON.isObject() &&
       JS_ObjectIsCallable(cx, &toJSON.toObject())) {
     // If toJSON is implemented, it must not throw
     if (!JS_CallFunctionValue(cx, obj, toJSON, JS::HandleValueArray::empty(), &val)) {
       if (JS_IsExceptionPending(cx))
         // passing NS_OK will throw the pending exception
         return NS_OK;
       // No exception, but still failed
       return NS_ERROR_FAILURE;
     }
     // Backward compatibility:
     // nsIJSON does not allow to serialize anything other than objects
     if (val.isPrimitive())
       return NS_ERROR_INVALID_ARG;
   }
   // GetMethod may have thrown
   else if (JS_IsExceptionPending(cx))
     // passing NS_OK will throw the pending exception
     return NS_OK;
   // Backward compatibility:
   // function shall not pass, just "plain" objects and arrays
   JSType type = JS_TypeOfValue(cx, val);
   if (type == JSTYPE_FUNCTION)
     return NS_ERROR_INVALID_ARG;
   // We're good now; try to stringify
   if (!JS_Stringify(cx, &val, JS::NullPtr(), JS::NullHandleValue, WriteCallback, writer))
     return NS_ERROR_FAILURE;
   return NS_OK;
 }
 nsJSONWriter::nsJSONWriter() : mStream(nullptr),
                                mBuffer(nullptr),
                                mBufferCount(0),
                                mDidWrite(false),
                                mEncoder(nullptr)
 {
 }
 nsJSONWriter::nsJSONWriter(nsIOutputStream *aStream) : mStream(aStream),
                                                        mBuffer(nullptr),
                                                        mBufferCount(0),
                                                        mDidWrite(false),
                                                        mEncoder(nullptr)
 {
 }
 nsJSONWriter::~nsJSONWriter()
 {
   delete [] mBuffer;
 }
 nsresult
 nsJSONWriter::SetCharset(const char* aCharset)
 {
   nsresult rv = NS_OK;
   if (mStream) {
     mEncoder = EncodingUtils::EncoderForEncoding(aCharset);
     rv = mEncoder->SetOutputErrorBehavior(nsIUnicodeEncoder::kOnError_Signal,
                                           nullptr, '\0');
     NS_ENSURE_SUCCESS(rv, rv);
   }
   return rv;
 }
 nsresult
 nsJSONWriter::Write(const char16_t *aBuffer, uint32_t aLength)
 {
   if (mStream) {
     return WriteToStream(mStream, mEncoder, aBuffer, aLength);
   }
   if (!mDidWrite) {
     mBuffer = new char16_t[JSON_STREAM_BUFSIZE];
     if (!mBuffer)
       return NS_ERROR_OUT_OF_MEMORY;
     mDidWrite = true;
   }
   if (JSON_STREAM_BUFSIZE <= aLength + mBufferCount) {
     mOutputString.Append(mBuffer, mBufferCount);
     mBufferCount = 0;
   }
   if (JSON_STREAM_BUFSIZE <= aLength) {
     // we know mBufferCount is 0 because we know we hit the if above
     mOutputString.Append(aBuffer, aLength);
   } else {
     memcpy(&mBuffer[mBufferCount], aBuffer, aLength * sizeof(char16_t));
     mBufferCount += aLength;
   }
   return NS_OK;
 }
 bool nsJSONWriter::DidWrite()
 {
   return mDidWrite;
 }
 void
 nsJSONWriter::FlushBuffer()
 {
   mOutputString.Append(mBuffer, mBufferCount);
 }
 nsresult
 nsJSONWriter::WriteToStream(nsIOutputStream *aStream,
                             nsIUnicodeEncoder *encoder,
                             const char16_t *aBuffer,
                             uint32_t aLength)
 {
   nsresult rv;
   int32_t srcLength = aLength;
   uint32_t bytesWritten;
   // The bytes written to the stream might differ from the char16_t size
   int32_t aDestLength;
   rv = encoder->GetMaxLength(aBuffer, srcLength, &aDestLength);
   NS_ENSURE_SUCCESS(rv, rv);
   // create the buffer we need
   char* destBuf = (char *) NS_Alloc(aDestLength);
   if (!destBuf)
     return NS_ERROR_OUT_OF_MEMORY;
   rv = encoder->Convert(aBuffer, &srcLength, destBuf, &aDestLength);
   if (NS_SUCCEEDED(rv))
     rv = aStream->Write(destBuf, aDestLength, &bytesWritten);
   NS_Free(destBuf);
   mDidWrite = true;
   return rv;
 }
 NS_IMETHODIMP
 nsJSON::Decode(const nsAString& json, JSContext* cx,
                JS::MutableHandle<JS::Value> aRetval)
 {
   nsresult rv = WarnDeprecatedMethod(DecodeWarning);
   if (NS_FAILED(rv))
     return rv;
   const char16_t *data;
   uint32_t len = NS_StringGetData(json, &data);
   nsCOMPtr<nsIInputStream> stream;
   rv = NS_NewByteInputStream(getter_AddRefs(stream),
                              reinterpret_cast<const char*>(data),
                              len * sizeof(char16_t),
                              NS_ASSIGNMENT_DEPEND);
   NS_ENSURE_SUCCESS(rv, rv);
   return DecodeInternal(cx, stream, len, false, aRetval);
 }
 NS_IMETHODIMP
 nsJSON::DecodeFromStream(nsIInputStream *aStream, int32_t aContentLength,
                          JSContext* cx, JS::MutableHandle<JS::Value> aRetval)
 {
   return DecodeInternal(cx, aStream, aContentLength, true, aRetval);
 }
 NS_IMETHODIMP
 nsJSON::DecodeToJSVal(const nsAString &str, JSContext *cx,
                       JS::MutableHandle<JS::Value> result)
 {
   if (!JS_ParseJSON(cx, static_cast<const jschar*>(PromiseFlatString(str).get()),
                     str.Length(), result)) {
     return NS_ERROR_UNEXPECTED;
   }
   return NS_OK;
 }
 nsresult
 nsJSON::DecodeInternal(JSContext* cx,
                        nsIInputStream *aStream,
                        int32_t aContentLength,
                        bool aNeedsConverter,
                        JS::MutableHandle<JS::Value> aRetval)
 {
   // Consume the stream
   nsCOMPtr<nsIChannel> jsonChannel;
   if (!mURI) {
     NS_NewURI(getter_AddRefs(mURI), NS_LITERAL_CSTRING("about:blank"), 0, 0 );
     if (!mURI)
       return NS_ERROR_OUT_OF_MEMORY;
   }
   nsresult rv =
     NS_NewInputStreamChannel(getter_AddRefs(jsonChannel), mURI, aStream,
                              NS_LITERAL_CSTRING("application/json"));
   if (!jsonChannel || NS_FAILED(rv))
     return NS_ERROR_FAILURE;
   nsRefPtr<nsJSONListener> jsonListener =
     new nsJSONListener(cx, aRetval.address(), aNeedsConverter);
   //XXX this stream pattern should be consolidated in netwerk
   rv = jsonListener->OnStartRequest(jsonChannel, nullptr);
   if (NS_FAILED(rv)) {
     jsonChannel->Cancel(rv);
     return rv;
   }
   nsresult status;
   jsonChannel->GetStatus(&status);
   uint64_t offset = 0;
   while (NS_SUCCEEDED(status)) {
     uint64_t available;
     rv = aStream->Available(&available);
     if (rv == NS_BASE_STREAM_CLOSED) {
       rv = NS_OK;
       break;
     }
     if (NS_FAILED(rv)) {
       jsonChannel->Cancel(rv);
       break;
     }
     if (!available)
       break; // blocking input stream has none available when done
     if (available > UINT32_MAX)
       available = UINT32_MAX;
     rv = jsonListener->OnDataAvailable(jsonChannel, nullptr,
                                        aStream,
                                        offset,
                                        (uint32_t)available);
     if (NS_FAILED(rv)) {
       jsonChannel->Cancel(rv);
       break;
     }
     offset += available;
     jsonChannel->GetStatus(&status);
   }
   NS_ENSURE_SUCCESS(rv, rv);
   rv = jsonListener->OnStopRequest(jsonChannel, nullptr, status);
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 nsresult
 NS_NewJSON(nsISupports* aOuter, REFNSIID aIID, void** aResult)
 {
   nsJSON* json = new nsJSON();
   if (!json)
     return NS_ERROR_OUT_OF_MEMORY;
   NS_ADDREF(json);
   *aResult = json;
   return NS_OK;
 }
 nsJSONListener::nsJSONListener(JSContext *cx, JS::Value *rootVal,
                                bool needsConverter)
   : mNeedsConverter(needsConverter),
     mCx(cx),
     mRootVal(rootVal)
 {
 }
 nsJSONListener::~nsJSONListener()
 {
 }
 NS_INTERFACE_MAP_BEGIN(nsJSONListener)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsJSONListener)
   NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
   NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
 NS_INTERFACE_MAP_END
 NS_IMPL_ADDREF(nsJSONListener)
 NS_IMPL_RELEASE(nsJSONListener)
 NS_IMETHODIMP
 nsJSONListener::OnStartRequest(nsIRequest *aRequest, nsISupports *aContext)
 {
   mSniffBuffer.Truncate();
   mDecoder = nullptr;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsJSONListener::OnStopRequest(nsIRequest *aRequest, nsISupports *aContext,
                               nsresult aStatusCode)
 {
   nsresult rv;
   // This can happen with short UTF-8 messages (<4 bytes)
   if (!mSniffBuffer.IsEmpty()) {
     // Just consume mSniffBuffer
     rv = ProcessBytes(nullptr, 0);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   JS::Rooted<JS::Value> reviver(mCx, JS::NullValue()), value(mCx);
   JS::ConstTwoByteChars chars(reinterpret_cast<const jschar*>(mBufferedChars.Elements()),
                               mBufferedChars.Length());
   bool ok = JS_ParseJSONWithReviver(mCx, chars.get(),
                                       uint32_t(mBufferedChars.Length()),
                                       reviver, &value);
   *mRootVal = value;
   mBufferedChars.TruncateLength(0);
   return ok ? NS_OK : NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsJSONListener::OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
                                 nsIInputStream *aStream,
                                 uint64_t aOffset, uint32_t aLength)
 {
   nsresult rv = NS_OK;
   if (mNeedsConverter && mSniffBuffer.Length() < 4) {
     uint32_t readCount = (aLength < 4) ? aLength : 4;
     rv = NS_ConsumeStream(aStream, readCount, mSniffBuffer);
     NS_ENSURE_SUCCESS(rv, rv);
     if (mSniffBuffer.Length() < 4)
       return NS_OK;
   }
   char buffer[JSON_STREAM_BUFSIZE];
   unsigned long bytesRemaining = aLength - mSniffBuffer.Length();
   while (bytesRemaining) {
     unsigned int bytesRead;
     rv = aStream->Read(buffer,
                        std::min((unsigned long)sizeof(buffer), bytesRemaining),
                        &bytesRead);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = ProcessBytes(buffer, bytesRead);
     NS_ENSURE_SUCCESS(rv, rv);
     bytesRemaining -= bytesRead;
   }
   return rv;
 }
 nsresult
 nsJSONListener::ProcessBytes(const char* aBuffer, uint32_t aByteLength)
 {
   nsresult rv;
   // Check for BOM, or sniff charset
   nsAutoCString charset;
   if (mNeedsConverter && !mDecoder) {
     if (!nsContentUtils::CheckForBOM((const unsigned char*) mSniffBuffer.get(),
                                       mSniffBuffer.Length(), charset)) {
       // OK, found no BOM, sniff the first character to see what this is
       // See section 3 of RFC4627 for details on why this works.
       const char *buffer = mSniffBuffer.get();
       if (mSniffBuffer.Length() >= 4) {
         if (buffer[0] == 0x00 && buffer[1] != 0x00 &&
             buffer[2] == 0x00 && buffer[3] != 0x00) {
           charset = "UTF-16BE";
         } else if (buffer[0] != 0x00 && buffer[1] == 0x00 &&
                    buffer[2] != 0x00 && buffer[3] == 0x00) {
           charset = "UTF-16LE";
         } else if (buffer[0] != 0x00 && buffer[1] != 0x00 &&
                    buffer[2] != 0x00 && buffer[3] != 0x00) {
           charset = "UTF-8";
         }
       } else {
         // Not enough bytes to sniff, assume UTF-8
         charset = "UTF-8";
       }
     }
     // We should have a unicode charset by now
     rv = CheckCharset(charset.get());
     NS_ENSURE_SUCCESS(rv, rv);
     mDecoder = EncodingUtils::DecoderForEncoding(charset);
     // consume the sniffed bytes
     rv = ConsumeConverted(mSniffBuffer.get(), mSniffBuffer.Length());
     NS_ENSURE_SUCCESS(rv, rv);
     mSniffBuffer.Truncate();
   }
   if (!aBuffer)
     return NS_OK;
   if (mNeedsConverter) {
     rv = ConsumeConverted(aBuffer, aByteLength);
   } else {
     uint32_t unichars = aByteLength / sizeof(char16_t);
     rv = Consume((char16_t *) aBuffer, unichars);
   }
   return rv;
 }
 nsresult
 nsJSONListener::ConsumeConverted(const char* aBuffer, uint32_t aByteLength)
 {
   nsresult rv;
   int32_t unicharLength = 0;
   int32_t srcLen = aByteLength;
   rv = mDecoder->GetMaxLength(aBuffer, srcLen, &unicharLength);
   NS_ENSURE_SUCCESS(rv, rv);
   char16_t* endelems = mBufferedChars.AppendElements(unicharLength);
   int32_t preLength = unicharLength;
   rv = mDecoder->Convert(aBuffer, &srcLen, endelems, &unicharLength);
   if (NS_FAILED(rv))
     return rv;
   NS_ABORT_IF_FALSE(preLength >= unicharLength, "GetMaxLength lied");
   if (preLength > unicharLength)
     mBufferedChars.TruncateLength(mBufferedChars.Length() - (preLength - unicharLength));
   return NS_OK;
 }
 nsresult
 nsJSONListener::Consume(const char16_t* aBuffer, uint32_t aByteLength)
 {
   if (!mBufferedChars.AppendElements(aBuffer, aByteLength))
     return NS_ERROR_FAILURE;
   return NS_OK;
 }

The Tor Browser / annotate

dom/src/json/nsJSON.cpp@b8a032363ba2 (annotated)

dom/src/json/nsJSON.cpp