Index: ps/trunk/source/scriptinterface/ScriptInterface.cpp
===================================================================
--- ps/trunk/source/scriptinterface/ScriptInterface.cpp	(revision 22679)
+++ ps/trunk/source/scriptinterface/ScriptInterface.cpp	(revision 22680)
@@ -1,1149 +1,1149 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "ScriptInterface.h"
 #include "ScriptRuntime.h"
 #include "ScriptStats.h"
 
 #include "lib/debug.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/Profile.h"
 #include "ps/utf16string.h"
 
 #include <cassert>
 #include <map>
 
 #define BOOST_MULTI_INDEX_DISABLE_SERIALIZATION
 #include <boost/preprocessor/punctuation/comma_if.hpp>
 #include <boost/preprocessor/repetition/repeat.hpp>
 #include <boost/random/linear_congruential.hpp>
 #include <boost/flyweight.hpp>
 #include <boost/flyweight/key_value.hpp>
 #include <boost/flyweight/no_locking.hpp>
 #include <boost/flyweight/no_tracking.hpp>
 
 #include "valgrind.h"
 
 #include "scriptinterface/ScriptExtraHeaders.h"
 
 /**
  * @file
  * Abstractions of various SpiderMonkey features.
  * Engine code should be using functions of these interfaces rather than
  * directly accessing the underlying JS api.
  */
 
 
 struct ScriptInterface_impl
 {
 	ScriptInterface_impl(const char* nativeScopeName, const shared_ptr<ScriptRuntime>& runtime);
 	~ScriptInterface_impl();
 	void Register(const char* name, JSNative fptr, uint nargs) const;
 
 	// Take care to keep this declaration before heap rooted members. Destructors of heap rooted
 	// members have to be called before the runtime destructor.
 	shared_ptr<ScriptRuntime> m_runtime;
 
 	JSContext* m_cx;
 	JS::PersistentRootedObject m_glob; // global scope object
 	JSCompartment* m_comp;
 	boost::rand48* m_rng;
 	JS::PersistentRootedObject m_nativeScope; // native function scope object
 };
 
 namespace
 {
 
 JSClass global_class = {
 	"global", JSCLASS_GLOBAL_FLAGS,
 	nullptr, nullptr,
 	nullptr, nullptr,
 	nullptr, nullptr, nullptr,
 	nullptr, nullptr, nullptr, nullptr,
 	JS_GlobalObjectTraceHook
 };
 
 void ErrorReporter(JSContext* cx, const char* message, JSErrorReport* report)
 {
 	JSAutoRequest rq(cx);
 
 	std::stringstream msg;
 	bool isWarning = JSREPORT_IS_WARNING(report->flags);
 	msg << (isWarning ? "JavaScript warning: " : "JavaScript error: ");
 	if (report->filename)
 	{
 		msg << report->filename;
 		msg << " line " << report->lineno << "\n";
 	}
 
 	msg << message;
 
 	// If there is an exception, then print its stack trace
 	JS::RootedValue excn(cx);
 	if (JS_GetPendingException(cx, &excn) && excn.isObject())
 	{
 		JS::RootedValue stackVal(cx);
 		JS::RootedObject excnObj(cx, &excn.toObject());
 		JS_GetProperty(cx, excnObj, "stack", &stackVal);
 
 		std::string stackText;
 		ScriptInterface::FromJSVal(cx, stackVal, stackText);
 
 		std::istringstream stream(stackText);
 		for (std::string line; std::getline(stream, line);)
 			msg << "\n  " << line;
 	}
 
 	if (isWarning)
 		LOGWARNING("%s", msg.str().c_str());
 	else
 		LOGERROR("%s", msg.str().c_str());
 
 	// When running under Valgrind, print more information in the error message
 //	VALGRIND_PRINTF_BACKTRACE("->");
 }
 
 // Functions in the global namespace:
 
 bool print(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	for (uint i = 0; i < args.length(); ++i)
 	{
 		std::wstring str;
 		if (!ScriptInterface::FromJSVal(cx, args[i], str))
 			return false;
 		debug_printf("%s", utf8_from_wstring(str).c_str());
 	}
 	fflush(stdout);
 	args.rval().setUndefined();
 	return true;
 }
 
 bool logmsg(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() < 1)
 	{
 		args.rval().setUndefined();
 		return true;
 	}
 
 	std::wstring str;
 	if (!ScriptInterface::FromJSVal(cx, args[0], str))
 		return false;
 	LOGMESSAGE("%s", utf8_from_wstring(str));
 	args.rval().setUndefined();
 	return true;
 }
 
 bool warn(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() < 1)
 	{
 		args.rval().setUndefined();
 		return true;
 	}
 
 	std::wstring str;
 	if (!ScriptInterface::FromJSVal(cx, args[0], str))
 		return false;
 	LOGWARNING("%s", utf8_from_wstring(str));
 	args.rval().setUndefined();
 	return true;
 }
 
 bool error(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() < 1)
 	{
 		args.rval().setUndefined();
 		return true;
 	}
 
 	std::wstring str;
 	if (!ScriptInterface::FromJSVal(cx, args[0], str))
 		return false;
 	LOGERROR("%s", utf8_from_wstring(str));
 	args.rval().setUndefined();
 	return true;
 }
 
 bool deepcopy(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JSAutoRequest rq(cx);
 
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() < 1)
 	{
 		args.rval().setUndefined();
 		return true;
 	}
 
 	JS::RootedValue ret(cx);
 	if (!JS_StructuredClone(cx, args[0], &ret, NULL, NULL))
 		return false;
 
 	args.rval().set(ret);
 	return true;
 }
 
 bool deepfreeze(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 
 	if (args.length() != 1 || !args.get(0).isObject())
 	{
 		JS_ReportError(cx, "deepfreeze requires exactly one object as an argument.");
 		return false;
 	}
 
 	ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface->FreezeObject(args.get(0), true);
 	args.rval().set(args.get(0));
 	return true;
 }
 
 bool ProfileStart(JSContext* cx, uint argc, JS::Value* vp)
 {
 	const char* name = "(ProfileStart)";
 
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() >= 1)
 	{
 		std::string str;
 		if (!ScriptInterface::FromJSVal(cx, args[0], str))
 			return false;
 
 		typedef boost::flyweight<
 			std::string,
 			boost::flyweights::no_tracking,
 			boost::flyweights::no_locking
 		> StringFlyweight;
 
 		name = StringFlyweight(str).get().c_str();
 	}
 
 	if (CProfileManager::IsInitialised() && ThreadUtil::IsMainThread())
 		g_Profiler.StartScript(name);
 
 	g_Profiler2.RecordRegionEnter(name);
 
 	args.rval().setUndefined();
 	return true;
 }
 
 bool ProfileStop(JSContext* UNUSED(cx), uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (CProfileManager::IsInitialised() && ThreadUtil::IsMainThread())
 		g_Profiler.Stop();
 
 	g_Profiler2.RecordRegionLeave();
 
 	args.rval().setUndefined();
 	return true;
 }
 
 bool ProfileAttribute(JSContext* cx, uint argc, JS::Value* vp)
 {
 	const char* name = "(ProfileAttribute)";
 
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() >= 1)
 	{
 		std::string str;
 		if (!ScriptInterface::FromJSVal(cx, args[0], str))
 			return false;
 
 		typedef boost::flyweight<
 			std::string,
 			boost::flyweights::no_tracking,
 			boost::flyweights::no_locking
 		> StringFlyweight;
 
 		name = StringFlyweight(str).get().c_str();
 	}
 
 	g_Profiler2.RecordAttribute("%s", name);
 
 	args.rval().setUndefined();
 	return true;
 }
 
 // Math override functions:
 
 // boost::uniform_real is apparently buggy in Boost pre-1.47 - for integer generators
 // it returns [min,max], not [min,max). The bug was fixed in 1.47.
 // We need consistent behaviour, so manually implement the correct version:
 static double generate_uniform_real(boost::rand48& rng, double min, double max)
 {
 	while (true)
 	{
 		double n = (double)(rng() - rng.min());
 		double d = (double)(rng.max() - rng.min()) + 1.0;
 		ENSURE(d > 0 && n >= 0 && n <= d);
 		double r = n / d * (max - min) + min;
 		if (r < max)
 			return r;
 	}
 }
 
 bool Math_random(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	double r;
 	if (!ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface->MathRandom(r))
 		return false;
 
 	args.rval().setNumber(r);
 	return true;
 }
 
 } // anonymous namespace
 
 bool ScriptInterface::MathRandom(double& nbr)
 {
 	if (m->m_rng == NULL)
 		return false;
 	nbr = generate_uniform_real(*(m->m_rng), 0.0, 1.0);
 	return true;
 }
 
 ScriptInterface_impl::ScriptInterface_impl(const char* nativeScopeName, const shared_ptr<ScriptRuntime>& runtime) :
 	m_runtime(runtime), m_glob(runtime->m_rt), m_nativeScope(runtime->m_rt)
 {
 	bool ok;
 
 	m_cx = JS_NewContext(m_runtime->m_rt, STACK_CHUNK_SIZE);
 	ENSURE(m_cx);
 
 	JS_SetOffthreadIonCompilationEnabled(m_runtime->m_rt, true);
 
 	// For GC debugging:
 	// JS_SetGCZeal(m_cx, 2, JS_DEFAULT_ZEAL_FREQ);
 
 	JS_SetContextPrivate(m_cx, NULL);
 
 	JS_SetErrorReporter(m_runtime->m_rt, ErrorReporter);
 
 	JS_SetGlobalJitCompilerOption(m_runtime->m_rt, JSJITCOMPILER_ION_ENABLE, 1);
 	JS_SetGlobalJitCompilerOption(m_runtime->m_rt, JSJITCOMPILER_BASELINE_ENABLE, 1);
 
 	JS::RuntimeOptionsRef(m_cx)
 		.setExtraWarnings(true)
 		.setWerror(false)
 		.setStrictMode(true);
 
 	JS::CompartmentOptions opt;
 	opt.setVersion(JSVERSION_LATEST);
 	// Keep JIT code during non-shrinking GCs. This brings a quite big performance improvement.
 	opt.setPreserveJitCode(true);
 
 	JSAutoRequest rq(m_cx);
 	JS::RootedObject globalRootedVal(m_cx, JS_NewGlobalObject(m_cx, &global_class, NULL, JS::OnNewGlobalHookOption::FireOnNewGlobalHook, opt));
 	m_comp = JS_EnterCompartment(m_cx, globalRootedVal);
 	ok = JS_InitStandardClasses(m_cx, globalRootedVal);
 	ENSURE(ok);
 	m_glob = globalRootedVal.get();
 
 	JS_DefineProperty(m_cx, m_glob, "global", globalRootedVal, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 
 	m_nativeScope = JS_DefineObject(m_cx, m_glob, nativeScopeName, nullptr, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 
 	JS_DefineFunction(m_cx, globalRootedVal, "print", ::print,        0, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "log",   ::logmsg,       1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "warn",  ::warn,         1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "error", ::error,        1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "clone", ::deepcopy,        1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "deepfreeze", ::deepfreeze, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 
 	Register("ProfileStart", ::ProfileStart, 1);
 	Register("ProfileStop", ::ProfileStop, 0);
 	Register("ProfileAttribute", ::ProfileAttribute, 1);
 
 	runtime->RegisterContext(m_cx);
 }
 
 ScriptInterface_impl::~ScriptInterface_impl()
 {
 	m_runtime->UnRegisterContext(m_cx);
 	{
 		JSAutoRequest rq(m_cx);
 		JS_LeaveCompartment(m_cx, m_comp);
 	}
 	JS_DestroyContext(m_cx);
 }
 
 void ScriptInterface_impl::Register(const char* name, JSNative fptr, uint nargs) const
 {
 	JSAutoRequest rq(m_cx);
 	JS::RootedObject nativeScope(m_cx, m_nativeScope);
 	JS::RootedFunction func(m_cx, JS_DefineFunction(m_cx, nativeScope, name, fptr, nargs, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT));
 }
 
 ScriptInterface::ScriptInterface(const char* nativeScopeName, const char* debugName, const shared_ptr<ScriptRuntime>& runtime) :
 	m(new ScriptInterface_impl(nativeScopeName, runtime))
 {
 	// Profiler stats table isn't thread-safe, so only enable this on the main thread
 	if (ThreadUtil::IsMainThread())
 	{
 		if (g_ScriptStatsTable)
 			g_ScriptStatsTable->Add(this, debugName);
 	}
 
 	m_CxPrivate.pScriptInterface = this;
 	JS_SetContextPrivate(m->m_cx, (void*)&m_CxPrivate);
 }
 
 ScriptInterface::~ScriptInterface()
 {
 	if (ThreadUtil::IsMainThread())
 	{
 		if (g_ScriptStatsTable)
 			g_ScriptStatsTable->Remove(this);
 	}
 }
 
 void ScriptInterface::SetCallbackData(void* pCBData)
 {
 	m_CxPrivate.pCBData = pCBData;
 }
 
 ScriptInterface::CxPrivate* ScriptInterface::GetScriptInterfaceAndCBData(JSContext* cx)
 {
 	CxPrivate* pCxPrivate = (CxPrivate*)JS_GetContextPrivate(cx);
 	return pCxPrivate;
 }
 
 
 bool ScriptInterface::LoadGlobalScripts()
 {
 	// Ignore this failure in tests
 	if (!g_VFS)
 		return false;
 
 	// Load and execute *.js in the global scripts directory
 	VfsPaths pathnames;
 	vfs::GetPathnames(g_VFS, L"globalscripts/", L"*.js", pathnames);
 	for (const VfsPath& path : pathnames)
 		if (!LoadGlobalScriptFile(path))
 		{
 			LOGERROR("LoadGlobalScripts: Failed to load script %s", path.string8());
 			return false;
 		}
 
 	return true;
 }
 
 bool ScriptInterface::ReplaceNondeterministicRNG(boost::rand48& rng)
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedValue math(m->m_cx);
 	JS::RootedObject global(m->m_cx, m->m_glob);
 	if (JS_GetProperty(m->m_cx, global, "Math", &math) && math.isObject())
 	{
 		JS::RootedObject mathObj(m->m_cx, &math.toObject());
 		JS::RootedFunction random(m->m_cx, JS_DefineFunction(m->m_cx, mathObj, "random", Math_random, 0,
 			JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT));
 		if (random)
 		{
 			m->m_rng = &rng;
 			return true;
 		}
 	}
 
 	LOGERROR("ReplaceNondeterministicRNG: failed to replace Math.random");
 	return false;
 }
 
 void ScriptInterface::Register(const char* name, JSNative fptr, size_t nargs) const
 {
 	m->Register(name, fptr, (uint)nargs);
 }
 
 JSContext* ScriptInterface::GetContext() const
 {
 	return m->m_cx;
 }
 
 JSRuntime* ScriptInterface::GetJSRuntime() const
 {
 	return m->m_runtime->m_rt;
 }
 
 shared_ptr<ScriptRuntime> ScriptInterface::GetRuntime() const
 {
 	return m->m_runtime;
 }
 
 void ScriptInterface::CallConstructor(JS::HandleValue ctor, JS::HandleValueArray argv, JS::MutableHandleValue out) const
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!ctor.isObject())
 	{
 		LOGERROR("CallConstructor: ctor is not an object");
 		out.setNull();
 		return;
 	}
 
 	JS::RootedObject ctorObj(m->m_cx, &ctor.toObject());
 	out.setObjectOrNull(JS_New(m->m_cx, ctorObj, argv));
 }
 
 void ScriptInterface::DefineCustomObjectType(JSClass *clasp, JSNative constructor, uint minArgs, JSPropertySpec *ps, JSFunctionSpec *fs, JSPropertySpec *static_ps, JSFunctionSpec *static_fs)
 {
 	JSAutoRequest rq(m->m_cx);
 	std::string typeName = clasp->name;
 
 	if (m_CustomObjectTypes.find(typeName) != m_CustomObjectTypes.end())
 	{
 		// This type already exists
 		throw PSERROR_Scripting_DefineType_AlreadyExists();
 	}
 
 	JS::RootedObject global(m->m_cx, m->m_glob);
 	JS::RootedObject obj(m->m_cx, JS_InitClass(m->m_cx, global, nullptr,
 	                                           clasp,
 	                                           constructor, minArgs,     // Constructor, min args
 	                                           ps, fs,                   // Properties, methods
 	                                           static_ps, static_fs));   // Constructor properties, methods
 
 	if (obj == NULL)
 		throw PSERROR_Scripting_DefineType_CreationFailed();
 
 	CustomType& type = m_CustomObjectTypes[typeName];
 
 	type.m_Prototype.init(m->m_cx, obj);
 	type.m_Class = clasp;
 	type.m_Constructor = constructor;
 }
 
 JSObject* ScriptInterface::CreateCustomObject(const std::string& typeName) const
 {
 	std::map<std::string, CustomType>::const_iterator it = m_CustomObjectTypes.find(typeName);
 
 	if (it == m_CustomObjectTypes.end())
 		throw PSERROR_Scripting_TypeDoesNotExist();
 
 	JS::RootedObject prototype(m->m_cx, it->second.m_Prototype.get());
 	return JS_NewObjectWithGivenProto(m->m_cx, it->second.m_Class, prototype);
 }
 
 bool ScriptInterface::CallFunction_(JS::HandleValue val, const char* name, JS::HandleValueArray argv, JS::MutableHandleValue ret) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedObject obj(m->m_cx);
 	if (!JS_ValueToObject(m->m_cx, val, &obj) || !obj)
 		return false;
 
 	// Check that the named function actually exists, to avoid ugly JS error reports
 	// when calling an undefined value
 	bool found;
 	if (!JS_HasProperty(m->m_cx, obj, name, &found) || !found)
 		return false;
 
 	bool ok = JS_CallFunctionName(m->m_cx, obj, name, argv, ret);
 
 	return ok;
 }
 
