8853441335d1fe342771971bb073d5d82e03d065
[WebKit-https.git] / Source / JavaScriptCore / API / JSVirtualMachine.mm
1 /*
2  * Copyright (C) 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27
28 #import "JavaScriptCore.h"
29
30 #if JSC_OBJC_API_ENABLED
31
32 #import "APICast.h"
33 #import "JSManagedValueInternal.h"
34 #import "JSVirtualMachine.h"
35 #import "JSVirtualMachineInternal.h"
36 #import "JSWrapperMap.h"
37 #import "SlotVisitorInlines.h"
38 #import <mutex>
39 #import <wtf/NeverDestroyed.h>
40
41 static NSMapTable *globalWrapperCache = 0;
42
43 static std::mutex& wrapperCacheMutex()
44 {
45     static NeverDestroyed<std::mutex> mutex;
46
47     return mutex;
48 }
49
50 static void initWrapperCache()
51 {
52     ASSERT(!globalWrapperCache);
53     NSPointerFunctionsOptions keyOptions = NSPointerFunctionsOpaqueMemory | NSPointerFunctionsOpaquePersonality;
54     NSPointerFunctionsOptions valueOptions = NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPersonality;
55     globalWrapperCache = [[NSMapTable alloc] initWithKeyOptions:keyOptions valueOptions:valueOptions capacity:0];
56 }
57
58 static NSMapTable *wrapperCache()
59 {
60     if (!globalWrapperCache)
61         initWrapperCache();
62     return globalWrapperCache;
63 }
64
65 @interface JSVMWrapperCache : NSObject
66 + (void)addWrapper:(JSVirtualMachine *)wrapper forJSContextGroupRef:(JSContextGroupRef)group;
67 + (JSVirtualMachine *)wrapperForJSContextGroupRef:(JSContextGroupRef)group;
68 @end
69
70 @implementation JSVMWrapperCache
71
72 + (void)addWrapper:(JSVirtualMachine *)wrapper forJSContextGroupRef:(JSContextGroupRef)group
73 {
74     std::lock_guard<std::mutex> lock(wrapperCacheMutex());
75     NSMapInsert(wrapperCache(), group, wrapper);
76 }
77
78 + (JSVirtualMachine *)wrapperForJSContextGroupRef:(JSContextGroupRef)group
79 {
80     std::lock_guard<std::mutex> lock(wrapperCacheMutex());
81     return static_cast<JSVirtualMachine *>(NSMapGet(wrapperCache(), group));
82 }
83
84 @end
85
86 @implementation JSVirtualMachine {
87     JSContextGroupRef m_group;
88     NSMapTable *m_contextCache;
89     NSMapTable *m_externalObjectGraph;
90 }
91
92 - (instancetype)init
93 {
94     JSContextGroupRef group = JSContextGroupCreate();
95     self = [self initWithContextGroupRef:group];
96     // The extra JSContextGroupRetain is balanced here.
97     JSContextGroupRelease(group);
98     return self;
99 }
100
101 - (instancetype)initWithContextGroupRef:(JSContextGroupRef)group
102 {
103     self = [super init];
104     if (!self)
105         return nil;
106     
107     m_group = JSContextGroupRetain(group);
108     
109     NSPointerFunctionsOptions keyOptions = NSPointerFunctionsOpaqueMemory | NSPointerFunctionsOpaquePersonality;
110     NSPointerFunctionsOptions valueOptions = NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPersonality;
111     m_contextCache = [[NSMapTable alloc] initWithKeyOptions:keyOptions valueOptions:valueOptions capacity:0];
112     
113     NSPointerFunctionsOptions weakIDOptions = NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPersonality;
114     NSPointerFunctionsOptions strongIDOptions = NSPointerFunctionsStrongMemory | NSPointerFunctionsObjectPersonality;
115     m_externalObjectGraph = [[NSMapTable alloc] initWithKeyOptions:weakIDOptions valueOptions:strongIDOptions capacity:0];
116    
117     [JSVMWrapperCache addWrapper:self forJSContextGroupRef:group];
118  
119     return self;
120 }
121
122 - (void)dealloc
123 {
124     JSContextGroupRelease(m_group);
125     [m_contextCache release];
126     [m_externalObjectGraph release];
127     [super dealloc];
128 }
129
130 static id getInternalObjcObject(id object)
131 {
132     if ([object isKindOfClass:[JSManagedValue class]]) {
133         JSValue* value = [static_cast<JSManagedValue *>(object) value];
134         id temp = tryUnwrapObjcObject([value.context JSGlobalContextRef], [value JSValueRef]);
135         if (temp)
136             return temp;
137         return object;
138     }
139     
140     if ([object isKindOfClass:[JSValue class]]) {
141         JSValue *value = static_cast<JSValue *>(object);
142         object = tryUnwrapObjcObject([value.context JSGlobalContextRef], [value JSValueRef]);
143     }
144
145     return object;
146 }
147
148 - (void)addManagedReference:(id)object withOwner:(id)owner
149 {    
150     if ([object isKindOfClass:[JSManagedValue class]])
151         [object didAddOwner:owner];
152         
153     object = getInternalObjcObject(object);
154     owner = getInternalObjcObject(owner);
155     
156     if (!object || !owner)
157         return;
158     
159     JSC::JSLockHolder locker(toJS(m_group));
160     
161     NSMapTable *ownedObjects = [m_externalObjectGraph objectForKey:owner];
162     if (!ownedObjects) {
163         NSPointerFunctionsOptions weakIDOptions = NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPersonality;
164         NSPointerFunctionsOptions integerOptions = NSPointerFunctionsOpaqueMemory | NSPointerFunctionsIntegerPersonality;
165         ownedObjects = [[NSMapTable alloc] initWithKeyOptions:weakIDOptions valueOptions:integerOptions capacity:1];
166
167         [m_externalObjectGraph setObject:ownedObjects forKey:owner];
168         [ownedObjects release];
169     }
170
171     size_t count = reinterpret_cast<size_t>(NSMapGet(ownedObjects, object));
172     NSMapInsert(ownedObjects, object, reinterpret_cast<void*>(count + 1));
173 }
174
175 - (void)removeManagedReference:(id)object withOwner:(id)owner
176 {
177     if ([object isKindOfClass:[JSManagedValue class]])
178         [object didRemoveOwner:owner];
179
180     object = getInternalObjcObject(object);
181     owner = getInternalObjcObject(owner);
182     
183     if (!object || !owner)
184         return;
185     
186     JSC::JSLockHolder locker(toJS(m_group));
187     
188     NSMapTable *ownedObjects = [m_externalObjectGraph objectForKey:owner];
189     if (!ownedObjects)
190         return;
191    
192     size_t count = reinterpret_cast<size_t>(NSMapGet(ownedObjects, object));
193     if (count > 1) {
194         NSMapInsert(ownedObjects, object, reinterpret_cast<void*>(count - 1));
195         return;
196     }
197     
198     if (count == 1)
199         NSMapRemove(ownedObjects, object);
200
201     if (![ownedObjects count])
202         [m_externalObjectGraph removeObjectForKey:owner];
203 }
204
205 @end
206
207 @implementation JSVirtualMachine(Internal)
208
209 JSContextGroupRef getGroupFromVirtualMachine(JSVirtualMachine *virtualMachine)
210 {
211     return virtualMachine->m_group;
212 }
213
214 + (JSVirtualMachine *)virtualMachineWithContextGroupRef:(JSContextGroupRef)group
215 {
216     JSVirtualMachine *virtualMachine = [JSVMWrapperCache wrapperForJSContextGroupRef:group];
217     if (!virtualMachine)
218         virtualMachine = [[[JSVirtualMachine alloc] initWithContextGroupRef:group] autorelease];
219     return virtualMachine;
220 }
221
222 - (JSContext *)contextForGlobalContextRef:(JSGlobalContextRef)globalContext
223 {
224     return static_cast<JSContext *>(NSMapGet(m_contextCache, globalContext));
225 }
226
227 - (void)addContext:(JSContext *)wrapper forGlobalContextRef:(JSGlobalContextRef)globalContext
228 {
229     NSMapInsert(m_contextCache, globalContext, wrapper);
230 }
231
232 - (NSMapTable *)externalObjectGraph
233 {
234     return m_externalObjectGraph;
235 }
236
237 @end
238
239 void scanExternalObjectGraph(JSC::VM& vm, JSC::SlotVisitor& visitor, void* root)
240 {
241     @autoreleasepool {
242         JSVirtualMachine *virtualMachine = [JSVMWrapperCache wrapperForJSContextGroupRef:toRef(&vm)];
243         if (!virtualMachine)
244             return;
245         NSMapTable *externalObjectGraph = [virtualMachine externalObjectGraph];
246         Vector<void*> stack;
247         stack.append(root);
248         while (!stack.isEmpty()) {
249             void* nextRoot = stack.last();
250             stack.removeLast();
251             if (visitor.containsOpaqueRootTriState(nextRoot) == TrueTriState)
252                 continue;
253             visitor.addOpaqueRoot(nextRoot);
254             
255             NSMapTable *ownedObjects = [externalObjectGraph objectForKey:static_cast<id>(nextRoot)];
256             id ownedObject;
257             NSEnumerator *enumerator = [ownedObjects keyEnumerator];
258             while ((ownedObject = [enumerator nextObject]))
259                 stack.append(static_cast<void*>(ownedObject));
260         }
261     }
262 }
263
264 #endif
265