Context Navigation

Changes between Version 39 and Version 40 of WebKitIDL

Timestamp:: Feb 19, 2012, 9:59:47 PM (15 years ago)
Author:: haraken@chromium.org
Comment:: --

Legend:

: Unmodified
: Added
: Removed
: Modified

WebKitIDL

-              v39
+              v40
 = THIS DOCUMENT IS STILL DRAFT =
+[#naming-rules naming rules]
 = Overview =
 …
  * CPP: WebKitBuild/Release/DerivedSources/WebCore/WebDOMXXX.h, WebKitBuild/Release/DerivedSources/WebCore/WebDOMXXX.cpp
 = Basic naming rules of IDL attribute =
+= Basic naming rules of IDL attribute = [=#naming-rules]
 There are a few rules of IDL attribute naming:
 …
         void func2(in int a, in int b, in [Optional=DefaultIsUndefined] int c);
         void func3(in int a, in int b, in [Optional=DefaultIsUndefined] DOMString c, in [Optional=DefaultIsNullString] DOMString d);
+    }
+    };
 }}}
 …
     ] HTMLFoo {
         void func(in int a, in [Callback] int b);
+    }
+    };
 }}}
 …
     interface XXX {
         [JSCustom] void func(in int a, in int b);
+    }
+    };
 }}}
 You need to prepare WebCore/bindings/js/JSXXXCustom.cpp and write custom bindings:
 …
     interface XXX {
         attribute [JSCustomGetter] DOMString str;
+    }
+    };
 }}}
 You need to prepare WebCore/bindings/js/JSXXXCustom.cpp and write custom bindings:
 …
     interface XXX {
         attribute [JSCustomSetter] DOMString str;
+    }
+    };
 }}}
 You need to prepare WebCore/bindings/js/JSXXXCustom.cpp and write custom bindings:
 …
     interface XXX {
         [V8Custom] void func(in int a, in int b);
+    }
+    };
 }}}
 You need to prepare WebCore/bindings/v8/custom/V8XXXCustom.cpp and write custom bindings in the following signature:
 …
     interface XXX {
         attribute [V8CustomGetter] DOMString str;
+    }
+    };
 }}}
 You need to prepare WebCore/bindings/v8/custom/V8XXXCustom.cpp and write custom bindings in the following signature:
 …
     interface XXX {
         attribute [V8CustomSetter] DOMString str;
+    }
+    };
 }}}
 You need to prepare WebCore/bindings/v8/custom/V8XXXCustom.cpp and write custom bindings in the following signature:
 …
         [CallWith=ScriptArguments|CallStack] void func3(in int a, in int b);
         [CallWith=CallStack|ScriptArguments] void func4(in int a, in int b);
+    }
+    };
 }}}
 [CallWith] can be specified on interfaces but it has a different meaning. Refer to the [Constructor] section for [CallWith] on interfaces.
 …
 HTMLFoo::func3(ScriptArguments* arguments, ScriptCallStack* callstack, int a, int b) is called.
 ==  [CheckAccessToNode](m,a) ==
+==  [CheckSecurityForNode](m,a) ==
 Summary: It checks if a given Node access is allowed in terms of security.
 Usage: [CheckAccessToNode] can be specified on methods and attributes:
 {{{
     attribute [CheckAccessToNode] Node contentDocument;
     [CheckAccessToNode] SVGDocument getSVGDocument();
+Usage: [CheckSecurityForNode] can be specified on methods and attributes:
+{{{
+    attribute [CheckSecurityForNode] Node contentDocument;
+    [CheckSecurityForNode] SVGDocument getSVGDocument();
 }}}
 In terms of security, node.contentDocument should return undefined if the parent frame and the child frame are from different origins.
 If the security check is needed, you should specify [CheckAccessToNode].
+If the security check is needed, you should specify [CheckSecurityForNode].
 This is really important for security.
 …
     interface DOMWindow {
         attribute [Replaceable] screenX;
+    }
+    };
 }}}
 …
         attribute [CachedAttribute] DOMString normalValue;
         attribute [CachedAttribute] SerializedScriptValue serializedValue;
