Reviewed by Oliver Hunt.
JS API is too aggressive about throwing exceptions for NULL get or set operations
https://bugs.webkit.org/show_bug.cgi?id=61678
* API/JSCallbackObject.h: Changed our staticValueGetter to a regular
function that returns a JSValue, so it can fail and still forward to
normal property lookup.
* API/JSCallbackObjectFunctions.h:
(JSC::::getOwnPropertySlot): Don't throw an exception when failing to
access a static property -- just forward the access. This allows objects
to observe get/set operations but still let the JS object manage lifetime.
(JSC::::put): Ditto.
(JSC::::getStaticValue): Same as JSCallbackObject.h.
* API/tests/testapi.c:
(MyObject_set_nullGetForwardSet):
* API/tests/testapi.js: Updated tests to reflect slightly less strict
behavior, which matches headerdoc claims.
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@87588
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
static EncodedJSValue JSC_HOST_CALL call(ExecState*);
static EncodedJSValue JSC_HOST_CALL construct(ExecState*);
- static JSValue staticValueGetter(ExecState*, JSValue, const Identifier&);
+ JSValue getStaticValue(ExecState*, const Identifier&);
static JSValue staticFunctionGetter(ExecState*, JSValue, const Identifier&);
static JSValue callbackGetter(ExecState*, JSValue, const Identifier&);
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(exec)) {
if (staticValues->contains(propertyName.impl())) {
- slot.setCustom(this, staticValueGetter);
- return true;
+ JSValue value = getStaticValue(exec, propertyName);
+ if (value) {
+ slot.setValue(value);
+ return true;
+ }
}
}
throwError(exec, toJS(exec, exception));
if (result || exception)
return;
- } else
- throwError(exec, createReferenceError(exec, "Attempt to set a property that is not settable."));
+ }
}
}
}
template <class Base>
-JSValue JSCallbackObject<Base>::staticValueGetter(ExecState* exec, JSValue slotBase, const Identifier& propertyName)
+JSValue JSCallbackObject<Base>::getStaticValue(ExecState* exec, const Identifier& propertyName)
{
- JSCallbackObject* thisObj = asCallbackObject(slotBase);
-
- JSObjectRef thisRef = toRef(thisObj);
+ JSObjectRef thisRef = toRef(this);
RefPtr<OpaqueJSString> propertyNameRef;
- for (JSClassRef jsClass = thisObj->classRef(); jsClass; jsClass = jsClass->parentClass)
+ for (JSClassRef jsClass = classRef(); jsClass; jsClass = jsClass->parentClass)
if (OpaqueJSClassStaticValuesTable* staticValues = jsClass->staticValues(exec))
if (StaticValueEntry* entry = staticValues->get(propertyName.impl()))
if (JSObjectGetPropertyCallback getProperty = entry->getProperty) {
return toJS(exec, value);
}
- return throwError(exec, createReferenceError(exec, "Static value property defined with NULL getProperty callback."));
+ return JSValue();
}
template <class Base>
return JSValueMakeNull(context);
}
+static bool MyObject_set_nullGetForwardSet(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef value, JSValueRef* exception)
+{
+ UNUSED_PARAM(ctx);
+ UNUSED_PARAM(object);
+ UNUSED_PARAM(propertyName);
+ UNUSED_PARAM(value);
+ UNUSED_PARAM(exception);
+ return false; // Forward to parent class.
+}
+
static JSStaticValue evilStaticValues[] = {
{ "nullGetSet", 0, 0, kJSPropertyAttributeNone },
+ { "nullGetForwardSet", 0, MyObject_set_nullGetForwardSet, kJSPropertyAttributeNone },
{ 0, 0, 0, 0 }
};
shouldBe("new MyObject('throwOnConstruct')", "an exception");
shouldBe("'throwOnHasInstance' instanceof MyObject", "an exception");
+MyObject.nullGetForwardSet = 1;
+shouldBe("MyObject.nullGetForwardSet", 1);
+
var foundMyPropertyName = false;
var foundRegularType = false;
for (var p in MyObject) {
shouldBe("myObject instanceof MyObject", true);
shouldBe("(new Object()) instanceof MyObject", false);
-shouldThrow("MyObject.nullGetSet = 1");
-shouldThrow("MyObject.nullGetSet");
+MyObject.nullGetSet = 1;
+shouldBe("MyObject.nullGetSet", 1);
shouldThrow("MyObject.nullCall()");
shouldThrow("MyObject.hasPropertyLie");
Reviewed by Oliver Hunt.
+ JS API is too aggressive about throwing exceptions for NULL get or set operations
+ https://bugs.webkit.org/show_bug.cgi?id=61678
+
+ * API/JSCallbackObject.h: Changed our staticValueGetter to a regular
+ function that returns a JSValue, so it can fail and still forward to
+ normal property lookup.
+
+ * API/JSCallbackObjectFunctions.h:
+ (JSC::::getOwnPropertySlot): Don't throw an exception when failing to
+ access a static property -- just forward the access. This allows objects
+ to observe get/set operations but still let the JS object manage lifetime.
+
+ (JSC::::put): Ditto.
+
+ (JSC::::getStaticValue): Same as JSCallbackObject.h.
+
+ * API/tests/testapi.c:
+ (MyObject_set_nullGetForwardSet):
+ * API/tests/testapi.js: Updated tests to reflect slightly less strict
+ behavior, which matches headerdoc claims.
+
+2011-05-27 Geoffrey Garen <ggaren@apple.com>
+
+ Reviewed by Oliver Hunt.
+
Property caching is too aggressive for API objects
https://bugs.webkit.org/show_bug.cgi?id=61677