-bool ScriptInterface::CreateObject(JS::MutableHandleValue objectValue) const
+bool ScriptInterface::CreateObject_(JS::MutableHandleObject object) const
 {
-	JSContext* cx = GetContext();
-	JSAutoRequest rq(cx);
+	// JSAutoRequest is the responsibility of the caller
 
-	objectValue.setObjectOrNull(JS_NewPlainObject(cx));
-	if (!objectValue.isObject())
+	object.set(JS_NewPlainObject(GetContext()));
+
+	if (!object)
 		throw PSERROR_Scripting_CreateObjectFailed();
 
 	return true;
 }
 
 void ScriptInterface::CreateArray(JS::MutableHandleValue objectValue, size_t length) const
 {
 	JSContext* cx = GetContext();
 	JSAutoRequest rq(cx);
 
 	objectValue.setObjectOrNull(JS_NewArrayObject(cx, length));
 	if (!objectValue.isObject())
 		throw PSERROR_Scripting_CreateObjectFailed();
 }
 
 JS::Value ScriptInterface::GetGlobalObject() const
 {
 	JSAutoRequest rq(m->m_cx);
 	return JS::ObjectValue(*JS::CurrentGlobalOrNull(m->m_cx));
 }
 
 bool ScriptInterface::SetGlobal_(const char* name, JS::HandleValue value, bool replace, bool constant, bool enumerate)
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedObject global(m->m_cx, m->m_glob);
 
 	bool found;
 	if (!JS_HasProperty(m->m_cx, global, name, &found))
 		return false;
 	if (found)
 	{
 		JS::Rooted<JSPropertyDescriptor> desc(m->m_cx);
 		if (!JS_GetOwnPropertyDescriptor(m->m_cx, global, name, &desc))
 			return false;
 
 		if (!desc.writable())
 		{
 			if (!replace)
 			{
 				JS_ReportError(m->m_cx, "SetGlobal \"%s\" called multiple times", name);
 				return false;
 			}
 
 			// This is not supposed to happen, unless the user has called SetProperty with constant = true on the global object
 			// instead of using SetGlobal.
 			if (!desc.configurable())
 			{
 				JS_ReportError(m->m_cx, "The global \"%s\" is permanent and cannot be hotloaded", name);
 				return false;
 			}
 
 			LOGMESSAGE("Hotloading new value for global \"%s\".", name);
 			ENSURE(JS_DeleteProperty(m->m_cx, global, name));
 		}
 	}
 
 	uint attrs = 0;
 	if (constant)
 		attrs |= JSPROP_READONLY;
 	if (enumerate)
 		attrs |= JSPROP_ENUMERATE;
 
 	return JS_DefineProperty(m->m_cx, global, name, value, attrs);
 }
 
 bool ScriptInterface::SetProperty_(JS::HandleValue obj, const char* name, JS::HandleValue value, bool constant, bool enumerate) const
 {
 	JSAutoRequest rq(m->m_cx);
 	uint attrs = 0;
 	if (constant)
 		attrs |= JSPROP_READONLY | JSPROP_PERMANENT;
 	if (enumerate)
 		attrs |= JSPROP_ENUMERATE;
 
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	if (!JS_DefineProperty(m->m_cx, object, name, value, attrs))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::SetProperty_(JS::HandleValue obj, const wchar_t* name, JS::HandleValue value, bool constant, bool enumerate) const
 {
 	JSAutoRequest rq(m->m_cx);
 	uint attrs = 0;
 	if (constant)
 		attrs |= JSPROP_READONLY | JSPROP_PERMANENT;
 	if (enumerate)
 		attrs |= JSPROP_ENUMERATE;
 
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	utf16string name16(name, name + wcslen(name));
 	if (!JS_DefineUCProperty(m->m_cx, object, reinterpret_cast<const char16_t*>(name16.c_str()), name16.length(), value, attrs))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::SetPropertyInt_(JS::HandleValue obj, int name, JS::HandleValue value, bool constant, bool enumerate) const
 {
 	JSAutoRequest rq(m->m_cx);
 	uint attrs = 0;
 	if (constant)
 		attrs |= JSPROP_READONLY | JSPROP_PERMANENT;
 	if (enumerate)
 		attrs |= JSPROP_ENUMERATE;
 
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	JS::RootedId id(m->m_cx, INT_TO_JSID(name));
 	if (!JS_DefinePropertyById(m->m_cx, object, id, value, attrs))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::GetProperty(JS::HandleValue obj, const char* name, JS::MutableHandleValue out) const
 {
 	return GetProperty_(obj, name, out);
 }
 
 bool ScriptInterface::GetProperty(JS::HandleValue obj, const char* name, JS::MutableHandleObject out) const
 {
 	JSContext* cx = GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue val(cx);
 	if (!GetProperty_(obj, name, &val))
 		return false;
 	if (!val.isObject())
 	{
 		LOGERROR("GetProperty failed: trying to get an object, but the property is not an object!");
 		return false;
 	}
 
 	out.set(&val.toObject());
 	return true;
 }
 
 bool ScriptInterface::GetPropertyInt(JS::HandleValue obj, int name, JS::MutableHandleValue out) const
 {
 	return GetPropertyInt_(obj, name, out);
 }
 
 bool ScriptInterface::GetProperty_(JS::HandleValue obj, const char* name, JS::MutableHandleValue out) const
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	if (!JS_GetProperty(m->m_cx, object, name, out))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::GetPropertyInt_(JS::HandleValue obj, int name, JS::MutableHandleValue out) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedId nameId(m->m_cx, INT_TO_JSID(name));
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	if (!JS_GetPropertyById(m->m_cx, object, nameId, out))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::HasProperty(JS::HandleValue obj, const char* name) const
 {
 	// TODO: proper errorhandling
 	JSAutoRequest rq(m->m_cx);
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	bool found;
 	if (!JS_HasProperty(m->m_cx, object, name, &found))
 		return false;
 	return found;
 }
 
 bool ScriptInterface::EnumeratePropertyNamesWithPrefix(JS::HandleValue objVal, const char* prefix, std::vector<std::string>& out) const
 {
 	JSAutoRequest rq(m->m_cx);
 
 	if (!objVal.isObjectOrNull())
 	{
 		LOGERROR("EnumeratePropertyNamesWithPrefix expected object type!");
 		return false;
 	}
 
 	if (objVal.isNull())
 		return true; // reached the end of the prototype chain
 
 	JS::RootedObject obj(m->m_cx, &objVal.toObject());
 	JS::Rooted<JS::IdVector> props(m->m_cx, JS::IdVector(m->m_cx));
 	if (!JS_Enumerate(m->m_cx, obj, &props))
 		return false;
 
 	for (size_t i = 0; i < props.length(); ++i)
 	{
 		JS::RootedId id(m->m_cx, props[i]);
 		JS::RootedValue val(m->m_cx);
 		if (!JS_IdToValue(m->m_cx, id, &val))
 			return false;
 
 		if (!val.isString())
 			continue; // ignore integer properties
 
 		JS::RootedString name(m->m_cx, val.toString());
 		size_t len = strlen(prefix)+1;
 		std::vector<char> buf(len);
 		size_t prefixLen = strlen(prefix) * sizeof(char);
 		JS_EncodeStringToBuffer(m->m_cx, name, &buf[0], prefixLen);
 		buf[len-1]= '\0';
 		if (0 == strcmp(&buf[0], prefix))
 		{
 			if (JS_StringHasLatin1Chars(name))
 			{
 				size_t length;
 				JS::AutoCheckCannotGC nogc;
 				const JS::Latin1Char* chars = JS_GetLatin1StringCharsAndLength(m->m_cx, nogc, name, &length);
 				if (chars)
 					out.push_back(std::string(chars, chars+length));
 			}
 			else
 			{
 				size_t length;
 				JS::AutoCheckCannotGC nogc;
 				const char16_t* chars = JS_GetTwoByteStringCharsAndLength(m->m_cx, nogc, name, &length);
 				if (chars)
 					out.push_back(std::string(chars, chars+length));
 			}
 		}
 	}
 
 	// Recurse up the prototype chain
 	JS::RootedObject prototype(m->m_cx);
 	if (JS_GetPrototype(m->m_cx, obj, &prototype))
 	{
 		JS::RootedValue prototypeVal(m->m_cx, JS::ObjectOrNullValue(prototype));
 		if (!EnumeratePropertyNamesWithPrefix(prototypeVal, prefix, out))
 			return false;
 	}
 
 	return true;
 }
 
 bool ScriptInterface::SetPrototype(JS::HandleValue objVal, JS::HandleValue protoVal)
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!objVal.isObject() || !protoVal.isObject())
 		return false;
 	JS::RootedObject obj(m->m_cx, &objVal.toObject());
 	JS::RootedObject proto(m->m_cx, &protoVal.toObject());
 	return JS_SetPrototype(m->m_cx, obj, proto);
 }
 
 bool ScriptInterface::FreezeObject(JS::HandleValue objVal, bool deep) const
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!objVal.isObject())
 		return false;
 
 	JS::RootedObject obj(m->m_cx, &objVal.toObject());
 
 	if (deep)
 		return JS_DeepFreezeObject(m->m_cx, obj);
 	else
 		return JS_FreezeObject(m->m_cx, obj);
 }
 
 bool ScriptInterface::LoadScript(const VfsPath& filename, const std::string& code) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedObject global(m->m_cx, m->m_glob);
 	utf16string codeUtf16(code.begin(), code.end());
 	uint lineNo = 1;
 	// CompileOptions does not copy the contents of the filename string pointer.
 	// Passing a temporary string there will cause undefined behaviour, so we create a separate string to avoid the temporary.
 	std::string filenameStr = filename.string8();
 
 	JS::CompileOptions options(m->m_cx);
 	options.setFileAndLine(filenameStr.c_str(), lineNo);
 	options.setIsRunOnce(false);
 
 	JS::RootedFunction func(m->m_cx);
 	JS::AutoObjectVector emptyScopeChain(m->m_cx);
 	if (!JS::CompileFunction(m->m_cx, emptyScopeChain, options, NULL, 0, NULL,
 	                         reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)(codeUtf16.length()), &func))
 		return false;
 
 	JS::RootedValue rval(m->m_cx);
 	return JS_CallFunction(m->m_cx, nullptr, func, JS::HandleValueArray::empty(), &rval);
 }
 
 shared_ptr<ScriptRuntime> ScriptInterface::CreateRuntime(shared_ptr<ScriptRuntime> parentRuntime, int runtimeSize, int heapGrowthBytesGCTrigger)
 {
 	return shared_ptr<ScriptRuntime>(new ScriptRuntime(parentRuntime, runtimeSize, heapGrowthBytesGCTrigger));
 }
 
 bool ScriptInterface::LoadGlobalScript(const VfsPath& filename, const std::wstring& code) const
 {
 	JSAutoRequest rq(m->m_cx);
 	utf16string codeUtf16(code.begin(), code.end());
 	uint lineNo = 1;
 	// CompileOptions does not copy the contents of the filename string pointer.
 	// Passing a temporary string there will cause undefined behaviour, so we create a separate string to avoid the temporary.
 	std::string filenameStr = filename.string8();
 
 	JS::RootedValue rval(m->m_cx);
 	JS::CompileOptions opts(m->m_cx);
 	opts.setFileAndLine(filenameStr.c_str(), lineNo);
 	return JS::Evaluate(m->m_cx, opts,
 			reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)(codeUtf16.length()), &rval);
 }
 
 bool ScriptInterface::LoadGlobalScriptFile(const VfsPath& path) const
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!VfsFileExists(path))
 	{
 		LOGERROR("File '%s' does not exist", path.string8());
 		return false;
 	}
 
 	CVFSFile file;
 
 	PSRETURN ret = file.Load(g_VFS, path);
 
 	if (ret != PSRETURN_OK)
 	{
 		LOGERROR("Failed to load file '%s': %s", path.string8(), GetErrorString(ret));
 		return false;
 	}
 
 	std::wstring code = wstring_from_utf8(file.DecodeUTF8()); // assume it's UTF-8
 
 	utf16string codeUtf16(code.begin(), code.end());
 	uint lineNo = 1;
 	// CompileOptions does not copy the contents of the filename string pointer.
 	// Passing a temporary string there will cause undefined behaviour, so we create a separate string to avoid the temporary.
 	std::string filenameStr = path.string8();
 
 	JS::RootedValue rval(m->m_cx);
 	JS::CompileOptions opts(m->m_cx);
 	opts.setFileAndLine(filenameStr.c_str(), lineNo);
 	return JS::Evaluate(m->m_cx, opts,
 			reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)(codeUtf16.length()), &rval);
 }
 
 bool ScriptInterface::Eval(const char* code) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedValue rval(m->m_cx);
 	return Eval_(code, &rval);
 }
 
 bool ScriptInterface::Eval_(const char* code, JS::MutableHandleValue rval) const
 {
 	JSAutoRequest rq(m->m_cx);
 	utf16string codeUtf16(code, code+strlen(code));
 
 	JS::CompileOptions opts(m->m_cx);
 	opts.setFileAndLine("(eval)", 1);
 	return JS::Evaluate(m->m_cx, opts, reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)codeUtf16.length(), rval);
 }
 
 bool ScriptInterface::Eval_(const wchar_t* code, JS::MutableHandleValue rval) const
 {
 	JSAutoRequest rq(m->m_cx);
 	utf16string codeUtf16(code, code+wcslen(code));
 
 	JS::CompileOptions opts(m->m_cx);
 	opts.setFileAndLine("(eval)", 1);
 	return JS::Evaluate(m->m_cx, opts, reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)codeUtf16.length(), rval);
 }
 
 bool ScriptInterface::ParseJSON(const std::string& string_utf8, JS::MutableHandleValue out) const
 {
 	JSAutoRequest rq(m->m_cx);
 	std::wstring attrsW = wstring_from_utf8(string_utf8);
  	utf16string string(attrsW.begin(), attrsW.end());
 	if (JS_ParseJSON(m->m_cx, reinterpret_cast<const char16_t*>(string.c_str()), (u32)string.size(), out))
 		return true;
 
 	LOGERROR("JS_ParseJSON failed!");
 	if (!JS_IsExceptionPending(m->m_cx))
 		return false;
 
 	JS::RootedValue exc(m->m_cx);
 	if (!JS_GetPendingException(m->m_cx, &exc))
 		return false;
 
 	JS_ClearPendingException(m->m_cx);
 	// We expect an object of type SyntaxError
 	if (!exc.isObject())
 		return false;
 
 	JS::RootedValue rval(m->m_cx);
 	JS::RootedObject excObj(m->m_cx, &exc.toObject());
 	if (!JS_CallFunctionName(m->m_cx, excObj, "toString", JS::HandleValueArray::empty(), &rval))
 		return false;
 
 	std::wstring error;
 	ScriptInterface::FromJSVal(m->m_cx, rval, error);
 	LOGERROR("%s", utf8_from_wstring(error));
 	return false;
 }
 
 void ScriptInterface::ReadJSONFile(const VfsPath& path, JS::MutableHandleValue out) const
 {
 	if (!VfsFileExists(path))
 	{
 		LOGERROR("File '%s' does not exist", path.string8());
 		return;
 	}
 
 	CVFSFile file;
 
 	PSRETURN ret = file.Load(g_VFS, path);
 
 	if (ret != PSRETURN_OK)
 	{
 		LOGERROR("Failed to load file '%s': %s", path.string8(), GetErrorString(ret));
 		return;
 	}
 
 	std::string content(file.DecodeUTF8()); // assume it's UTF-8
 
 	if (!ParseJSON(content, out))
 		LOGERROR("Failed to parse '%s'", path.string8());
 }
 
 struct Stringifier
 {
 	static bool callback(const char16_t* buf, u32 len, void* data)
 	{
 		utf16string str(buf, buf+len);
 		std::wstring strw(str.begin(), str.end());
 
 		Status err; // ignore Unicode errors
 		static_cast<Stringifier*>(data)->stream << utf8_from_wstring(strw, &err);
 		return true;
 	}
 
 	std::stringstream stream;
 };
 
 // TODO: It's not quite clear why JS_Stringify needs JS::MutableHandleValue. |obj| should not get modified.
 // It probably has historical reasons and could be changed by SpiderMonkey in the future.
 std::string ScriptInterface::StringifyJSON(JS::MutableHandleValue obj, bool indent) const
 {
 	JSAutoRequest rq(m->m_cx);
 	Stringifier str;
 	JS::RootedValue indentVal(m->m_cx, indent ? JS::Int32Value(2) : JS::UndefinedValue());
 	if (!JS_Stringify(m->m_cx, obj, nullptr, indentVal, &Stringifier::callback, &str))
 	{
 		JS_ClearPendingException(m->m_cx);
 		LOGERROR("StringifyJSON failed");
 		return std::string();
 	}
 
 	return str.stream.str();
 }
 
 
 std::string ScriptInterface::ToString(JS::MutableHandleValue obj, bool pretty) const
 {
 	JSAutoRequest rq(m->m_cx);
 
 	if (obj.isUndefined())
 		return "(void 0)";
 
 	// Try to stringify as JSON if possible
 	// (TODO: this is maybe a bad idea since it'll drop 'undefined' values silently)
 	if (pretty)
 	{
 		Stringifier str;
 		JS::RootedValue indentVal(m->m_cx, JS::Int32Value(2));
 
 		// Temporary disable the error reporter, so we don't print complaints about cyclic values
 		JSErrorReporter er = JS_SetErrorReporter(m->m_runtime->m_rt, NULL);
 
 		bool ok = JS_Stringify(m->m_cx, obj, nullptr, indentVal, &Stringifier::callback, &str);
 
 		// Restore error reporter
 		JS_SetErrorReporter(m->m_runtime->m_rt, er);
 
 		if (ok)
 			return str.stream.str();
 
 		// Clear the exception set when Stringify failed
 		JS_ClearPendingException(m->m_cx);
 	}
 
 	// Caller didn't want pretty output, or JSON conversion failed (e.g. due to cycles),
 	// so fall back to obj.toSource()
 
 	std::wstring source = L"(error)";
 	CallFunction(obj, "toSource", source);
 	return utf8_from_wstring(source);
 }
 
 void ScriptInterface::ReportError(const char* msg) const
 {
 	JSAutoRequest rq(m->m_cx);
 	// JS_ReportError by itself doesn't seem to set a JS-style exception, and so
 	// script callers will be unable to catch anything. So use JS_SetPendingException
 	// to make sure there really is a script-level exception. But just set it to undefined
 	// because there's not much value yet in throwing a real exception object.
 	JS_SetPendingException(m->m_cx, JS::UndefinedHandleValue);
 	// And report the actual error
 	JS_ReportError(m->m_cx, "%s", msg);
 
 	// TODO: Why doesn't JS_ReportPendingException(m->m_cx); work?
 }
 
 bool ScriptInterface::IsExceptionPending(JSContext* cx)
 {
 	JSAutoRequest rq(cx);
 	return JS_IsExceptionPending(cx) ? true : false;
 }
 
 JS::Value ScriptInterface::CloneValueFromOtherContext(const ScriptInterface& otherContext, JS::HandleValue val) const
 {
 	PROFILE("CloneValueFromOtherContext");
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedValue out(m->m_cx);
 	shared_ptr<StructuredClone> structuredClone = otherContext.WriteStructuredClone(val);
 	ReadStructuredClone(structuredClone, &out);
 	return out.get();
 }
 
 ScriptInterface::StructuredClone::StructuredClone() :
 	m_Data(NULL), m_Size(0)
 {
 }
 
 ScriptInterface::StructuredClone::~StructuredClone()
 {
 	if (m_Data)
 		JS_ClearStructuredClone(m_Data, m_Size, NULL, NULL);
 }
 
 shared_ptr<ScriptInterface::StructuredClone> ScriptInterface::WriteStructuredClone(JS::HandleValue v) const
 {
 	JSAutoRequest rq(m->m_cx);
 	u64* data = NULL;
 	size_t nbytes = 0;
 	if (!JS_WriteStructuredClone(m->m_cx, v, &data, &nbytes, NULL, NULL, JS::UndefinedHandleValue))
 	{
 		debug_warn(L"Writing a structured clone with JS_WriteStructuredClone failed!");
 		return shared_ptr<StructuredClone>();
 	}
 
 	shared_ptr<StructuredClone> ret(new StructuredClone);
 	ret->m_Data = data;
 	ret->m_Size = nbytes;
 	return ret;
 }
 
 void ScriptInterface::ReadStructuredClone(const shared_ptr<ScriptInterface::StructuredClone>& ptr, JS::MutableHandleValue ret) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS_ReadStructuredClone(m->m_cx, ptr->m_Data, ptr->m_Size, JS_STRUCTURED_CLONE_VERSION, ret, NULL, NULL);
 }
