#import "config.h"

#import "JSManagedValue.h"

#if JSC_OBJC_API_ENABLED

#import "APICast.h"

#import "Heap.h"

#import "JSContextInternal.h"

#import "JSValueInternal.h"

#import "JSWeakValue.h"

#import "WeakHandleOwner.h"

#import "ObjcRuntimeExtras.h"

#import "JSCInlines.h"

#import <wtf/NeverDestroyed.h>

#import <wtf/RetainPtr.h>

class JSManagedValueHandleOwner final : public JSC::WeakHandleOwner {

void finalize(JSC::Handle<JSC::Unknown>, void* context) final;

bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::AbstractSlotVisitor&, ASCIILiteral*) final;

};

static JSManagedValueHandleOwner& managedValueHandleOwner()

{

static NeverDestroyed<JSManagedValueHandleOwner> jsManagedValueHandleOwner;

return jsManagedValueHandleOwner;

}

@implementation JSManagedValue {

JSC::Weak<JSC::JSGlobalObject> m_globalObject;

RefPtr<JSC::JSLock> m_lock;

JSC::JSWeakValue m_weakValue;

RetainPtr<NSMapTable> m_owners;

}

+ (JSManagedValue *)managedValueWithValue:(JSValue *)value

{

return adoptNS([[self alloc] initWithValue:value]).autorelease();

}

+ (JSManagedValue *)managedValueWithValue:(JSValue *)value andOwner:(id)owner

{

auto managedValue = adoptNS([[self alloc] initWithValue:value]);

[value.context.virtualMachine addManagedReference:managedValue.get() withOwner:owner];

return managedValue.autorelease();

}

- (instancetype)init

{

return [self initWithValue:nil];

}

- (instancetype)initWithValue:(JSValue *)value

{

self = [super init];

if (!self)

return nil;

if (!value)

return self;

JSC::JSGlobalObject* globalObject = toJS([value.context JSGlobalContextRef]);

JSC::VM& vm = globalObject->vm();

JSC::JSLockHolder apiLocker(vm);

auto& owner = managedValueHandleOwner();

JSC::Weak<JSC::JSGlobalObject> weak(globalObject, &owner, (__bridge void*)self);

m_globalObject.swap(weak);

m_lock = vm.apiLock();

NSPointerFunctionsOptions weakIDOptions = NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPersonality;

NSPointerFunctionsOptions integerOptions = NSPointerFunctionsOpaqueMemory | NSPointerFunctionsIntegerPersonality;

m_owners = adoptNS([[NSMapTable alloc] initWithKeyOptions:weakIDOptions valueOptions:integerOptions capacity:1]);

JSC::JSValue jsValue = toJS(globalObject, [value JSValueRef]);

if (jsValue.isObject())

m_weakValue.setObject(uncheckedDowncast<JSC::JSObject>(jsValue.asCell()), owner, (__bridge void*)self);

else if (jsValue.isString())

m_weakValue.setString(uncheckedDowncast<JSC::JSString>(jsValue.asCell()), owner, (__bridge void*)self);

else

m_weakValue.setPrimitive(jsValue);

return self;

}

- (void)dealloc

{

JSVirtualMachine *virtualMachine = [[[self value] context] virtualMachine];

if (virtualMachine) {

auto copy = adoptNS([m_owners copy]);

for (id owner in [copy keyEnumerator]) {

size_t count = reinterpret_cast<size_t>(NSMapGet(m_owners.get(), (__bridge void*)owner));

while (count--)

[virtualMachine removeManagedReference:self withOwner:owner];

}

}

[self disconnectValue];

[super dealloc];

}

- (void)didAddOwner:(id)owner

{

size_t count = reinterpret_cast<size_t>(NSMapGet(m_owners.get(), (__bridge void*)owner));

NSMapInsert(m_owners.get(), (__bridge void*)owner, reinterpret_cast<void*>(count + 1));

}

- (void)didRemoveOwner:(id)owner

{

size_t count = reinterpret_cast<size_t>(NSMapGet(m_owners.get(), (__bridge void*)owner));

if (!count)

return;

if (count == 1) {

NSMapRemove(m_owners.get(), (__bridge void*)owner);

return;

}

NSMapInsert(m_owners.get(), (__bridge void*)owner, reinterpret_cast<void*>(count - 1));

}

- (JSValue *)value

{

if (!m_lock)

return nil;

WTF::Locker<JSC::JSLock> locker(m_lock.get());

RefPtr<JSC::VM> vm = m_lock->vm();

if (!vm)

return nil;

if (!m_globalObject)

return nil;

if (m_weakValue.isClear())

return nil;

JSC::JSGlobalObject* globalObject = m_globalObject.get();

JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];

JSC::JSValue value;

if (m_weakValue.isPrimitive())

value = m_weakValue.primitive();

else if (m_weakValue.isString())

value = m_weakValue.string();

else

value = m_weakValue.object();

return [JSValue valueWithJSValueRef:toRef(globalObject, value) inContext:context];

}

- (void)disconnectValue

{

m_globalObject.clear();

m_weakValue.clear();

}

@interface JSManagedValue (PrivateMethods)

- (void)disconnectValue;

bool JSManagedValueHandleOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown>, void* context, JSC::AbstractSlotVisitor& visitor, ASCIILiteral* reason)

{

if (reason) [[unlikely]]

*reason = "JSManagedValue is opaque root"_s;

JSManagedValue *managedValue = (__bridge JSManagedValue *)context;

return visitor.containsOpaqueRoot((__bridge void*)managedValue);

}

void JSManagedValueHandleOwner::finalize(JSC::Handle<JSC::Unknown>, void* context)

{

JSManagedValue *managedValue = (__bridge JSManagedValue *)context;

[managedValue disconnectValue];

}

#endif // JSC_OBJC_API_ENABLED