The Tor Browser: js/src/jsexn.cpp@129ffea94266 (annotated)

js/src/jsexn.cpp@129ffea94266 (annotated)

js/src/jsexn.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * vim: set ts=8 sts=4 et sw=4 tw=99:
  * 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/. */
 /*
  * JS standard exception implementation.
  */
 #include "jsexn.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/PodOperations.h"
 #include <string.h>
 #include "jsapi.h"
 #include "jscntxt.h"
 #include "jsfun.h"
 #include "jsnum.h"
 #include "jsobj.h"
 #include "jsscript.h"
 #include "jstypes.h"
 #include "jsutil.h"
 #include "jswrapper.h"
 #include "gc/Marking.h"
 #include "vm/ErrorObject.h"
 #include "vm/GlobalObject.h"
 #include "vm/StringBuffer.h"
 #include "jsobjinlines.h"
 #include "vm/ErrorObject-inl.h"
 using namespace js;
 using namespace js::gc;
 using namespace js::types;
 using mozilla::ArrayLength;
 using mozilla::PodArrayZero;
 using mozilla::PodZero;
 static void
 exn_finalize(FreeOp *fop, JSObject *obj);
 const Class ErrorObject::class_ = {
     js_Error_str,
     JSCLASS_IMPLEMENTS_BARRIERS |
     JSCLASS_HAS_CACHED_PROTO(JSProto_Error) |
     JSCLASS_HAS_RESERVED_SLOTS(ErrorObject::RESERVED_SLOTS),
     JS_PropertyStub,         /* addProperty */
     JS_DeletePropertyStub,   /* delProperty */
     JS_PropertyStub,         /* getProperty */
     JS_StrictPropertyStub,   /* setProperty */
     JS_EnumerateStub,
     JS_ResolveStub,
     JS_ConvertStub,
     exn_finalize,
     nullptr,                 /* call        */
     nullptr,                 /* hasInstance */
     nullptr                  /* construct   */
 };
 JSErrorReport *
 js::CopyErrorReport(JSContext *cx, JSErrorReport *report)
 {
     /*
      * We use a single malloc block to make a deep copy of JSErrorReport with
      * the following layout:
      *   JSErrorReport
      *   array of copies of report->messageArgs
      *   jschar array with characters for all messageArgs
      *   jschar array with characters for ucmessage
      *   jschar array with characters for uclinebuf and uctokenptr
      *   char array with characters for linebuf and tokenptr
      *   char array with characters for filename
      * Such layout together with the properties enforced by the following
      * asserts does not need any extra alignment padding.
      */
     JS_STATIC_ASSERT(sizeof(JSErrorReport) % sizeof(const char *) == 0);
     JS_STATIC_ASSERT(sizeof(const char *) % sizeof(jschar) == 0);
     size_t filenameSize;
     size_t linebufSize;
     size_t uclinebufSize;
     size_t ucmessageSize;
     size_t i, argsArraySize, argsCopySize, argSize;
     size_t mallocSize;
     JSErrorReport *copy;
     uint8_t *cursor;
 #define JS_CHARS_SIZE(jschars) ((js_strlen(jschars) + 1) * sizeof(jschar))
     filenameSize = report->filename ? strlen(report->filename) + 1 : 0;
     linebufSize = report->linebuf ? strlen(report->linebuf) + 1 : 0;
     uclinebufSize = report->uclinebuf ? JS_CHARS_SIZE(report->uclinebuf) : 0;
     ucmessageSize = 0;
     argsArraySize = 0;
     argsCopySize = 0;
     if (report->ucmessage) {
         ucmessageSize = JS_CHARS_SIZE(report->ucmessage);
         if (report->messageArgs) {
             for (i = 0; report->messageArgs[i]; ++i)
                 argsCopySize += JS_CHARS_SIZE(report->messageArgs[i]);
             /* Non-null messageArgs should have at least one non-null arg. */
             JS_ASSERT(i != 0);
             argsArraySize = (i + 1) * sizeof(const jschar *);
         }
     }
     /*
      * The mallocSize can not overflow since it represents the sum of the
      * sizes of already allocated objects.
      */
     mallocSize = sizeof(JSErrorReport) + argsArraySize + argsCopySize +
                  ucmessageSize + uclinebufSize + linebufSize + filenameSize;
     cursor = cx->pod_malloc<uint8_t>(mallocSize);
     if (!cursor)
         return nullptr;
     copy = (JSErrorReport *)cursor;
     memset(cursor, 0, sizeof(JSErrorReport));
     cursor += sizeof(JSErrorReport);
     if (argsArraySize != 0) {
         copy->messageArgs = (const jschar **)cursor;
         cursor += argsArraySize;
         for (i = 0; report->messageArgs[i]; ++i) {
             copy->messageArgs[i] = (const jschar *)cursor;
             argSize = JS_CHARS_SIZE(report->messageArgs[i]);
             js_memcpy(cursor, report->messageArgs[i], argSize);
             cursor += argSize;
         }
         copy->messageArgs[i] = nullptr;
         JS_ASSERT(cursor == (uint8_t *)copy->messageArgs[0] + argsCopySize);
     }
     if (report->ucmessage) {
         copy->ucmessage = (const jschar *)cursor;
         js_memcpy(cursor, report->ucmessage, ucmessageSize);
         cursor += ucmessageSize;
     }
     if (report->uclinebuf) {
         copy->uclinebuf = (const jschar *)cursor;
         js_memcpy(cursor, report->uclinebuf, uclinebufSize);
         cursor += uclinebufSize;
         if (report->uctokenptr) {
             copy->uctokenptr = copy->uclinebuf + (report->uctokenptr -
                                                   report->uclinebuf);
         }
     }
     if (report->linebuf) {
         copy->linebuf = (const char *)cursor;
         js_memcpy(cursor, report->linebuf, linebufSize);
         cursor += linebufSize;
         if (report->tokenptr) {
             copy->tokenptr = copy->linebuf + (report->tokenptr -
                                               report->linebuf);
         }
     }
     if (report->filename) {
         copy->filename = (const char *)cursor;
         js_memcpy(cursor, report->filename, filenameSize);
     }
     JS_ASSERT(cursor + filenameSize == (uint8_t *)copy + mallocSize);
     /* HOLD called by the destination error object. */
     copy->originPrincipals = report->originPrincipals;
     /* Copy non-pointer members. */
     copy->lineno = report->lineno;
     copy->column = report->column;
     copy->errorNumber = report->errorNumber;
     copy->exnType = report->exnType;
     /* Note that this is before it gets flagged with JSREPORT_EXCEPTION */
     copy->flags = report->flags;
 #undef JS_CHARS_SIZE
     return copy;
 }
 struct SuppressErrorsGuard
 {
     JSContext *cx;
     JSErrorReporter prevReporter;
     JS::AutoSaveExceptionState prevState;
     SuppressErrorsGuard(JSContext *cx)
       : cx(cx),
         prevReporter(JS_SetErrorReporter(cx, nullptr)),
         prevState(cx)
     {}
     ~SuppressErrorsGuard()
     {
         JS_SetErrorReporter(cx, prevReporter);
     }
 };
 JSString *
 js::ComputeStackString(JSContext *cx)
 {
     StringBuffer sb(cx);
     {
         RootedAtom atom(cx);
         SuppressErrorsGuard seg(cx);
         for (NonBuiltinFrameIter i(cx, FrameIter::ALL_CONTEXTS, FrameIter::GO_THROUGH_SAVED,
                                    cx->compartment()->principals);
              !i.done();
              ++i)
         {
             /* First append the function name, if any. */
             if (i.isNonEvalFunctionFrame())
                 atom = i.functionDisplayAtom();
             else
                 atom = nullptr;
             if (atom && !sb.append(atom))
                 return nullptr;
             /* Next a @ separating function name from source location. */
             if (!sb.append('@'))
                 return nullptr;
             /* Now the filename. */
             const char *cfilename = i.scriptFilename();
             if (!cfilename)
                 cfilename = "";
             if (!sb.appendInflated(cfilename, strlen(cfilename)))
                 return nullptr;
             uint32_t column = 0;
             uint32_t line = i.computeLine(&column);
             // Now the line number
             if (!sb.append(':') || !NumberValueToStringBuffer(cx, NumberValue(line), sb))
                 return nullptr;
             // Finally, : followed by the column number (1-based, as in other browsers)
             // and a newline.
             if (!sb.append(':') || !NumberValueToStringBuffer(cx, NumberValue(column + 1), sb) ||
                 !sb.append('\n'))
             {
                 return nullptr;
             }
             /*
              * Cut off the stack if it gets too deep (most commonly for
              * infinite recursion errors).
              */
             const size_t MaxReportedStackDepth = 1u << 20;
             if (sb.length() > MaxReportedStackDepth)
                 break;
         }
     }
     return sb.finishString();
 }
 static void
 exn_finalize(FreeOp *fop, JSObject *obj)
 {
     if (JSErrorReport *report = obj->as<ErrorObject>().getErrorReport()) {
         /* These were held by ErrorObject::init. */
         if (JSPrincipals *prin = report->originPrincipals)
             JS_DropPrincipals(fop->runtime(), prin);
         fop->free_(report);
     }
 }
 JSErrorReport *
 js_ErrorFromException(JSContext *cx, HandleObject objArg)
 {
     // It's ok to UncheckedUnwrap here, since all we do is get the
     // JSErrorReport, and consumers are careful with the information they get
     // from that anyway.  Anyone doing things that would expose anything in the
     // JSErrorReport to page script either does a security check on the
     // JSErrorReport's principal or also tries to do toString on our object and
     // will fail if they can't unwrap it.
     RootedObject obj(cx, UncheckedUnwrap(objArg));
     if (!obj->is<ErrorObject>())
         return nullptr;
     return obj->as<ErrorObject>().getOrCreateErrorReport(cx);
 }
 static bool
 Error(JSContext *cx, unsigned argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
     /* Compute the error message, if any. */
     RootedString message(cx, nullptr);
     if (args.hasDefined(0)) {
         message = ToString<CanGC>(cx, args[0]);
         if (!message)
             return false;
     }
     /* Find the scripted caller. */
     NonBuiltinFrameIter iter(cx);
     /* Set the 'fileName' property. */
     RootedString fileName(cx);
     if (args.length() > 1) {
         fileName = ToString<CanGC>(cx, args[1]);
     } else {
         fileName = cx->runtime()->emptyString;
         if (!iter.done()) {
             if (const char *cfilename = iter.scriptFilename())
                 fileName = JS_NewStringCopyZ(cx, cfilename);
         }
     }
     if (!fileName)
         return false;
     /* Set the 'lineNumber' property. */
     uint32_t lineNumber, columnNumber = 0;
     if (args.length() > 2) {
         if (!ToUint32(cx, args[2], &lineNumber))
             return false;
     } else {
         lineNumber = iter.done() ? 0 : iter.computeLine(&columnNumber);
     }
     Rooted<JSString*> stack(cx, ComputeStackString(cx));
     if (!stack)
         return false;
     /*
      * ECMA ed. 3, 15.11.1 requires Error, etc., to construct even when
      * called as functions, without operator new.  But as we do not give
      * each constructor a distinct JSClass, we must get the exception type
      * ourselves.
      */
     JSExnType exnType = JSExnType(args.callee().as<JSFunction>().getExtendedSlot(0).toInt32());
     RootedObject obj(cx, ErrorObject::create(cx, exnType, stack, fileName,
                                              lineNumber, columnNumber, nullptr, message));
     if (!obj)
         return false;
     args.rval().setObject(*obj);
     return true;
 }
 /* ES5 15.11.4.4 (NB: with subsequent errata). */
 static bool
 exn_toString(JSContext *cx, unsigned argc, Value *vp)
 {
     JS_CHECK_RECURSION(cx, return false);
     CallArgs args = CallArgsFromVp(argc, vp);
     /* Step 2. */
     if (!args.thisv().isObject()) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_BAD_PROTOTYPE, "Error");
         return false;
     }
     /* Step 1. */
     RootedObject obj(cx, &args.thisv().toObject());
     /* Step 3. */
     RootedValue nameVal(cx);
     if (!JSObject::getProperty(cx, obj, obj, cx->names().name, &nameVal))
         return false;
     /* Step 4. */
     RootedString name(cx);
     if (nameVal.isUndefined()) {
         name = cx->names().Error;
     } else {
         name = ToString<CanGC>(cx, nameVal);
         if (!name)
             return false;
     }
     /* Step 5. */
     RootedValue msgVal(cx);
     if (!JSObject::getProperty(cx, obj, obj, cx->names().message, &msgVal))
         return false;
     /* Step 6. */
     RootedString message(cx);
     if (msgVal.isUndefined()) {
         message = cx->runtime()->emptyString;
     } else {
         message = ToString<CanGC>(cx, msgVal);
         if (!message)
             return false;
     }
     /* Step 7. */
     if (name->empty() && message->empty()) {
         args.rval().setString(cx->names().Error);
         return true;
     }
     /* Step 8. */
     if (name->empty()) {
         args.rval().setString(message);
         return true;
     }
     /* Step 9. */
     if (message->empty()) {
         args.rval().setString(name);
         return true;
     }
     /* Step 10. */
     StringBuffer sb(cx);
     if (!sb.append(name) || !sb.append(": ") || !sb.append(message))
         return false;
     JSString *str = sb.finishString();
     if (!str)
         return false;
     args.rval().setString(str);
     return true;
 }
 #if JS_HAS_TOSOURCE
 /*
  * Return a string that may eval to something similar to the original object.
  */
 static bool
 exn_toSource(JSContext *cx, unsigned argc, Value *vp)
 {
     JS_CHECK_RECURSION(cx, return false);
     CallArgs args = CallArgsFromVp(argc, vp);
     RootedObject obj(cx, ToObject(cx, args.thisv()));
     if (!obj)
         return false;
     RootedValue nameVal(cx);
     RootedString name(cx);
     if (!JSObject::getProperty(cx, obj, obj, cx->names().name, &nameVal) ||
         !(name = ToString<CanGC>(cx, nameVal)))
     {
         return false;
     }
     RootedValue messageVal(cx);
     RootedString message(cx);
     if (!JSObject::getProperty(cx, obj, obj, cx->names().message, &messageVal) ||
         !(message = ValueToSource(cx, messageVal)))
     {
         return false;
     }
     RootedValue filenameVal(cx);
     RootedString filename(cx);
     if (!JSObject::getProperty(cx, obj, obj, cx->names().fileName, &filenameVal) ||
         !(filename = ValueToSource(cx, filenameVal)))
     {
         return false;
     }
     RootedValue linenoVal(cx);
     uint32_t lineno;
     if (!JSObject::getProperty(cx, obj, obj, cx->names().lineNumber, &linenoVal) ||
         !ToUint32(cx, linenoVal, &lineno))
     {
         return false;
     }
     StringBuffer sb(cx);
     if (!sb.append("(new ") || !sb.append(name) || !sb.append("("))
         return false;
     if (!sb.append(message))
         return false;
     if (!filename->empty()) {
         if (!sb.append(", ") || !sb.append(filename))
             return false;
     }
     if (lineno != 0) {
         /* We have a line, but no filename, add empty string */
         if (filename->empty() && !sb.append(", \"\""))
                 return false;
         JSString *linenumber = ToString<CanGC>(cx, linenoVal);
         if (!linenumber)
             return false;
         if (!sb.append(", ") || !sb.append(linenumber))
             return false;
     }
     if (!sb.append("))"))
         return false;
     JSString *str = sb.finishString();
     if (!str)
         return false;
     args.rval().setString(str);
     return true;
 }
 #endif
 static const JSFunctionSpec exception_methods[] = {
 #if JS_HAS_TOSOURCE
     JS_FN(js_toSource_str,   exn_toSource,           0,0),
 #endif
     JS_FN(js_toString_str,   exn_toString,           0,0),
     JS_FS_END
 };
 /* JSProto_ ordering for exceptions shall match JSEXN_ constants. */
 JS_STATIC_ASSERT(JSEXN_ERR == 0);
 JS_STATIC_ASSERT(JSProto_Error + JSEXN_INTERNALERR  == JSProto_InternalError);
 JS_STATIC_ASSERT(JSProto_Error + JSEXN_EVALERR      == JSProto_EvalError);
 JS_STATIC_ASSERT(JSProto_Error + JSEXN_RANGEERR     == JSProto_RangeError);
 JS_STATIC_ASSERT(JSProto_Error + JSEXN_REFERENCEERR == JSProto_ReferenceError);
 JS_STATIC_ASSERT(JSProto_Error + JSEXN_SYNTAXERR    == JSProto_SyntaxError);
 JS_STATIC_ASSERT(JSProto_Error + JSEXN_TYPEERR      == JSProto_TypeError);
 JS_STATIC_ASSERT(JSProto_Error + JSEXN_URIERR       == JSProto_URIError);
 /* static */ ErrorObject *
 ErrorObject::createProto(JSContext *cx, JS::Handle<GlobalObject*> global, JSExnType type,
                          JS::HandleObject proto)
 {
     RootedObject errorProto(cx);
     errorProto = global->createBlankPrototypeInheriting(cx, &ErrorObject::class_, *proto);
     if (!errorProto)
         return nullptr;
     Rooted<ErrorObject*> err(cx, &errorProto->as<ErrorObject>());
     RootedString emptyStr(cx, cx->names().empty);
     if (!ErrorObject::init(cx, err, type, nullptr, emptyStr, emptyStr, 0, 0, emptyStr))
         return nullptr;
     // The various prototypes also have .name in addition to the normal error
     // instance properties.
     JSProtoKey key = GetExceptionProtoKey(type);
     RootedPropertyName name(cx, ClassName(key, cx));
     RootedValue nameValue(cx, StringValue(name));
     if (!JSObject::defineProperty(cx, err, cx->names().name, nameValue,
                                   JS_PropertyStub, JS_StrictPropertyStub, 0))
     {
         return nullptr;
     }
     // Create the corresponding constructor.
     RootedFunction ctor(cx, global->createConstructor(cx, Error, name, 1,
                                                       JSFunction::ExtendedFinalizeKind));
     if (!ctor)
         return nullptr;
     ctor->setExtendedSlot(0, Int32Value(int32_t(type)));
     if (!LinkConstructorAndPrototype(cx, ctor, err))
         return nullptr;
     if (!GlobalObject::initBuiltinConstructor(cx, global, key, ctor, err))
         return nullptr;
     return err;
 }
 JSObject *
 js_InitExceptionClasses(JSContext *cx, HandleObject obj)
 {
     JS_ASSERT(obj->is<GlobalObject>());
     JS_ASSERT(obj->isNative());
     Rooted<GlobalObject*> global(cx, &obj->as<GlobalObject>());
     RootedObject objProto(cx, global->getOrCreateObjectPrototype(cx));
     if (!objProto)
         return nullptr;
     /* Initialize the base Error class first. */
     RootedObject errorProto(cx, ErrorObject::createProto(cx, global, JSEXN_ERR, objProto));
     if (!errorProto)
         return nullptr;
     /* |Error.prototype| alone has method properties. */
     if (!DefinePropertiesAndBrand(cx, errorProto, nullptr, exception_methods))
         return nullptr;
     /* Define all remaining *Error constructors. */
     for (int i = JSEXN_ERR + 1; i < JSEXN_LIMIT; i++) {
         if (!ErrorObject::createProto(cx, global, JSExnType(i), errorProto))
             return nullptr;
     }
     return errorProto;
 }
 const JSErrorFormatString*
 js_GetLocalizedErrorMessage(ExclusiveContext *cx, void *userRef, const char *locale,
                             const unsigned errorNumber)
 {
     const JSErrorFormatString *errorString = nullptr;
     // The locale callbacks might not be thread safe, so don't call them if
     // we're not on the main thread. When used with XPConnect,
     // |localeGetErrorMessage| will be nullptr anyways.
     if (cx->isJSContext() &&
         cx->asJSContext()->runtime()->localeCallbacks &&
         cx->asJSContext()->runtime()->localeCallbacks->localeGetErrorMessage)
     {
         JSLocaleCallbacks *callbacks = cx->asJSContext()->runtime()->localeCallbacks;
         errorString = callbacks->localeGetErrorMessage(userRef, locale, errorNumber);
     }
     if (!errorString)
         errorString = js_GetErrorMessage(userRef, locale, errorNumber);
     return errorString;
 }
 JS_FRIEND_API(const jschar*)
 js::GetErrorTypeName(JSRuntime* rt, int16_t exnType)
 {
     /*
      * JSEXN_INTERNALERR returns null to prevent that "InternalError: "
      * is prepended before "uncaught exception: "
      */
     if (exnType <= JSEXN_NONE || exnType >= JSEXN_LIMIT ||
         exnType == JSEXN_INTERNALERR)
     {
         return nullptr;
     }
     JSProtoKey key = GetExceptionProtoKey(JSExnType(exnType));
     return ClassName(key, rt)->chars();
 }
 bool
 js_ErrorToException(JSContext *cx, const char *message, JSErrorReport *reportp,
                     JSErrorCallback callback, void *userRef)
 {
     // Tell our caller to report immediately if this report is just a warning.
     JS_ASSERT(reportp);
     if (JSREPORT_IS_WARNING(reportp->flags))
         return false;
     // Find the exception index associated with this error.
     JSErrNum errorNumber = static_cast<JSErrNum>(reportp->errorNumber);
     const JSErrorFormatString *errorString;
     if (!callback || callback == js_GetErrorMessage)
         errorString = js_GetLocalizedErrorMessage(cx, nullptr, nullptr, errorNumber);
     else
         errorString = callback(userRef, nullptr, errorNumber);
     JSExnType exnType = errorString ? static_cast<JSExnType>(errorString->exnType) : JSEXN_NONE;
     MOZ_ASSERT(exnType < JSEXN_LIMIT);
     // Return false (no exception raised) if no exception is associated
     // with the given error number.
     if (exnType == JSEXN_NONE)
         return false;
     // Prevent infinite recursion.
     if (cx->generatingError)
         return false;
     AutoScopedAssign<bool> asa(&cx->generatingError, true);
     // Create an exception object.
     RootedString messageStr(cx, reportp->ucmessage ? JS_NewUCStringCopyZ(cx, reportp->ucmessage)
                                                    : JS_NewStringCopyZ(cx, message));
     if (!messageStr)
         return cx->isExceptionPending();
     RootedString fileName(cx, JS_NewStringCopyZ(cx, reportp->filename));
     if (!fileName)
         return cx->isExceptionPending();
     uint32_t lineNumber = reportp->lineno;
     uint32_t columnNumber = reportp->column;
     RootedString stack(cx, ComputeStackString(cx));
     if (!stack)
         return cx->isExceptionPending();
     js::ScopedJSFreePtr<JSErrorReport> report(CopyErrorReport(cx, reportp));
     if (!report)
         return cx->isExceptionPending();
     RootedObject errObject(cx, ErrorObject::create(cx, exnType, stack, fileName,
                                                    lineNumber, columnNumber, &report, messageStr));
     if (!errObject)
         return cx->isExceptionPending();
     // Throw it.
     RootedValue errValue(cx, ObjectValue(*errObject));
     JS_SetPendingException(cx, errValue);
     // Flag the error report passed in to indicate an exception was raised.
     reportp->flags |= JSREPORT_EXCEPTION;
     return true;
 }
 static bool
 IsDuckTypedErrorObject(JSContext *cx, HandleObject exnObject, const char **filename_strp)
 {
     bool found;
     if (!JS_HasProperty(cx, exnObject, js_message_str, &found) || !found)
         return false;
     const char *filename_str = *filename_strp;
     if (!JS_HasProperty(cx, exnObject, filename_str, &found) || !found) {
         /* DOMException duck quacks "filename" (all lowercase) */
         filename_str = "filename";
         if (!JS_HasProperty(cx, exnObject, filename_str, &found) || !found)
             return false;
     }
     if (!JS_HasProperty(cx, exnObject, js_lineNumber_str, &found) || !found)
         return false;
     *filename_strp = filename_str;
     return true;
 }
 JS_FRIEND_API(JSString *)
 js::ErrorReportToString(JSContext *cx, JSErrorReport *reportp)
 {
     JSExnType type = static_cast<JSExnType>(reportp->exnType);
     RootedString str(cx, cx->runtime()->emptyString);
     if (type != JSEXN_NONE)
         str = ClassName(GetExceptionProtoKey(type), cx);
     RootedString toAppend(cx, JS_NewUCStringCopyN(cx, MOZ_UTF16(": "), 2));
     if (!str || !toAppend)
         return nullptr;
     str = ConcatStrings<CanGC>(cx, str, toAppend);
     if (!str)
         return nullptr;
     toAppend = JS_NewUCStringCopyZ(cx, reportp->ucmessage);
     if (toAppend)
         str = ConcatStrings<CanGC>(cx, str, toAppend);
     return str;
 }
 bool
 js_ReportUncaughtException(JSContext *cx)
 {
     if (!cx->isExceptionPending())
         return true;
     RootedValue exn(cx);
     if (!cx->getPendingException(&exn))
         return false;
     /*
      * Because ToString below could error and an exception object could become
      * unrooted, we must root exnObject.  Later, if exnObject is non-null, we
      * need to root other intermediates, so allocate an operand stack segment
      * to protect all of these values.
      */
     RootedObject exnObject(cx);
     if (JSVAL_IS_PRIMITIVE(exn)) {
         exnObject = nullptr;
     } else {
         exnObject = JSVAL_TO_OBJECT(exn);
     }
     JS_ClearPendingException(cx);
     JSErrorReport *reportp = exnObject ? js_ErrorFromException(cx, exnObject)
                                        : nullptr;
     // Be careful not to invoke ToString if we've already successfully extracted
     // an error report, since the exception might be wrapped in a security
     // wrapper, and ToString-ing it might throw.
     RootedString str(cx);
     if (reportp)
         str = ErrorReportToString(cx, reportp);
     else
         str = ToString<CanGC>(cx, exn);
     JSErrorReport report;
     // If js_ErrorFromException didn't get us a JSErrorReport, then the object
     // was not an ErrorObject, security-wrapped or otherwise. However, it might
     // still quack like one. Give duck-typing a chance.
     const char *filename_str = js_fileName_str;
     JSAutoByteString filename;
     if (!reportp && exnObject && IsDuckTypedErrorObject(cx, exnObject, &filename_str))
     {
         // Temporary value for pulling properties off of duck-typed objects.
         RootedValue val(cx);
         RootedString name(cx);
         if (JS_GetProperty(cx, exnObject, js_name_str, &val) && val.isString())
             name = val.toString();
         RootedString msg(cx);
         if (JS_GetProperty(cx, exnObject, js_message_str, &val) && val.isString())
             msg = val.toString();
         // If we have the right fields, override the ToString we performed on
         // the exception object above with something built out of its quacks
         // (i.e. as much of |NameQuack: MessageQuack| as we can make).
         //
         // It would be nice to use ErrorReportToString here, but we can't quite
         // do it - mostly because we'd need to figure out what JSExnType |name|
         // corresponds to, which may not be any JSExnType at all.
         if (name && msg) {
             RootedString colon(cx, JS_NewStringCopyZ(cx, ": "));
             if (!colon)
                 return false;
             RootedString nameColon(cx, ConcatStrings<CanGC>(cx, name, colon));
             if (!nameColon)
                 return false;
             str = ConcatStrings<CanGC>(cx, nameColon, msg);
             if (!str)
                 return false;
         } else if (name) {
             str = name;
         } else if (msg) {
             str = msg;
         }
         if (JS_GetProperty(cx, exnObject, filename_str, &val)) {
             JSString *tmp = ToString<CanGC>(cx, val);
             if (tmp)
                 filename.encodeLatin1(cx, tmp);
         }
         uint32_t lineno;
         if (!JS_GetProperty(cx, exnObject, js_lineNumber_str, &val) ||
             !ToUint32(cx, val, &lineno))
         {
             lineno = 0;
         }
         uint32_t column;
         if (!JS_GetProperty(cx, exnObject, js_columnNumber_str, &val) ||
             !ToUint32(cx, val, &column))
         {
             column = 0;
         }
         reportp = &report;
         PodZero(&report);
         report.filename = filename.ptr();
         report.lineno = (unsigned) lineno;
         report.exnType = int16_t(JSEXN_NONE);
         report.column = (unsigned) column;
         if (str) {
             // Note that using |str| for |ucmessage| here is kind of wrong,
             // because |str| is supposed to be of the format
             // |ErrorName: ErrorMessage|, and |ucmessage| is supposed to
             // correspond to |ErrorMessage|. But this is what we've historically
             // done for duck-typed error objects.
             //
             // If only this stuff could get specced one day...
             if (JSFlatString *flat = str->ensureFlat(cx))
                 report.ucmessage = flat->chars();
         }
     }
     JSAutoByteString bytesStorage;
     const char *bytes = nullptr;
     if (str)
         bytes = bytesStorage.encodeLatin1(cx, str);
     if (!bytes)
         bytes = "unknown (can't convert to string)";
     if (!reportp) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr,
                              JSMSG_UNCAUGHT_EXCEPTION, bytes);
     } else {
         /* Flag the error as an exception. */
         reportp->flags |= JSREPORT_EXCEPTION;
         /* Pass the exception object. */
         JS_SetPendingException(cx, exn);
         CallErrorReporter(cx, bytes, reportp);
     }
     JS_ClearPendingException(cx);
     return true;
 }
 JSObject *
 js_CopyErrorObject(JSContext *cx, Handle<ErrorObject*> err, HandleObject scope)
 {
     assertSameCompartment(cx, scope);
     js::ScopedJSFreePtr<JSErrorReport> copyReport;
     if (JSErrorReport *errorReport = err->getErrorReport()) {
         copyReport = CopyErrorReport(cx, errorReport);
         if (!copyReport)
             return nullptr;
     }
     RootedString message(cx, err->getMessage());
     if (message && !cx->compartment()->wrap(cx, message.address()))
         return nullptr;
     RootedString fileName(cx, err->fileName(cx));
     if (!cx->compartment()->wrap(cx, fileName.address()))
         return nullptr;
     RootedString stack(cx, err->stack(cx));
     if (!cx->compartment()->wrap(cx, stack.address()))
         return nullptr;
     uint32_t lineNumber = err->lineNumber();
     uint32_t columnNumber = err->columnNumber();
     JSExnType errorType = err->type();
     // Create the Error object.
     return ErrorObject::create(cx, errorType, stack, fileName,
                                lineNumber, columnNumber, &copyReport, message);
 }
 JS_PUBLIC_API(bool)
 JS::CreateTypeError(JSContext *cx, HandleString stack, HandleString fileName,
                     uint32_t lineNumber, uint32_t columnNumber, JSErrorReport *report,
                     HandleString message, MutableHandleValue rval)
 {
     assertSameCompartment(cx, stack, fileName, message);
     js::ScopedJSFreePtr<JSErrorReport> rep;
     if (report)
         rep = CopyErrorReport(cx, report);
     RootedObject obj(cx,
         js::ErrorObject::create(cx, JSEXN_TYPEERR, stack, fileName,
                                 lineNumber, columnNumber, &rep, message));
     if (!obj)
         return false;
     rval.setObject(*obj);
     return true;
 }

The Tor Browser / annotate

js/src/jsexn.cpp@129ffea94266 (annotated)

js/src/jsexn.cpp