Index: ps/trunk/source/scriptinterface/ScriptInterface.h
===================================================================
--- ps/trunk/source/scriptinterface/ScriptInterface.h	(revision 22679)
+++ ps/trunk/source/scriptinterface/ScriptInterface.h	(revision 22680)
@@ -1,607 +1,620 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_SCRIPTINTERFACE
 #define INCLUDED_SCRIPTINTERFACE
 
 #include "lib/file/vfs/vfs_path.h"
 #include "maths/Fixed.h"
 #include "ScriptTypes.h"
 #include "ps/Errors.h"
 
 #include <boost/random/linear_congruential.hpp>
 #include <map>
 
 ERROR_GROUP(Scripting);
 ERROR_TYPE(Scripting, SetupFailed);
 
 ERROR_SUBGROUP(Scripting, LoadFile);
 ERROR_TYPE(Scripting_LoadFile, OpenFailed);
 ERROR_TYPE(Scripting_LoadFile, EvalErrors);
 
 ERROR_TYPE(Scripting, ConversionFailed);
 ERROR_TYPE(Scripting, CallFunctionFailed);
 ERROR_TYPE(Scripting, RegisterFunctionFailed);
 ERROR_TYPE(Scripting, DefineConstantFailed);
 ERROR_TYPE(Scripting, CreateObjectFailed);
 ERROR_TYPE(Scripting, TypeDoesNotExist);
 
 ERROR_SUBGROUP(Scripting, DefineType);
 ERROR_TYPE(Scripting_DefineType, AlreadyExists);
 ERROR_TYPE(Scripting_DefineType, CreationFailed);
 
 // Set the maximum number of function arguments that can be handled
 // (This should be as small as possible (for compiler efficiency),
 // but as large as necessary for all wrapped functions)
 #define SCRIPT_INTERFACE_MAX_ARGS 8
 
 // TODO: what's a good default?
 #define DEFAULT_RUNTIME_SIZE 16 * 1024 * 1024
 #define DEFAULT_HEAP_GROWTH_BYTES_GCTRIGGER 2 * 1024 *1024
 
 struct ScriptInterface_impl;
 
 class ScriptRuntime;
 
 extern shared_ptr<ScriptRuntime> g_ScriptRuntime;
 
 
 /**
  * Abstraction around a SpiderMonkey JSContext.
  *
  * Thread-safety:
  * - May be used in non-main threads.
  * - Each ScriptInterface must be created, used, and destroyed, all in a single thread
  *   (it must never be shared between threads).
  */
 class ScriptInterface
 {
 	NONCOPYABLE(ScriptInterface);
 
 public:
 
 	/**
 	 * Returns a runtime, which can used to initialise any number of
 	 * ScriptInterfaces contexts. Values created in one context may be used
 	 * in any other context from the same runtime (but not any other runtime).
 	 * Each runtime should only ever be used on a single thread.
 	 * @param runtimeSize Maximum size in bytes of the new runtime
 	 */
 	static shared_ptr<ScriptRuntime> CreateRuntime(shared_ptr<ScriptRuntime> parentRuntime = shared_ptr<ScriptRuntime>(), int runtimeSize = DEFAULT_RUNTIME_SIZE,
 		int heapGrowthBytesGCTrigger = DEFAULT_HEAP_GROWTH_BYTES_GCTRIGGER);
 
 
 	/**
 	 * Constructor.
 	 * @param nativeScopeName Name of global object that functions (via RegisterFunction) will
 	 *   be placed into, as a scoping mechanism; typically "Engine"
 	 * @param debugName Name of this interface for CScriptStats purposes.
 	 * @param runtime ScriptRuntime to use when initializing this interface.
 	 */
 	ScriptInterface(const char* nativeScopeName, const char* debugName, const shared_ptr<ScriptRuntime>& runtime);
 
 	~ScriptInterface();
 
 	struct CxPrivate
 	{
 		ScriptInterface* pScriptInterface; // the ScriptInterface object the current context belongs to
 		void* pCBData; // meant to be used as the "this" object for callback functions
 	} m_CxPrivate;
 
 	void SetCallbackData(void* pCBData);
 	static CxPrivate* GetScriptInterfaceAndCBData(JSContext* cx);
 
 	JSContext* GetContext() const;
 	JSRuntime* GetJSRuntime() const;
 	shared_ptr<ScriptRuntime> GetRuntime() const;
 
 	/**
 	 * Load global scripts that most script contexts need,
 	 * located in the /globalscripts directory. VFS must be initialized.
 	 */
 	bool LoadGlobalScripts();
 
 	/**
 	 * Replace the default JS random number geenrator with a seeded, network-sync'd one.
 	 */
 	bool ReplaceNondeterministicRNG(boost::rand48& rng);
 
 	/**
 	 * Call a constructor function, equivalent to JS "new ctor(arg)".
 	 * @param ctor An object that can be used as constructor
 	 * @param argv Constructor arguments
 	 * @param out The new object; On error an error message gets logged and out is Null (out.isNull() == true).
 	 */
 	void CallConstructor(JS::HandleValue ctor, JS::HandleValueArray argv, JS::MutableHandleValue out) const;
 
 	JSObject* CreateCustomObject(const std::string & typeName) const;
 	void DefineCustomObjectType(JSClass *clasp, JSNative constructor, uint minArgs, JSPropertySpec *ps, JSFunctionSpec *fs, JSPropertySpec *static_ps, JSFunctionSpec *static_fs);
 
 	/**
-	 * Sets the given value to a new plain JS::Object. Can throw an exception in case of running out of memory.
-	 */
-	bool CreateObject(JS::MutableHandleValue objectValue) const;
-
-	/**
 	 * Sets the given value to a new plain JS::Object, converts the arguments to JS::Values and sets them as properties.
 	 * Can throw an exception.
 	 */
-	template<typename T, typename... Args>
-	bool CreateObject(JS::MutableHandleValue objectValue, const char* propertyName, const T& propertyValue, Args const&... args) const
+	template<typename... Args>
+	bool CreateObject(JS::MutableHandleValue objectValue, Args const&... args) const
 	{
-		return CreateObject(objectValue, args...) && SetProperty(objectValue, propertyName, propertyValue);
-	}
+		JSContext* cx = GetContext();
+		JSAutoRequest rq(cx);
+		JS::RootedObject obj(cx);
 
-	template<typename T, typename... Args>
-	bool CreateObject(JS::MutableHandleValue objectValue, const wchar_t* propertyName, const T& propertyValue, Args const&... args) const
-	{
-		return CreateObject(objectValue, args...) && SetProperty(objectValue, propertyName, propertyValue);
+		if (!CreateObject_(&obj, args...))
+			return false;
+
+		objectValue.setObject(*obj);
+		return true;
 	}
 
 	/**
 	 * Sets the given value to a new JS object or Null Value in case of out-of-memory.
 	 */
 	void CreateArray(JS::MutableHandleValue objectValue, size_t length = 0) const;
 
 	JS::Value GetGlobalObject() const;
 
 	/**
 	 * Set the named property on the global object.
 	 * Optionally makes it {ReadOnly, DontEnum}. We do not allow to make it DontDelete, so that it can be hotloaded
 	 * by deleting it and re-creating it, which is done by setting @p replace to true.
 	 */
 	template<typename T>
 	bool SetGlobal(const char* name, const T& value, bool replace = false, bool constant = true, bool enumerate = true);
 
 	/**
 	 * Set the named property on the given object.
 	 * Optionally makes it {ReadOnly, DontDelete, DontEnum}.
 	 */
 	template<typename T>
 	bool SetProperty(JS::HandleValue obj, const char* name, const T& value, bool constant = false, bool enumerate = true) const;
 
 	/**
 	 * Set the named property on the given object.
 	 * Optionally makes it {ReadOnly, DontDelete, DontEnum}.
 	 */
 	template<typename T>
 	bool SetProperty(JS::HandleValue obj, const wchar_t* name, const T& value, bool constant = false, bool enumerate = true) const;
 
 	/**
 	 * Set the integer-named property on the given object.
 	 * Optionally makes it {ReadOnly, DontDelete, DontEnum}.
 	 */
 	template<typename T>
 	bool SetPropertyInt(JS::HandleValue obj, int name, const T& value, bool constant = false, bool enumerate = true) const;
 
 	/**
 	 * Get the named property on the given object.
 	 */
 	template<typename T>
 	bool GetProperty(JS::HandleValue obj, const char* name, T& out) const;
 
 	/**
 	 * Get the named property of the given object.
 	 */
 	bool GetProperty(JS::HandleValue obj, const char* name, JS::MutableHandleValue out) const;
 	bool GetProperty(JS::HandleValue obj, const char* name, JS::MutableHandleObject out) const;
 
 	/**
 	 * Get the integer-named property on the given object.
 	 */
 	template<typename T>
 	bool GetPropertyInt(JS::HandleValue obj, int name, T& out) const;
 
 	/**
 	 * Get the named property of the given object.
 	 */
 	bool GetPropertyInt(JS::HandleValue obj, int name, JS::MutableHandleValue out) const;
 
 	/**
 	 * Check the named property has been defined on the given object.
 	 */
 	bool HasProperty(JS::HandleValue obj, const char* name) const;
 
 	bool EnumeratePropertyNamesWithPrefix(JS::HandleValue objVal, const char* prefix, std::vector<std::string>& out) const;
 
 	bool SetPrototype(JS::HandleValue obj, JS::HandleValue proto);
 
 	bool FreezeObject(JS::HandleValue objVal, bool deep) const;
 
 	bool Eval(const char* code) const;
 
 	template<typename CHAR> bool Eval(const CHAR* code, JS::MutableHandleValue out) const;
 	template<typename T, typename CHAR> bool Eval(const CHAR* code, T& out) const;
 
 	/**
 	 * Convert an object to a UTF-8 encoded string, either with JSON
 	 * (if pretty == true and there is no JSON error) or with toSource().
 	 *
 	 * We have to use a mutable handle because JS_Stringify requires that for unknown reasons.
 	 */
 	std::string ToString(JS::MutableHandleValue obj, bool pretty = false) const;
 
 	/**
 	 * Parse a UTF-8-encoded JSON string. Returns the unmodified value on error
 	 * and prints an error message.
 	 * @return true on success; false otherwise
 	 */
 	bool ParseJSON(const std::string& string_utf8, JS::MutableHandleValue out) const;
 
 	/**
 	 * Read a JSON file. Returns the unmodified value on error and prints an error message.
 	 */
 	void ReadJSONFile(const VfsPath& path, JS::MutableHandleValue out) const;
 
 	/**
 	 * Stringify to a JSON string, UTF-8 encoded. Returns an empty string on error.
 	 */
 	std::string StringifyJSON(JS::MutableHandleValue obj, bool indent = true) const;
 
 	/**
 	 * Report the given error message through the JS error reporting mechanism,
 	 * and throw a JS exception. (Callers can check IsPendingException, and must
 	 * return false in that case to propagate the exception.)
 	 */
 	void ReportError(const char* msg) const;
 
 	/**
 	 * Load and execute the given script in a new function scope.
 	 * @param filename Name for debugging purposes (not used to load the file)
 	 * @param code JS code to execute
 	 * @return true on successful compilation and execution; false otherwise
 	 */
 	bool LoadScript(const VfsPath& filename, const std::string& code) const;
 
 	/**
 	 * Load and execute the given script in the global scope.
 	 * @param filename Name for debugging purposes (not used to load the file)
 	 * @param code JS code to execute
 	 * @return true on successful compilation and execution; false otherwise
 	 */
 	bool LoadGlobalScript(const VfsPath& filename, const std::wstring& code) const;
 
 	/**
 	 * Load and execute the given script in the global scope.
 	 * @return true on successful compilation and execution; false otherwise
 	 */
 	bool LoadGlobalScriptFile(const VfsPath& path) const;
 
 	/**
 	 * Construct a new value (usable in this ScriptInterface's context) by cloning
 	 * a value from a different context.
 	 * Complex values (functions, XML, etc) won't be cloned correctly, but basic
 	 * types and cyclic references should be fine.
 	 */
 	JS::Value CloneValueFromOtherContext(const ScriptInterface& otherContext, JS::HandleValue val) const;
 
 	/**
 	 * Convert a JS::Value to a C++ type. (This might trigger GC.)
 	 */
 	template<typename T> static bool FromJSVal(JSContext* cx, const JS::HandleValue val, T& ret);
 
 	/**
 	 * Convert a C++ type to a JS::Value. (This might trigger GC. The return
 	 * value must be rooted if you don't want it to be collected.)
 	 * NOTE: We are passing the JS::Value by reference instead of returning it by value.
 	 * The reason is a memory corruption problem that appears to be caused by a bug in Visual Studio.
 	 * Details here: http://www.wildfiregames.com/forum/index.php?showtopic=17289&p=285921
 	 */
 	template<typename T> static void ToJSVal(JSContext* cx, JS::MutableHandleValue ret, T const& val);
 
 	/**
 	 * Convert a named property of an object to a C++ type.
 	 */
 	template<typename T> static bool FromJSProperty(JSContext* cx, const JS::HandleValue val, const char* name, T& ret);
 
 	/**
 	 * MathRandom (this function) calls the random number generator assigned to this ScriptInterface instance and
 	 * returns the generated number.
 	 * Math_random (with underscore, not this function) is a global function, but different random number generators can be
 	 * stored per ScriptInterface. It calls MathRandom of the current ScriptInterface instance.
 	 */
 	bool MathRandom(double& nbr);
 
 	/**
 	 * Structured clones are a way to serialize 'simple' JS::Values into a buffer
 	 * that can safely be passed between contexts and runtimes and threads.
 	 * A StructuredClone can be stored and read multiple times if desired.
 	 * We wrap them in shared_ptr so memory management is automatic and
 	 * thread-safe.
 	 */
 	class StructuredClone
 	{
 		NONCOPYABLE(StructuredClone);
 	public:
 		StructuredClone();
 		~StructuredClone();
 		u64* m_Data;
 		size_t m_Size;
 	};
 
 	shared_ptr<StructuredClone> WriteStructuredClone(JS::HandleValue v) const;
 	void ReadStructuredClone(const shared_ptr<StructuredClone>& ptr, JS::MutableHandleValue ret) const;
 
 	/**
 	 * Retrieve the private data field of a JSObject that is an instance of the given JSClass.
 	 */
 	template <typename T>
 	static T* GetPrivate(JSContext* cx, JS::HandleObject thisobj, JSClass* jsClass)
 	{
 		JSAutoRequest rq(cx);
 		T* value = static_cast<T*>(JS_GetInstancePrivate(cx, thisobj, jsClass, nullptr));
 		if (value == nullptr && !JS_IsExceptionPending(cx))
 			JS_ReportError(cx, "Private data of the given object is null!");
 		return value;
 	}
 
 	/**
 	 * Retrieve the private data field of a JS Object that is an instance of the given JSClass.
 	 * If an error occurs, GetPrivate will report it with the according stack.
 	 */
 	template <typename T>
 	static T* GetPrivate(JSContext* cx, JS::CallArgs& callArgs, JSClass* jsClass)
 	{
 		JSAutoRequest rq(cx);
 		if (!callArgs.thisv().isObject())
 		{
 			JS_ReportError(cx, "Cannot retrieve private JS class data because from a non-object value!");
 			return nullptr;
 		}
 		JS::RootedObject thisObj(cx, &callArgs.thisv().toObject());
 		T* value = static_cast<T*>(JS_GetInstancePrivate(cx, thisObj, jsClass, &callArgs));
 		if (value == nullptr && !JS_IsExceptionPending(cx))
 			JS_ReportError(cx, "Private data of the given object is null!");
 		return value;
 	}
 
 	/**
 	 * Converts |a| if needed and assigns it to |handle|.
 	 * This is meant for use in other templates where we want to use the same code for JS::RootedValue&/JS::HandleValue and
 	 * other types. Note that functions are meant to take JS::HandleValue instead of JS::RootedValue&, but this implicit
 	 * conversion does not work for templates (exact type matches required for type deduction).
 	 * A similar functionality could also be implemented as a ToJSVal specialization. The current approach was preferred
 	 * because "conversions" from JS::HandleValue to JS::MutableHandleValue are unusual and should not happen "by accident".
 	 */
 	template <typename T>
 	static void AssignOrToJSVal(JSContext* cx, JS::MutableHandleValue handle, const T& a);
 
 	/**
 	 * The same as AssignOrToJSVal, but also allows JS::Value for T.
 	 * In most cases it's not safe to use the plain (unrooted) JS::Value type, but this can happen quite
 	 * easily with template functions. The idea is that the linker prints an error if AssignOrToJSVal is
 	 * used with JS::Value. If the specialization for JS::Value should be allowed, you can use this
 	 * "unrooted" version of AssignOrToJSVal.
 	 */
 	template <typename T>
 	static void AssignOrToJSValUnrooted(JSContext* cx, JS::MutableHandleValue handle, const T& a)
 	{
 		AssignOrToJSVal(cx, handle, a);
 	}
 
 	/**
 	 * Converts |val| to T if needed or just returns it if it's a handle.
 	 * This is meant for use in other templates where we want to use the same code for JS::HandleValue and
 	 * other types.
 	 */
 	template <typename T>
 	static T AssignOrFromJSVal(JSContext* cx, const JS::HandleValue& val, bool& ret);
 
 private:
 
+	/**
+	 * Careful, the CreateObject_ helpers avoid creation of the JSAutoRequest!
+	 */
+	bool CreateObject_(JS::MutableHandleObject obj) const;
+
+	template<typename T, typename... Args>
+	bool CreateObject_(JS::MutableHandleObject obj, const char* propertyName, const T& propertyValue, Args const&... args) const
+	{
+		// JSAutoRequest is the responsibility of the caller
+		JSContext* cx = GetContext();
+		JS::RootedValue val(cx);
+		AssignOrToJSVal(cx, &val, propertyValue);
+
+		return CreateObject_(obj, args...) && JS_DefineProperty(cx, obj, propertyName, val, JSPROP_ENUMERATE);
+	}
+
 	bool CallFunction_(JS::HandleValue val, const char* name, JS::HandleValueArray argv, JS::MutableHandleValue ret) const;
 	bool Eval_(const char* code, JS::MutableHandleValue ret) const;
 	bool Eval_(const wchar_t* code, JS::MutableHandleValue ret) const;
 	bool SetGlobal_(const char* name, JS::HandleValue value, bool replace, bool constant, bool enumerate);
 	bool SetProperty_(JS::HandleValue obj, const char* name, JS::HandleValue value, bool constant, bool enumerate) const;
 	bool SetProperty_(JS::HandleValue obj, const wchar_t* name, JS::HandleValue value, bool constant, bool enumerate) const;
 	bool SetPropertyInt_(JS::HandleValue obj, int name, JS::HandleValue value, bool constant, bool enumerate) const;
 	bool GetProperty_(JS::HandleValue obj, const char* name, JS::MutableHandleValue out) const;
 	bool GetPropertyInt_(JS::HandleValue obj, int name, JS::MutableHandleValue value) const;
 	static bool IsExceptionPending(JSContext* cx);
 
 	struct CustomType
 	{
 		// TODO: Move assignment operator and move constructor only have to be
 		// explicitly defined for Visual Studio. VS2013 is still behind on C++11 support
 		// What's missing is what they call "Rvalue references v3.0", see
 		// https://msdn.microsoft.com/en-us/library/hh567368.aspx#rvref
 		CustomType() {}
 		CustomType& operator=(CustomType&& other)
 		{
 			m_Prototype = std::move(other.m_Prototype);
 			m_Class = std::move(other.m_Class);
 			m_Constructor = std::move(other.m_Constructor);
 			return *this;
 		}
 		CustomType(CustomType&& other)
 		{
 			m_Prototype = std::move(other.m_Prototype);
 			m_Class = std::move(other.m_Class);
 			m_Constructor = std::move(other.m_Constructor);
 		}
 
 		JS::PersistentRootedObject m_Prototype;
 		JSClass* m_Class;
 		JSNative m_Constructor;
 	};
 	void Register(const char* name, JSNative fptr, size_t nargs) const;
 
 	// Take care to keep this declaration before heap rooted members. Destructors of heap rooted
 	// members have to be called before the runtime destructor.
 	std::unique_ptr<ScriptInterface_impl> m;
 
 	boost::rand48* m_rng;
 	std::map<std::string, CustomType> m_CustomObjectTypes;
 
 // The nasty macro/template bits are split into a separate file so you don't have to look at them
 public:
 	#include "NativeWrapperDecls.h"
 	// This declares:
 	//
 	//   template <R, T0..., TR (*fptr) (void* cbdata, T0...)>
 	//   void RegisterFunction(const char* functionName) const;
 	//
 	//   template <R, T0..., TR (*fptr) (void* cbdata, T0...)>
 	//   static JSNative call;
 	//
 	//   template <R, T0..., JSClass*, TC, TR (TC:*fptr) (T0...)>
 	//   static JSNative callMethod;
 	//
 	//   template <R, T0..., JSClass*, TC, TR (TC:*fptr) const (T0...)>
 	//   static JSNative callMethodConst;
 	//
 	//   template <T0...>
 	//   static size_t nargs();
 	//
 	//   template <R, T0...>
 	//   bool CallFunction(JS::HandleValue val, const char* name, R& ret, const T0&...) const;
 	//
 	//   template <R, T0...>
 	//   bool CallFunction(JS::HandleValue val, const char* name, JS::Rooted<R>* ret, const T0&...) const;
 	//
 	//   template <R, T0...>
 	//   bool CallFunction(JS::HandleValue val, const char* name, JS::MutableHandle<R> ret, const T0&...) const;
 	//
 	//   template <T0...>
 	//   bool CallFunctionVoid(JS::HandleValue val, const char* name, const T0&...) const;
 };
 
 // Implement those declared functions
 #include "NativeWrapperDefns.h"
 
 template<typename T>
 inline void ScriptInterface::AssignOrToJSVal(JSContext* cx, JS::MutableHandleValue handle, const T& a)
 {
 	ToJSVal(cx, handle, a);
 }
 
 template<>
 inline void ScriptInterface::AssignOrToJSVal<JS::PersistentRootedValue>(JSContext* UNUSED(cx), JS::MutableHandleValue handle, const JS::PersistentRootedValue& a)
 {
 	handle.set(a);
 }
 
 template<>
 inline void ScriptInterface::AssignOrToJSVal<JS::RootedValue>(JSContext* UNUSED(cx), JS::MutableHandleValue handle, const JS::RootedValue& a)
 {
 	handle.set(a);
 }
 
 template <>
 inline void ScriptInterface::AssignOrToJSVal<JS::HandleValue>(JSContext* UNUSED(cx), JS::MutableHandleValue handle, const JS::HandleValue& a)
 {
 	handle.set(a);
 }
 
 template <>
 inline void ScriptInterface::AssignOrToJSValUnrooted<JS::Value>(JSContext* UNUSED(cx), JS::MutableHandleValue handle, const JS::Value& a)
 {
 	handle.set(a);
 }
 
 template<typename T>
 inline T ScriptInterface::AssignOrFromJSVal(JSContext* cx, const JS::HandleValue& val, bool& ret)
 {
 	T retVal;
 	ret = FromJSVal(cx, val, retVal);
 	return retVal;
 }
 
 template<>
 inline JS::HandleValue ScriptInterface::AssignOrFromJSVal<JS::HandleValue>(JSContext* UNUSED(cx), const JS::HandleValue& val, bool& ret)
 {
 	ret = true;
 	return val;
 }
 
 template<typename T>
 bool ScriptInterface::SetGlobal(const char* name, const T& value, bool replace, bool constant, bool enumerate)
 {
 	JSAutoRequest rq(GetContext());
 	JS::RootedValue val(GetContext());
 	AssignOrToJSVal(GetContext(), &val, value);
 	return SetGlobal_(name, val, replace, constant, enumerate);
 }
 
 template<typename T>
 bool ScriptInterface::SetProperty(JS::HandleValue obj, const char* name, const T& value, bool constant, bool enumerate) const
 {
 	JSAutoRequest rq(GetContext());
 	JS::RootedValue val(GetContext());
 	AssignOrToJSVal(GetContext(), &val, value);
 	return SetProperty_(obj, name, val, constant, enumerate);
 }
 
 template<typename T>
 bool ScriptInterface::SetProperty(JS::HandleValue obj, const wchar_t* name, const T& value, bool constant, bool enumerate) const
 {
 	JSAutoRequest rq(GetContext());
 	JS::RootedValue val(GetContext());
 	AssignOrToJSVal(GetContext(), &val, value);
 	return SetProperty_(obj, name, val, constant, enumerate);
 }
 
 template<typename T>
 bool ScriptInterface::SetPropertyInt(JS::HandleValue obj, int name, const T& value, bool constant, bool enumerate) const
 {
 	JSAutoRequest rq(GetContext());
 	JS::RootedValue val(GetContext());
 	AssignOrToJSVal(GetContext(), &val, value);
 	return SetPropertyInt_(obj, name, val, constant, enumerate);
 }
 
 template<typename T>
 bool ScriptInterface::GetProperty(JS::HandleValue obj, const char* name, T& out) const
 {
 	JSContext* cx = GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue val(cx);
 	if (!GetProperty_(obj, name, &val))
 		return false;
 	return FromJSVal(cx, val, out);
 }
 
 template<typename T>
 bool ScriptInterface::GetPropertyInt(JS::HandleValue obj, int name, T& out) const
 {
 	JSAutoRequest rq(GetContext());
 	JS::RootedValue val(GetContext());
 	if (!GetPropertyInt_(obj, name, &val))
 		return false;
 	return FromJSVal(GetContext(), val, out);
 }
 
 template<typename CHAR>
 bool ScriptInterface::Eval(const CHAR* code, JS::MutableHandleValue ret) const
 {
 	if (!Eval_(code, ret))
 		return false;
 	return true;
 }
 
 template<typename T, typename CHAR>
 bool ScriptInterface::Eval(const CHAR* code, T& ret) const
 {
 	JSAutoRequest rq(GetContext());
 	JS::RootedValue rval(GetContext());
 	if (!Eval_(code, &rval))
 		return false;
 	return FromJSVal(GetContext(), rval, ret);
 }
 
 #endif // INCLUDED_SCRIPTINTERFACE