NS_IMETHODIMP
nsBinaryInputStream::ReadArrayBuffer(uint32_t aLength, JS::Handle<JS::Value> aBuffer, JSContext* cx)
{
if (!aBuffer.isObject()) {
return NS_ERROR_FAILURE;
}
JS::RootedObject buffer(cx, &aBuffer.toObject());
if (!JS_IsArrayBufferObject(buffer) ||
JS_GetArrayBufferByteLength(buffer) < aLength) {
return NS_ERROR_FAILURE;
}
uint8_t* data = JS_GetStableArrayBufferData(cx, buffer);
if (!data) {
return NS_ERROR_FAILURE;
}
uint32_t bytesRead;
nsresult rv = Read(reinterpret_cast<char*>(data), aLength, &bytesRead);
if (NS_WARN_IF(NS_FAILED(rv)))
return rv;
if (bytesRead != aLength) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
NS_IMETHODIMP
ArrayBufferInputStream::SetData(JS::Handle<JS::Value> aBuffer,
uint32_t aByteOffset,
uint32_t aLength,
JSContext* aCx)
{
if (!aBuffer.isObject()) {
return NS_ERROR_FAILURE;
}
JS::RootedObject arrayBuffer(aCx, &aBuffer.toObject());
if (!JS_IsArrayBufferObject(arrayBuffer)) {
return NS_ERROR_FAILURE;
}
mArrayBuffer.construct(aCx, aBuffer);
uint32_t buflen = JS_GetArrayBufferByteLength(arrayBuffer);
mOffset = std::min(buflen, aByteOffset);
mBufferLength = std::min(buflen - mOffset, aLength);
mBuffer = JS_GetStableArrayBufferData(aCx, arrayBuffer);
if (!mBuffer) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
JSBool js_cocos2dx_extension_WebSocket_send(JSContext *cx, uint32_t argc, jsval *vp)
{
jsval *argv = JS_ARGV(cx, vp);
JSObject *obj = JS_THIS_OBJECT(cx, vp);
js_proxy_t *proxy = jsb_get_js_proxy(obj);
WebSocket* cobj = (WebSocket *)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( cobj, cx, JS_FALSE, "Invalid Native Object");
if(argc == 1){
do
{
if (JSVAL_IS_STRING(argv[0]))
{
std::string data;
jsval_to_std_string(cx, argv[0], &data);
cobj->send(data);
break;
}
if (argv[0].isObject())
{
uint8_t *bufdata = NULL;
uint32_t len = 0;
JSObject* jsobj = JSVAL_TO_OBJECT(argv[0]);
if (JS_IsArrayBufferObject(jsobj))
{
bufdata = JS_GetArrayBufferData(jsobj);
len = JS_GetArrayBufferByteLength(jsobj);
}
else if (JS_IsArrayBufferViewObject(jsobj))
{
bufdata = (uint8_t*)JS_GetArrayBufferViewData(jsobj);
len = JS_GetArrayBufferViewByteLength(jsobj);
}
if (bufdata && len > 0)
{
cobj->send(bufdata, len);
break;
}
}
JS_ReportError(cx, "data type to be sent is unsupported.");
} while (0);
JS_SET_RVAL(cx, vp, JSVAL_VOID);
return JS_TRUE;
}
JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
return JS_TRUE;
}
// convert buffer to json
bool js_FlatUtil_flat2js(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
if (4 == argc) {
std::string arg0;
ok &= jsval_to_std_string(cx, args.get(0), &arg0);
JSB_PRECONDITION2(ok, cx, false, "js_FlatUtil_flat2js : Error processing arguments");
cocos2d::Data arg1;
uint8_t *bufdata = NULL;
uint32_t len = 0;
JSObject* jsobj = args.get(1).toObjectOrNull();
if (JS_IsArrayBufferObject(jsobj))
{
bufdata = JS_GetArrayBufferData(jsobj);
len = JS_GetArrayBufferByteLength(jsobj);
}
else if (JS_IsArrayBufferViewObject(jsobj))
{
bufdata = (uint8_t*)JS_GetArrayBufferViewData(jsobj);
len = JS_GetArrayBufferViewByteLength(jsobj);
}
JSB_PRECONDITION2(bufdata && len > 0, cx, false, "js_FlatUtil_flat2js : Error processing arguments");
arg1.copy(bufdata, len);
std::string arg2;
ok &= jsval_to_std_string(cx, args.get(2), &arg2);
JSB_PRECONDITION2(ok, cx, false, "js_FlatUtil_flat2js : Error processing arguments");
bool arg3;
arg3 = JS::ToBoolean(args.get(3));
auto ret = FlatUtil::flat2js(arg0, arg1, arg2, arg3);
jsval jsret = JSVAL_NULL;
jsret = std_string_to_jsval(cx, ret);
args.rval().set(jsret);
return true;
}
JS_ReportError(cx, "js_FlatUtil_flat2js : wrong number of arguments");
return false;
}
bool VerifyObject(JS::HandleObject obj, uint32_t offset, uint32_t length, const bool mapped)
{
JS::AutoCheckCannotGC nogc;
CHECK(obj);
CHECK(JS_IsArrayBufferObject(obj));
CHECK_EQUAL(JS_GetArrayBufferByteLength(obj), length);
if (mapped)
CHECK(JS_IsMappedArrayBufferObject(obj));
else
CHECK(!JS_IsMappedArrayBufferObject(obj));
bool sharedDummy;
const char* data =
reinterpret_cast<const char*>(JS_GetArrayBufferData(obj, &sharedDummy, nogc));
CHECK(data);
CHECK(memcmp(data, test_data + offset, length) == 0);
return true;
}
/* [implicit_jscontext] uint32_t getAlignmentOffset (in jsval source); */
NS_IMETHODIMP dpoCContext::GetAlignmentOffset(const JS::Value & source, JSContext* cx, uint32_t *_retval)
{
JSObject *object;
uint8_t *data;
if (JSVAL_IS_PRIMITIVE(source)) {
return NS_ERROR_INVALID_ARG;
}
object = JSVAL_TO_OBJECT(source);
if (JS_IsTypedArrayObject(object)) {
data = GetPointerFromTA(object, cx);
} else if (JS_IsArrayBufferObject(object)) {
data = JS_GetArrayBufferData(object);
} else {
return NS_ERROR_INVALID_ARG;
}
*_retval = (((uintptr_t) data) + alignment_size) / alignment_size * alignment_size - ((uintptr_t) data);
return NS_OK;
}
NS_IMETHODIMP
ArrayBufferInputStream::SetData(const JS::Value& aBuffer,
uint32_t aByteOffset,
uint32_t aLength,
JSContext* aCx)
{
if (!aBuffer.isObject()) {
return NS_ERROR_FAILURE;
}
JS::RootedObject arrayBuffer(aCx, &aBuffer.toObject());
if (!JS_IsArrayBufferObject(arrayBuffer)) {
return NS_ERROR_FAILURE;
}
mRt = JS_GetRuntime(aCx);
mArrayBuffer = aBuffer;
JS_AddNamedValueRootRT(mRt, &mArrayBuffer, "mArrayBuffer");
uint32_t buflen = JS_GetArrayBufferByteLength(arrayBuffer);
mOffset = std::min(buflen, aByteOffset);
mBufferLength = std::min(buflen - mOffset, aLength);
mBuffer = JS_GetArrayBufferData(arrayBuffer);
return NS_OK;
}
NS_IMETHODIMP
TCPSocketParent::SendEvent(const nsAString& aType, JS::Handle<JS::Value> aDataVal,
const nsAString& aReadyState, JSContext* aCx)
{
if (!mIPCOpen) {
NS_WARNING("Dropping callback due to no IPC connection");
return NS_OK;
}
CallbackData data;
if (aDataVal.isString()) {
JSString* jsstr = aDataVal.toString();
nsAutoJSString str;
if (!str.init(aCx, jsstr)) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
data = SendableData(str);
} else if (aDataVal.isUndefined() || aDataVal.isNull()) {
data = mozilla::void_t();
} else if (aDataVal.isObject()) {
JS::Rooted<JSObject *> obj(aCx, &aDataVal.toObject());
if (JS_IsArrayBufferObject(obj)) {
FallibleTArray<uint8_t> fallibleArr;
uint32_t errLine = 0;
do {
JS::AutoCheckCannotGC nogc;
uint32_t nbytes = JS_GetArrayBufferByteLength(obj);
uint8_t* buffer = JS_GetArrayBufferData(obj, nogc);
if (!buffer) {
errLine = __LINE__;
break;
}
if (!fallibleArr.InsertElementsAt(0, buffer, nbytes, fallible)) {
errLine = __LINE__;
break;
}
} while (false);
if (errLine) {
FireInteralError(this, errLine);
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> arr;
arr.SwapElements(fallibleArr);
data = SendableData(arr);
} else {
nsAutoJSString name;
JS::Rooted<JS::Value> val(aCx);
if (!JS_GetProperty(aCx, obj, "name", &val)) {
NS_ERROR("No name property on supposed error object");
} else if (val.isString()) {
if (!name.init(aCx, val.toString())) {
NS_WARNING("couldn't initialize string");
}
}
data = TCPError(name);
}
} else {
NS_ERROR("Unexpected JS value encountered");
FireInteralError(this, __LINE__);
return NS_ERROR_FAILURE;
}
mozilla::unused <<
PTCPSocketParent::SendCallback(nsString(aType), data,
nsString(aReadyState));
return NS_OK;
}
NS_IMETHODIMP
TCPSocketParent::SendCallback(const nsAString& aType, const JS::Value& aDataVal,
const nsAString& aReadyState, uint32_t aBuffered,
JSContext* aCx)
{
if (!mIPCOpen) {
NS_WARNING("Dropping callback due to no IPC connection");
return NS_OK;
}
CallbackData data;
if (aDataVal.isString()) {
JSString* jsstr = aDataVal.toString();
nsDependentJSString str;
if (!str.init(aCx, jsstr)) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
data = SendableData(str);
} else if (aDataVal.isUndefined() || aDataVal.isNull()) {
data = mozilla::void_t();
} else if (aDataVal.isObject()) {
JSObject* obj = &aDataVal.toObject();
if (JS_IsArrayBufferObject(obj)) {
uint32_t nbytes = JS_GetArrayBufferByteLength(obj);
uint8_t* buffer = JS_GetArrayBufferData(obj);
if (!buffer) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
FallibleTArray<uint8_t> fallibleArr;
if (!fallibleArr.InsertElementsAt(0, buffer, nbytes)) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> arr;
arr.SwapElements(fallibleArr);
data = SendableData(arr);
} else {
nsDependentJSString name;
JS::Rooted<JS::Value> val(aCx);
if (!JS_GetProperty(aCx, obj, "name", val.address())) {
NS_ERROR("No name property on supposed error object");
} else if (JSVAL_IS_STRING(val)) {
if (!name.init(aCx, JSVAL_TO_STRING(val))) {
NS_WARNING("couldn't initialize string");
}
}
data = TCPError(name);
}
} else {
NS_ERROR("Unexpected JS value encountered");
FireInteralError(this, __LINE__);
return NS_ERROR_FAILURE;
}
mozilla::unused <<
PTCPSocketParent::SendCallback(nsString(aType), data,
nsString(aReadyState), aBuffered);
return NS_OK;
}
bool AppDelegate::applicationDidFinishLaunching()
{
// initialize director
auto director = Director::getInstance();
auto glview = director->getOpenGLView();
if(!glview) {
#if(CC_TARGET_PLATFORM == CC_PLATFORM_WP8) || (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
glview = cocos2d::GLViewImpl::create("CocosProtobuf");
#else
glview = cocos2d::GLViewImpl::createWithRect("CocosProtobuf", Rect(0,0,960,640));
#endif
director->setOpenGLView(glview);
}
// set FPS. the default value is 1.0/60 if you don't call this
director->setAnimationInterval(1.0 / 60);
ScriptingCore* sc = ScriptingCore::getInstance();
sc->addRegisterCallback(register_all_cocos2dx);
sc->addRegisterCallback(register_cocos2dx_js_core);
sc->start();
sc->runScript("script/jsb_boot.js");
ScriptEngineProtocol *engine = ScriptingCore::getInstance();
ScriptEngineManager::getInstance()->setScriptEngine(engine);
ScriptingCore::getInstance()->runScript("main.js");
// test send protobuf message from C++
JSObject* pGlobalObject = ScriptingCore::getInstance()->getGlobalObject();
JSContext* pGlobalContext = ScriptingCore::getInstance()->getGlobalContext();
// Create a GameInfo object first
game::info::GameInfo gameInfo;
// add RoleInfo object to repeated field
game::info::RoleInfo *pRoleInfo1 = gameInfo.add_roleinfo();
pRoleInfo1->set_name("cpp_name1");
pRoleInfo1->set_type(game::enumeration::FIGHTER);
// add another RoleInfo object to repeated field
game::info::RoleInfo *pRoleInfo2 = gameInfo.add_roleinfo();
pRoleInfo2->set_name("cpp_name2");
pRoleInfo2->set_type(game::enumeration::BOWMAN);
// add ItemInfo object to repeated field
game::info::ItemInfo *pItemInfo1 = gameInfo.add_iteminfo();
pItemInfo1->set_name("cpp_item1");
pItemInfo1->set_price(100);
// add another ItemInfo object to repeated field
game::info::ItemInfo *pItemInfo2 = gameInfo.add_iteminfo();
pItemInfo2->set_name("cpp_item2");
pItemInfo2->set_price(200);
std::string gameInfoString;
gameInfo.SerializeToString(&gameInfoString);
// need this before JS_NewArrayBuffer
JSAutoCompartment ac(pGlobalContext, pGlobalObject);
int length = gameInfoString.length();
JSObject* pMessageJSObject = JS_NewArrayBuffer(pGlobalContext, length);
uint8_t* pMessageData = JS_GetArrayBufferData(pMessageJSObject);
memcpy((void*)pMessageData, (const void*)gameInfoString.c_str(), gameInfoString.length());
JS::RootedValue ret(pGlobalContext);
jsval arg = OBJECT_TO_JSVAL(pMessageJSObject);
ScriptingCore::getInstance()->executeFunctionWithOwner(OBJECT_TO_JSVAL(pGlobalObject), "test_protobuf", 1, &arg, &ret);
//
game::info::GameInfo* pGameInfo = new game::info::GameInfo;
JSObject* pRetJSObject = ret.toObjectOrNull();
if(pRetJSObject && JS_IsArrayBufferObject(pRetJSObject)) {
uint8_t* pDataBuffer = nullptr;
int dataBufferCount = 0;
pDataBuffer = JS_GetArrayBufferData(pRetJSObject);
dataBufferCount = JS_GetArrayBufferByteLength(pRetJSObject);
pGameInfo->ParseFromArray(pDataBuffer, dataBufferCount);
// RoleInfo Array
for (int i = 0; i < pGameInfo->roleinfo_size(); i++) {
// role info
game::info::RoleInfo roleInfo = pGameInfo->roleinfo(i);
CCLOG("roleInfo: \n%s\n", roleInfo.Utf8DebugString().c_str());
}
// ItemInfo Array
for (int i = 0; i < pGameInfo->iteminfo_size(); i++) {
// role info
game::info::ItemInfo itemInfo = pGameInfo->iteminfo(i);
CCLOG("itemInfo: \n%s\n", itemInfo.Utf8DebugString().c_str());
}
}
return true;
}
void CBinarySerializerScriptImpl::HandleScriptVal(JS::HandleValue val)
{
JSContext* cx = m_ScriptInterface.GetContext();
JSAutoRequest rq(cx);
switch (JS_TypeOfValue(cx, val))
{
case JSTYPE_VOID:
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_VOID);
break;
}
case JSTYPE_NULL: // This type is never actually returned (it's a JS2 feature)
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_NULL);
break;
}
case JSTYPE_OBJECT:
{
if (val.isNull())
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_NULL);
break;
}
JS::RootedObject obj(cx, &val.toObject());
// If we've already serialized this object, just output a reference to it
u32 tag = GetScriptBackrefTag(obj);
if (tag)
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_BACKREF);
m_Serializer.NumberU32_Unbounded("tag", tag);
break;
}
// Arrays are special cases of Object
if (JS_IsArrayObject(cx, obj))
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_ARRAY);
// TODO: probably should have a more efficient storage format
// Arrays like [1, 2, ] have an 'undefined' at the end which is part of the
// length but seemingly isn't enumerated, so store the length explicitly
uint length = 0;
if (!JS_GetArrayLength(cx, obj, &length))
throw PSERROR_Serialize_ScriptError("JS_GetArrayLength failed");
m_Serializer.NumberU32_Unbounded("array length", length);
}
else if (JS_IsTypedArrayObject(obj))
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_TYPED_ARRAY);
m_Serializer.NumberU8_Unbounded("array type", GetArrayType(JS_GetArrayBufferViewType(obj)));
m_Serializer.NumberU32_Unbounded("byte offset", JS_GetTypedArrayByteOffset(obj));
m_Serializer.NumberU32_Unbounded("length", JS_GetTypedArrayLength(obj));
// Now handle its array buffer
// this may be a backref, since ArrayBuffers can be shared by multiple views
JS::RootedValue bufferVal(cx, JS::ObjectValue(*JS_GetArrayBufferViewBuffer(cx, obj)));
HandleScriptVal(bufferVal);
break;
}
else if (JS_IsArrayBufferObject(obj))
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_ARRAY_BUFFER);
#if BYTE_ORDER != LITTLE_ENDIAN
#error TODO: need to convert JS ArrayBuffer data to little-endian
#endif
u32 length = JS_GetArrayBufferByteLength(obj);
m_Serializer.NumberU32_Unbounded("buffer length", length);
JS::AutoCheckCannotGC nogc;
m_Serializer.RawBytes("buffer data", (const u8*)JS_GetArrayBufferData(obj, nogc), length);
break;
}
else
{
// Find type of object
const JSClass* jsclass = JS_GetClass(obj);
if (!jsclass)
throw PSERROR_Serialize_ScriptError("JS_GetClass failed");
// TODO: Remove this workaround for upstream API breakage when updating SpiderMonkey
// See https://bugzilla.mozilla.org/show_bug.cgi?id=1236373
#define JSCLASS_CACHED_PROTO_WIDTH js::JSCLASS_CACHED_PROTO_WIDTH
JSProtoKey protokey = JSCLASS_CACHED_PROTO_KEY(jsclass);
#undef JSCLASS_CACHED_PROTO_WIDTH
if (protokey == JSProto_Object)
{
// Object class - check for user-defined prototype
JS::RootedObject proto(cx);
JS_GetPrototype(cx, obj, &proto);
if (!proto)
throw PSERROR_Serialize_ScriptError("JS_GetPrototype failed");
if (m_SerializablePrototypes->empty() || !IsSerializablePrototype(proto))
{
// Standard Object prototype
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT);
// TODO: maybe we should throw an error for unrecognized non-Object prototypes?
// (requires fixing AI serialization first and excluding component scripts)
}
else
{
// User-defined custom prototype
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_PROTOTYPE);
const std::wstring prototypeName = GetPrototypeName(proto);
m_Serializer.String("proto name", prototypeName, 0, 256);
// Does it have custom Serialize function?
// if so, we serialize the data it returns, rather than the object's properties directly
bool hasCustomSerialize;
if (!JS_HasProperty(cx, obj, "Serialize", &hasCustomSerialize))
throw PSERROR_Serialize_ScriptError("JS_HasProperty failed");
if (hasCustomSerialize)
{
JS::RootedValue serialize(cx);
if (!JS_GetProperty(cx, obj, "Serialize", &serialize))
throw PSERROR_Serialize_ScriptError("JS_GetProperty failed");
// If serialize is null, so don't serialize anything more
if (!serialize.isNull())
{
JS::RootedValue data(cx);
if (!m_ScriptInterface.CallFunction(val, "Serialize", &data))
throw PSERROR_Serialize_ScriptError("Prototype Serialize function failed");
HandleScriptVal(data);
}
break;
}
}
}
else if (protokey == JSProto_Number)
{
// Standard Number object
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_NUMBER);
// Get primitive value
double d;
if (!JS::ToNumber(cx, val, &d))
throw PSERROR_Serialize_ScriptError("JS::ToNumber failed");
m_Serializer.NumberDouble_Unbounded("value", d);
break;
}
else if (protokey == JSProto_String)
{
// Standard String object
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_STRING);
// Get primitive value
JS::RootedString str(cx, JS::ToString(cx, val));
if (!str)
throw PSERROR_Serialize_ScriptError("JS_ValueToString failed");
ScriptString("value", str);
break;
}
else if (protokey == JSProto_Boolean)
{
// Standard Boolean object
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_BOOLEAN);
// Get primitive value
bool b = JS::ToBoolean(val);
m_Serializer.Bool("value", b);
break;
}
// TODO: Follow upstream progresses about a JS::IsMapObject
// https://bugzilla.mozilla.org/show_bug.cgi?id=1285909
else if (protokey == JSProto_Map)
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_MAP);
m_Serializer.NumberU32_Unbounded("map size", JS::MapSize(cx, obj));
JS::RootedValue keyValueIterator(cx);
if (!JS::MapEntries(cx, obj, &keyValueIterator))
throw PSERROR_Serialize_ScriptError("JS::MapEntries failed");
JS::ForOfIterator it(cx);
if (!it.init(keyValueIterator))
throw PSERROR_Serialize_ScriptError("JS::ForOfIterator::init failed");
JS::RootedValue keyValuePair(cx);
bool done;
while (true)
{
if (!it.next(&keyValuePair, &done))
throw PSERROR_Serialize_ScriptError("JS::ForOfIterator::next failed");
if (done)
break;
JS::RootedObject keyValuePairObj(cx, &keyValuePair.toObject());
JS::RootedValue key(cx);
JS::RootedValue value(cx);
ENSURE(JS_GetElement(cx, keyValuePairObj, 0, &key));
ENSURE(JS_GetElement(cx, keyValuePairObj, 1, &value));
HandleScriptVal(key);
HandleScriptVal(value);
}
break;
}
// TODO: Follow upstream progresses about a JS::IsSetObject
// https://bugzilla.mozilla.org/show_bug.cgi?id=1285909
else if (protokey == JSProto_Set)
{
// TODO: When updating SpiderMonkey to a release after 38 use the C++ API for Sets.
// https://bugzilla.mozilla.org/show_bug.cgi?id=1159469
u32 setSize;
m_ScriptInterface.GetProperty(val, "size", setSize);
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_SET);
m_Serializer.NumberU32_Unbounded("set size", setSize);
JS::RootedValue valueIterator(cx);
m_ScriptInterface.CallFunction(val, "values", &valueIterator);
for (u32 i=0; i<setSize; ++i)
{
JS::RootedValue currentIterator(cx);
JS::RootedValue value(cx);
ENSURE(m_ScriptInterface.CallFunction(valueIterator, "next", ¤tIterator));
m_ScriptInterface.GetProperty(currentIterator, "value", &value);
HandleScriptVal(value);
}
break;
}
else
{
// Unrecognized class
LOGERROR("Cannot serialise JS objects with unrecognized class '%s'", jsclass->name);
throw PSERROR_Serialize_InvalidScriptValue();
}
}
// Find all properties (ordered by insertion time)
JS::AutoIdArray ida (cx, JS_Enumerate(cx, obj));
if (!ida)
throw PSERROR_Serialize_ScriptError("JS_Enumerate failed");
m_Serializer.NumberU32_Unbounded("num props", (u32)ida.length());
for (size_t i = 0; i < ida.length(); ++i)
{
JS::RootedId id(cx, ida[i]);
JS::RootedValue idval(cx);
JS::RootedValue propval(cx);
// Forbid getters, which might delete values and mess things up.
JS::Rooted<JSPropertyDescriptor> desc(cx);
if (!JS_GetPropertyDescriptorById(cx, obj, id, &desc))
throw PSERROR_Serialize_ScriptError("JS_GetPropertyDescriptorById failed");
if (desc.hasGetterObject())
throw PSERROR_Serialize_ScriptError("Cannot serialize property getters");
// Get the property name as a string
if (!JS_IdToValue(cx, id, &idval))
throw PSERROR_Serialize_ScriptError("JS_IdToValue failed");
JS::RootedString idstr(cx, JS::ToString(cx, idval));
if (!idstr)
throw PSERROR_Serialize_ScriptError("JS_ValueToString failed");
ScriptString("prop name", idstr);
if (!JS_GetPropertyById(cx, obj, id, &propval))
throw PSERROR_Serialize_ScriptError("JS_GetPropertyById failed");
HandleScriptVal(propval);
}
break;
}
case JSTYPE_FUNCTION:
{
// We can't serialise functions, but we can at least name the offender (hopefully)
std::wstring funcname(L"(unnamed)");
JS::RootedFunction func(cx, JS_ValueToFunction(cx, val));
if (func)
{
JS::RootedString string(cx, JS_GetFunctionId(func));
if (string)
{
if (JS_StringHasLatin1Chars(string))
{
size_t length;
JS::AutoCheckCannotGC nogc;
const JS::Latin1Char* ch = JS_GetLatin1StringCharsAndLength(cx, nogc, string, &length);
if (ch && length > 0)
funcname.assign(ch, ch + length);
}
else
{
size_t length;
JS::AutoCheckCannotGC nogc;
const char16_t* ch = JS_GetTwoByteStringCharsAndLength(cx, nogc, string, &length);
if (ch && length > 0)
funcname.assign(ch, ch + length);
}
}
}
LOGERROR("Cannot serialise JS objects of type 'function': %s", utf8_from_wstring(funcname));
throw PSERROR_Serialize_InvalidScriptValue();
}
case JSTYPE_STRING:
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_STRING);
JS::RootedString stringVal(cx, val.toString());
ScriptString("string", stringVal);
break;
}
case JSTYPE_NUMBER:
{
// To reduce the size of the serialized data, we handle integers and doubles separately.
// We can't check for val.isInt32 and val.isDouble directly, because integer numbers are not guaranteed
// to be represented as integers. A number like 33 could be stored as integer on the computer of one player
// and as double on the other player's computer. That would cause out of sync errors in multiplayer games because
// their binary representation and thus the hash would be different.
double d;
d = val.toNumber();
i32 integer;
if (JS_DoubleIsInt32(d, &integer))
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_INT);
m_Serializer.NumberI32_Unbounded("value", integer);
}
else
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_DOUBLE);
m_Serializer.NumberDouble_Unbounded("value", d);
}
break;
}
case JSTYPE_BOOLEAN:
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_BOOLEAN);
bool b = val.toBoolean();
m_Serializer.NumberU8_Unbounded("value", b ? 1 : 0);
break;
}
default:
{
debug_warn(L"Invalid TypeOfValue");
throw PSERROR_Serialize_InvalidScriptValue();
}
}
}
jsval CStdDeserializer::ReadScriptVal(const char* UNUSED(name), JS::HandleObject appendParent)
{
JSContext* cx = m_ScriptInterface.GetContext();
JSAutoRequest rq(cx);
uint8_t type;
NumberU8_Unbounded("type", type);
switch (type)
{
case SCRIPT_TYPE_VOID:
return JS::UndefinedValue();
case SCRIPT_TYPE_NULL:
return JS::NullValue();
case SCRIPT_TYPE_ARRAY:
case SCRIPT_TYPE_OBJECT:
case SCRIPT_TYPE_OBJECT_PROTOTYPE:
{
JS::RootedObject obj(cx);
if (appendParent)
{
obj.set(appendParent);
}
else if (type == SCRIPT_TYPE_ARRAY)
{
u32 length;
NumberU32_Unbounded("array length", length);
obj.set(JS_NewArrayObject(cx, length));
}
else if (type == SCRIPT_TYPE_OBJECT)
{
obj.set(JS_NewPlainObject(cx));
}
else // SCRIPT_TYPE_OBJECT_PROTOTYPE
{
std::wstring prototypeName;
String("proto name", prototypeName, 0, 256);
// Get constructor object
JS::RootedObject proto(cx);
GetSerializablePrototype(prototypeName, &proto);
if (!proto)
throw PSERROR_Deserialize_ScriptError("Failed to find serializable prototype for object");
JS::RootedObject parent(cx, JS_GetParent(proto));
if (!proto || !parent)
throw PSERROR_Deserialize_ScriptError();
// TODO: Remove support for parent since this is dropped upstream SpiderMonkey
obj.set(JS_NewObjectWithGivenProto(cx, nullptr, proto, parent));
if (!obj)
throw PSERROR_Deserialize_ScriptError("JS_NewObject failed");
// Does it have custom Deserialize function?
// if so, we let it handle the deserialized data, rather than adding properties directly
bool hasCustomDeserialize, hasCustomSerialize;
if (!JS_HasProperty(cx, obj, "Serialize", &hasCustomSerialize) || !JS_HasProperty(cx, obj, "Deserialize", &hasCustomDeserialize))
throw PSERROR_Serialize_ScriptError("JS_HasProperty failed");
if (hasCustomDeserialize)
{
AddScriptBackref(obj);
JS::RootedValue serialize(cx);
if (!JS_GetProperty(cx, obj, "Serialize", &serialize))
throw PSERROR_Serialize_ScriptError("JS_GetProperty failed");
bool hasNullSerialize = hasCustomSerialize && serialize.isNull();
// If Serialize is null, we'll still call Deserialize but with undefined argument
JS::RootedValue data(cx);
if (!hasNullSerialize)
ScriptVal("data", &data);
JS::RootedValue objVal(cx, JS::ObjectValue(*obj));
m_ScriptInterface.CallFunctionVoid(objVal, "Deserialize", data);
return JS::ObjectValue(*obj);
}
}
if (!obj)
throw PSERROR_Deserialize_ScriptError("Deserializer failed to create new object");
AddScriptBackref(obj);
uint32_t numProps;
NumberU32_Unbounded("num props", numProps);
bool isLatin1;
for (uint32_t i = 0; i < numProps; ++i)
{
Bool("isLatin1", isLatin1);
if (isLatin1)
{
std::vector<JS::Latin1Char> propname;
ReadStringLatin1("prop name", propname);
JS::RootedValue propval(cx, ReadScriptVal("prop value", JS::NullPtr()));
utf16string prp(propname.begin(), propname.end());;
// TODO: Should ask upstream about getting a variant of JS_SetProperty with a length param.
if (!JS_SetUCProperty(cx, obj, (const char16_t*)prp.data(), prp.length(), propval))
throw PSERROR_Deserialize_ScriptError();
}
else
{
utf16string propname;
ReadStringUTF16("prop name", propname);
JS::RootedValue propval(cx, ReadScriptVal("prop value", JS::NullPtr()));
if (!JS_SetUCProperty(cx, obj, (const char16_t*)propname.data(), propname.length(), propval))
throw PSERROR_Deserialize_ScriptError();
}
}
return JS::ObjectValue(*obj);
}
case SCRIPT_TYPE_STRING:
{
JS::RootedString str(cx);
ScriptString("string", &str);
return JS::StringValue(str);
}
case SCRIPT_TYPE_INT:
{
int32_t value;
NumberI32("value", value, JSVAL_INT_MIN, JSVAL_INT_MAX);
return JS::NumberValue(value);
}
case SCRIPT_TYPE_DOUBLE:
{
double value;
NumberDouble_Unbounded("value", value);
JS::RootedValue rval(cx, JS::NumberValue(value));
if (rval.isNull())
throw PSERROR_Deserialize_ScriptError("JS_NewNumberValue failed");
return rval;
}
case SCRIPT_TYPE_BOOLEAN:
{
uint8_t value;
NumberU8("value", value, 0, 1);
return JS::BooleanValue(value ? true : false);
}
case SCRIPT_TYPE_BACKREF:
{
u32 tag;
NumberU32_Unbounded("tag", tag);
JS::RootedObject obj(cx);
GetScriptBackref(tag, &obj);
if (!obj)
throw PSERROR_Deserialize_ScriptError("Invalid backref tag");
return JS::ObjectValue(*obj);
}
case SCRIPT_TYPE_OBJECT_NUMBER:
{
double value;
NumberDouble_Unbounded("value", value);
JS::RootedValue val(cx, JS::NumberValue(value));
JS::RootedObject ctorobj(cx);
if (!JS_GetClassObject(cx, JSProto_Number, &ctorobj))
throw PSERROR_Deserialize_ScriptError("JS_GetClassObject failed");
JS::RootedObject obj(cx, JS_New(cx, ctorobj, JS::HandleValueArray(val)));
if (!obj)
throw PSERROR_Deserialize_ScriptError("JS_New failed");
AddScriptBackref(obj);
return JS::ObjectValue(*obj);
}
case SCRIPT_TYPE_OBJECT_STRING:
{
JS::RootedString str(cx);
ScriptString("value", &str);
if (!str)
throw PSERROR_Deserialize_ScriptError();
JS::RootedValue val(cx, JS::StringValue(str));
JS::RootedObject ctorobj(cx);
if (!JS_GetClassObject(cx, JSProto_String, &ctorobj))
throw PSERROR_Deserialize_ScriptError("JS_GetClassObject failed");
JS::RootedObject obj(cx, JS_New(cx, ctorobj, JS::HandleValueArray(val)));
if (!obj)
throw PSERROR_Deserialize_ScriptError("JS_New failed");
AddScriptBackref(obj);
return JS::ObjectValue(*obj);
}
case SCRIPT_TYPE_OBJECT_BOOLEAN:
{
bool value;
Bool("value", value);
JS::RootedValue val(cx, JS::BooleanValue(value));
JS::RootedObject ctorobj(cx);
if (!JS_GetClassObject(cx, JSProto_Boolean, &ctorobj))
throw PSERROR_Deserialize_ScriptError("JS_GetClassObject failed");
JS::RootedObject obj(cx, JS_New(cx, ctorobj, JS::HandleValueArray(val)));
if (!obj)
throw PSERROR_Deserialize_ScriptError("JS_New failed");
AddScriptBackref(obj);
return JS::ObjectValue(*obj);
}
case SCRIPT_TYPE_TYPED_ARRAY:
{
u8 arrayType;
u32 byteOffset, length;
NumberU8_Unbounded("array type", arrayType);
NumberU32_Unbounded("byte offset", byteOffset);
NumberU32_Unbounded("length", length);
// To match the serializer order, we reserve the typed array's backref tag here
JS::RootedObject arrayObj(cx);
AddScriptBackref(arrayObj);
// Get buffer object
JS::RootedValue bufferVal(cx, ReadScriptVal("buffer", JS::NullPtr()));
if (!bufferVal.isObject())
throw PSERROR_Deserialize_ScriptError();
JS::RootedObject bufferObj(cx, &bufferVal.toObject());
if (!JS_IsArrayBufferObject(bufferObj))
throw PSERROR_Deserialize_ScriptError("js_IsArrayBuffer failed");
switch(arrayType)
{
case SCRIPT_TYPED_ARRAY_INT8:
arrayObj = JS_NewInt8ArrayWithBuffer(cx, bufferObj, byteOffset, length);
break;
case SCRIPT_TYPED_ARRAY_UINT8:
arrayObj = JS_NewUint8ArrayWithBuffer(cx, bufferObj, byteOffset, length);
break;
case SCRIPT_TYPED_ARRAY_INT16:
arrayObj = JS_NewInt16ArrayWithBuffer(cx, bufferObj, byteOffset, length);
break;
case SCRIPT_TYPED_ARRAY_UINT16:
arrayObj = JS_NewUint16ArrayWithBuffer(cx, bufferObj, byteOffset, length);
break;
case SCRIPT_TYPED_ARRAY_INT32:
arrayObj = JS_NewInt32ArrayWithBuffer(cx, bufferObj, byteOffset, length);
break;
case SCRIPT_TYPED_ARRAY_UINT32:
arrayObj = JS_NewUint32ArrayWithBuffer(cx, bufferObj, byteOffset, length);
break;
case SCRIPT_TYPED_ARRAY_FLOAT32:
arrayObj = JS_NewFloat32ArrayWithBuffer(cx, bufferObj, byteOffset, length);
break;
case SCRIPT_TYPED_ARRAY_FLOAT64:
arrayObj = JS_NewFloat64ArrayWithBuffer(cx, bufferObj, byteOffset, length);
break;
case SCRIPT_TYPED_ARRAY_UINT8_CLAMPED:
arrayObj = JS_NewUint8ClampedArrayWithBuffer(cx, bufferObj, byteOffset, length);
break;
default:
throw PSERROR_Deserialize_ScriptError("Failed to deserialize unrecognized typed array view");
}
if (!arrayObj)
throw PSERROR_Deserialize_ScriptError("js_CreateTypedArrayWithBuffer failed");
return JS::ObjectValue(*arrayObj);
}
case SCRIPT_TYPE_ARRAY_BUFFER:
{
u32 length;
NumberU32_Unbounded("buffer length", length);
#if BYTE_ORDER != LITTLE_ENDIAN
#error TODO: need to convert JS ArrayBuffer data from little-endian
#endif
void* contents = malloc(length);
ENSURE(contents);
RawBytes("buffer data", (u8*)contents, length);
JS::RootedObject bufferObj(cx, JS_NewArrayBufferWithContents(cx, length, contents));
AddScriptBackref(bufferObj);
return JS::ObjectValue(*bufferObj);
}
case SCRIPT_TYPE_OBJECT_MAP:
{
JS::RootedObject obj(cx, JS::NewMapObject(cx));
AddScriptBackref(obj);
u32 mapSize;
NumberU32_Unbounded("map size", mapSize);
for (u32 i=0; i<mapSize; ++i)
{
JS::RootedValue key(cx, ReadScriptVal("map key", JS::NullPtr()));
JS::RootedValue value(cx, ReadScriptVal("map value", JS::NullPtr()));
JS::MapSet(cx, obj, key, value);
}
return JS::ObjectValue(*obj);
}
case SCRIPT_TYPE_OBJECT_SET:
{
JS::RootedValue setVal(cx);
m_ScriptInterface.Eval("(new Set())", &setVal);
JS::RootedObject setObj(cx, &setVal.toObject());
AddScriptBackref(setObj);
u32 setSize;
NumberU32_Unbounded("set size", setSize);
for (u32 i=0; i<setSize; ++i)
{
JS::RootedValue value(cx, ReadScriptVal("set value", JS::NullPtr()));
m_ScriptInterface.CallFunctionVoid(setVal, "add", value);
}
return setVal;
}
default:
throw PSERROR_Deserialize_OutOfBounds();
}
}