+    }
+    };
 }}}
 …
 Usage: The possible usage is
 {{{
+    interface [Supplemental=YYY] XXX { ... }
+    interface [
+        Supplemental=YYY
+    ] XXX {
+    };
 }}}
 where XXX implements YYY. [Supplemental] can be specified on interfaces.
 …
         CallWith=ScriptExecutionContext|ScriptState
     ] XXX {
+    }
+    };
 }}}
 …
         attribute DOMString str1;
         attribute [InitializedByEventConstructor] DOMString str2;
+    }
+    };
 }}}
 …
         NamedConstructor=Audio()
     ] HTMLAudioElement {
+    }
+    };
 }}}
 …
         ConstractorParameters=4
     ] XXX {
+    }
+    };
 }}}
 …
         ConstructorParameters=2
     ] XXX {
+    }
+    };
 }}}
 You need to prepare WebCore/bindings/js/JSXXXCustom.cpp and write custom bindings:
 …
         ConstructorParameters=2
     ] XXX {
+    }
+    };
 }}}
 You need to prepare WebCore/bindings/v8/custom/V8XXXConstructor.cpp and write custom bindings:
 …
         Conditional=INDEXED_DATABASE
     ] XXX {
+    }
+    };
 }}}
 {{{
 …
         attribute [Conditional=INDEXED_DATABASE] DOMString str;
         [Conditional=INDEXED_DATABASE] void open();
+    }
+    };
 }}}
 …
         V8EnabledAtRuntime
     ] XXX {
+    }
+    };
 }}}
 {{{
 …
         [V8EnabledAtRuntime] void open1();
         [V8EnabledAtRuntime=foo] void open2();
+    }
+    };
 }}}
 …
         CustomToJSObject
     ] XXX {
+    }
+    };
 }}}
 …
 }}}
 ==  [CheckAccessToFrame](i), [DoNotCheckAccessToFrame](m,a), [DoNotCheckAccessToFrameOnGetter](a), [DoNotCheckAccessToFrameOnSetter](a) ==
