--- libraries/source/spidermonkey/FixBug1021171.diff 1970-01-01 01:00:00.000000000 +0100 +++ libraries/source/spidermonkey/FixBug1021171.diff 2015-05-25 01:23:08.000000000 +0200 @@ -0,0 +1,245 @@ +# Based on +# HG changeset patch +# User Trevor Saunders +# Date 1402083090 14400 +# Node ID fc756706366d983e5d70345cab419fbf72db3d36 +# Parent 78c20dbe259e808fb58d65731efd4f05e8921820 +bug 1021171 - don't return nulllptr in functions returning bool r=bz,waldo + +diff --git a/js/src/builtin/TypedObject.cpp b/js/src/builtin/TypedObject.cpp +--- a/js/src/builtin/TypedObject.cpp ++++ b/js/src/builtin/TypedObject.cpp +@@ -705,35 +705,35 @@ ArrayMetaTypeDescr::construct(JSContext + + // Construct a canonical string `new ArrayType()`: + StringBuffer contents(cx); + contents.append("new ArrayType("); + contents.append(&elementType->stringRepr()); + contents.append(")"); + RootedAtom stringRepr(cx, contents.finishAtom()); + if (!stringRepr) +- return nullptr; ++ return false; + + // Extract ArrayType.prototype + RootedObject arrayTypePrototype(cx, GetPrototype(cx, arrayTypeGlobal)); + if (!arrayTypePrototype) +- return nullptr; ++ return false; + + // Create the instance of ArrayType + Rooted obj(cx); + obj = create(cx, arrayTypePrototype, elementType, + stringRepr, 0); + if (!obj) + return false; + + // Add `length` property, which is undefined for an unsized array. + if (!JSObject::defineProperty(cx, obj, cx->names().length, + UndefinedHandleValue, nullptr, nullptr, + JSPROP_READONLY | JSPROP_PERMANENT)) +- return nullptr; ++ return false; + + args.rval().setObject(*obj); + return true; + } + + /*static*/ bool + UnsizedArrayTypeDescr::dimension(JSContext *cx, unsigned int argc, jsval *vp) + { +@@ -757,30 +757,30 @@ UnsizedArrayTypeDescr::dimension(JSConte + int32_t length = args[0].toInt32(); + Rooted elementType(cx, &unsizedTypeDescr->elementType()); + + // Compute the size. + CheckedInt32 size = CheckedInt32(elementType->size()) * length; + if (!size.isValid()) { + JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, + JSMSG_TYPEDOBJECT_TOO_BIG); +- return nullptr; ++ return false; + } + + // Construct a canonical string `new ArrayType().dimension(N)`: + StringBuffer contents(cx); + contents.append("new ArrayType("); + contents.append(&elementType->stringRepr()); + contents.append(").dimension("); + if (!NumberValueToStringBuffer(cx, NumberValue(length), contents)) + return false; + contents.append(")"); + RootedAtom stringRepr(cx, contents.finishAtom()); + if (!stringRepr) +- return nullptr; ++ return false; + + // Create the sized type object. + Rooted obj(cx); + obj = ArrayMetaTypeDescr::create(cx, unsizedTypeDescr, + elementType, + stringRepr, size.value()); + if (!obj) + return false; +@@ -788,25 +788,25 @@ UnsizedArrayTypeDescr::dimension(JSConte + obj->initReservedSlot(JS_DESCR_SLOT_SIZED_ARRAY_LENGTH, + Int32Value(length)); + + // Add `length` property. + RootedValue lengthVal(cx, Int32Value(length)); + if (!JSObject::defineProperty(cx, obj, cx->names().length, + lengthVal, nullptr, nullptr, + JSPROP_READONLY | JSPROP_PERMANENT)) +- return nullptr; ++ return false; + + // Add `unsized` property, which is a link from the sized + // array to the unsized array. + RootedValue unsizedTypeDescrValue(cx, ObjectValue(*unsizedTypeDescr)); + if (!JSObject::defineProperty(cx, obj, cx->names().unsized, + unsizedTypeDescrValue, nullptr, nullptr, + JSPROP_READONLY | JSPROP_PERMANENT)) +- return nullptr; ++ return false; + + args.rval().setObject(*obj); + return true; + } + + bool + js::IsTypedObjectArray(JSObject &obj) + { +@@ -1248,17 +1248,17 @@ DefineSimpleTypeDescr(JSContext *cx, + if (!JS_DefineFunctions(cx, descr, T::typeObjectMethods)) + return false; + + // Create the typed prototype for the scalar type. This winds up + // not being user accessible, but we still create one for consistency. + Rooted proto(cx); + proto = NewObjectWithProto(cx, objProto, nullptr, TenuredObject); + if (!proto) +- return nullptr; ++ return false; + proto->initTypeDescrSlot(*descr); + descr->initReservedSlot(JS_DESCR_SLOT_TYPROTO, ObjectValue(*proto)); + + RootedValue descrValue(cx, ObjectValue(*descr)); + if (!JSObject::defineProperty(cx, module, className, + descrValue, nullptr, nullptr, 0)) + { + return false; +@@ -1353,66 +1353,66 @@ GlobalObject::initTypedObjectModule(JSCo + if (!JS_DefineFunctions(cx, module, TypedObjectMethods)) + return false; + + // uint8, uint16, any, etc + + #define BINARYDATA_SCALAR_DEFINE(constant_, type_, name_) \ + if (!DefineSimpleTypeDescr(cx, global, module, constant_, \ + cx->names().name_)) \ +- return nullptr; ++ return false; + JS_FOR_EACH_SCALAR_TYPE_REPR(BINARYDATA_SCALAR_DEFINE) + #undef BINARYDATA_SCALAR_DEFINE + + #define BINARYDATA_REFERENCE_DEFINE(constant_, type_, name_) \ + if (!DefineSimpleTypeDescr(cx, global, module, constant_, \ + cx->names().name_)) \ +- return nullptr; ++ return false; + JS_FOR_EACH_REFERENCE_TYPE_REPR(BINARYDATA_REFERENCE_DEFINE) + #undef BINARYDATA_REFERENCE_DEFINE + + // ArrayType. + + RootedObject arrayType(cx); + arrayType = DefineMetaTypeDescr( + cx, global, module, TypedObjectModuleObject::ArrayTypePrototype); + if (!arrayType) +- return nullptr; ++ return false; + + RootedValue arrayTypeValue(cx, ObjectValue(*arrayType)); + if (!JSObject::defineProperty(cx, module, cx->names().ArrayType, + arrayTypeValue, + nullptr, nullptr, + JSPROP_READONLY | JSPROP_PERMANENT)) +- return nullptr; ++ return false; + + // StructType. + + RootedObject structType(cx); + structType = DefineMetaTypeDescr( + cx, global, module, TypedObjectModuleObject::StructTypePrototype); + if (!structType) +- return nullptr; ++ return false; + + RootedValue structTypeValue(cx, ObjectValue(*structType)); + if (!JSObject::defineProperty(cx, module, cx->names().StructType, + structTypeValue, + nullptr, nullptr, + JSPROP_READONLY | JSPROP_PERMANENT)) +- return nullptr; ++ return false; + + // Everything is setup, install module on the global object: + RootedValue moduleValue(cx, ObjectValue(*module)); + global->setConstructor(JSProto_TypedObject, moduleValue); + if (!JSObject::defineProperty(cx, global, cx->names().TypedObject, + moduleValue, + nullptr, nullptr, + 0)) + { +- return nullptr; ++ return false; + } + + return module; + } + + JSObject * + js_InitTypedObjectModuleObject(JSContext *cx, HandleObject obj) + { +@@ -2444,17 +2444,17 @@ TypedObject::constructUnsized(JSContext + } + + // Length constructor. + if (args[0].isInt32()) { + int32_t length = args[0].toInt32(); + if (length < 0) { + JS_ReportErrorNumber(cx, js_GetErrorMessage, + nullptr, JSMSG_TYPEDOBJECT_BAD_ARGS); +- return nullptr; ++ return false; + } + Rooted obj(cx, createZeroed(cx, callee, length)); + if (!obj) + return false; + args.rval().setObject(*obj); + return true; + } + +diff --git a/js/src/frontend/BytecodeCompiler.cpp b/js/src/frontend/BytecodeCompiler.cpp +--- a/js/src/frontend/BytecodeCompiler.cpp ++++ b/js/src/frontend/BytecodeCompiler.cpp +@@ -539,17 +539,17 @@ CompileFunctionBody(JSContext *cx, Mutab + + MaybeCallSourceHandler(cx, options, srcBuf); + + if (!CheckLength(cx, srcBuf)) + return false; + + RootedScriptSource sourceObject(cx, CreateScriptSourceObject(cx, options)); + if (!sourceObject) +- return nullptr; ++ return false; + ScriptSource *ss = sourceObject->source(); + + SourceCompressionTask sct(cx); + JS_ASSERT(!options.sourceIsLazy); + if (!cx->compartment()->options().discardSource()) { + if (!ss->setSourceCopy(cx, srcBuf, true, &sct)) + return false; + }