Add API to generate and consume cached bytecode
[WebKit-https.git] / Source / JavaScriptCore / API / JSContext.mm
index 253a74a..518fb87 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2019 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #import "APICast.h"
-#import "APIShims.h"
+#import "Completion.h"
+#import "JSCInlines.h"
 #import "JSContextInternal.h"
+#import "JSContextPrivate.h"
+#import "JSContextRefInternal.h"
 #import "JSGlobalObject.h"
+#import "JSInternalPromise.h"
+#import "JSModuleLoader.h"
 #import "JSValueInternal.h"
 #import "JSVirtualMachineInternal.h"
 #import "JSWrapperMap.h"
 #import "JavaScriptCore.h"
 #import "ObjcRuntimeExtras.h"
-#import "Operations.h"
 #import "StrongInlines.h"
-#import <wtf/HashSet.h>
+
+#import <wtf/WeakObjCPtr.h>
 
 #if JSC_OBJC_API_ENABLED
 
 @implementation JSContext {
     JSVirtualMachine *m_virtualMachine;
     JSGlobalContextRef m_context;
-    JSWrapperMap *m_wrapperMap;
     JSC::Strong<JSC::JSObject> m_exception;
+    WeakObjCPtr<id <JSModuleLoaderDelegate>> m_moduleLoaderDelegate;
 }
 
-@synthesize exceptionHandler;
-
 - (JSGlobalContextRef)JSGlobalContextRef
 {
     return m_context;
 }
 