+==  [CheckSecurity](i), [DoNotCheckSecurity](m,a), [DoNotCheckSecurityOnGetter](a), [DoNotCheckSecurityOnSetter](a) ==
 Summary: It checks if a given Frame access is allowed or not, in terms of security.
 Usage: [CheckAccessToFrame] can be specified on interfaces.
 [DoNotCheckAccessToFrame] can be specified on methods or attributes which belong to interfaces which have [CheckAccessToFrame].
 [DoNotCheckAccessToFrameOnGetter] and [DoNotCheckAccessToFrameOnSetter] can be specified on attributes
 which belong to interfaces which have [CheckAccessToFrame]:
 {{{
     interface [
         CheckAccessToFrame
+Usage: [CheckSecurity] can be specified on interfaces.
+[DoNotCheckSecurity] can be specified on methods or attributes which belong to interfaces which have [CheckSecurity].
+[DoNotCheckSecurityOnGetter] and [DoNotCheckSecurityOnSetter] can be specified on attributes
+which belong to interfaces which have [CheckSecurity]:
+{{{
+    interface [
+        CheckSecurity
     ] DOMWindow {
         attribute DOMString str1;
         attribute [DoNotCheckAccessToFrame] DOMString str2:
         attribute [DoNotCheckAccessToFrameOnGetter] DOMString str3:
         attribute [DoNotCheckAccessToFrameOnSetter] DOMString str4:
+        attribute [DoNotCheckSecurity] DOMString str2:
+        attribute [DoNotCheckSecurityOnGetter] DOMString str3:
+        attribute [DoNotCheckSecurityOnSetter] DOMString str4:
         void func1();
         [DoNotCheckAccessToFrame] void func2();
+    }
+        [DoNotCheckSecurity] void func2();
+    };
 }}}
 Consider the case where you access window.parent from inside iframe which comes from a different origin.
 While it is allowed to access window.parent, it is not allowed to access window.parent.document.
 In such cases, you need to specify [CheckAccessToFrame] in order to check
+In such cases, you need to specify [CheckSecurity] in order to check
 whether a given Frame is allowed to access the attribute or method.
 This is really important for security.
 If you specify [CheckAccessToFrame] on an interface, the security check is enabled on all the attributes and methods in the interface.
+If you specify [CheckSecurity] on an interface, the security check is enabled on all the attributes and methods in the interface.
 To disable the security check for some attribute or method, you can use
 [DoNotCheckAccessToFrame], [DoNotCheckAccessToFrameOnGetter] or [DoNotCheckAccessToFrameOnSetter].
  * [DoNotCheckAccessToFrame] on a method disables the security check for the method.
  * [DoNotCheckAccessToFrame] on an attribute disables the security check for a getter and setter of the attribute.
  * [DoNotCheckAccessToFrameOnGetter] on an attribute disables the security check for a getter of the attribute.
  * [DoNotCheckAccessToFrameOnSetter] on an attribute disables the security check for a setter of the attribute.
  * [DoNotCheckAccessToFrame] on an attribute is equivalent to [DoNotCheckAccessToFrameOnGetter, DoNotCheckAccessToFrameOnSetter].
+[DoNotCheckSecurity], [DoNotCheckSecurityOnGetter] or [DoNotCheckSecurityOnSetter].
+ * [DoNotCheckSecurity] on a method disables the security check for the method.
+ * [DoNotCheckSecurity] on an attribute disables the security check for a getter and setter of the attribute.
+ * [DoNotCheckSecurityOnGetter] on an attribute disables the security check for a getter of the attribute.
+ * [DoNotCheckSecurityOnSetter] on an attribute disables the security check for a setter of the attribute.
+ * [DoNotCheckSecurity] on an attribute is equivalent to [DoNotCheckSecurityOnGetter, DoNotCheckSecurityOnSetter].
 ==  [IndexedGetter](i) ==
 …
         IndexedGetter
     ] XXX {
+    }
+    };
 }}}
 …
         CustomIndexedSetter
     ] XXX {
+    }
+    };
 }}}
 …
         NamedGetter
     ] XXX {
+    }
+    };
 }}}
 …
         CustomNamedSetter
     ] XXX {
+    }
+    };
 }}}
 …
         EventTarget
     ] XXX {
+    }
+    };
 }}}
 …
         const unsigned short NOT_FOUND_ERR = 123;
         const unsigned short SYNTAX_ERR = 124;
+    }
+    };
 }}}
 …
         ActiveDOMObject
     ] XMLHttpRequest {
+    }
+    };
 }}}
 …
         V8DependentLifeTime
     ] XXX {
+    }
+    };
 }}}
 …
         CustomDeleteProperty
     ] XXX {
+    }
+    };
 }}}
 …
     ] SharedWorkerContext {
         ...;
+    }
+    };
 }}}
 …
         CustomCall
     ] XXX {
+    }
+    };
 }}}
 …
         JSCustomGetOwnPropertySlotAndDescriptor
     ] XXX {
+    }
+    };
 }}}
 …
         JSGenerateToNativeObject
     ] XXX {
+    }
+    };
 }}}
 …
         JSCustomHeader
     ] XXX {
+    }
+    };
 }}}
 …
         JSLegacyParent=JSDOMWindowBase
     ] DOMWindow {
+    }
+    };
 }}}
 …
         JSInlineGetOwnPropertySlot
     ] XXX {
+    }
+    };
 }}}
 …
         JSNoStaticTables
     ] XXX {
+    }
+    };
 }}}