diff --git a/test-app/app/src/main/assets/app/mainpage.js b/test-app/app/src/main/assets/app/mainpage.js index a89f86029..f6126dcdc 100644 --- a/test-app/app/src/main/assets/app/mainpage.js +++ b/test-app/app/src/main/assets/app/mainpage.js @@ -86,6 +86,7 @@ require("./tests/testRuntimeImplementedAPIs"); require("./tests/testsInstanceOfOperator"); require("./tests/testProxyReceivers"); require("./tests/testReleaseNativeCounterpart"); +require("./tests/testObjectArgumentPath"); require("./tests/testJSONObjects"); require("./tests/kotlin/companions/testCompanionObjectsSupport"); require("./tests/kotlin/properties/testPropertiesSupport"); diff --git a/test-app/app/src/main/assets/app/tests/testObjectArgumentPath.js b/test-app/app/src/main/assets/app/tests/testObjectArgumentPath.js new file mode 100644 index 000000000..785312e35 --- /dev/null +++ b/test-app/app/src/main/assets/app/tests/testObjectArgumentPath.js @@ -0,0 +1,177 @@ +describe("Object arguments and cached call signatures", function () { + function roundTrip(obj) { + return java.util.Collections.singletonList(obj).get(0); + } + + it("passes a Java wrapper as an object argument on every call", function () { + var list = new java.util.ArrayList(); + for (var i = 0; i < 3; i++) { + expect(roundTrip(list)).toBe(list); + } + }); + + it("passes an extended class instance as an object argument", function () { + var Extended = java.lang.Object.extend({ + toString: function () { + return "extended arg"; + } + }); + var instance = new Extended(); + for (var i = 0; i < 3; i++) { + expect(roundTrip(instance)).toBe(instance); + expect(new java.lang.StringBuilder().append(instance).toString()).toBe("extended arg"); + } + }); + + it("passes a TypeScript subclass instance as an object argument", function () { + var TsButton = (function (_super) { + __extends(TsButton, _super); + function TsButton() { + var _this = _super.call(this) || this; + _this.label = "ts arg"; + return _this; + } + TsButton.prototype.toString = function () { + return this.label; + }; + return TsButton; + })(com.tns.tests.Button1); + + var button = new TsButton(); + for (var i = 0; i < 3; i++) { + expect(roundTrip(button)).toBe(button); + expect(new java.lang.StringBuilder().append(button).toString()).toBe("ts arg"); + } + }); + + it("rejects a released wrapper as an object argument", function () { + var released = new java.lang.Object(); + global.__releaseNativeCounterpart(released); + expect(function () { + roundTrip(released); + }).toThrow(); + }); + + it("resolves numeric casts, typed nulls and wrappers on a warm overload cache", function () { + var list = new java.util.ArrayList(); + var sb = new java.lang.StringBuilder(); + for (var i = 0; i < 3; i++) { + sb.append(long(5)); + sb.append(char("x")); + sb.append(double(1)); + sb.append(float(2)); + sb.append(java.lang.String.null); + sb.append(java.lang.Object.null); + sb.append(list); + sb.append("|"); + } + var round = "5x1.02.0nullnull[]|"; + expect(sb.toString()).toBe(round + round + round); + }); + + it("passes a numeric cast to a method with a single signature", function () { + for (var i = 0; i < 3; i++) { + expect(java.lang.Long.toHexString(long("4294967296"))).toBe("100000000"); + } + }); + + it("constructs through each overload on a warm constructor cache", function () { + for (var i = 0; i < 3; i++) { + expect(new java.lang.StringBuilder("ab").toString()).toBe("ab"); + expect(new java.lang.StringBuilder(32).capacity()).toBe(32); + expect(new java.lang.StringBuilder(new java.lang.StringBuilder("cs")).toString()).toBe("cs"); + var plain = new java.lang.Object(); + expect(plain.getClass().getName()).toBe("java.lang.Object"); + } + }); + + it("constructs extended classes repeatedly, interleaved and with arguments", function () { + var Counting = java.util.ArrayList.extend({ + size: function () { + return this.super.size() + 100; + } + }); + var Named = java.lang.Object.extend({ + toString: function () { + return "named"; + } + }); + var source = new java.util.ArrayList(); + source.add("a"); + + var seen = []; + for (var i = 0; i < 20; i++) { + var empty = new Counting(); + empty.add("x"); + expect(empty.size()).toBe(101); + expect(new Counting(10).size()).toBe(100); + expect(new Counting(source).size()).toBe(101); + var named = new Named(); + expect(named.toString()).toBe("named"); + expect(seen.indexOf(empty)).toBe(-1); + seen.push(empty); + } + }); + + describe("cached Java objects of linked wrappers", function () { + var Holder = com.tns.tests.WrapperHolder; + + function collectJava() { + for (var i = 0; i < 3; i++) { + java.lang.Runtime.getRuntime().gc(); + java.lang.System.runFinalization(); + } + } + + afterEach(function () { + Holder.held = null; + }); + + it("never pass null for a wrapper whose Java object was collected after Java weakened it", function () { + (function () { + Holder.held = new java.lang.StringBuilder("weakened"); + })(); + gc(); + // Any Java call flushes the collected wrapper, weakening its Java object. + collectJava(); + var again = Holder.held; + Holder.held = null; + collectJava(); + + var passed; + try { + passed = java.util.Collections.singletonList(again).get(0); + } catch (e) { + passed = "threw"; + } + expect(passed === again || passed === "threw").toBe(true); + }); + + it("resolve a reachable wrapper after warm instance calls and a collection", function () { + var sb = new java.lang.StringBuilder("warm"); + for (var i = 0; i < 50; i++) { + expect(sb.length()).toBe(4); + } + for (var j = 0; j < 2000; j++) { + new java.lang.Object(); + } + gc(); + collectJava(); + expect(sb.toString()).toBe("warm"); + expect(java.util.Collections.singletonList(sb).get(0)).toBe(sb); + }); + + it("resolve a constructed instance after Java made another of its class during the constructor", function () { + var Outer = com.tns.tests.SelfNesting.extend({ + touch: function () { + this.super.touch(); + }, + selfNestingSpec: true + }); + var outer = new Outer(true); + expect(outer.getTag()).toBe(2); + collectJava(); + expect(outer.getTag()).toBe(2); + }); + }); +}); diff --git a/test-app/app/src/main/java/com/tns/tests/SelfNesting.java b/test-app/app/src/main/java/com/tns/tests/SelfNesting.java new file mode 100644 index 000000000..baa553a03 --- /dev/null +++ b/test-app/app/src/main/java/com/tns/tests/SelfNesting.java @@ -0,0 +1,25 @@ +package com.tns.tests; + +/** Creates an instance of its own runtime class while its constructor runs. */ +public class SelfNesting { + private final int tag; + + public SelfNesting() { + tag = 1; + } + + public SelfNesting(boolean nest) throws Exception { + tag = 2; + if (nest) { + SelfNesting nested = getClass().getConstructor().newInstance(); + nested.touch(); + } + } + + public int getTag() { + return tag; + } + + public void touch() { + } +} diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp index 51a88bad3..819f836ae 100644 --- a/test-app/runtime/src/main/cpp/CallbackHandlers.cpp +++ b/test-app/runtime/src/main/cpp/CallbackHandlers.cpp @@ -214,7 +214,8 @@ bool CallbackHandlers::RegisterInstance(Isolate *isolate, const Local &j bool isInterface, const std::string &baseClassName, uint64_t defaultOverrides, - const vector *contentMemberNames) { + const vector *contentMemberNames, + jclass *resolvedClass) { bool success; DEBUG_WRITE("RegisterInstance called for '%s'", fullClassName.c_str()); @@ -230,9 +231,15 @@ bool CallbackHandlers::RegisterInstance(Isolate *isolate, const Local &j // The default-overriding class does not depend on the implementation object, whose // properties ResolveClass would otherwise read, getters included. - jclass generatedJavaClass = ResolveClass(isolate, baseClassName, fullClassName, - defaultOverrides != 0 ? Local() : implementationObject, - isInterface, contentMemberNames); + jclass generatedJavaClass = resolvedClass != nullptr ? *resolvedClass : nullptr; + if (generatedJavaClass == nullptr) { + generatedJavaClass = ResolveClass(isolate, baseClassName, fullClassName, + defaultOverrides != 0 ? Local() : implementationObject, + isInterface, contentMemberNames); + if (resolvedClass != nullptr) { + *resolvedClass = generatedJavaClass; + } + } int javaObjectID = objectManager->GenerateNewObjectID(); @@ -253,7 +260,7 @@ bool CallbackHandlers::RegisterInstance(Isolate *isolate, const Local &j instance = env.NewObject(generatedJavaClass, mi.mid); } else { // resolve arguments before passing them on to the constructor - JsArgConverter argConverter(argWrapper.args, mi.signature); + JsArgConverter argConverter(argWrapper.args, mi.parsedSig); auto ctorArgs = argConverter.ToArgs(); instance = env.NewObjectA(generatedJavaClass, mi.mid, ctorArgs); @@ -268,6 +275,9 @@ bool CallbackHandlers::RegisterInstance(Isolate *isolate, const Local &j jlong usedJavaMemory = env.CallLongMethod(runtime->GetJavaRuntime(), REGISTER_CONSTRUCTED_INSTANCE_ID, instance, javaObjectID); + // While the constructor ran, an instance of the same class that Java created could take + // this id until the registration above replaced it; a jweak cached then names that one. + objectManager->ForgetCachedJavaObject(javaObjectID); AdjustAmountOfExternalAllocatedMemory(isolate, usedJavaMemory); @@ -505,9 +515,10 @@ void CallbackHandlers::CallJavaMethod(const Local &caller, const string methodName.c_str()); } + const std::vector *parsedSig = mi != nullptr ? &mi->parsedSig : nullptr; JsArgConverter argConverter = (entry != nullptr && entry->isExtensionFunction) - ? JsArgConverter(caller, args, *sig, entry) - : JsArgConverter(args, false, *sig, entry); + ? JsArgConverter(caller, args, *sig, entry, parsedSig) + : JsArgConverter(args, false, *sig, entry, parsedSig); if (!argConverter.IsValid()) { diff --git a/test-app/runtime/src/main/cpp/CallbackHandlers.h b/test-app/runtime/src/main/cpp/CallbackHandlers.h index 1bd3865fd..d9f9d71b6 100644 --- a/test-app/runtime/src/main/cpp/CallbackHandlers.h +++ b/test-app/runtime/src/main/cpp/CallbackHandlers.h @@ -42,7 +42,8 @@ namespace tns { bool isInterface, const std::string &baseClassName = std::string(), uint64_t defaultOverrides = 0, - const std::vector *contentMemberNames = nullptr); + const std::vector *contentMemberNames = nullptr, + jclass *resolvedClass = nullptr); // Whether GetImplementedInterfaces would list any interface, without calling Java. static bool HasImplementedInterfaces(v8::Isolate *isolate, const v8::Local &implementationObject); diff --git a/test-app/runtime/src/main/cpp/JsArgConverter.cpp b/test-app/runtime/src/main/cpp/JsArgConverter.cpp index 898f65635..392a6ad59 100644 --- a/test-app/runtime/src/main/cpp/JsArgConverter.cpp +++ b/test-app/runtime/src/main/cpp/JsArgConverter.cpp @@ -89,25 +89,33 @@ namespace { } } +void JsArgConverter::SetTokens(const string &methodSignature, MetadataEntry *entry, + const std::vector *parsedSignature) { + if (parsedSignature != nullptr) { + m_tokens = parsedSignature; + } else if ((entry != nullptr) && (entry->getIsResolved())) { + if (entry->parsedSig.empty()) { + JniSignatureParser parser(methodSignature); + entry->parsedSig = parser.Parse(); + } + m_tokens = &entry->parsedSig; + } else { + JniSignatureParser parser(methodSignature); + m_ownedTokens = parser.Parse(); + } +} + JsArgConverter::JsArgConverter(const Local &caller, const v8::FunctionCallbackInfo &args, - const string &methodSignature, MetadataEntry *entry) + const string &methodSignature, MetadataEntry *entry, + const std::vector *parsedSignature) : m_isolate(args.GetIsolate()), m_isValid(true), m_error(Error()) { int v8ProvidedArgumentsLength = args.Length(); m_argsLen = 1 + v8ProvidedArgumentsLength; if (m_argsLen > 0) { - if ((entry != nullptr) && (entry->getIsResolved())) { - if (entry->parsedSig.empty()) { - JniSignatureParser parser(methodSignature); - entry->parsedSig = parser.Parse(); - } - m_tokens = &entry->parsedSig; - } else { - JniSignatureParser parser(methodSignature); - m_ownedTokens = parser.Parse(); - } + SetTokens(methodSignature, entry, parsedSignature); m_isValid = ConvertArg(caller, 0); @@ -127,22 +135,14 @@ JsArgConverter::JsArgConverter(const Local &caller, JsArgConverter::JsArgConverter(const v8::FunctionCallbackInfo &args, bool hasImplementationObject, const string &methodSignature, - MetadataEntry *entry) + MetadataEntry *entry, + const std::vector *parsedSignature) : m_isolate(args.GetIsolate()), m_isValid(true), m_error(Error()) { m_argsLen = !hasImplementationObject ? args.Length() : args.Length() - 1; if (m_argsLen > 0) { - if ((entry != nullptr) && (entry->getIsResolved())) { - if (entry->parsedSig.empty()) { - JniSignatureParser parser(methodSignature); - entry->parsedSig = parser.Parse(); - } - m_tokens = &entry->parsedSig; - } else { - JniSignatureParser parser(methodSignature); - m_ownedTokens = parser.Parse(); - } + SetTokens(methodSignature, entry, parsedSignature); for (int i = 0; i < m_argsLen; i++) { m_isValid = ConvertArg(args[i], i); @@ -155,16 +155,11 @@ JsArgConverter::JsArgConverter(const v8::FunctionCallbackInfo &args, } JsArgConverter::JsArgConverter(const v8::FunctionCallbackInfo &args, - const string &methodSignature) + const std::vector &parsedSignature) : m_isolate(args.GetIsolate()), m_isValid(true), - m_error(Error()) { + m_tokens(&parsedSignature), m_error(Error()) { m_argsLen = args.Length(); - if (m_argsLen > 0) { - JniSignatureParser parser(methodSignature); - m_ownedTokens = parser.Parse(); - } - for (int i = 0; i < m_argsLen; i++) { m_isValid = ConvertArg(args[i], i); @@ -321,7 +316,10 @@ bool JsArgConverter::ConvertArg(const Local &jsArg, int index) { auto context = m_isolate->GetCurrentContext(); auto jsObject = arg->ToObject(context).ToLocalChecked(); - auto castType = NumericCasts::GetCastType(m_isolate, jsObject); + // Cast markers and the null sentinel are only put on plain objects, never on a + // Java wrapper (an object with the runtime's internal fields). + bool isWrapper = ObjectManager::HasMetadataField(jsObject); + auto castType = isWrapper ? CastType::None : NumericCasts::GetCastType(m_isolate, jsObject); Local castValue; JniLocalRef obj; @@ -419,8 +417,10 @@ bool JsArgConverter::ConvertArg(const Local &jsArg, int index) { ? GetOrLinkJavaBuffer(m_objectManager, jsObject) : m_objectManager->GetJavaObjectByJsObject(jsObject); - V8GetPrivateValue(m_isolate, jsObject, V8StringConstants::GetNullNodePrivate(m_isolate), - castValue); + if (!isWrapper) { + V8GetPrivateValue(m_isolate, jsObject, V8StringConstants::GetNullNodePrivate(m_isolate), + castValue); + } if (!castValue.IsEmpty()) { SetConvertedObject(index, nullptr); diff --git a/test-app/runtime/src/main/cpp/JsArgConverter.h b/test-app/runtime/src/main/cpp/JsArgConverter.h index 12787019e..42cbcadcd 100644 --- a/test-app/runtime/src/main/cpp/JsArgConverter.h +++ b/test-app/runtime/src/main/cpp/JsArgConverter.h @@ -24,11 +24,14 @@ namespace tns { class JsArgConverter { public: - JsArgConverter(const v8::Local& caller, const v8::FunctionCallbackInfo& args, const std::string& methodSignature, MetadataEntry* entry); + // parsedSignature, when given, is methodSignature already parsed and must outlive the + // converter. + JsArgConverter(const v8::Local& caller, const v8::FunctionCallbackInfo& args, const std::string& methodSignature, MetadataEntry* entry, const std::vector* parsedSignature = nullptr); - JsArgConverter(const v8::FunctionCallbackInfo& args, bool hasImplementationObject, const std::string& methodSignature, MetadataEntry* entry); + JsArgConverter(const v8::FunctionCallbackInfo& args, bool hasImplementationObject, const std::string& methodSignature, MetadataEntry* entry, const std::vector* parsedSignature = nullptr); - JsArgConverter(const v8::FunctionCallbackInfo& args, const std::string& methodSignature); + // parsedSignature must outlive the converter. + JsArgConverter(const v8::FunctionCallbackInfo& args, const std::vector& parsedSignature); JsArgConverter(const JsArgConverter&) = delete; @@ -69,6 +72,8 @@ namespace tns { private: + void SetTokens(const std::string& methodSignature, MetadataEntry* entry, const std::vector* parsedSignature); + bool ConvertArg(const v8::Local& jsArg, int index); bool ConvertJavaScriptArray(const v8::Local& source, size_t length, int index); diff --git a/test-app/runtime/src/main/cpp/JsArgToArrayConverter.cpp b/test-app/runtime/src/main/cpp/JsArgToArrayConverter.cpp index 82ea5e3f7..8f616e7ff 100644 --- a/test-app/runtime/src/main/cpp/JsArgToArrayConverter.cpp +++ b/test-app/runtime/src/main/cpp/JsArgToArrayConverter.cpp @@ -142,7 +142,9 @@ bool JsArgToArrayConverter::ConvertArg(Local context, const LocalIsObject()) { auto jsObj = arg->ToObject(context).ToLocalChecked(); - auto castType = NumericCasts::GetCastType(isolate, jsObj); + // Cast markers and the null sentinel are never put on a Java wrapper. + bool isWrapper = ObjectManager::HasMetadataField(jsObj); + auto castType = isWrapper ? CastType::None : NumericCasts::GetCastType(isolate, jsObj); Local castValue; jchar charValue; @@ -252,8 +254,10 @@ bool JsArgToArrayConverter::ConvertArg(Local context, const LocalGetJavaObjectByJsObject(jsObj); - V8GetPrivateValue(isolate, jsObj, V8StringConstants::GetNullNodePrivate(isolate), - castValue); + if (!isWrapper) { + V8GetPrivateValue(isolate, jsObj, V8StringConstants::GetNullNodePrivate(isolate), + castValue); + } if (!castValue.IsEmpty()) { auto node = reinterpret_cast(castValue.As()->Value(v8::kExternalPointerTypeTagDefault)); diff --git a/test-app/runtime/src/main/cpp/LRUCache.h b/test-app/runtime/src/main/cpp/LRUCache.h index 87ed14cba..adda08abc 100644 --- a/test-app/runtime/src/main/cpp/LRUCache.h +++ b/test-app/runtime/src/main/cpp/LRUCache.h @@ -51,13 +51,14 @@ class LRUCache { NS_CHECK((0 < m_capacity) && (m_capacity < 10000)); } - // Obtain value of the cached function for k - value_type operator()(const key_type& k) { + // Obtain value of the cached function for k. validate=false skips the validity + // callback for a hit the caller knows is still valid. + value_type operator()(const key_type& k, bool validate = true) { // Attempt to find existing record auto it = m_key_to_value.find(k); - if (m_cacheValidCallback != nullptr && it != m_key_to_value.end()) { + if (validate && m_cacheValidCallback != nullptr && it != m_key_to_value.end()) { //check if cache is still valid if (!m_cacheValidCallback(k, (*it).second.first, m_state)) { //cache is not valid anymore, evict the key @@ -122,8 +123,6 @@ class LRUCache { m_key_tracker.clear(); } - private: - void evictKey(const key_type& key) { auto it = m_key_to_value.find(key); if (it != m_key_to_value.end()) { @@ -135,6 +134,8 @@ class LRUCache { } } + private: + // Record a fresh key-value pair in the cache void insert(const key_type& k, const value_type& v) { // Method is only called on cache misses diff --git a/test-app/runtime/src/main/cpp/MetadataNode.cpp b/test-app/runtime/src/main/cpp/MetadataNode.cpp index db6f8c36e..15eb80cac 100644 --- a/test-app/runtime/src/main/cpp/MetadataNode.cpp +++ b/test-app/runtime/src/main/cpp/MetadataNode.cpp @@ -491,6 +491,8 @@ void MetadataNode::NullObjectAccessorGetterCallback(const FunctionCallbackInfo nullObject; if (!thiz->GetPrivate(context, nullObjectKey).ToLocal(&nullObject) || !nullObject->IsObject()) { auto node = reinterpret_cast(info.Data().As()->Value(v8::kExternalPointerTypeTagDefault)); + // A plain object: argument conversion never reads the null-node private + // from a Java wrapper. auto sentinel = Object::New(isolate); V8SetPrivateValue(isolate, sentinel, V8StringConstants::GetNullNodePrivate(isolate), External::New(isolate, node, v8::kExternalPointerTypeTagDefault)); // Function::New does not cache its template in the context, so the @@ -1525,7 +1527,8 @@ void MetadataNode::ExtendedClassConstructorCallback(const v8::FunctionCallbackIn ArgsWrapper argWrapper(info, ArgType::Class); bool success = CallbackHandlers::RegisterInstance(isolate, thiz, extData->fullClassName, argWrapper, implementationObject, false, extData->node->m_name, extData->defaultOverrides, - extData->contentMemberNames ? &*extData->contentMemberNames : nullptr); + extData->contentMemberNames ? &*extData->contentMemberNames : nullptr, + &extData->resolvedClass); } catch (NativeScriptException& e) { e.ReThrowToV8(); } catch (std::exception e) { diff --git a/test-app/runtime/src/main/cpp/MetadataNode.h b/test-app/runtime/src/main/cpp/MetadataNode.h index 3313d2a3b..2cad92ba9 100644 --- a/test-app/runtime/src/main/cpp/MetadataNode.h +++ b/test-app/runtime/src/main/cpp/MetadataNode.h @@ -319,6 +319,9 @@ class MetadataNode { std::string fullClassName; uint64_t defaultOverrides = 0; std::optional> contentMemberNames; + // The class cache's global ref for fullClassName once resolved; that cache never + // drops or replaces an entry. + jclass resolvedClass = nullptr; }; struct TypeMetadata { diff --git a/test-app/runtime/src/main/cpp/MethodCache.cpp b/test-app/runtime/src/main/cpp/MethodCache.cpp index d114a239c..36d9b53bc 100644 --- a/test-app/runtime/src/main/cpp/MethodCache.cpp +++ b/test-app/runtime/src/main/cpp/MethodCache.cpp @@ -2,6 +2,7 @@ #include #include "JniLocalRef.h" +#include "JniSignatureParser.h" #include "JsArgToArrayConverter.h" #include "MetadataNode.h" #include "NativeScriptAssert.h" @@ -69,6 +70,7 @@ const MethodCache::CacheMethodInfo& MethodCache::ResolveMethodSignature(const st NS_DCHECK(clazz != nullptr); method_info.clazz = clazz; method_info.signature = signature; + method_info.parsedSig = JniSignatureParser(signature).Parse(); method_info.returnType = MetadataReader::ParseReturnType(method_info.signature); method_info.retType = MetadataReader::GetReturnType(method_info.returnType); method_info.isStatic = isStatic; @@ -78,7 +80,7 @@ const MethodCache::CacheMethodInfo& MethodCache::ResolveMethodSignature(const st env.GetMethodID(clazz, methodName, signature); std::unique_lock lock(signatureCacheMutex); - return s_mthod_ctor_signature_cache.emplace(encoded_method_signature, method_info).first->second; + return s_mthod_ctor_signature_cache.emplace(encoded_method_signature, std::move(method_info)).first->second; } return s_unresolved; @@ -107,6 +109,7 @@ const MethodCache::CacheMethodInfo& MethodCache::ResolveConstructorSignature(con JEnv env; constructor_info.clazz = javaClass; constructor_info.signature = signature; + constructor_info.parsedSig = JniSignatureParser(signature).Parse(); constructor_info.mid = env.GetMethodID(javaClass, "", signature); // Runtime.resolveConstructorSignature answers this for no Java arguments only for an // interface proxy; any other class would need a one-argument call to resolve to it. @@ -114,7 +117,7 @@ const MethodCache::CacheMethodInfo& MethodCache::ResolveConstructorSignature(con constructor_info.isInterfaceProxy = !hasJavaArgs && signature == "(Ljava/lang/reflect/InvocationHandler;)V"; std::unique_lock lock(signatureCacheMutex); - return s_mthod_ctor_signature_cache.emplace(encoded_ctor_signature, constructor_info).first->second; + return s_mthod_ctor_signature_cache.emplace(encoded_ctor_signature, std::move(constructor_info)).first->second; } return s_unresolved; @@ -140,7 +143,10 @@ void MethodCache::AppendType(string& type, Isolate* isolate, const v8::LocalIsObject()) { + // Cast markers and the null sentinel are never put on a Java wrapper. + bool isWrapper = value->IsObject() && ObjectManager::HasMetadataField(value.As()); + + if (value->IsObject() && !isWrapper) { auto context = isolate->GetCurrentContext(); auto objVal = value->ToObject(context).ToLocalChecked(); Local nullNode; //out @@ -199,7 +205,7 @@ void MethodCache::AppendType(string& type, Isolate* isolate, const v8::LocalIsObject()) { auto context = isolate->GetCurrentContext(); auto object = value->ToObject(context).ToLocalChecked(); - auto castType = NumericCasts::GetCastType(isolate, object); + auto castType = isWrapper ? CastType::None : NumericCasts::GetCastType(isolate, object); MetadataNode* node; switch (castType) { diff --git a/test-app/runtime/src/main/cpp/MethodCache.h b/test-app/runtime/src/main/cpp/MethodCache.h index 127eff086..56f5e3785 100644 --- a/test-app/runtime/src/main/cpp/MethodCache.h +++ b/test-app/runtime/src/main/cpp/MethodCache.h @@ -2,6 +2,7 @@ #define METHODCACHE_H_ #include +#include #include #include "v8.h" #include "JEnv.h" @@ -23,6 +24,8 @@ class MethodCache { retType(MethodReturnType::Unknown), mid(nullptr), clazz(nullptr), isStatic(false), isInterfaceProxy(false) { } std::string signature; + // signature parsed into argument types; set before the entry is published. + std::vector parsedSig; std::string returnType; MethodReturnType retType; jmethodID mid; diff --git a/test-app/runtime/src/main/cpp/NumericCasts.h b/test-app/runtime/src/main/cpp/NumericCasts.h index 3e3d3f7cd..54eae81ed 100644 --- a/test-app/runtime/src/main/cpp/NumericCasts.h +++ b/test-app/runtime/src/main/cpp/NumericCasts.h @@ -27,6 +27,8 @@ class NumericCasts { static v8::Local GetCastValue(v8::Isolate* isolate, const v8::Local& object); + // object must have no internal fields: argument conversion never reads a cast + // marker from a Java wrapper. static void MarkAsLong(v8::Isolate* isolate, const v8::Local& object, const v8::Local& value); private: diff --git a/test-app/runtime/src/main/cpp/ObjectManager.cpp b/test-app/runtime/src/main/cpp/ObjectManager.cpp index 71395e499..d96d4068d 100644 --- a/test-app/runtime/src/main/cpp/ObjectManager.cpp +++ b/test-app/runtime/src/main/cpp/ObjectManager.cpp @@ -110,7 +110,8 @@ JniLocalRef ObjectManager::GetJavaObjectByJsObject( if (jsInstanceInfo != nullptr) { jweak existingObject; try { - existingObject = GetJavaObjectByID(jsInstanceInfo->javaObjectID); + existingObject = GetJavaObjectByID(jsInstanceInfo->javaObjectID, + jsInstanceInfo->javaWeakened); } catch (const NativeScriptException& e) { // this captures usually the error auto className = GetClassName(jsInstanceInfo->objectClazz); @@ -286,10 +287,8 @@ bool ObjectManager::IsJsRuntimeObject(const v8::Local& object) { internalFieldCount == V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT; } -jweak ObjectManager::GetJavaObjectByID(uint32_t javaObjectID) { - jweak obj = m_cache(javaObjectID); - - return obj; +jweak ObjectManager::GetJavaObjectByID(uint32_t javaObjectID, bool validate) { + return m_cache(javaObjectID, validate); } jobject ObjectManager::GetJavaObjectByIDImpl(uint32_t javaObjectID) { @@ -682,6 +681,11 @@ void ObjectManager::FlushFinalizedBatch() { return; } + // Before the call: one that fails part way may already have weakened some of them. + for (jint id : weaken) { + m_idToObject.Find(id)->javaWeakened = true; + } + JEnv env; JNIEnv* raw = env; auto toJava = [raw](const std::vector& ids) -> jintArray { @@ -726,8 +730,7 @@ void ObjectManager::FlushFinalizedBatch() { return; } - auto settle = [this, raw](const std::vector& ids, jintArray array, - bool weakened) { + auto settle = [this, raw](const std::vector& ids, jintArray array) { if (ids.empty()) { return; } @@ -744,13 +747,10 @@ void ObjectManager::FlushFinalizedBatch() { continue; } state->queued = false; - if (weakened) { - state->javaWeakened = true; - } } }; - settle(weaken, (jintArray) weakenArray, true); - settle(check, (jintArray) checkArray, false); + settle(weaken, (jintArray) weakenArray); + settle(check, (jintArray) checkArray); } void ObjectManager::ReleaseCollectedWrapper(int javaObjectID) { diff --git a/test-app/runtime/src/main/cpp/ObjectManager.h b/test-app/runtime/src/main/cpp/ObjectManager.h index 469a18898..62c1217d1 100644 --- a/test-app/runtime/src/main/cpp/ObjectManager.h +++ b/test-app/runtime/src/main/cpp/ObjectManager.h @@ -49,6 +49,10 @@ class ObjectManager { void UpdateCache(int objectID, jobject obj); + // Drops the jweak cached for objectID, after Java may have registered a different object + // under it. + void ForgetCachedJavaObject(int objectID) { m_cache.evictKey(objectID); } + jclass GetJavaClass(const v8::Local& instance); void SetJavaClass(const v8::Local& instance, jclass clazz); @@ -182,8 +186,9 @@ class ObjectManager { // Cleared by ReleaseNativeCounterpart; the registration itself lives until the // wrapper is collected. bool linked = true; - // The Java side holds the object weakly; a finalization now only asks - // whether it is still alive. + // The Java side may hold the object weakly; a finalization now only asks + // whether it is still alive. While false, Java holds the object strongly under + // javaObjectID, so a jweak cached for that id still names it. bool javaWeakened = false; // Queued in a finalizer batch that has not been flushed yet. bool queued = false; @@ -261,7 +266,9 @@ class ObjectManager { // A flush failed; crossings leave the retry to the delayed task. bool m_flushBackingOff = false; - jweak GetJavaObjectByID(uint32_t javaObjectID); + // validate=false only while the Java side holds the object strongly: its jweak + // cannot have been cleared then. + jweak GetJavaObjectByID(uint32_t javaObjectID, bool validate); jobject GetJavaObjectByIDImpl(uint32_t javaObjectID); diff --git a/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp b/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp index a9cd161d5..f3b4c2673 100644 --- a/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp +++ b/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp @@ -108,10 +108,17 @@ bool tns::V8SetPrivateValue(Isolate* isolate, const Local& obj, const Lo return res.FromMaybe(false); } +// A private-symbol access is an own-property lookup that skips interceptors, proxy traps +// and access checks, so it runs no JS and its result does not depend on the context. +static Local PrivateAccessContext(Isolate* isolate, const Local& obj) { + auto context = isolate->GetCurrentContext(); + return context.IsEmpty() ? tns::GetCreationContextOrCurrent(isolate, obj) : context; +} + // An absent private reads as undefined, so one GetPrivate replaces the // HasPrivate + GetPrivate pair; callers never store undefined under these keys. bool tns::V8GetPrivateValue(Isolate* isolate, const Local& obj, const Local& privateKey, Local& out) { - auto context = GetCreationContextOrCurrent(isolate, obj); + auto context = PrivateAccessContext(isolate, obj); Local value; if (!obj->GetPrivate(context, privateKey).ToLocal(&value)) { throw tns::NativeScriptException("Failed to Get Private Value"); @@ -126,7 +133,7 @@ bool tns::V8GetPrivateValue(Isolate* isolate, const Local& obj, const Lo } bool tns::V8SetPrivateValue(Isolate* isolate, const Local& obj, const Local& privateKey, const Local& value) { - auto context = GetCreationContextOrCurrent(isolate, obj); + auto context = PrivateAccessContext(isolate, obj); auto res = obj->SetPrivate(context, privateKey, value); if (res.IsNothing()) {