9ffaf569fbddac2afd4529061ca1487447ff0aba
[WebKit-https.git] / Source / JavaScriptCore / API / JSWrapperMap.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 #import "JavaScriptCore.h"
28
29 #if JSC_OBJC_API_ENABLED
30
31 #import "APICast.h"
32 #import "APIShims.h"
33 #import "JSAPIWrapperObject.h"
34 #import "JSCallbackObject.h"
35 #import "JSContextInternal.h"
36 #import "JSWrapperMap.h"
37 #import "ObjCCallbackFunction.h"
38 #import "ObjcRuntimeExtras.h"
39 #import "Operations.h"
40 #import "WeakGCMap.h"
41 #import <wtf/TCSpinLock.h>
42 #import <wtf/Vector.h>
43
44 @class JSObjCClassInfo;
45
46 @interface JSWrapperMap () 
47
48 - (JSObjCClassInfo*)classInfoForClass:(Class)cls;
49
50 @end
51
52 // Default conversion of selectors to property names.
53 // All semicolons are removed, lowercase letters following a semicolon are capitalized.
54 static NSString *selectorToPropertyName(const char* start)
55 {
56     // Use 'index' to check for colons, if there are none, this is easy!
57     const char* firstColon = index(start, ':');
58     if (!firstColon)
59         return [NSString stringWithUTF8String:start];
60
61     // 'header' is the length of string up to the first colon.
62     size_t header = firstColon - start;
63     // The new string needs to be long enough to hold 'header', plus the remainder of the string, excluding
64     // at least one ':', but including a '\0'. (This is conservative if there are more than one ':').
65     char* buffer = static_cast<char*>(malloc(header + strlen(firstColon + 1) + 1));
66     // Copy 'header' characters, set output to point to the end of this & input to point past the first ':'.
67     memcpy(buffer, start, header);
68     char* output = buffer + header;
69     const char* input = start + header + 1;
70
71     // On entry to the loop, we have already skipped over a ':' from the input.
72     while (true) {
73         char c;
74         // Skip over any additional ':'s. We'll leave c holding the next character after the
75         // last ':', and input pointing past c.
76         while ((c = *(input++)) == ':');
77         // Copy the character, converting to upper case if necessary.
78         // If the character we copy is '\0', then we're done!
79         if (!(*(output++) = toupper(c)))
80             goto done;
81         // Loop over characters other than ':'.
82         while ((c = *(input++)) != ':') {
83             // Copy the character.
84             // If the character we copy is '\0', then we're done!
85             if (!(*(output++) = c))
86                 goto done;
87         }
88         // If we get here, we've consumed a ':' - wash, rinse, repeat.
89     }
90 done:
91     NSString *result = [NSString stringWithUTF8String:buffer];
92     free(buffer);
93     return result;
94 }
95
96 static JSObjectRef makeWrapper(JSContextRef ctx, JSClassRef jsClass, id wrappedObject)
97 {
98     JSC::ExecState* exec = toJS(ctx);
99     JSC::APIEntryShim entryShim(exec);
100
101     ASSERT(jsClass);
102     JSC::JSCallbackObject<JSC::JSAPIWrapperObject>* object = JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::create(exec, exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->objcWrapperObjectStructure(), jsClass, 0);
103     object->setWrappedObject(wrappedObject);
104     if (JSC::JSObject* prototype = jsClass->prototype(exec))
105         object->setPrototype(exec->vm(), prototype);
106
107     return toRef(object);
108 }
109
110 // Make an object that is in all ways a completely vanilla JavaScript object,
111 // other than that it has a native brand set that will be displayed by the default
112 // Object.prototype.toString conversion.
113 static JSValue *objectWithCustomBrand(JSContext *context, NSString *brand, Class cls = 0)
114 {
115     JSClassDefinition definition;
116     definition = kJSClassDefinitionEmpty;
117     definition.className = [brand UTF8String];
118     JSClassRef classRef = JSClassCreate(&definition);
119     JSObjectRef result = makeWrapper([context JSGlobalContextRef], classRef, cls);
120     JSClassRelease(classRef);
121     return [JSValue valueWithJSValueRef:result inContext:context];
122 }
123
124 // Look for @optional properties in the prototype containing a selector to property
125 // name mapping, separated by a __JS_EXPORT_AS__ delimiter.
126 static NSMutableDictionary *createRenameMap(Protocol *protocol, BOOL isInstanceMethod)
127 {
128     NSMutableDictionary *renameMap = [[NSMutableDictionary alloc] init];
129
130     forEachMethodInProtocol(protocol, NO, isInstanceMethod, ^(SEL sel, const char*){
131         NSString *rename = @(sel_getName(sel));
132         NSRange range = [rename rangeOfString:@"__JS_EXPORT_AS__"];
133         if (range.location == NSNotFound)
134             return;
135         NSString *selector = [rename substringToIndex:range.location];
136         NSUInteger begin = range.location + range.length;
137         NSUInteger length = [rename length] - begin - 1;
138         NSString *name = [rename substringWithRange:(NSRange){ begin, length }];
139         renameMap[selector] = name;
140     });
141
142     return renameMap;
143 }
144
145 inline void putNonEnumerable(JSValue *base, NSString *propertyName, JSValue *value)
146 {
147     [base defineProperty:propertyName descriptor:@{
148         JSPropertyDescriptorValueKey: value,
149         JSPropertyDescriptorWritableKey: @YES,
150         JSPropertyDescriptorEnumerableKey: @NO,
151         JSPropertyDescriptorConfigurableKey: @YES
152     }];
153 }
154
155 // This method will iterate over the set of required methods in the protocol, and:
156 //  * Determine a property name (either via a renameMap or default conversion).
157 //  * If an accessorMap is provided, and contains this name, store the method in the map.
158 //  * Otherwise, if the object doesn't already contain a property with name, create it.
159 static void copyMethodsToObject(JSContext *context, Class objcClass, Protocol *protocol, BOOL isInstanceMethod, JSValue *object, NSMutableDictionary *accessorMethods = nil)
160 {
161     NSMutableDictionary *renameMap = createRenameMap(protocol, isInstanceMethod);
162
163     forEachMethodInProtocol(protocol, YES, isInstanceMethod, ^(SEL sel, const char* types){
164         const char* nameCStr = sel_getName(sel);
165         NSString *name = @(nameCStr);
166         if (accessorMethods && accessorMethods[name]) {
167             JSObjectRef method = objCCallbackFunctionForMethod(context, objcClass, protocol, isInstanceMethod, sel, types);
168             if (!method)
169                 return;
170             accessorMethods[name] = [JSValue valueWithJSValueRef:method inContext:context];
171         } else {
172             name = renameMap[name];
173             if (!name)
174                 name = selectorToPropertyName(nameCStr);
175             if ([object hasProperty:name])
176                 return;
177             JSObjectRef method = objCCallbackFunctionForMethod(context, objcClass, protocol, isInstanceMethod, sel, types);
178             if (method)
179                 putNonEnumerable(object, name, [JSValue valueWithJSValueRef:method inContext:context]);
180         }
181     });
182
183     [renameMap release];
184 }
185
186 static bool parsePropertyAttributes(objc_property_t property, char*& getterName, char*& setterName)
187 {
188     bool readonly = false;
189     unsigned attributeCount;
190     objc_property_attribute_t* attributes = property_copyAttributeList(property, &attributeCount);
191     if (attributeCount) {
192         for (unsigned i = 0; i < attributeCount; ++i) {
193             switch (*(attributes[i].name)) {
194             case 'G':
195                 getterName = strdup(attributes[i].value);
196                 break;
197             case 'S':
198                 setterName = strdup(attributes[i].value);
199                 break;
200             case 'R':
201                 readonly = true;
202                 break;
203             default:
204                 break;
205             }
206         }
207         free(attributes);
208     }
209     return readonly;
210 }
211
212 static char* makeSetterName(const char* name)
213 {
214     size_t nameLength = strlen(name);
215     char* setterName = (char*)malloc(nameLength + 5); // "set" Name ":\0"
216     setterName[0] = 's';
217     setterName[1] = 'e';
218     setterName[2] = 't';
219     setterName[3] = toupper(*name);
220     memcpy(setterName + 4, name + 1, nameLength - 1);
221     setterName[nameLength + 3] = ':';
222     setterName[nameLength + 4] = '\0';
223     return setterName;
224 }
225
226 static void copyPrototypeProperties(JSContext *context, Class objcClass, Protocol *protocol, JSValue *prototypeValue)
227 {
228     // First gather propreties into this list, then handle the methods (capturing the accessor methods).
229     struct Property {
230         const char* name;
231         char* getterName;
232         char* setterName;
233     };
234     __block Vector<Property> propertyList;
235
236     // Map recording the methods used as getters/setters.
237     NSMutableDictionary *accessorMethods = [NSMutableDictionary dictionary];
238
239     // Useful value.
240     JSValue *undefined = [JSValue valueWithUndefinedInContext:context];
241
242     forEachPropertyInProtocol(protocol, ^(objc_property_t property){
243         char* getterName = 0;
244         char* setterName = 0;
245         bool readonly = parsePropertyAttributes(property, getterName, setterName);
246         const char* name = property_getName(property);
247
248         // Add the names of the getter & setter methods to 
249         if (!getterName)
250             getterName = strdup(name);
251         accessorMethods[@(getterName)] = undefined;
252         if (!readonly) {
253             if (!setterName)
254                 setterName = makeSetterName(name);
255             accessorMethods[@(setterName)] = undefined;
256         }
257
258         // Add the properties to a list.
259         propertyList.append((Property){ name, getterName, setterName });
260     });
261
262     // Copy methods to the prototype, capturing accessors in the accessorMethods map.
263     copyMethodsToObject(context, objcClass, protocol, YES, prototypeValue, accessorMethods);
264
265     // Iterate the propertyList & generate accessor properties.
266     for (size_t i = 0; i < propertyList.size(); ++i) {
267         Property& property = propertyList[i];
268
269         JSValue *getter = accessorMethods[@(property.getterName)];
270         free(property.getterName);
271         ASSERT(![getter isUndefined]);
272
273         JSValue *setter = undefined;
274         if (property.setterName) {
275             setter = accessorMethods[@(property.setterName)];
276             free(property.setterName);
277             ASSERT(![setter isUndefined]);
278         }
279         
280         [prototypeValue defineProperty:@(property.name) descriptor:@{
281             JSPropertyDescriptorGetKey: getter,
282             JSPropertyDescriptorSetKey: setter,
283             JSPropertyDescriptorEnumerableKey: @NO,
284             JSPropertyDescriptorConfigurableKey: @YES
285         }];
286     }
287 }
288
289 @interface JSObjCClassInfo : NSObject {
290     JSContext *m_context;
291     Class m_class;
292     bool m_block;
293     JSClassRef m_classRef;
294     JSC::Weak<JSC::JSObject> m_prototype;
295     JSC::Weak<JSC::JSObject> m_constructor;
296 }
297
298 - (id)initWithContext:(JSContext *)context forClass:(Class)cls superClassInfo:(JSObjCClassInfo*)superClassInfo;
299 - (JSValue *)wrapperForObject:(id)object;
300 - (JSValue *)constructor;
301
302 @end
303
304 @implementation JSObjCClassInfo
305
306 - (id)initWithContext:(JSContext *)context forClass:(Class)cls superClassInfo:(JSObjCClassInfo*)superClassInfo
307 {
308     self = [super init];
309     if (!self)
310         return nil;
311
312     const char* className = class_getName(cls);
313     m_context = context;
314     m_class = cls;
315     m_block = [cls isSubclassOfClass:getNSBlockClass()];
316     JSClassDefinition definition;
317     definition = kJSClassDefinitionEmpty;
318     definition.className = className;
319     m_classRef = JSClassCreate(&definition);
320
321     [self allocateConstructorAndPrototypeWithSuperClassInfo:superClassInfo];
322
323     return self;
324 }
325
326 - (void)dealloc
327 {
328     JSClassRelease(m_classRef);
329     [super dealloc];
330 }
331
332 - (void)allocateConstructorAndPrototypeWithSuperClassInfo:(JSObjCClassInfo*)superClassInfo
333 {
334     ASSERT(!m_constructor || !m_prototype);
335     ASSERT((m_class == [NSObject class]) == !superClassInfo);
336     if (!superClassInfo) {
337         JSContextRef cContext = [m_context JSGlobalContextRef];
338         JSValue *constructor = m_context[@"Object"];
339         if (!m_constructor)
340             m_constructor = toJS(JSValueToObject(cContext, valueInternalValue(constructor), 0));
341
342         if (!m_prototype) {
343             JSValue *prototype = constructor[@"prototype"];
344             m_prototype = toJS(JSValueToObject(cContext, valueInternalValue(prototype), 0));
345         }
346     } else {
347         const char* className = class_getName(m_class);
348
349         // Create or grab the prototype/constructor pair.
350         JSValue *prototype;
351         JSValue *constructor;
352         if (m_prototype)
353             prototype = [JSValue valueWithJSValueRef:toRef(m_prototype.get()) inContext:m_context];
354         else
355             prototype = objectWithCustomBrand(m_context, [NSString stringWithFormat:@"%sPrototype", className]);
356
357         if (m_constructor)
358             constructor = [JSValue valueWithJSValueRef:toRef(m_constructor.get()) inContext:m_context];
359         else
360             constructor = objectWithCustomBrand(m_context, [NSString stringWithFormat:@"%sConstructor", className], m_class);
361
362         JSContextRef cContext = [m_context JSGlobalContextRef];
363         m_prototype = toJS(JSValueToObject(cContext, valueInternalValue(prototype), 0));
364         m_constructor = toJS(JSValueToObject(cContext, valueInternalValue(constructor), 0));
365
366         putNonEnumerable(prototype, @"constructor", constructor);
367         putNonEnumerable(constructor, @"prototype", prototype);
368
369         Protocol *exportProtocol = getJSExportProtocol();
370         forEachProtocolImplementingProtocol(m_class, exportProtocol, ^(Protocol *protocol){
371             copyPrototypeProperties(m_context, m_class, protocol, prototype);
372             copyMethodsToObject(m_context, m_class, protocol, NO, constructor);
373         });
374
375         // Set [Prototype].
376         JSObjectSetPrototype([m_context JSGlobalContextRef], toRef(m_prototype.get()), toRef(superClassInfo->m_prototype.get()));
377     }
378 }
379
380 - (void)reallocateConstructorAndOrPrototype
381 {
382     [self allocateConstructorAndPrototypeWithSuperClassInfo:[m_context.wrapperMap classInfoForClass:class_getSuperclass(m_class)]];
383 }
384
385 - (JSValue *)wrapperForObject:(id)object
386 {
387     ASSERT([object isKindOfClass:m_class]);
388     ASSERT(m_block == [object isKindOfClass:getNSBlockClass()]);
389     if (m_block) {
390         if (JSObjectRef method = objCCallbackFunctionForBlock(m_context, object))
391             return [JSValue valueWithJSValueRef:method inContext:m_context];
392     }
393
394     if (!m_prototype)
395         [self reallocateConstructorAndOrPrototype];
396     ASSERT(!!m_prototype);
397
398     JSObjectRef wrapper = makeWrapper([m_context JSGlobalContextRef], m_classRef, object);
399     JSObjectSetPrototype([m_context JSGlobalContextRef], wrapper, toRef(m_prototype.get()));
400     return [JSValue valueWithJSValueRef:wrapper inContext:m_context];
401 }
402
403 - (JSValue *)constructor
404 {
405     if (!m_constructor)
406         [self reallocateConstructorAndOrPrototype];
407     ASSERT(!!m_constructor);
408     return [JSValue valueWithJSValueRef:toRef(m_constructor.get()) inContext:m_context];
409 }
410
411 @end
412
413 @implementation JSWrapperMap {
414     JSContext *m_context;
415     NSMutableDictionary *m_classMap;
416     JSC::WeakGCMap<id, JSC::JSObject> m_cachedJSWrappers;
417     NSMapTable *m_cachedObjCWrappers;
418 }
419
420 - (id)initWithContext:(JSContext *)context
421 {
422     self = [super init];
423     if (!self)
424         return nil;
425
426     NSPointerFunctionsOptions keyOptions = NSPointerFunctionsOpaqueMemory | NSPointerFunctionsOpaquePersonality;
427     NSPointerFunctionsOptions valueOptions = NSPointerFunctionsWeakMemory | NSPointerFunctionsObjectPersonality;
428     m_cachedObjCWrappers = [[NSMapTable alloc] initWithKeyOptions:keyOptions valueOptions:valueOptions capacity:0];
429     
430     m_context = context;
431     m_classMap = [[NSMutableDictionary alloc] init];
432     return self;
433 }
434
435 - (void)dealloc
436 {
437     [m_cachedObjCWrappers release];
438     [m_classMap release];
439     [super dealloc];
440 }
441
442 - (JSObjCClassInfo*)classInfoForClass:(Class)cls
443 {
444     if (!cls)
445         return nil;
446
447     // Check if we've already created a JSObjCClassInfo for this Class.
448     if (JSObjCClassInfo* classInfo = (JSObjCClassInfo*)m_classMap[cls])
449         return classInfo;
450
451     // Skip internal classes beginning with '_' - just copy link to the parent class's info.
452     if ('_' == *class_getName(cls))
453         return m_classMap[cls] = [self classInfoForClass:class_getSuperclass(cls)];
454
455     return m_classMap[cls] = [[[JSObjCClassInfo alloc] initWithContext:m_context forClass:cls superClassInfo:[self classInfoForClass:class_getSuperclass(cls)]] autorelease];
456 }
457
458 - (JSValue *)jsWrapperForObject:(id)object
459 {
460     JSC::JSObject* jsWrapper = m_cachedJSWrappers.get(object);
461     if (jsWrapper)
462         return [JSValue valueWithJSValueRef:toRef(jsWrapper) inContext:m_context];
463
464     JSValue *wrapper;
465     if (class_isMetaClass(object_getClass(object)))
466         wrapper = [[self classInfoForClass:(Class)object] constructor];
467     else {
468         JSObjCClassInfo* classInfo = [self classInfoForClass:[object class]];
469         wrapper = [classInfo wrapperForObject:object];
470     }
471
472     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=105891
473     // This general approach to wrapper caching is pretty effective, but there are a couple of problems:
474     // (1) For immortal objects JSValues will effectively leak and this results in error output being logged - we should avoid adding associated objects to immortal objects.
475     // (2) A long lived object may rack up many JSValues. When the contexts are released these will unprotect the associated JavaScript objects,
476     //     but still, would probably nicer if we made it so that only one associated object was required, broadcasting object dealloc.
477     JSC::ExecState* exec = toJS([m_context JSGlobalContextRef]);
478     jsWrapper = toJS(exec, valueInternalValue(wrapper)).toObject(exec);
479     m_cachedJSWrappers.set(object, jsWrapper);
480     return wrapper;
481 }
482
483 - (JSValue *)objcWrapperForJSValueRef:(JSValueRef)value
484 {
485     JSValue *wrapper = static_cast<JSValue *>(NSMapGet(m_cachedObjCWrappers, value));
486     if (!wrapper) {
487         wrapper = [[[JSValue alloc] initWithValue:value inContext:m_context] autorelease];
488         NSMapInsert(m_cachedObjCWrappers, value, wrapper);
489     }
490     return wrapper;
491 }
492
493 @end
494
495 id tryUnwrapObjcObject(JSGlobalContextRef context, JSValueRef value)
496 {
497     if (!JSValueIsObject(context, value))
498         return nil;
499     JSValueRef exception = 0;
500     JSObjectRef object = JSValueToObject(context, value, &exception);
501     ASSERT(!exception);
502     if (toJS(object)->inherits(JSC::JSCallbackObject<JSC::JSAPIWrapperObject>::info()))
503         return (id)JSC::jsCast<JSC::JSAPIWrapperObject*>(toJS(object))->wrappedObject();
504     if (id target = tryUnwrapBlock(object))
505         return target;
506     return nil;
507 }
508
509 // This class ensures that the JSExport protocol is registered with the runtime.
510 NS_ROOT_CLASS @interface JSExport <JSExport>
511 @end
512 @implementation JSExport
513 @end
514
515 Protocol *getJSExportProtocol()
516 {
517     static Protocol *protocol = objc_getProtocol("JSExport");
518     return protocol;
519 }
520
521 Class getNSBlockClass()
522 {
523     static Class cls = objc_getClass("NSBlock");
524     return cls;
525 }
526
527 #endif