Changes between Version 96 and Version 97 of WebKitIDL


Ignore:
Timestamp:
May 8, 2013 1:14:45 AM (8 years ago)
Author:
Christophe Dumez
Comment:

Use more monospace

Legend:

Unmodified
Added
Removed
Modified
  • WebKitIDL

    v96 v97  
    10351035This is really important for security.
    10361036
    1037 == [IndexedGetter](i) == #IndexedGetter
     1037== `[IndexedGetter]`(i) == #IndexedGetter
    10381038
    10391039 * [http://dev.w3.org/2006/webapi/WebIDL/#idl-indexed-properties The spec of indexed properties] (Note: The WebKit behavior explained below is different from the spec)
    10401040
    1041 Summary: [IndexedGetter] means that a given interface should have a getter of indexed properties.
    1042 
    1043 Usage: [IndexedGetter] can be specified on interfaces:
     1041Summary: `[IndexedGetter]` means that a given interface should have a getter of indexed properties.
     1042
     1043Usage: `[IndexedGetter]` can be specified on interfaces:
    10441044{{{
    10451045    interface [
     
    10491049}}}
    10501050
    1051 Indexed getters define the behavior when XXX[i] is evaluated.
    1052 For example, if XXX is an array-type interface, it should have indexed getters (and setters).
    1053 The bindings code for indexed getters is generated automatically so that XXX[i] behaves equivalent to XXX.item(i).
    1054 
    1055 == [V8CustomIndexedGetter](i) == #V8CustomIndexedGetter
    1056 
    1057 Summary: [V8CustomIndexedGetter] allows you to write custom bindings for a getter of indexed properties.
    1058 
    1059 Usage: [V8CustomIndexedGetter] can be specified on interfaces:
     1051Indexed getters define the behavior when `XXX[i]` is evaluated.
     1052For example, if `XXX` is an array-type interface, it should have indexed getters (and setters).
     1053The bindings code for indexed getters is generated automatically so that `XXX[i]` behaves equivalent to `XXX.item(i)`.
     1054
     1055== `[V8CustomIndexedGetter]`(i) == #V8CustomIndexedGetter
     1056
     1057Summary: `[V8CustomIndexedGetter]` allows you to write custom bindings for a getter of indexed properties.
     1058
     1059Usage: `[V8CustomIndexedGetter]` can be specified on interfaces:
    10601060{{{
    10611061    interface [
     
    10671067Interface that have V8CustomIndexedGetter attribute must have also IndexedGetter attribute.
    10681068
    1069 == [CustomIndexedSetter](i) == #CustomIndexedSetter
     1069== `[CustomIndexedSetter]`(i) == #CustomIndexedSetter
    10701070
    10711071 * [http://dev.w3.org/2006/webapi/WebIDL/#idl-indexed-properties The spec of indexed properties] (Note: The WebKit behavior explained below is different from the spec)
    10721072
    1073 Summary: [CustomIndexedSetter] allows you to write custom bindings for a setter of indexed properties.
     1073Summary: `[CustomIndexedSetter]` allows you to write custom bindings for a setter of indexed properties.
    10741074
    10751075Usage: [CustomIndexedSetter] can be specified on interfaces:
     
    10831083Indexed setters define the behavior when "XXX[i] = ..." is evaluated.
    10841084For example, if XXX is an array-type interface, it should have indexed (getters and) setters.
    1085 [CustomIndexedSetter] allows you to write the custom bindings, as follows.
    1086 
    1087  * JavaScriptCore: You can write custom JSXXX::indexSetter(...) in WebCore/bindings/js/JSXXXCustom.cpp:
     1085`[CustomIndexedSetter]` allows you to write the custom bindings, as follows.
     1086
     1087 * JavaScriptCore: You can write custom `JSXXX::indexSetter(...)` in WebCore/bindings/js/JSXXXCustom.cpp:
    10881088
    10891089{{{
     
    10931093    }
    10941094}}}
    1095  * In V8: You can write custom V8XXX::indexedPropertySetter(...) in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
     1095 * In V8: You can write custom `V8XXX::indexedPropertySetter(...)` in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
    10961096
    10971097{{{
     
    11021102}}}
    11031103
    1104 == [NamedGetter](i) == #NamedGetter
     1104== `[NamedGetter]`(i) == #NamedGetter
    11051105
    11061106 * [http://dev.w3.org/2006/webapi/WebIDL/#idl-named-properties The spec of named properties] (Note: The WebKit behavior explained below is different from the spec)
    11071107
    1108 Summary: [NamedGetter] means that a given interface should have a getter of named properties.
    1109 
    1110 Usage: [NamedGetter] can be specified on interfaces:
     1108Summary: `[NamedGetter]` means that a given interface should have a getter of named properties.
     1109
     1110Usage: `[NamedGetter]` can be specified on interfaces:
    11111111{{{
    11121112    interface [
     
    11191119The bindings code for named getters is generated automatically so that XXX.foooooooo behaves equivalent to XXX.namedItem(i).
    11201120
    1121 == [CustomNamedGetter](i), [CustomNamedSetter](i) == #CustomNamedGetter
     1121== `[CustomNamedGetter]`(i), `[CustomNamedSetter]`(i) == #CustomNamedGetter
    11221122
    11231123 * [http://dev.w3.org/2006/webapi/WebIDL/#idl-named-properties The spec of named properties] (Note: The WebKit behavior explained below is different from the spec)
    11241124
    1125 Summary: [CustomNamedGetter] or [CustomNamedSetter] allows you to write custom bindings for a getter or setter of named properties.
     1125Summary: `[CustomNamedGetter]` or `[CustomNamedSetter]` allows you to write custom bindings for a getter or setter of named properties.
    11261126
    11271127Usage: They can be specified on interfaces:
     
    11361136Named getters define the behavior when XXX.foooooooo is evaluated, where foooooooo is not an attribute of XXX.
    11371137Named setters define the behavior when "XXX.foooooooo = ..." is evaluated.
    1138 [CustomNamedGetter] or [CustomNamedSetter] allow you to write the custom bindings, as follows:
    1139 
    1140  * [CustomNamedGetter] in JavaScriptCore: You can write custom JSXXX::canGetItemsForName(...) and JSXXX::nameGetter(...) in WebCore/bindings/js/JSXXXCustom.cpp:
     1138`[CustomNamedGetter]` or `[CustomNamedSetter]` allow you to write the custom bindings, as follows:
     1139
     1140 * `[CustomNamedGetter]` in JavaScriptCore: You can write custom `JSXXX::canGetItemsForName(...)` and `JSXXX::nameGetter(...)` in WebCore/bindings/js/JSXXXCustom.cpp:
    11411141
    11421142{{{
     
    11511151    }
    11521152}}}
    1153  * [CustomNamedGetter] in V8: You can write custom V8XXX::namedPropertyGetter(...) in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
     1153 * `[CustomNamedGetter]` in V8: You can write custom `V8XXX::namedPropertyGetter(...)` in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
    11541154
    11551155{{{
     
    11591159    }
    11601160}}}
    1161  * [CustomNamedSetter] in JavaScriptCore: You can write custom JSXXX::putDelegate(...) in WebCore/bindings/js/JSXXXCustom.cpp:
     1161 * `[CustomNamedSetter]` in JavaScriptCore: You can write custom `JSXXX::putDelegate(...)` in WebCore/bindings/js/JSXXXCustom.cpp:
    11621162
    11631163{{{
     
    11671167    }
    11681168}}}
    1169  * [CustomNamedSetter] in V8: You can write custom V8XXX::namedPropertySetter(...) in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
     1169 * `[CustomNamedSetter]` in V8: You can write custom `V8XXX::namedPropertySetter(...)` in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
    11701170
    11711171{{{
     
    11761176}}}
    11771177
    1178 == [InterfaceName](i) == #InterfaceName
    1179 
    1180 Summary: If you want to expose a different interface name to JavaScript, you can specify the name by [InterfaceName].
    1181 
    1182 Usage: The possible usage is [InterfaceName=X], where X is the interface name exposed to JavaScript.
    1183 [InterfaceName] can be specified on interfaces:
     1178== `[InterfaceName]`(i) == #InterfaceName
     1179
     1180Summary: If you want to expose a different interface name to JavaScript, you can specify the name by `[InterfaceName]`.
     1181
     1182Usage: The possible usage is `[InterfaceName=X]`, where `X` is the interface name exposed to JavaScript.
     1183`[InterfaceName]` can be specified on interfaces:
    11841184{{{
    11851185    interface [
     
    11891189}}}
    11901190
    1191 Without [InterfaceName=...], the interface name exposed to JavaScript becomes the same as the interface name in an IDL file.
    1192 If you want change it based on the spec, you can use [InterfaceName=...].
     1191Without `[InterfaceName=...]`, the interface name exposed to JavaScript becomes the same as the interface name in an IDL file.
     1192If you want change it based on the spec, you can use `[InterfaceName=...]`.
    11931193In the above example, `window.toString()` will return `"[object Window]"` in JavaScript.
    11941194
    1195 == [EventTarget](i) FIXME == #EventTarget
     1195== `[EventTarget]`(i) FIXME == #EventTarget
    11961196
    11971197Summary: ADD SUMMARY
    11981198
    1199 Usage: [EventTarget] can be specified on interfaces:
     1199Usage: `[EventTarget]` can be specified on interfaces:
    12001200{{{
    12011201    interface [
     
    12071207ADD EXPLANATIONS
    12081208
    1209 == [DoNotCheckConstants](i) == #DoNotCheckConstants
    1210 
    1211 Summary: [DoNotCheckConstants] indicates that constant values in an IDL file can be different from constant values in WebCore implementation.
    1212 
    1213 Usage: [DoNotCheckConstants] can be specified on interfaces:
     1209== `[DoNotCheckConstants]`(i) == #DoNotCheckConstants
     1210
     1211Summary: `[DoNotCheckConstants]` indicates that constant values in an IDL file can be different from constant values in WebCore implementation.
     1212
     1213Usage: `[DoNotCheckConstants]` can be specified on interfaces:
    12141214{{{
    12151215    interface [
     
    12211221}}}
    12221222
    1223 By default (i.e. without [DoNotCheckConstants]), compile-time assertions are inserted to check if the constant values defined in IDL files
     1223By default (i.e. without `[DoNotCheckConstants]`), compile-time assertions are inserted to check if the constant values defined in IDL files
    12241224are equal to the constant values in WebCore implementation.
    12251225In the above example, if NOT_FOUND_ERR were implemented as 100 in WebCore, the build will fail.
     
    12281228and thus the values in WebCore implementation should be equal to the values defined in the spec.
    12291229If you really want to introduce non-speced constant values and allow different values between IDL files and WebCore implementation,
    1230 you can specify [DoNotCheckConstants] to skip the compile-time assertions.
    1231 
    1232 == [ActiveDOMObject](i) == #ActiveDOMObject
    1233 
    1234 Summary: [ActiveDOMObject] indicates that a given DOM object should be kept alive as long as the DOM object has pending activities.
    1235 
    1236 Usage: [ActiveDOMObject] can be specified on interfaces:
     1230you can specify `[DoNotCheckConstants]` to skip the compile-time assertions.
     1231
     1232== `[ActiveDOMObject]`(i) == #ActiveDOMObject
     1233
     1234Summary: `[ActiveDOMObject]` indicates that a given DOM object should be kept alive as long as the DOM object has pending activities.
     1235
     1236Usage: `[ActiveDOMObject]` can be specified on interfaces:
    12371237{{{
    12381238    interface [
     
    12421242}}}
    12431243
    1244 If a given DOM object needs to be kept alive as long as the DOM object has pending activities, you need to specify [ActiveDOMObject].
    1245 For example, [ActiveDOMObject] can be used when the DOM object is expecting events to be raised in the future.
    1246 
    1247 If you use [ActiveDOMObject], the corresponding WebCore class needs to inherit ActiveDOMObject.
     1244If a given DOM object needs to be kept alive as long as the DOM object has pending activities, you need to specify `[ActiveDOMObject]`.
     1245For example, `[ActiveDOMObject]` can be used when the DOM object is expecting events to be raised in the future.
     1246
     1247If you use `[ActiveDOMObject]`, the corresponding WebCore class needs to inherit ActiveDOMObject.
    12481248For example, in case of XMLHttpRequest, WebCore/xml/XMLHttpRequest.h would look like this:
    12491249{{{
     
    12541254Then you need to implement the virtual methods of the ActiveDOMObject class, e.g. contextDestroyed(), canSuspend(), suspend(), resume() and stop().
    12551255
    1256 If an interface X has [ActiveDOMObject] and an interface Y inherits the interface X,
    1257 then the interface Y should also have [ActiveDOMObject].
    1258 
    1259 == [V8DependentLifeTime](i) FIXME == #V8DependentLifeTime
     1256If an interface X has `[ActiveDOMObject]` and an interface Y inherits the interface X,
     1257then the interface Y should also have `[ActiveDOMObject]`.
     1258
     1259== `[V8DependentLifeTime]`(i) FIXME == #V8DependentLifeTime
    12601260
    12611261Summary: ADD SUMMARY
    12621262
    1263 Usage: [V8DependentLifeTime] can be specified on interfaces:
     1263Usage: `[V8DependentLifeTime]` can be specified on interfaces:
    12641264{{{
    12651265    interface [
     
    12711271ADD EXPLANATIONS
    12721272
    1273 == [CustomEnumerateProperty](i), [CustomDeleteProperty](i) == #CustomEnumerateProperty
    1274 
    1275 Summary: [CustomEnumerateProperty] allows you to write custom bindings for the case where properties of a given interface are enumerated.
    1276 [CustomDeleteProperty] allows you to write custom bindings for the case where a property of a given interface is deleted.
     1273== `[CustomEnumerateProperty]`(i), `[CustomDeleteProperty]`(i) == #CustomEnumerateProperty
     1274
     1275Summary: `[CustomEnumerateProperty]` allows you to write custom bindings for the case where properties of a given interface are enumerated.
     1276`[CustomDeleteProperty]` allows you to write custom bindings for the case where a property of a given interface is deleted.
    12771277
    12781278Usage: They can be specified on interfaces:
     
    12851285}}}
    12861286
    1287  * [CustomEnumerateProperty] in JavaScriptCore: You can write custom bindings when properties of XXX are enumerated.
    1288 Specifically, you can write custom JSXXX::getOwnPropertyNames(...) in WebCore/bindings/js/JSXXXCustom.cpp:
     1287 * `[CustomEnumerateProperty]` in JavaScriptCore: You can write custom bindings when properties of XXX are enumerated.
     1288Specifically, you can write custom `JSXXX::getOwnPropertyNames(...)` in WebCore/bindings/js/JSXXXCustom.cpp:
    12891289
    12901290{{{
     
    12951295}}}
    12961296
    1297  * [CustomEnumerateProperty] in V8: You can write custom bindings as V8XXX::namedPropertyQuery(...) and V8XXX::namedPropertyEnumerator(...) in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
     1297 * `[CustomEnumerateProperty]` in V8: You can write custom bindings as `V8XXX::namedPropertyQuery(...)` and `V8XXX::namedPropertyEnumerator(...)` in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
    12981298
    12991299{{{
     
    13091309}}}
    13101310
    1311  * [CustomDeleteProperty] in JavaScriptCore: You can write custom bindings for the case where a property of XXX is deleted.
    1312 Specifically, you can write custom JSXXX::deleteProperty(...) in WebCore/bindings/js/JSXXXCustom.cpp:
     1311 * `[CustomDeleteProperty]` in JavaScriptCore: You can write custom bindings for the case where a property of XXX is deleted.
     1312Specifically, you can write custom `JSXXX::deleteProperty(...)` in WebCore/bindings/js/JSXXXCustom.cpp:
    13131313
    13141314{{{
     
    13191319}}}
    13201320
    1321  * [CustomDeleteProperty] in V8: You can write custom bindings as V8XXX::namedPropertyDeleter(...) in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
     1321 * `[CustomDeleteProperty]` in V8: You can write custom bindings as `V8XXX::namedPropertyDeleter(...)` in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
    13221322
    13231323{{{
     
    13281328}}}
    13291329
    1330 == [IsWorkerContext](i) == #IsWorkerContext
    1331 
    1332 Summary: [IsWorkerContext] indicates that a given interface is a WorkerContext-related interface.
    1333 
    1334 Usage: [IsWorkerContext] can be specified on WorkerContext-related interfaces only:
     1330== `[IsWorkerContext]`(i) == #IsWorkerContext
     1331
     1332Summary: `[IsWorkerContext]` indicates that a given interface is a WorkerContext-related interface.
     1333
     1334Usage: `[IsWorkerContext]` can be specified on WorkerContext-related interfaces only:
    13351335{{{
    13361336    interface [
     
    13401340}}}
    13411341
    1342 == [TransferList](p) == #TransferList
    1343 
    1344 Summary: [TransferList] allows a SerializedScriptValue parameter used
     1342== `[TransferList]`(p) == #TransferList
     1343
     1344Summary: `[TransferList]` allows a SerializedScriptValue parameter used
    13451345with the structured clone algorithm to specify another parameter used
    13461346to pass the transfer list.
    13471347
    1348 Usage: The possible usage is [TransferList=XXX] where XXX is another
     1348Usage: The possible usage is `[TransferList=XXX]` where `XXX` is another
    13491349parameter in the same method signature as the SerializedScriptValue
    13501350parameter on which the modifier is placed. The referenced parameter
     
    13711371}}}
    13721372
    1373 == [TypedArray](i), [ConstructorTemplate=TypedArray](i) == #TypedArray
     1373== `[TypedArray]`(i), [ConstructorTemplate=TypedArray](i) == #TypedArray
    13741374
    13751375* [http://www.khronos.org/registry/typedarray/specs/latest/#7 The spec of TypedArray]
     
    13781378TypedArray implements ArrayBufferView. Each of the typed array types has the following constructors, properties, constants and methods.
    13791379
    1380 Usage: [TypedArray] must be specified on interfaces in conjunction with [ConstructorTemplate=TypedArray]:
     1380Usage: `[TypedArray]` must be specified on interfaces in conjunction with `[ConstructorTemplate=TypedArray]`:
    13811381Example:
    13821382
     
    13901390}}}
    13911391
    1392 TypedArray=* Allows us to specify any valid typed array view type.
    1393 TypedArray interfaces require special bindings code, you need to use [ConstructorTemplate=TypedArray] instead of normal [Constructor].
    1394 
    1395 == [CustomCall](i) == #CustomCall
    1396 
    1397 Summary: [CustomCall] allows you to write custom bindings for call(...) of a given interface.
    1398 
    1399 Usage: [CustomCall] can be specified on interfaces:
     1392`TypedArray=*` Allows us to specify any valid typed array view type.
     1393TypedArray interfaces require special bindings code, you need to use `[ConstructorTemplate=TypedArray]` instead of normal `[Constructor]`.
     1394
     1395== `[CustomCall]`(i) == #CustomCall
     1396
     1397Summary: `[CustomCall]` allows you to write custom bindings for `call(...)` of a given interface.
     1398
     1399Usage: `[CustomCall]` can be specified on interfaces:
    14001400{{{
    14011401    interface [
     
    14051405}}}
    14061406
    1407 If you want to write custom bindings for XXX.call(...), you can use [CustomCall].
    1408 
    1409  * JavaScriptCore: You can write custom JSXXX::getCallData(...) in WebCore/bindings/js/JSXXXCustom.cpp:
     1407If you want to write custom bindings for XXX.call(...), you can use `[CustomCall]`.
     1408
     1409 * JavaScriptCore: You can write custom `JSXXX::getCallData(...)` in WebCore/bindings/js/JSXXXCustom.cpp:
    14101410
    14111411{{{
     
    14151415    }
    14161416}}}
    1417  * V8: You can write custom V8XXX::callAsFunctionCallback(...) in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
     1417 * V8: You can write custom `V8XXX::callAsFunctionCallback(...)` in WebCore/bindings/v8/custom/V8XXXCustom.cpp:
    14181418
    14191419{{{
     
    14241424}}}
    14251425
    1426 == [JSCustomToNativeObject](i), [JSCustomFinalize](i), [JSCustomIsReachable](i), [JSCustomMarkFunction](i), [JSCustomNamedGetterOnPrototype](i), [JSCustomPushEventHandlerScope](i), [JSCustomDefineOwnProperty](i), [JSCustomDefineOwnPropertyOnPrototype](i), [JSCustomGetOwnPropertySlotAndDescriptor](i) == #JSCustomToNativeObject
     1426== `[JSCustomToNativeObject]`(i), `[JSCustomFinalize]`(i), `[JSCustomIsReachable]`(i), `[JSCustomMarkFunction]`(i), `[JSCustomNamedGetterOnPrototype]`(i), `[JSCustomPushEventHandlerScope]`(i), `[JSCustomDefineOwnProperty]`(i), `[JSCustomDefineOwnPropertyOnPrototype]`(i), `[JSCustomGetOwnPropertySlotAndDescriptor]`(i) == #JSCustomToNativeObject
    14271427
    14281428Summary: They allow you to write custom bindings for the JavaScriptCore-specific code that would be generated automatically by default.
     
    14471447Refer to use cases in WebCore/bindings/js/JSXXXCustom.cpp for more details.
    14481448
    1449  * [JSCustomToNativeObject]: You can write custom toXXX(...):
     1449 * `[JSCustomToNativeObject]`: You can write custom `toXXX(...)`:
    14501450
    14511451{{{
     
    14551455    }
    14561456}}}
    1457  * [JSCustomFinalize]: You can write custom JSXXXOwner::finalize(...):
     1457 * `[JSCustomFinalize]`: You can write custom `JSXXXOwner::finalize(...)`:
    14581458
    14591459{{{
     
    14631463    }
    14641464}}}
    1465  * [JSCustomIsReachable]: You can write custom JSXXXOwner::isReachableFromOpaqueRoots(...):
     1465 * `[JSCustomIsReachable]`: You can write custom `JSXXXOwner::isReachableFromOpaqueRoots(...)`:
    14661466
    14671467{{{
     
    14711471    }
    14721472}}}
    1473  * [JSCustomMarkFunction]: You can write custom JSXXX::visitChildren(...):
     1473 * `[JSCustomMarkFunction]`: You can write custom `JSXXX::visitChildren(...)`:
    14741474
    14751475{{{
     
    14791479    }
    14801480}}}
    1481  * [JSCustomNamedGetterOnPrototype]: You can write custom JSXXXPrototype::putDelegate(...):
     1481 * `[JSCustomNamedGetterOnPrototype]`: You can write custom `JSXXXPrototype::putDelegate(...)`:
    14821482
    14831483{{{
     
    14871487    }
    14881488}}}
    1489  * [JSCustomPushEventHandlerScope]: You can write custom JSXXX::pushEventHandlerScope(...):
     1489 * `[JSCustomPushEventHandlerScope]`: You can write custom `JSXXX::pushEventHandlerScope(...)`:
    14901490
    14911491{{{
     
    14951495    }
    14961496}}}
    1497  * [JSCustomDefineOwnProperty]: You can write custom JSXXX::defineOwnProperty(...):
     1497 * `[JSCustomDefineOwnProperty]`: You can write custom `JSXXX::defineOwnProperty(...)`:
    14981498
    14991499{{{
     
    15031503    }
    15041504}}}
    1505  * [JSCustomDefineOwnPropertyOnPrototype]: You can write custom JSXXXPrototype::defineOwnProperty(...):
     1505 * `[JSCustomDefineOwnPropertyOnPrototype]`: You can write custom `JSXXXPrototype::defineOwnProperty(...)`:
    15061506
    15071507{{{
     
    15111511    }
    15121512}}}
    1513  * [JSCustomGetOwnPropertySlotAndDescriptor]: You can write custom JSXXX::getOwnPropertySlotDelegate(...) and JSXXX::getOwnPropertyDescriptorDelegate(...):
     1513 * `[JSCustomGetOwnPropertySlotAndDescriptor]`: You can write custom `JSXXX::getOwnPropertySlotDelegate(...)` and `JSXXX::getOwnPropertyDescriptorDelegate(...)`:
    15141514
    15151515{{{
     
    15251525}}}
    15261526
    1527 == [JSGenerateToJSObject](i), [JSGenerateToNativeObject](i) == #JSGenerateToJSObject
     1527== `[JSGenerateToJSObject]`(i), `[JSGenerateToNativeObject]`(i) == #JSGenerateToJSObject
    15281528
    15291529Summary: They force JavaScriptCore bindings to generate JavaScriptCore-specific methods, even if a given interface has a parent interface.
     
    15381538}}}
    15391539
    1540 toJS(...), isReachableFromOpaqueRoots(...) or toXXX() is not generated if XXX has a parent interface.
     1540`toJS(...)`, `isReachableFromOpaqueRoots(...)` or `toXXX()` is not generated if XXX has a parent interface.
    15411541If you want to generate it even if XXX does not have a parent interface, you can specify
    1542 [JSGenerateToJSObject] or [JSGenerateToNativeObject], respectively.
    1543 
    1544 == [JSGenerateIsReachable](i) == #JSGenerateIsReachable
     1542`[JSGenerateToJSObject]` or `[JSGenerateToNativeObject]`, respectively.
     1543
     1544== `[JSGenerateIsReachable]`(i) == #JSGenerateIsReachable
    15451545
    15461546Summary: This generates code that determines if a wrapper is reachable.
    15471547
    1548 Usage: The JSGenerateIsReachable can be specified on the interface. This attribute is ignored if CustomIsReachable is present.
     1548Usage: The `JSGenerateIsReachable` can be specified on the interface. This attribute is ignored if `CustomIsReachable` is present.
    15491549
    15501550{{{
     
    15551555}}}
    15561556
    1557 The code generates a function called XXX::isReachableFromOpaqueRoots which returns a boolean if the wrapper is reachable.
     1557The code generates a function called `XXX::isReachableFromOpaqueRoots` which returns a boolean if the wrapper is reachable.
    15581558
    15591559The currently valid values are:
     
    16161616}
    16171617}}}
    1618 == [GenerateIsReachable](i) == #GenerateIsReachable
    1619 
    1620 Summary: This is the shared version of [JSGenerateIsReachable] and V8GenerateIsReachable. The accepted values are the intersection of those two.
     1618== `[GenerateIsReachable]`(i) == #GenerateIsReachable
     1619
     1620Summary: This is the shared version of `[JSGenerateIsReachable]` and `V8GenerateIsReachable`. The accepted values are the intersection of those two.
    16211621
    16221622 - ImplElementRoot
    16231623 - ImplBaseRoot
    16241624
    1625 == [JSCustomHeader](i) == #JSCustomHeader
    1626 
    1627 Summary: [JSCustomHeader] allows you to write a custom header for a given interface.
    1628 
    1629 Usage: [JSCustomHeader] can be specified on interfaces:
     1625== `[JSCustomHeader]`(i) == #JSCustomHeader
     1626
     1627Summary: `[JSCustomHeader]` allows you to write a custom header for a given interface.
     1628
     1629Usage: `[JSCustomHeader]` can be specified on interfaces:
    16301630{{{
    16311631    interface [
     
    16361636
    16371637By default, JSXXX.h and JSXXX.cpp are generated automatically.
    1638 By specifying [Custom*], you can write custom bindings in WebCore/bindings/js/JSXXXCustom.cpp.
    1639 In addition, by specifying [JSCustomHeader], you can write custom header in WebCore/bindings/js/JSXXXCustom.h, which will be included by JSXXX.h.
    1640 
    1641 == [JSLegacyParent](i) == #JSLegacyParent
    1642 
    1643 Summary: [JSLegacyParent] explicitly controls the parent interface of a given interface.
    1644 
    1645 Usage: [JSLegacyParent] can be specified on interfaces that do not have a parent interface:
     1638By specifying `[Custom*]`, you can write custom bindings in WebCore/bindings/js/JSXXXCustom.cpp.
     1639In addition, by specifying `[JSCustomHeader]`, you can write custom header in WebCore/bindings/js/JSXXXCustom.h, which will be included by JSXXX.h.
     1640
     1641== `[JSLegacyParent]`(i) == #JSLegacyParent
     1642
     1643Summary: `[JSLegacyParent]` explicitly controls the parent interface of a given interface.
     1644
     1645Usage: `[JSLegacyParent]` can be specified on interfaces that do not have a parent interface:
    16461646{{{
    16471647    interface [
     
    16511651}}}
    16521652
    1653 Even if a given interface does not have a parent interface, you can specify a parent interface using [JSLegacyParent].
    1654 
    1655 == [JSInlineGetOwnPropertySlot](i) == #JSInlineGetOwnPropertySlot
    1656 
    1657 Summary: For performance, [JSInlineGetOwnPropertySlot] makes getOwnPropertySlot(...) and getOwnPropertyDescriptor(...) an inline method.
    1658 
    1659 Usage: [JSInlineGetOwnPropertySlot] can be specified on interfaces:
     1653Even if a given interface does not have a parent interface, you can specify a parent interface using `[JSLegacyParent]`.
     1654
     1655== `[JSInlineGetOwnPropertySlot]`(i) == #JSInlineGetOwnPropertySlot
     1656
     1657Summary: For performance, `[JSInlineGetOwnPropertySlot]` makes `getOwnPropertySlot(...)` and `getOwnPropertyDescriptor(...)` an inline method.
     1658
     1659Usage: `[JSInlineGetOwnPropertySlot]` can be specified on interfaces:
    16601660{{{
    16611661    interface [
     
    16651665}}}
    16661666
    1667 == [JSNoStaticTables](i) == #JSNoStaticTables
     1667== `[JSNoStaticTables]`(i) == #JSNoStaticTables
    16681668
    16691669Summary: By default, there is only a single static prototype table for the interface.  This flag turns off creation of the static table, and each user gets its own table.
     
    16711671Sharing a single static prototype table only works when a class is guaranteed to be accessed from a single heap, because the lookup code expects the key (attribute name) to have the same address across all instances of the object. For interfaces that are exposed to Workers, a single static table won't work because a given string used to look up a property on the object will lie at a different address in each heap.
    16721672
    1673 Usage: [JSNoStaticTables] can be specified on interfaces:
     1673Usage: `[JSNoStaticTables]` can be specified on interfaces:
    16741674{{{
    16751675    interface [
     
    16811681ADD EXPLANATIONS
    16821682
    1683 == [ObjCProtocol](i), [ObjCPolymorphic](i), [ObjCLegacyUnnamedParameters](m), [ObjCUseDefaultView](m), [ObjCImplementedAsUnsignedLongLong](a) == #ObjCProtocol
     1683== `[ObjCProtocol]`(i), `[ObjCPolymorphic]`(i), `[ObjCLegacyUnnamedParameters]`(m), `[ObjCUseDefaultView]`(m), `[ObjCImplementedAsUnsignedLongLong]`(a) == #ObjCProtocol
    16841684
    16851685Used by ObjC bindings only.
    16861686
    1687 == [CPPPureInterface](i) == #CPPPureInterface
     1687== `[CPPPureInterface]`(i) == #CPPPureInterface
    16881688
    16891689Used by CPP bindings only.
    16901690
    1691 == [CustomReturn](p) == #CustomReturn
     1691== `[CustomReturn]`(p) == #CustomReturn
    16921692
    16931693Used by ObjC, GObject and CPP bindings only.
    16941694
    1695 == [ArrayClass](i) == #ArrayClass
     1695== `[ArrayClass]`(i) == #ArrayClass
    16961696
    16971697* [http://dev.w3.org/2006/webapi/WebIDL/#ArrayClass The spec of ArrayClass]
     
    16991699Summary: Allows an interface to extend JavaScript arrays.
    17001700
    1701 Usage: [ArrayClass] can be specified on interfaces. An interface may not both have [ArrayClass] and extend another interface.
     1701Usage: `[ArrayClass]` can be specified on interfaces. An interface may not both have `[ArrayClass]` and extend another interface.
    17021702
    17031703The bindings for the interface will have the `[[Prototype]]` of the constructor prototype set to `Array.prototype` which means that the methods defined on JavaScript arrays work on the instances of this interface.
     
    17181718}}}
    17191719
    1720 == [OmitConstructor], [Immutable], [MasqueradesAsUndefined], [CustomGetOwnPropertySlot], [ReplaceableConstructor], [ExtendsDOMGlobalObject], [IsIndex], [V8DoNotCheckSignature], [NumericIndexedGetter] == #OmitConstructor
     1720== `[OmitConstructor]`, `[Immutable]`, `[MasqueradesAsUndefined]`, `[CustomGetOwnPropertySlot]`, `[ReplaceableConstructor]`, `[ExtendsDOMGlobalObject]`, `[IsIndex]`, `[V8DoNotCheckSignature]`, `[NumericIndexedGetter]` == #OmitConstructor
    17211721
    17221722Might be deprecated. Discussion is on-going.
    17231723
    1724 == [ImplementationNameSpace] == #ImplementationNamespace
     1724== `[ImplementationNameSpace]` == #ImplementationNamespace
    17251725
    17261726Summary: Specifies the namespace for the corresponding native type. 
     
    17281728By default, the namespace is WebCore.  This is presently used to mark WTF types.
    17291729
    1730 Usage: [ImplementationNamespace] can be specified on interfaces:
     1730Usage: `[ImplementationNamespace]` can be specified on interfaces:
    17311731{{{
    17321732    interface [
     
    17361736}}}
    17371737
    1738 == [V8SkipVTableValidation], [ImplementationLacksVTable] == #V8SkipVTableValidation
     1738== `[V8SkipVTableValidation]`, `[ImplementationLacksVTable]` == #V8SkipVTableValidation
    17391739
    17401740Summary: Specifies that a type can not be checked as part of the V8 Bindings Integrity option.
     
    17421742V8 Bindings Integrity tries to ensure that free/corrupted objects are not wrapped by V8, thereby reducing their exploitability. In order for that to be the case, the implementation must have a distinct VTable pointer in its first word.
    17431743
    1744 Usage: [V8SkipVTableValidation] and [ImplementationLacksVTable] can be specified on interfaces.
     1744Usage: `[V8SkipVTableValidation]` and `[ImplementationLacksVTable]` can be specified on interfaces.
    17451745
    17461746{{{