+- (void)ensureWrapperMap
+{
+    if (!toJS([self JSGlobalContextRef])->lexicalGlobalObject()->wrapperMap()) {
+        // The map will be retained by the GlobalObject in initialization.
+        [[[JSWrapperMap alloc] initWithGlobalContextRef:[self JSGlobalContextRef]] release];
+    }
+}
+
 - (instancetype)init
 {
     return [self initWithVirtualMachine:[[[JSVirtualMachine alloc] init] autorelease]];
 
     m_virtualMachine = [virtualMachine retain];
     m_context = JSGlobalContextCreateInGroup(getGroupFromVirtualMachine(virtualMachine), 0);
-    m_wrapperMap = [[JSWrapperMap alloc] initWithContext:self];
 
     self.exceptionHandler = ^(JSContext *context, JSValue *exceptionValue) {
         context.exception = exceptionValue;
     };
 
+    [self ensureWrapperMap];
     [m_virtualMachine addContext:self forGlobalContextRef:m_context];
 
     return self;
 
 - (void)dealloc
 {
-    [m_wrapperMap release];
+    m_exception.clear();
     JSGlobalContextRelease(m_context);
     [m_virtualMachine release];
-    [self.exceptionHandler release];
+    [_exceptionHandler release];
     [super dealloc];
 }
 
 - (JSValue *)evaluateScript:(NSString *)script
 {
-    JSValueRef exceptionValue = 0;
-    JSStringRef scriptJS = JSStringCreateWithCFString((CFStringRef)script);
-    JSValueRef result = JSEvaluateScript(m_context, scriptJS, 0, 0, 0, &exceptionValue);
-    JSStringRelease(scriptJS);
+    return [self evaluateScript:script withSourceURL:nil];
+}
+
+- (JSValue *)evaluateScript:(NSString *)script withSourceURL:(NSURL *)sourceURL
+{
+    JSValueRef exceptionValue = nullptr;
+    auto scriptJS = OpaqueJSString::tryCreate(script);
+    auto sourceURLJS = OpaqueJSString::tryCreate([sourceURL absoluteString]);
+    JSValueRef result = JSEvaluateScript(m_context, scriptJS.get(), nullptr, sourceURLJS.get(), 0, &exceptionValue);
 
     if (exceptionValue)
         return [self valueFromNotifyException:exceptionValue];
 
 - (void)setException:(JSValue *)value
 {
+    JSC::ExecState* exec = toJS(m_context);
+    JSC::VM& vm = exec->vm();
+    JSC::JSLockHolder locker(vm);
     if (value)
-        m_exception.set(toJS(m_context)->vm(), toJS(JSValueToObject(m_context, valueInternalValue(value), 0)));
+        m_exception.set(vm, toJS(JSValueToObject(m_context, valueInternalValue(value), 0)));
     else
         m_exception.clear();
 }
     return [JSValue valueWithJSValueRef:toRef(m_exception.get()) inContext:self];
 }
 
-- (JSWrapperMap *)wrapperMap
-{
-    return m_wrapperMap;
-}
-
 - (JSValue *)globalObject
 {
     return [JSValue valueWithJSValueRef:JSContextGetGlobalObject(m_context) inContext:self];
 
 + (JSContext *)currentContext
 {
-    WTFThreadData& threadData = wtfThreadData();
-    CallbackData *entry = (CallbackData *)threadData.m_apiData;
+    Thread& thread = Thread::current();
+    CallbackData *entry = (CallbackData *)thread.m_apiData;
     return entry ? entry->context : nil;
 }
 
 + (JSValue *)currentThis
 {
-    WTFThreadData& threadData = wtfThreadData();
-    CallbackData *entry = (CallbackData *)threadData.m_apiData;
+    Thread& thread = Thread::current();
+    CallbackData *entry = (CallbackData *)thread.m_apiData;
     if (!entry)
         return nil;
     return [JSValue valueWithJSValueRef:entry->thisValue inContext:[JSContext currentContext]];
 
 + (JSValue *)currentCallee
 {
-    WTFThreadData& threadData = wtfThreadData();
-    CallbackData *entry = (CallbackData *)threadData.m_apiData;
-    if (!entry)
+    Thread& thread = Thread::current();
+    CallbackData *entry = (CallbackData *)thread.m_apiData;
+    // calleeValue may be null if we are initializing a promise.
+    if (!entry || !entry->calleeValue)
         return nil;
     return [JSValue valueWithJSValueRef:entry->calleeValue inContext:[JSContext currentContext]];
 }
 
 + (NSArray *)currentArguments
 {
-    WTFThreadData& threadData = wtfThreadData();
-    CallbackData *entry = (CallbackData *)threadData.m_apiData;
+    Thread& thread = Thread::current();
+    CallbackData *entry = (CallbackData *)thread.m_apiData;
 
     if (!entry)
         return nil;
     if (!name)
         return nil;
 
-    return [(NSString *)JSStringCopyCFString(kCFAllocatorDefault, name) autorelease];
+    return CFBridgingRelease(JSStringCopyCFString(kCFAllocatorDefault, name));
 }
 
 - (void)setName:(NSString *)name
 {
-    JSStringRef nameJS = JSStringCreateWithCFString((CFStringRef)[name copy]);
-    JSGlobalContextSetName(m_context, nameJS);
-    JSStringRelease(nameJS);
+    JSGlobalContextSetName(m_context, OpaqueJSString::tryCreate(name).get());
+}
+
+- (BOOL)_remoteInspectionEnabled
+{
+    return JSGlobalContextGetRemoteInspectionEnabled(m_context);
+}
+
+- (void)_setRemoteInspectionEnabled:(BOOL)enabled
+{
+    JSGlobalContextSetRemoteInspectionEnabled(m_context, enabled);
+}
+
+- (BOOL)_includesNativeCallStackWhenReportingExceptions
+{
+    return JSGlobalContextGetIncludesNativeCallStackWhenReportingExceptions(m_context);
+}
+
+- (void)_setIncludesNativeCallStackWhenReportingExceptions:(BOOL)includeNativeCallStack
+{
+    JSGlobalContextSetIncludesNativeCallStackWhenReportingExceptions(m_context, includeNativeCallStack);
+}
+
+- (CFRunLoopRef)_debuggerRunLoop
+{
+    return JSGlobalContextGetDebuggerRunLoop(m_context);
+}
+
+- (void)_setDebuggerRunLoop:(CFRunLoopRef)runLoop
+{
+    JSGlobalContextSetDebuggerRunLoop(m_context, runLoop);
+}
+
+- (id<JSModuleLoaderDelegate>)moduleLoaderDelegate
+{
+    return m_moduleLoaderDelegate.getAutoreleased();
+}
+
+- (void)setModuleLoaderDelegate:(id<JSModuleLoaderDelegate>)moduleLoaderDelegate
+{
+    m_moduleLoaderDelegate = moduleLoaderDelegate;
 }
 
 @end
     m_virtualMachine = [[JSVirtualMachine virtualMachineWithContextGroupRef:toRef(&globalObject->vm())] retain];
     ASSERT(m_virtualMachine);
     m_context = JSGlobalContextRetain(context);
-    m_wrapperMap = [[JSWrapperMap alloc] initWithContext:self];
+    [self ensureWrapperMap];
 
     self.exceptionHandler = ^(JSContext *context, JSValue *exceptionValue) {
         context.exception = exceptionValue;
 
 - (void)beginCallbackWithData:(CallbackData *)callbackData calleeValue:(JSValueRef)calleeValue thisValue:(JSValueRef)thisValue argumentCount:(size_t)argumentCount arguments:(const JSValueRef *)arguments
 {
-    WTFThreadData& threadData = wtfThreadData();
+    Thread& thread = Thread::current();
     [self retain];
-    CallbackData *prevStack = (CallbackData *)threadData.m_apiData;
+    CallbackData *prevStack = (CallbackData *)thread.m_apiData;
     *callbackData = (CallbackData){ prevStack, self, [self.exception retain], calleeValue, thisValue, argumentCount, arguments, nil };
-    threadData.m_apiData = callbackData;
+    thread.m_apiData = callbackData;
     self.exception = nil;
 }
 
 - (void)endCallbackWithData:(CallbackData *)callbackData
 {
-    WTFThreadData& threadData = wtfThreadData();
+    Thread& thread = Thread::current();
     self.exception = callbackData->preservedException;
     [callbackData->preservedException release];
     [callbackData->currentArguments release];
-    threadData.m_apiData = callbackData->next;
+    thread.m_apiData = callbackData->next;
     [self release];
 }
 
 - (JSValue *)wrapperForObjCObject:(id)object
 {
-    // Lock access to m_wrapperMap
-    JSC::JSLockHolder lock(toJS(m_context));
-    return [m_wrapperMap jsWrapperForObject:object];
+    JSC::JSLockHolder locker(toJS(m_context));
+    return [[self wrapperMap] jsWrapperForObject:object inContext:self];
+}
+
+- (JSWrapperMap *)wrapperMap
+{
+    return toJS(m_context)->lexicalGlobalObject()->wrapperMap();
 }
 
 - (JSValue *)wrapperForJSObject:(JSValueRef)value
 {
-    JSC::JSLockHolder lock(toJS(m_context));
-    return [m_wrapperMap objcWrapperForJSValueRef:value];
+    JSC::JSLockHolder locker(toJS(m_context));
+    return [[self wrapperMap] objcWrapperForJSValueRef:value inContext:self];
 }
 
 + (JSContext *)contextWithJSGlobalContextRef:(JSGlobalContextRef)globalContext
 
 @end
 
-WeakContextRef::WeakContextRef(JSContext *context)
-{
-    objc_initWeak(&m_weakContext, context);
-}
-
-WeakContextRef::~WeakContextRef()
-{
-    objc_destroyWeak(&m_weakContext);
-}
-
-JSContext * WeakContextRef::get()
-{
-    return objc_loadWeak(&m_weakContext);
-}
-
-void WeakContextRef::set(JSContext *context)
-{
-    objc_storeWeak(&m_weakContext, context);
-}
-
 #endif