Diff
Modified: trunk/LayoutTests/imported/w3c/ChangeLog (215418 => 215419)
--- trunk/LayoutTests/imported/w3c/ChangeLog 2017-04-17 17:00:52 UTC (rev 215418)
+++ trunk/LayoutTests/imported/w3c/ChangeLog 2017-04-17 17:58:32 UTC (rev 215419)
@@ -1,3 +1,17 @@
+2017-04-17 Tim Horton <timothy_hor...@apple.com>
+
+ Remove some accidentally-added .orig files
+ https://bugs.webkit.org/show_bug.cgi?id=170908
+
+ Reviewed by Youenn Fablet.
+
+ * web-platform-tests/resources/docs/api.md.orig: Removed.
+ * web-platform-tests/resources/examples/apisample12.html.orig: Removed.
+ * web-platform-tests/resources/webidl2/test/widlproc/doc/htmltodtd.xsl.orig: Removed.
+ * web-platform-tests/resources/webidl2/test/widlproc/doc/widlproc.html.orig: Removed.
+ * web-platform-tests/resources/webidl2/test/widlproc/examples/spectowidl.xsl.orig: Removed.
+ * web-platform-tests/resources/webidl2/test/widlproc/src/widlprocxmltohtml.xsl.orig: Removed.
+
2017-04-14 Jiewen Tan <jiewen_...@apple.com>
[WebCrypto] Support HKDF
Deleted: trunk/LayoutTests/imported/w3c/web-platform-tests/resources/docs/api.md.orig (215418 => 215419)
--- trunk/LayoutTests/imported/w3c/web-platform-tests/resources/docs/api.md.orig 2017-04-17 17:00:52 UTC (rev 215418)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/resources/docs/api.md.orig 2017-04-17 17:58:32 UTC (rev 215419)
@@ -1,704 +0,0 @@
-## Introduction ##
-
-testharness.js provides a framework for writing testcases. It is intended to
-provide a convenient API for making common assertions, and to work both
-for testing synchronous and asynchronous DOM features in a way that
-promotes clear, robust, tests.
-
-## Basic Usage ##
-
-The test harness script can be used from HTML or SVG documents and web worker
-scripts.
-
-From an HTML or SVG document, start by importing both `testharness.js` and
-`testharnessreport.js` scripts into the document:
-
-```html
-<script src=""
-<script src=""
-```
-
-Refer to the [Web Workers](#web-workers) section for details and an example on
-testing within a web worker.
-
-Within each file one may define one or more tests. Each test is atomic in the
-sense that a single test has a single result (`PASS`/`FAIL`/`TIMEOUT`/`NOTRUN`).
-Within each test one may have a number of asserts. The test fails at the first
-failing assert, and the remainder of the test is (typically) not run.
-
-If the file containing the tests is a HTML file, a table containing the test
-results will be added to the document after all tests have run. By default this
-will be added to a `div` element with `id=log` if it exists, or a new `div`
-element appended to `document.body` if it does not.
-
-NOTE: By default tests must be created before the load event fires. For ways
-to create tests after the load event, see "Determining when all tests
-are complete", below.
-
-## Synchronous Tests ##
-
-To create a synchronous test use the `test()` function:
-
-```js
-test(test_function, name, properties)
-```
-
-`test_function` is a function that contains the code to test. For example a
-trivial test for the DOM
-[`hasFeature()`](https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature)
-method (which is defined to always return true) would be:
-
-```js
-test(function() {
- assert_true(document.implementation.hasFeature());
-}, "hasFeature() with no arguments")
-```
-
-The function passed in is run in the `test()` call.
-
-`properties` is a _javascript_ object for passing extra options to the
-test. Currently it is only used to provide test-specific
-metadata, as described in the [metadata](#metadata) section below.
-
-## Asynchronous Tests ##
-
-Testing asynchronous features is somewhat more complex since the result of
-a test may depend on one or more events or other callbacks. The API provided
-for testing these features is intended to be rather low-level but hopefully
-applicable to many situations.
-
-To create a test, one starts by getting a `Test` object using `async_test`:
-
-```js
-async_test(name, properties)
-```
-
-e.g.
-
-```js
-var t = async_test("DOMContentLoaded")
-```
-
-Assertions can be added to the test by calling the step method of the test
-object with a function containing the test assertions:
-
-```js
-document.addEventListener("DOMContentLoaded", function() {
- t.step(function() {
- assert_true(e.bubbles, "bubbles should be true");
- });
-});
-```
-
-When all the steps are complete, the `done()` method must be called:
-
-```js
-t.done();
-```
-
-As a convenience, `async_test` can also takes a function as first argument.
-This function is called with the test object as both its `this` object and
-first argument. The above example can be rewritten as:
-
-```js
-async_test(function(t) {
- document.addEventListener("DOMContentLoaded", function() {
- t.step(function() {
- assert_true(e.bubbles, "bubbles should be true");
- });
- t.done();
- });
-}, "DOMContentLoaded");
-```
-
-which avoids cluttering the global scope with references to async
-tests instances.
-
-The properties argument is identical to that for `test()`.
-
-In many cases it is convenient to run a step in response to an event or a
-callback. A convenient method of doing this is through the `step_func` method
-which returns a function that, when called runs a test step. For example
-
-```js
-document.addEventListener("DOMContentLoaded", t.step_func(function() {
- assert_true(e.bubbles, "bubbles should be true");
- t.done();
-});
-```
-
-As a further convenience, the `step_func` that calls `done()` can instead
-use `step_func_done`, as follows:
-
-```js
-document.addEventListener("DOMContentLoaded", t.step_func_done(function() {
- assert_true(e.bubbles, "bubbles should be true");
-});
-```
-
-For asynchronous callbacks that should never execute, `unreached_func` can
-be used. For example:
-
-```js
-document.documentElement.addEventListener("DOMContentLoaded",
- t.unreached_func("DOMContentLoaded should not be fired on the document element"));
-```
-
-Keep in mind that other tests could start executing before an Asynchronous
-Test is finished.
-
-## Promise Tests ##
-
-`promise_test` can be used to test APIs that are based on Promises:
-
-```js
-promise_test(test_function, name, properties)
-```
-
-`test_function` is a function that receives a test as an argument and returns a
-promise. The test completes when the returned promise resolves. The test fails
-if the returned promise rejects.
-
-E.g.:
-
-```js
-function foo() {
- return Promise.resolve("foo");
-}
-
-promise_test(function() {
- return foo()
- .then(function(result) {
- assert_equals(result, "foo", "foo should return 'foo'");
- });
-}, "Simple example");
-```
-
-In the example above, `foo()` returns a Promise that resolves with the string
-"foo". The `test_function` passed into `promise_test` invokes `foo` and attaches
-a resolve reaction that verifies the returned value.
-
-Note that in the promise chain constructed in `test_function` assertions don't
-need to wrapped in `step` or `step_func` calls.
-
-Unlike Asynchronous Tests, Promise Tests don't start running until after the
-previous Promise Test finishes.
-
-`promise_rejects` can be used to test Promises that need to reject:
-
-```js
-promise_rejects(test_object, code, promise, description)
-```
-
-The `code` argument is equivalent to the same argument to the `assert_throws`
-function.
-
-Here's an example where the `bar()` function returns a Promise that rejects
-with a TypeError:
-
-```js
-function bar() {
- return Promise.reject(new TypeError());
-}
-
-promise_test(function(t) {
- return promise_rejects(t, new TypeError(), bar());
-}, "Another example");
-```
-
-`EventWatcher` is a constructor function that allows DOM events to be handled
-using Promises, which can make it a lot easier to test a very specific series
-of events, including ensuring that unexpected events are not fired at any point.
-
-Here's an example of how to use `EventWatcher`:
-
-```js
-var t = async_test("Event order on animation start");
-
-var animation = watchedNode.getAnimations()[0];
-var eventWatcher = new EventWatcher(watchedNode, ['animationstart',
- 'animationiteration',
- 'animationend']);
-
-eventWatcher.wait_for(t, 'animationstart').then(t.step_func(function() {
- assertExpectedStateAtStartOfAnimation();
- animation.currentTime = END_TIME; // skip to end
- // We expect two animationiteration events then an animationend event on
- // skipping to the end of the animation.
- return eventWatcher.wait_for(['animationiteration',
- 'animationiteration',
- 'animationend']);
-})).then(t.step_func(function() {
- assertExpectedStateAtEndOfAnimation();
- t.done();
-}));
-```
-
-`wait_for` either takes the name of a single event and returns a Promise that
-will resolve after that event is fired at the watched node, or else it takes an
-array of the names of a series of events and returns a Promise that will
-resolve after that specific series of events has been fired at the watched node.
-
-`EventWatcher` will assert if an event occurs while there is no `wait_for`()
-created Promise waiting to be fulfilled, or if the event is of a different type
-to the type currently expected. This ensures that only the events that are
-expected occur, in the correct order, and with the correct timing.
-
-## Single Page Tests ##
-
-Sometimes, particularly when dealing with asynchronous behaviour,
-having exactly one test per page is desirable, and the overhead of
-wrapping everything in functions for isolation becomes
-burdensome. For these cases `testharness.js` support "single page
-tests".
-
-In order for a test to be interpreted as a single page test, then
-it must simply not call `test()` or `async_test()` anywhere on the page, and
-must call the `done()` function to indicate that the test is complete. All
-the `assert_*` functions are avaliable as normal, but are called without
-the normal step function wrapper. For example:
-
-```html
-<!doctype html>
-<title>Basic document.body test</title>
-<script src=""
-<script src=""
-<body>
- <script>
- assert_equals(document.body, document.getElementsByTagName("body")[0])
- done()
- </script>
-```
-
-The test title for single page tests is always taken from `document.title`.
-
-## Making assertions ##
-
-Functions for making assertions start `assert_`. The full list of
-asserts avaliable is documented in the [asserts](#list-of-assertions) section
-below. The general signature is
-
-```js
-assert_something(actual, expected, description)
-```
-
-although not all assertions precisely match this pattern e.g. `assert_true`
-only takes `actual` and `description` as arguments.
-
-The description parameter is used to present more useful error messages when
-a test fails
-
-NOTE: All asserts must be located in a `test()` or a step of an
-`async_test()`, unless the test is a single page test. Asserts outside
-these places won't be detected correctly by the harness and may cause
-unexpected exceptions that will lead to an error in the harness.
-
-## Cleanup ##
-
-Occasionally tests may create state that will persist beyond the test itself.
-In order to ensure that tests are independent, such state should be cleaned
-up once the test has a result. This can be achieved by adding cleanup
-callbacks to the test. Such callbacks are registered using the `add_cleanup`
-function on the test object. All registered callbacks will be run as soon as
-the test result is known. For example
-
-```js
- test(function() {
- var element = document.createElement("div");
- element.setAttribute("id", "null");
- document.body.appendChild(element);
- this.add_cleanup(function() { document.body.removeChild(element) });
- assert_equals(document.getElementById(null), element);
- }, "Calling document.getElementById with a null argument.");
-```
-
-## Timeouts in Tests ##
-
-In general the use of timeouts in tests is discouraged because this is
-an observed source of instability in real tests when run on CI
-infrastructure. In particular if a test should fail when something
-doesn't happen, it is good practice to simply let the test run to the
-full timeout rather than trying to guess an appropriate shorter
-timeout to use.
-
-In other cases it may be necessary to use a timeout (e.g., for a test
-that only passes if some event is *not* fired). In this case it is
-*not* permitted to use the standard `setTimeout` function. Instead one
-must use the `step_timeout` function:
-
-```js
-async_test(function(t) {
- var gotEvent = false;
- document.addEventListener("DOMContentLoaded", t.step_func(function() {
- assert_false(gotEvent, "Unexpected DOMContentLoaded event");
- gotEvent = true;
- t.step_timeout(function() { t.done(); }, 2000);
- });
-}, "Only one DOMContentLoaded");
-```
-
-The difference between `setTimeout` and `step_timeout` is that the
-latter takes account of the timeout multiplier when computing the
-delay; e.g., in the above case a timeout multiplier of 2 would cause a
-pause of 4000ms before calling the callback. This makes it less likely
-to produce unstable results in slow configurations.
-
-Note that timeouts generally need to be a few seconds long in order to
-produce stable results in all test environments.
-
-For single-page tests, `step_timeout` is also available as a global
-function.
-
-## Harness Timeout ##
-
-The overall harness admits two timeout values `"normal"` (the
-default) and `"long"`, used for tests which have an unusually long
-runtime. After the timeout is reached, the harness will stop
-waiting for further async tests to complete. By default the
-timeouts are set to 10s and 60s, respectively, but may be changed
-when the test is run on hardware with different performance
-characteristics to a common desktop computer. In order to opt-in
-to the longer test timeout, the test must specify a meta element:
-
-```html
-<meta name="timeout" content="long">
-```
-
-Occasionally tests may have a race between the harness timing out and
-a particular test failing; typically when the test waits for some event
-that never occurs. In this case it is possible to use `test.force_timeout()`
-in place of `assert_unreached()`, to immediately fail the test but with a
-status of `TIMEOUT`. This should only be used as a last resort when it is
-not possible to make the test reliable in some other way.
-
-## Setup ##
-
-Sometimes tests require non-trivial setup that may fail. For this purpose
-there is a `setup()` function, that may be called with one or two arguments.
-The two argument version is:
-
-```js
-setup(func, properties)
-```
-
-The one argument versions may omit either argument.
-func is a function to be run synchronously. `setup()` becomes a no-op once
-any tests have returned results. Properties are global properties of the test
-harness. Currently recognised properties are:
-
-`explicit_done` - Wait for an explicit call to done() before declaring all
-tests complete (see below; implicitly true for single page tests)
-
-`output_document` - The document to which results should be logged. By default
-this is the current document but could be an ancestor document in some cases
-e.g. a SVG test loaded in an HTML wrapper
-
-`explicit_timeout` - disable file timeout; only stop waiting for results
-when the `timeout()` function is called (typically for use when integrating
-with some existing test framework that has its own timeout mechanism).
-
-`allow_uncaught_exception` - don't treat an uncaught exception as an error;
-needed when e.g. testing the `window.onerror` handler.
-
-`timeout_multiplier` - Multiplier to apply to per-test timeouts.
-
-## Determining when all tests are complete ##
-
-By default the test harness will assume there are no more results to come
-when:
-
- 1. There are no `Test` objects that have been created but not completed
- 2. The load event on the document has fired
-
-This behaviour can be overridden by setting the `explicit_done` property to
-true in a call to `setup()`. If `explicit_done` is true, the test harness will
-not assume it is done until the global `done()` function is called. Once `done()`
-is called, the two conditions above apply like normal.
-
-Dedicated and shared workers don't have an event that corresponds to the `load`
-event in a document. Therefore these worker tests always behave as if the
-`explicit_done` property is set to true. Service workers depend on the
-[install](https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#service-worker-global-scope-install-event)
-event which is fired following the completion of [running the
-worker](https://html.spec.whatwg.org/multipage/workers.html#run-a-worker).
-
-## Generating tests ##
-
-There are scenarios in which is is desirable to create a large number of
-(synchronous) tests that are internally similar but vary in the parameters
-used. To make this easier, the `generate_tests` function allows a single
-function to be called with each set of parameters in a list:
-
-```js
-generate_tests(test_function, parameter_lists, properties)
-```
-
-For example:
-
-```js
-generate_tests(assert_equals, [
- ["Sum one and one", 1+1, 2],
- ["Sum one and zero", 1+0, 1]
- ])
-```
-
-Is equivalent to:
-
-```js
-test(function() {assert_equals(1+1, 2)}, "Sum one and one")
-test(function() {assert_equals(1+0, 1)}, "Sum one and zero")
-```
-
-Note that the first item in each parameter list corresponds to the name of
-the test.
-
-The properties argument is identical to that for `test()`. This may be a
-single object (used for all generated tests) or an array.
-
-## Callback API ##
-
-The framework provides callbacks corresponding to 4 events:
-
- * `start` - triggered when the first Test is created
- * `test_state` - triggered when a test state changes
- * `result` - triggered when a test result is received
- * `complete` - triggered when all results are received
-
-The page defining the tests may add callbacks for these events by calling
-the following methods:
-
- `add_start_callback(callback)` - callback called with no arguments
-
- `add_test_state_callback(callback)` - callback called with a test argument
-
- `add_result_callback(callback)` - callback called with a test argument
-
- `add_completion_callback(callback)` - callback called with an array of tests
- and an status object
-
-tests have the following properties:
-
- * `status` - A status code. This can be compared to the `PASS`, `FAIL`,
- `TIMEOUT` and `NOTRUN` properties on the test object
-
- * `message` - A message indicating the reason for failure. In the future this
- will always be a string
-
- The status object gives the overall status of the harness. It has the
- following properties:
-
- * `status` - Can be compared to the `OK`, `ERROR` and `TIMEOUT` properties
-
- * `message` - An error message set when the status is `ERROR`
-
-## External API ##
-
-In order to collect the results of multiple pages containing tests, the test
-harness will, when loaded in a nested browsing context, attempt to call
-certain functions in each ancestor and opener browsing context:
-
- * start - `start_callback`
- * test\_state - `test_state_callback`
- * result - `result_callback`
- * complete - `completion_callback`
-
-These are given the same arguments as the corresponding internal callbacks
-described above.
-
-## External API through cross-document messaging ##
-
-Where supported, the test harness will also send messages using cross-document
-messaging to each ancestor and opener browsing context. Since it uses the
-wildcard keyword (\*), cross-origin communication is enabled and script on
-different origins can collect the results.
-
-This API follows similar conventions as those described above only slightly
-modified to accommodate message event API. Each message is sent by the harness
-is passed a single vanilla object, available as the `data` property of the event
-object. These objects are structures as follows:
-
- * start - `{ type: "start" }`
- * test\_state - `{ type: "test_state", test: Test }`
- * result - `{ type: "result", test: Test }`
- * complete - `{ type: "complete", tests: [Test, ...], status: TestsStatus }`
-
-## Web Workers ##
-
-The `testharness.js` script can be used from within [dedicated workers, shared
-workers](https://html.spec.whatwg.org/multipage/workers.html) and [service
-workers](https://slightlyoff.github.io/ServiceWorker/spec/service_worker/).
-
-Testing from a worker script is different from testing from an HTML document in
-several ways:
-
-* Workers have no reporting capability since they are runing in the background.
- Hence they rely on `testharness.js` running in a companion client HTML document
- for reporting.
-
-* Shared and service workers do not have a unique client document since there
- could be more than one document that communicates with these workers. So a
- client document needs to explicitly connect to a worker and fetch test results
- from it using `fetch_tests_from_worker`. This is true even for a dedicated
- worker. Once connected, the individual tests running in the worker (or those
- that have already run to completion) will be automatically reflected in the
- client document.
-
-* The client document controls the timeout of the tests. All worker scripts act
- as if they were started with the `explicit_timeout` option (see the [Harness
- timeout](#harness-timeout) section).
-
-* Dedicated and shared workers don't have an equivalent of an `onload` event.
- Thus the test harness has no way to know when all tests have completed (see
- [Determining when all tests are
- complete](#determining-when-all-tests-are-complete)). So these worker tests
- behave as if they were started with the `explicit_done` option. Service
- workers depend on the
- [oninstall](https://slightlyoff.github.io/ServiceWorker/spec/service_worker/index.html#service-worker-global-scope-install-event)
- event and don't require an explicit `done` call.
-
-Here's an example that uses a dedicated worker.
-
-`worker.js`:
-
-```js
-importScripts("/resources/testharness.js");
-
-test(function(t) {
- assert_true(true, "true is true");
-}, "Simple test");
-
-// done() is needed because the testharness is running as if explicit_done
-// was specified.
-done();
-```
-
-`test.html`:
-
-```html
-<!DOCTYPE html>
-<title>Simple test</title>
-<script src=""
-<script src=""
-<div id="log"></div>
-<script>
-
-fetch_tests_from_worker(new Worker("worker.js"));
-
-</script>
-```
-
-The argument to the `fetch_tests_from_worker` function can be a
-[`Worker`](https://html.spec.whatwg.org/multipage/workers.html#dedicated-workers-and-the-worker-interface),
-a [`SharedWorker`](https://html.spec.whatwg.org/multipage/workers.html#shared-workers-and-the-sharedworker-interface)
-or a [`ServiceWorker`](https://slightlyoff.github.io/ServiceWorker/spec/service_worker/#service-worker-obj).
-Once called, the containing document fetches all the tests from the worker and
-behaves as if those tests were running in the containing document itself.
-
-## List of Assertions ##
-
-### `assert_true(actual, description)`
-asserts that `actual` is strictly true
-
-### `assert_false(actual, description)`
-asserts that `actual` is strictly false
-
-### `assert_equals(actual, expected, description)`
-asserts that `actual` is the same value as `expected`
-
-### `assert_not_equals(actual, expected, description)`
-asserts that `actual` is a different value to `expected`.
-This means that `expected` is a misnomer.
-
-### `assert_in_array(actual, expected, description)`
-asserts that `expected` is an Array, and `actual` is equal to one of the
-members i.e. `expected.indexOf(actual) != -1`
-
-### `assert_array_equals(actual, expected, description)`
-asserts that `actual` and `expected` have the same
-length and the value of each indexed property in `actual` is the strictly equal
-to the corresponding property value in `expected`
-
-### `assert_approx_equals(actual, expected, epsilon, description)`
-asserts that `actual` is a number within ±`epsilon` of `expected`
-
-### `assert_less_than(actual, expected, description)`
-asserts that `actual` is a number less than `expected`
-
-### `assert_greater_than(actual, expected, description)`
-asserts that `actual` is a number greater than `expected`
-
-### `assert_between_exclusive(actual, lower, upper, description`
-asserts that `actual` is a number between `lower` and `upper` but not
-equal to either of them
-
-### `assert_less_than_equal(actual, expected, description)`
-asserts that `actual` is a number less than or equal to `expected`
-
-### `assert_greater_than_equal(actual, expected, description)`
-asserts that `actual` is a number greater than or equal to `expected`
-
-### `assert_between_inclusive(actual, lower, upper, description`
-asserts that `actual` is a number between `lower` and `upper` or
-equal to either of them
-
-### `assert_regexp_match(actual, expected, description)`
-asserts that `actual` matches the regexp `expected`
-
-### `assert_class_string(object, class_name, description)`
-asserts that the class string of `object` as returned in
-`Object.prototype.toString` is equal to `class_name`.
-
-### `assert_own_property(object, property_name, description)`
-assert that object has own property `property_name`
-
-### `assert_inherits(object, property_name, description)`
-assert that object does not have an own property named
-`property_name` but that `property_name` is present in the prototype
-chain for object
-
-### `assert_idl_attribute(object, attribute_name, description)`
-assert that an object that is an instance of some interface has the
-attribute attribute_name following the conditions specified by WebIDL
-
-### `assert_readonly(object, property_name, description)`
-assert that property `property_name` on object is readonly
-
-### `assert_throws(code, func, description)`
-`code` - the expected exception. This can take several forms:
-
- * string - the thrown exception must be a DOMException with the given
- name, e.g., "TimeoutError" (for compatibility with existing
- tests, a constant is also supported, e.g., "TIMEOUT_ERR")
- * object - the thrown exception must have a property called "name" that
- matches code.name
- * null - allow any exception (in general, one of the options above
- should be used)
-
-`func` - a function that should throw
-
-### `assert_unreached(description)`
-asserts if called. Used to ensure that some codepath is *not* taken e.g.
-an event does not fire.
-
-### `assert_any(assert_func, actual, expected_array, extra_arg_1, ... extra_arg_N)`
-asserts that one `assert_func(actual, expected_array_N, extra_arg1, ..., extra_arg_N)`
- is true for some `expected_array_N` in `expected_array`. This only works for `assert_func`
- with signature `assert_func(actual, expected, args_1, ..., args_N)`. Note that tests
- with multiple allowed pass conditions are bad practice unless the spec specifically
- allows multiple behaviours. Test authors should not use this method simply to hide
- UA bugs.
-
-### `assert_exists(object, property_name, description)`
-**deprecated**
-asserts that object has an own property `property_name`
-
-### `assert_not_exists(object, property_name, description)`
-**deprecated**
-assert that object does not have own property `property_name`
-
-## Metadata ##
-
-It is possible to add optional metadata to tests; this can be done in
-one of two ways; either by adding `<meta>` elements to the head of the
-document containing the tests, or by adding the metadata to individual
-`[async_]test` calls, as properties.
Deleted: trunk/LayoutTests/imported/w3c/web-platform-tests/resources/examples/apisample12.html.orig (215418 => 215419)
--- trunk/LayoutTests/imported/w3c/web-platform-tests/resources/examples/apisample12.html.orig 2017-04-17 17:00:52 UTC (rev 215418)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/resources/examples/apisample12.html.orig 2017-04-17 17:58:32 UTC (rev 215419)
@@ -1,67 +0,0 @@
-<!DOCTYPE HTML>
-<html>
-<head>
-<title>Example with iframe that notifies containing document via cross document messaging</title>
-<script src=""
-<script src=""
-</head>
-<body>
-<h1>Notifications From Tests Running In An IFRAME</h1>
-<p>A test is run inside an <tt>iframe</tt> with a same origin document. The
-containing document should receive messages via <tt>postMessage</tt>/
-<tt>onmessage</tt> as the tests progress inside the <tt>iframe</tt>. A single
-passing test is expected in the summary below.
-</p>
-<div id="log"></div>
-
-<script>
-var t = async_test("Containing document receives messages");
-var start_received = false;
-var result_received = false;
-var completion_received = false;
-
-// These are the messages that are expected to be seen while running the tests
-// in the IFRAME.
-var expected_messages = [
- t.step_func(
- function(message) {
- assert_equals(message.data.type, "start");
- assert_own_property(message.data, "properties");
- }),
-
- t.step_func(
- function(message) {
- assert_equals(message.data.type, "test_state");
- assert_equals(message.data.test.status, message.data.test.NOTRUN);
- }),
-
- t.step_func(
- function(message) {
- assert_equals(message.data.type, "result");
- assert_equals(message.data.test.status, message.data.test.PASS);
- }),
-
- t.step_func(
- function(message) {
- assert_equals(message.data.type, "complete");
- assert_equals(message.data.tests.length, 1);
- assert_equals(message.data.tests[0].status,
- message.data.tests[0].PASS);
- assert_equals(message.data.status.status, message.data.status.OK);
- t.done();
- }),
-
- t.unreached_func("Too many messages received")
-];
-
-on_event(window,
- "message",
- function(message) {
- var handler = expected_messages.shift();
- handler(message);
- });
-</script>
-<iframe src="" style="display:none">
- <!-- apisample6 implements a file_is_test test. -->
-</iframe>
-</body>
Deleted: trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/doc/htmltodtd.xsl.orig (215418 => 215419)
--- trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/doc/htmltodtd.xsl.orig 2017-04-17 17:00:52 UTC (rev 215418)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/doc/htmltodtd.xsl.orig 2017-04-17 17:58:32 UTC (rev 215419)
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="us-ascii"?>
-<!--====================================================================
-$Id$
-Copyright 2009 Aplix Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
- http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-Stylesheet to extract DTD for widlprocxml from widlproc.html
-=====================================================================-->
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-<xsl:output method="text" encoding="us-ascii" indent="no"/>
-
-<!-- <pre class="dtd"> element -->
-<xsl:template match="pre[@class='dtd']">
- <xsl:value-of select="."/>
-</xsl:template>
-
-<!--Ignore other text. -->
-<xsl:template match="text()" priority="-100"/>
-
-</xsl:stylesheet>
Deleted: trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/doc/widlproc.html.orig (215418 => 215419)
--- trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/doc/widlproc.html.orig 2017-04-17 17:00:52 UTC (rev 215418)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/doc/widlproc.html.orig 2017-04-17 17:58:32 UTC (rev 215419)
@@ -1,1124 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
-<!--====================================================================
-Copyright 2009 Aplix Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
- http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-=====================================================================-->
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
-<title>widlproc</title>
-<style type="text/css">
- body { color: black; font: 10pt verdana; }
- a:link { text-decoration: none; }
- a:visited { text-decoration: none; }
- a:hover { text-decoration: underline; }
- dt { margin-top: 0.5em; }
- dd { margin-left: 1em; margin-bottom: 0.5em; }
- li { margin-bottom: 0; }
- h4 { font-size: 10pt; }
- table { border: 1px solid; border-collapse: collapse; }
- td { border: 1px solid; }
- th { border: 1px solid; }
- code { background-color: #f0f0f0; }
- pre { background-color: #f0f0f0; }
- .indent { margin-left: 3em; }
- .issue { background-color: #00CCCC; }
-</style>
-</head>
-<body>
-<h1>widlproc</h1>
-
-<p>Tim Renouf, Aplix Corp</p>
-<p>$Id$
-</p>
-
-<h2>Introduction</h2>
-
-<p>
-widlproc is a processor that accepts as input
-<a href="" IDL</a> (the 30 September 2009 editor's draft),
-with comments in a subset of the format used by
-<a href=""
-The format it accepts is proposed by Aplix for authoring
-<a href="" interface definitions.
-</p>
-
-<p>
-The output of widlproc is an XML representation of the
-<a href="" IDL</a> input,
-with added XML elements representing the
-<a href="" comments.
-</p>
-
-<h2>Usage</h2>
-
-<p>
-<code>widlproc <i>filename</i></code>
-</p>
-
-<p>
-widlproc reads the file named <em>filename</em>, and
-sends its XML output format to stdout.
-</p>
-
-<h2>Input format</h2>
-
-<p>
-The input format accepted by widlproc is
-<a href="" IDL</a>
-(with an extension used in the
-<a href="" Geolocation API</a>),
-with comments in a format reminiscent of that used by
-<a href=""
-</p>
-
-<h3>Web IDL extension from W3C geolocation API</h3>
-
-<h4>double</h4>
-
-<p>
-<code>double</code> is allowed as a DeclarationType or a BoxedType.
-</p>
-
-<h3>Doxygen-like comment introduction</h3>
-
-<p>
-Only a small subset of Doxygen functionality is supported by
-widlproc, plus additions to handle the BONDI concepts of API features
-and device capabilities.
-</p>
-
-<p>
-In particular, no links are added automatically. (This could be added
-in the future.)
-</p>
-
-<h3>Doxygen comment block</h3>
-
-<h4>Comment referral point</h4>
-
-<p>
-Each <em>Doxygen comment block</em> refers to a <em>comment referral
-point</em> in the Web IDL, one of
-module, interface, exception, const, attribute, operation or argument.
-</p>
-
-<h4>Block comment</h4>
-
-<p>
-A block comment (delimited by <code>/* */</code>) whose first character
-after the <code>/*</code> is <code>!</code> or a second <code>*</code>
-is a <em>Doxygen comment block</em>.
-</p>
-
-<p>
-Normally the comment block refers to the next comment referral point in
-the Web IDL.
-If the first character is <code><</code>, so the comment block is introduced
-with <code>/**<</code> or <code>/*!<</code> , then the comment block
-refers back to the previous comment referral point.
-</p>
-
-<p>
-The text of the comment block
-excludes the initial <code>!</code> or <code>*</code> (and the <code><</code>
-for a referring back block),
-and excludes an initial (after whitespace) <code>*</code>
-on each line,
-and, when not in a <a href="" block,
-excludes any line consisting entirely of whitespace, then <code>*</code>
-characters, then whitespace.
-</p>
-
-<p>
-widlproc does not support Doxygen commands to force a comment
-block to refer to a different referral point.
-</p>
-
-<h4>Inline comments</h4>
-
-<p>
-The maximal sequence of inline comments (delimited by <code>//</code>)
-on adjacent lines, where all of the following conditions hold:
-</p>
-<ul>
-<li>
-each has a first character after the <code>/</code> of <code>!</code> or
-a third <code>/</code>;
-<li>
-no comment referral point intervenes;
-<li>
-either each comment in the sequence starts with a <code><</code>
-(see below), or none does;
-<li>
-the sequence contains at least two inline comments, or, if only one,
-then it starts with <code><</code> (see below);
-</ul>
-<p>
-forms a <em>Doxygen comment block</em>.
-</p>
-
-<p>
-Normally the comment block refers to the next comment referral point in
-the Web IDL.
-If the first character of each comment is <code><</code>, so each
-comment in the block is introduced
-with <code>///<</code> or <code>//!<</code> , then the comment block
-refers back to the previous comment referral point.
-</p>
-
-<p>
-The text of the comment block
-excludes the initial <code>!</code> or <code>/</code> (and the <code><</code>
-for a referring back block) of each inline comment,
-and, when not in a <a href="" block,
-excludes any line consisting entirely of whitespace, then <code>/</code>
-characters, then whitespace.
-</p>
-
-<p>
-widlproc does not support Doxygen commands to force a comment
-block to refer to a different referral point.
-</p>
-
-<h3>Paragraph</h3>
-
-<p>
-A comment block is broken into zero or more <em>paragraph</em>s.
-One or more blank lines break the paragraphs (unless in a
-<a href="" block).
-</p>
-
-<p>
-Certain commands (below) also start a new paragraph.
-</p>
-
-<p>
-An
-<a href="" block element</a>
-is a paragraph.
-A blank line (other than in a
-<a href="" block)
-implicitly closes any open HTML elements, thus ending the paragraph.
-</p>
-
-<h3>Doxygen-like commands</h3>
-
-<p>
-widlproc supports a small subset of Doxygen commands, plus some additions
-to handle BONDI API features and device capabilities.
-</p>
-
-<p>
-A command is always introduced with a <code>\</code> character.
-The Doxygen alternative (from JavaDoc) of <code>@</code> is not
-supported.
-</p>
-
-<h4 id="api-feature">\api-feature</h4>
-
-<p>
-Starts a new paragraph. The following word is the name of an API feature
-used by the method being documented. The remainder of the paragraph is
-any description required of how (eg in what circumstance) the API feature
-is used.
-</p>
-
-<h4>\name</h4>
-
-<p>
-Declares a name for the document node associated with the current referral
-point. This is useful for the root document node that otherwise does not have
-a WebIDL identifier.
-</p>
-
-<h4>\author</h4>
-
-<p>
-Starts a new paragraph. The remainder of the paragraph contains
-information about a single author of the specification. Multiple
-<code>\author</code> commands should be used for multiple authors.
-</p>
-
-<p>
-(Here widlproc differs from Doxygen; Doxygen also allows
-multiple authors on separate lines to appear in one <code>\author</code>
-paragraph.)
-</p>
-
-<h4>\b</h4>
-
-<p>
-This renders the next word as bold. It is equivalent to enclosing the
-next word with <code><b> </b></code>.
-</p>
-
-<h4>\brief</h4>
-
-<p>
-Starts a new paragraph. The remainder of the paragraph contains a brief
-description of the entity being documented.
-</p>
-
-<h4 id="code">\code, \endcode</h4>
-
-<p>
-<code>\code</code>
-starts a new paragraph which is a <em>code block</em>. The code block
-ends at the next <code>\endcode</code> command.
-</p>
-
-<p>
-Within the code block, whitespace and newlines are passed verbatim into
-the output.
-</p>
-
-<h4 id="def-api-feature">\def-api-feature</h4>
-
-<p>
-Starts a new paragraph. The following word is the name of the API feature
-which is defined here. The description is an <em>def-api-feature block</em>,
-consisting of the
-remainder of the paragraph, together with
-further paragraphs in the same block comment each of which is a plain
-paragraph, a paragraph started due to HTML markup, a <code>\brief</code>
-paragraph, or a
-<a href=""
-paragraph.
-</p>
-
-<h4 id="def-api-feature-set">\def-api-feature-set</h4>
-
-<p>
-Starts a new paragraph. The following word is the name of the API feature
-set which is defined here. The description is an <em>def-api-feature-set block</em>,
-consisting of the
-remainder of the paragraph, together with
-further paragraphs in the same block comment each of which is a plain
-paragraph, a paragraph started due to HTML markup, a <code>\brief</code>
-paragraph, or a
-<a href=""
-paragraph.
-</p>
-
-<h4>\def-device-cap</h4>
-
-<p>
-Starts a new paragraph. The following word is the name of the device capability
-which is defined here. The description consists of the
-remainder of the paragraph, together with
-further paragraphs in the same block comment each of which is a plain
-paragraph, a paragraph started due to HTML markup, a <code>\brief</code>
-paragraph, or a
-<a href=""
-paragraph.
-</p>
-
-<h4 id="def-instantiated">\def-instantiated</h4>
-
-<p>
-Starts a new paragraph. The description is an <em>def-instantiated block</em>,
-consisting of the
-remainder of the paragraph, together with
-further paragraphs in the same block comment each of which is a plain
-paragraph, a paragraph started due to HTML markup, a <code>\brief</code>
-paragraph, or a
-<a href=""
-paragraph.
-</p>
-
-<h4 id="device-cap">\device-cap</h4>
-
-<p>
-Starts a new paragraph.
-This command can appear only inside an
-<a href="" block</a>.
-The following word is the name of a device capability
-used by the API feature being documented.
-The remainder of the paragraph is
-any description required of how (eg in what circumstance) the device capability
-is used.
-</p>
-
-<h4>\n</h4>
-
-<p>
-Creates a line break in the output.
-</p>
-
-<h4 id="param">\param</h4>
-
-<p>
-Starts a new paragraph. This takes the following word as the name of
-a parameter (argument) of the entity being documented, then makes the
-remainder of the paragraph refer to that parameter.
-</p>
-
-<h4>\return</h4>
-
-<p>
-Starts a new paragraph. The remainder of the paragraph is made to refer to
-the return type of the entity being documented.
-</p>
-
-<h4>\throw</h4>
-
-<p>
-Starts a new paragraph. The next word is taken to be the name of an
-exception thrown by the entity being documented, and the remainder of
-the paragraph documents that exception (in the <code>raises</code> list of
-an <code>operation</code>, or the <code>setraises</code>
-clause of an <code>attribute</code>).
-</p>
-
-<h4>\version</h4>
-
-<p>
-Starts a new paragraph. The remainder of the paragraph contains
-version number information.
-</p>
-
-<h3>Escape sequences</h3>
-
-<p>
-The following escape sequences are recognized in a comment block:
-</p>
-
-<table>
-<tr>
-<th>escape sequence
-<th>result
-<tr>
-<td><code>\\</code>
-<td><code>\</code>
-<tr>
-<td><code>\&</code>
-<td><code>&</code> (escaped to <code>&amp;</code> in output XML)
-<tr>
-<td><code>\$</code>
-<td><code>$</code>
-<tr>
-<td><code>\#</code>
-<td><code>#</code>
-<tr>
-<td><code>\<</code>
-<td><code><</code> (escaped to <code>&lt;</code> in output XML)
-<tr>
-<td><code>\></code>
-<td><code>></code>
-<tr>
-<td><code>\%</code>
-<td><code>%</code>
-</table>
-
-<p>
-Some of these escape sequences are used to avoid Doxygen features that
-widlproc does not currently implement. In particular,
-widlproc insists on a <code>$</code> being escaped, to
-allow for possible future functionality.
-</p>
-
-<h3 id="html">HTML in comments</h3>
-
-<p>
-widlproc accepts a small subset of HTML elements.
-</p>
-
-<p>
-An HTML block element is a paragraph.
-A blank line (other than in a
-<a href="" block)
-implicitly closes any open HTML elements, thus ending the paragraph.
-</p>
-
-<p>
-The following HTML block elements are accepted:
-<code>dl</code>
-<code>ol</code>
-<code>p</code>
-<code>table</code>
-<code>ul</code>
-</p>
-
-<p>
-The following HTML inline elements are accepted:
-<code>a</code>
-<code>img</code>
-<code>b</code>
-<code>br</code>
-<code>em</code>
-</p>
-
-<p>
-The following HTML elements are accepted where valid inside one of the
-other elements:
-<code>dd</code>
-<code>dt</code>
-<code>li</code>
-<code>td</code>
-<code>th</code>
-<code>tr</code>
-</p>
-
-
-<h2>Output format</h2>
-
-<p>
-The output of widlproc is an XML representation of the
-<a href="" IDL</a>,
-with added XML elements representing the
-<a href="" comments.
-</p>
-
-<h3>Annotated document type declaration</h3>
-
-<pre class="dtd">
-<!-- Autogenerated from widlproc.html : do not edit. -->
-</pre>
-
-<h4>Entities used elsewhere</h4>
-
-<pre class="dtd">
-<!ENTITY % block 'dl | p | table | ul' >
-<!ENTITY % Block '(%block;)*' >
-<!ENTITY % inline 'a | b | br | em | img' >
-<!ENTITY % Inline '(#PCDATA | %inline;)*' >
-<!ENTITY % Flow '(#PCDATA | %inline; | %block;)*' >
-
-<!ELEMENT webidl (#PCDATA | ref)* >
-</pre>
-
-<p>
-The <code><webidl></code> element contains the literal text of the
-original Web IDL that the parent
-element was parsed from, minus the comments, with each reference to
-an interface name
-enclosed in a <code><ref></code>..<code></ref></code>.
-</p>
-
-<h4>Definitions</h4>
-
-<p>
-<em>Definitions</em> is the root element of the XML document.
-</p>
-
-<p>
-The <em>ExtendedAttributeList</em> specifies any extended attributes
-for the <em>Interface</em>, <em>Dictionary</em>, <em>Exception</em>,
-<em>Typedef</em>, <em>Valuetype</em> or <em>Const</em> in the
-<em>Definition</em>.
-</p>
-
-<pre class="dtd">
-<!ELEMENT Definitions ( webidl, descriptive?, (Interface | Dictionary | Callback
- | Enum | Exception | Typedef | Implements)*) >
-</pre>
-
-<h4>Interface</h4>
-
-<p>
-An <em>Interface</em> represents an interface. The <em>name</em>
-attribute specifies the name of the interface. The <em>descriptive</em> element
-provides its documentation if any.
-The <em>id</em> attribute specifies the absolute scoped name of the interface.
-</p>
-
-<p>The <em>partial</em> attribute indicates that the definition of the interface complements an existing definition. The <em>callback</em> attribute specificies that a given interface is a callback interface.</p>
-
-<p>
-The <em>InterfaceInheritance</em> element indicates that the interface
-inherits from other interface(s). Each <em>Name</em> in the
-<em>InterfaceInheritance</em> has a <em>name</em> attribute giving the
-scoped name of the interface being inherited from.
-</p>
-
-<pre class="dtd">
-<!ELEMENT Interface (webidl, descriptive?, ExtendedAttributeList?,
- InterfaceInheritance?, (Const | Attribute | Operation | Stringifier* | Serializer* | Iterator | IteratorObject)* ) >
-<!ATTLIST Interface name CDATA #REQUIRED
- partial (partial) #IMPLIED
- callback (callback) #IMPLIED
- id CDATA #REQUIRED >
-
-<!ELEMENT InterfaceInheritance (Name+) >
-
-<!ELEMENT Name EMPTY >
-<!ATTLIST Name name CDATA #REQUIRED >
-</pre>
-
-<h4>Dictionary</h4>
-
-<p>
-A <em>Dictionary</em> represents a dictionary. The <em>name</em>
-attribute specifies the name of the dictionary. The <em>descriptive</em> element
-provides its documentation if any.
-The <em>id</em> attribute specifies the absolute scoped name of the dictionary.
-</p>
-
-<p>The <em>partial</em> attribute indicates that the definition of the interface complements an existing definition.</p>
-
-<p>
-The <em>DictionaryInheritance</em> element indicates that the dictionary
-inherits from other dictionary(s). Each <em>Name</em> in the
-<em>DictionaryInheritance</em> has a <em>name</em> attribute giving the
-scoped name of the dictionary being inherited from.
-</p>
-
-
-<pre class="dtd">
-<!ELEMENT Dictionary (webidl, descriptive?, DictionaryInheritance?, DictionaryMember* ) >
-<!ATTLIST Dictionary name CDATA #REQUIRED
- partial (partial) #IMPLIED
- id CDATA #REQUIRED >
-
-<!ELEMENT DictionaryInheritance (Name+) >
-</pre>
-
-<h4>Callback</h4>
-
-<p>
-A <em>Callback</em> represents a callback type. The <em>name</em>
-attribute specifies the name of the dictionary. The <em>descriptive</em> element
-provides its documentation if any.</p>
-
-<p>The <em>Type</em> element specifies its return type.</p>
-
-<p>
-An <em>Argument</em> is an argument to an operation.
-The <em>Type</em> element specifies its type. The <em>name</em>
-attribute specifies its name if it has one.
-</p>
-
-<pre class="dtd">
-<!ELEMENT Callback (webidl, descriptive?, Type, ArgumentList? ) >
-<!ATTLIST Callback name CDATA #REQUIRED
- id CDATA #REQUIRED>
-</pre>
-
-
-<h4>Enum</h4>
-
-<p>
-An <em>Enum</em> represents an enumeration. The <em>name</em>
-attribute specifies the name of the enumeration. The <em>descriptive</em> element
-provides its documentation if any.
-</p>
-
-<p>
-The <em>EnumValue</em> element indicates the values defined for that enumeration in its <em>stringvalue</em> attribute.
-</p>
-
-
-<pre class="dtd">
-<!ELEMENT Enum (webidl, descriptive?, EnumValue* ) >
-<!ATTLIST Enum name CDATA #REQUIRED
- id CDATA #REQUIRED >
-
-<!ELEMENT EnumValue (webidl, descriptive?) >
-<!ATTLIST EnumValue stringvalue CDATA #REQUIRED >
-</pre>
-
-
-
-<h4>Exception</h4>
-
-<p>
-An <em>Exception</em> represents an exception.
-The <em>name</em>
-attribute specifies the name of the exception.
-The <em>descriptive</em> element
-provides its documentation if any.
-The <em>id</em> attribute specifies the absolute scoped name of the exception.
-</p>
-
-<p>
-An <em>ExceptionField</em> represents a field in an exception.
-The <em>name</em>
-attribute specifies the name of the field.
-The <em>Type</em> element specifies its type.
-The <em>descriptive></em> element
-provides its documentation if any.
-The <em>id</em> attribute specifies the absolute scoped name of the field.
-</p>
-
-<p>
-The <em>ExceptionInheritance</em> element indicates that the exception
-inherits from another exception. The <em>Name</em> in the
-<em>ExceptionInheritance</em> has a <em>name</em> attribute giving the
-scoped name of the exception being inherited from.
-</p>
-
-
-<pre class="dtd">
-<!ELEMENT Exception (webidl, descriptive?, ExtendedAttributeList?, ExceptionInheritance?,
- (Const | ExceptionField)* ) >
-<!ATTLIST Exception name CDATA #REQUIRED
- id CDATA #REQUIRED >
-
-<!ELEMENT ExceptionInheritance (Name) >
-<!ELEMENT ExceptionField (webidl, descriptive?, ExtendedAttributeList?, (Type)) >
-<!ATTLIST ExceptionField name CDATA #REQUIRED
- id CDATA #REQUIRED >
-</pre>
-
-<h4>Typedef</h4>
-
-<p>
-A <em>Typedef</em> represents a type definition.
-The <em>name</em>
-attribute specifies the name of the new type.
-The <em>Type</em> element specifies it in terms of other types.
-The <em>descriptive></em> element
-provides its documentation if any.
-The <em>id</em> attribute specifies the absolute scoped name of the typedef.
-</p>
-
-<pre class="dtd">
-<!ELEMENT Typedef (webidl, descriptive?, ExtendedAttributeList?, (Type)) >
-<!ATTLIST Typedef name CDATA #REQUIRED
- id CDATA #REQUIRED >
-</pre>
-
-<h4>Implements</h4>
-
-<p>
-An <em>Implements</em> represents Web IDL's
-<code><i>ScopedName</i> implements <i>ScopedName</i>;</code>
-syntax. The <em>name1</em> and <em>name2</em> attributes give the
-first and second scoped names respectively.
-The <em>descriptive></em> element
-provides the <em>Implements</em>'s documentation if any.
-</p>
-
-<pre class="dtd">
-<!ELEMENT Implements (webidl, descriptive?, ExtendedAttributeList?) >
-<!ATTLIST Implements name1 CDATA #REQUIRED
- name2 CDATA #REQUIRED >
-</pre>
-
-<h4>Const</h4>
-
-<p>
-<em>Const</em> represents Web IDL's
-<code>const <i>Type</i> <i>identifier</i> = <i>ConstExpr</i>;</code>
-syntax.
-The <em>Type</em> specifies the constant's type, the
-<em>name</em> attribute specifies the constant's name, and the
-<em>value</em> attribute specifies its value.
-The <em>descriptive></em> element
-provides the <em>Const</em>'s documentation if any.
-The <em>id</em> attribute specifies the absolute scoped name of the const.
-</p>
-
-<pre class="dtd">
-<!ELEMENT Const (webidl, descriptive?, ExtendedAttributeList?, Type) >
-<!ATTLIST Const name CDATA #REQUIRED
- value CDATA #IMPLIED
- id CDATA #REQUIRED >
-</pre>
-
-<h4>Stringifier</h4>
-
-<p>
-A <em>Stringifier</em> represents the Web IDL <code>stringifier;</code>
-syntax as an interface member.
-The <em>descriptive></em> element
-provides the <em>Stringifier</em>'s documentation if any.
-</p>
-
-<pre class="dtd">
-<!ELEMENT Stringifier (webidl, descriptive?, ExtendedAttributeList?) >
-</pre>
-
-<h4>Attribute</h4>
-
-<p>
-An <em>Attribute</em> represents an attribute as an interface member.
-The <em>Type</em> element specifies its type. The <em>name</em>
-attribute specifies its name. Each of the <em>stringifier</em>, <em>static</em> and
-<em>readonly</em> attributes is set to a value the same as the attribute
-name when the corresponding keyword appears in the Web IDL input. The <em>inherit</em> attribute is set to <em>inherit</em> when the attribute inherits its getter.
-</p>
-
-
-<p>
-The <em>descriptive></em> element provides the attribute's documentation
-if any.
-The <em>id</em> attribute specifies the absolute scoped name of the attribute.
-</p>
-
-<pre class="dtd">
-<!ELEMENT Attribute (webidl, descriptive?, ExtendedAttributeList?, (Type)) >
-<!ATTLIST Attribute stringifier (stringifier) #IMPLIED
- readonly (readonly) #IMPLIED
- inherit (inherit) #IMPLIED
- static (static) #IMPLIED
- name CDATA #REQUIRED
- id CDATA #REQUIRED >
-
-</pre>
-
-
-<h4>Operation</h4>
-
-<p>
-An <em>Operation</em> represents a method on interface.
-The <em>Type</em> element specifies its return type. The <em>name</em>
-attribute specifies its name.
-</p>
-
-<p>
-Each of the <em>stringifier</em>, <em>static</em>, <em>getter</em>,
-<em>setter</em>, <em>creator</em>, <em>deleter</em> and <em>legacycaller</em>, <em>serializer</em>
-attributes is set to a value the same as the attribute
-name when the corresponding keyword appears in the Web IDL input.
-</p>
-
-
-<p>
-The <em>descriptive></em> element provides the attribute's documentation
-if any.
-The <em>id</em> attribute specifies the absolute scoped name of the operation if it has one.
-</p>
-
-<p>
-An <em>Argument</em> is an argument to an operation.
-The <em>Type</em> element specifies its type. The <em>name</em>
-attribute specifies its name if it has one.
-</p>
-
-<p>
-Each of the <em>optional</em> and <em>ellipsis</em>
-attributes is set to a value the same as the attribute
-name when the corresponding syntax appears in the Web IDL input.
-</p>
-
-<p>The
-<em>value</em> attribute used on optional arguments specifies default value for non-string values, and <em>stringvalue</em> for string values.</p>
-
-
-<pre class="dtd">
-<!ELEMENT Operation (webidl, descriptive?, ExtendedAttributeList?,
- (Type), ArgumentList) >
-<!ATTLIST Operation stringifier (stringifier) #IMPLIED
- static (static) #IMPLIED
- getter (getter) #IMPLIED
- setter (setter) #IMPLIED
- creator (creator) #IMPLIED
- deleter (deleter) #IMPLIED
- serializer (serializer) #IMPLIED
- legacycaller (legacycaller) #IMPLIED
- name NMTOKEN #IMPLIED
- id NMTOKEN #IMPLIED >
-
-
-<!ELEMENT ArgumentList (Argument*) >
-
-<!ELEMENT Argument (descriptive?, ExtendedAttributeList?, (Type)) >
-<!ATTLIST Argument
- optional (optional) #IMPLIED
- ellipsis (ellipsis) #IMPLIED
- value CDATA #IMPLIED
- stringvalue CDATA #IMPLIED
- name NMTOKEN #REQUIRED >
-</pre>
-
-<h4>Serializer</h4>
-<p>A <em>Serializer</em> represents a serializer for an interface, either defined in the prose or via a pattern.</p>
-
-<p>The <em>descriptive</em> element provides the serializer's documentation if any.</p>
-
-
-<p>The <em>attribute</em> attribute defines the attribute that is used for serialization if any.</p>
-
-<p>The optional <em>Map</em> and <em>List</em> elements describe the pattern (if any) for the serializer. They take <em>PatternAttribute</em> elements with a <em>name</em> attribute that describes the attributes used for serialization.</p>
-
-<p><em>Map</em> elements take a <em>pattern</em> attribute that can be set to either "getter" (if the getter is used for serialization), "all" if all serializable attributes are to be used, or "selection" if the attributes named as children elements are to be used. Optionally, they take a <em>inherit</em> attribute set to "inherit" if the serialization takes also into account inherited attributes.</p>
-
-<p><em>List</em> elements take a <em>pattern</em> attribute that can be set to either "getter" (if the getter is used for serialization), or "selection" if the attributes named as children elements are to be used.</p>
-
-<pre class="dtd">
-<!ELEMENT Serializer (webidl, descriptive?, ExtendedAttributeList?, (Map | List)?) >
-<!ATTLIST Serializer attribute CDATA #IMPLIED >
-
-<!ELEMENT Map ((PatternAttribute*)) >
-
-<!ATTLIST Map inherit (inherit) #IMPLIED
- pattern (getter|all|selection) #REQUIRED>
-
-<!ELEMENT List ((PatternAttribute*)) >
-
-<!ATTLIST List pattern (getter|selection) #REQUIRED>
-
-<!ELEMENT PatternAttribute EMPTY>
-<!ATTLIST PatternAttribute name CDATA #REQUIRED>
-
-</pre>
-
-<h4>Iterator</h4>
-<p>An <em>Iterator</em> element defines whether the interface has a custom iterator; the type of the iterated objects is defined in the <em>Type</em> child. If that interator implements a particular interface, the name of that interface is set in the <em>interface</em> attribute.</p>
-<pre class="dtd">
-<!ELEMENT Iterator (webidl, descriptive?, ExtendedAttributeList?, Type) >
-<!ATTLIST Iterator interface CDATA #IMPLIED>
-</pre>
-
-<h4>IteratorObject</h4>
-<p>An <em>IteratorObject</em> element denotes that the interface serves as an iterator object interface; the type of the iterated objects is defined in the <em>Type</em> child.</p>
-
-<pre class="dtd">
-<!ELEMENT IteratorObject (webidl, descriptive?, ExtendedAttributeList?, Type) >
-</pre>
-
-
-<h4>DictionaryMember</h4>
-
-<p>
-A <em>DictionaryMember</em> represents a member of a dictionary.
-The <em>Type</em> element specifies its type. The <em>name</em>
-attribute specifies its name.
-</p>
-
-<p>
-The <em>descriptive></em> element provides the dictionary member's documentation
-if any.
-The <em>id</em> attribute specifies the absolute scoped name of the attribute.
-</p>
-
-<p>The
-<em>value</em> attribute specifies its value for non-string values, and <em>stringvalue</em> for string values.</p>
-
-<pre class="dtd">
-<!ELEMENT DictionaryMember (webidl, descriptive?, ExtendedAttributeList?, Type) >
-<!ATTLIST DictionaryMember name CDATA #REQUIRED
- id CDATA #REQUIRED
- value CDATA #IMPLIED
- stringvalue CDATA #IMPLIED >
-
-</pre>
-
-
-<h4>Extended attributes</h4>
-
-<p>
-An <em>ExtendedAttributeList</em> contains one or more
-<em>ExtendedAttribute</em> element. Each <em>ExtendedAttribute</em>
-has:
-</p>
-<ul>
-<li>
-a <em>name</em> attribute giving the name of the extended attribute;
-<li>
-if the extended attribute contains an <code>=</code> sign followed by a
-value, a <em>value</em> attribute giving the value, which is a scoped
-name or an identifier;
-<li>
-if the extended attribute contains parentheses (either with or without
-an <code>=</code> sign), an <em>ArgumentList</em> element giving the
-contents of the parentheses.
-</ul>
-<p>
-If the <em>value</em> attribute and the <em>ArgumentList</em> element are
-both present, then <em>value</em> must give an identifier rather than
-a scoped name.
-</p>
-
-<pre class="dtd">
-<!ELEMENT ExtendedAttributeList (ExtendedAttribute+) >
-
-<!ELEMENT ExtendedAttribute (webidl, ArgumentList?) >
-<!ATTLIST ExtendedAttribute name NMTOKEN #REQUIRED
- value CDATA #IMPLIED >
-</pre>
-
-<h4>Type</h4>
-
-<p>
-<em>Type</em> represents a type. It has one of these forms:
-</p>
-<ul>
-<li>
-The <code>any</code>, <code>object</code> and <code>void</code>
-types have the attribute
-<em>type</em> set to the type, and no other attributes or elements.
-Note that the <code>void</code> type appears only when the <em>Type</em>
-element is a child of <em>Operation</em>.
-<li>
-A type that is an interface has the attribute <em>name</em> set to the
-name of that interface, and no other attributes or elements.
-<li>
-For the primitive types <code>short</code>, <code>unsigned short</code>,
-<code>long</code>, <code>unsigned long</code>, <code>long long</code>,
-<code>unsigned long long</code>, <code>float</code>, <code>double</code>,
-<code>boolean</code>, <code>octet</code>, <code>byte</code> and <code>DOMString</code>,
-there is an attribute <em>type</em>
-whose value is one of those strings, and no other attributes or elements.
-However, if the type was specified in the Web IDL with a trailing <code>?</code>
-sign, then there is an attribute <em>nullable</em> with the value
-<code>nullable</code>.
-</ul>
-<p>
-The restrictions on which combinations of elements and attributes are
-permitted are not encoded by the DTD.
-</p>
-<p>
-The <em>descriptive</em> element provides the documentation
-if any, when the <em>Type</em> is a child of <em>Operation</em>, and thus
-representing an operation's return type.
-</p>
-
-<p>The <em>ExtendedAttributeList</em> element provides the optional extended attributes that can be defined for a type through typedef, à la <code>typedef [Clamp] octet Value;</code>.</p>
-
-<!-- can't use enumerated values for the values of type, since DTD don't allow enumerated values to have space in them (which would be needed e.g. for "long long") -->
-<pre class="dtd">
-<!ELEMENT Type (descriptive?, ExtendedAttributeList?, Type*) >
-<!ATTLIST Type type CDATA #IMPLIED
- name NMTOKEN #IMPLIED
- nullable (nullable) #IMPLIED >
-</pre>
-
-<h4>Sequence</h4>
-
-<p>For a sequence type, the <em>Type</em> element with an attribute <em>type</em> set to <em>sequence</em> contains an element <em>Type</em> giving the sequence element type, and no other attributes or elements. If the sequence is specified in the Web IDL with a trailing <code>?</code>
-sign, then there is an attribute <em>nullable</em> with the value
-<code>nullable</code>.
-
-
-<h4>Array</h4>
-
-<p>For an array type, the <em>Type</em> element with an attribute <em>type</em> set to <em>array</em> contains an element <em>Type</em> giving the array element type. If the array is specified in the Web IDL with a trailing <code>?</code>
-sign, then there is an attribute <em>nullable</em> with the value
-<code>nullable</code>.
-
-<h4>Union</h4>
-
-<p>For a union type, the <em>Type</em> element with an attribute <em>type</em> set to <em>union</em> contains at least two element <em>Type</em> giving the union members type. If the union is specified in the Web IDL with a trailing <code>?</code>
-sign, then there is an attribute <em>nullable</em> with the value
-<code>nullable</code>.
-
-
-
-<h4>Descriptive elements</h4>
-
-<p>
-The following elements contain documentation, extracted from the
-Doxygen-like comments in the input. <code><param></code>
-derives only from a <code>\param</code> command used inside a
-<code>\def-device-cap</code> block; any other <code>\param</code> command
-is linked to a parameter (argument) of the method being documented.
-</p>
-
-<pre class="dtd">
-<!ELEMENT descriptive (description | brief | throw | author
- | version | Code | api-feature | device-cap | def-api-feature
- | def-api-feature-set | def-device-cap | def-instantiated | param)* >
-
-<!ELEMENT description %Block; >
-
-<!ELEMENT brief %Inline; >
-
-<!ELEMENT throw %Inline; >
-
-<!ELEMENT author %Inline; >
-
-<!ELEMENT version %Inline; >
-
-<!ELEMENT Code %Inline; >
-
-<!ELEMENT api-feature %Inline; >
-<!ATTLIST api-feature identifier CDATA #REQUIRED >
-
-<!ELEMENT device-cap %Inline; >
-<!ATTLIST device-cap identifier CDATA #REQUIRED >
-
-<!ELEMENT param %Inline; >
-<!ATTLIST param identifier CDATA #REQUIRED >
-
-<!ELEMENT def-api-feature (descriptive?) >
-<!ATTLIST def-api-feature identifier CDATA #REQUIRED >
-
-<!ELEMENT def-api-feature-set (descriptive?) >
-<!ATTLIST def-api-feature-set identifier CDATA #REQUIRED >
-
-<!ELEMENT def-instantiated (descriptive?) >
-
-<!ELEMENT def-device-cap (descriptive?) >
-<!ATTLIST def-device-cap identifier CDATA #REQUIRED >
-
-<!ELEMENT ref (#PCDATA) >
-</pre>
-
-<h4>XHTML elements</h4>
-
-<p>
-The following XHTML elements are part of widlprocxml:
-</p>
-
-<pre class="dtd">
-<!ELEMENT a %Inline; >
-<!ATTLIST a href CDATA #REQUIRED >
-
-<!ELEMENT b %Inline; >
-
-<!ELEMENT br EMPTY >
-
-<!ELEMENT dd %Flow; >
-
-<!ELEMENT dl ((dt | dd)*) >
-
-<!ELEMENT dt %Inline; >
-
-<!ELEMENT em %Inline; >
-
-<!ELEMENT img %Inline; >
-<!ATTLIST img src CDATA #REQUIRED
- alt CDATA #IMPLIED>
-
-
-<!ELEMENT li %Flow; >
-
-<!ELEMENT p %Inline; >
-
-<!ELEMENT table (tr*) >
-
-<!ELEMENT td %Flow; >
-
-<!ELEMENT th %Flow; >
-
-<!ELEMENT tr ((th | td)*) >
-
-<!ELEMENT ul (li*) >
-</pre>
-
-
-<h2>Bibliography</h2>
-
-<p id="bondi">
-BONDI - an open source industry collaboration for widget and web technologies,
-<a href=""
-</p>
-
-<p id="doxygen">
-Doxygen Source code documentation generator tool,
-<a href=""
-http://www.stack.nl/~dimitri/doxygen/index.html</a>
-</p>
-
-<p id="w3cgeo">
-W3C Geolocation API Specification Editor's Draft 3 April 2009,
-<a href=""
-http://dev.w3.org/geo/api/spec-source.html</a>
-</p>
-
-<p id="webidl">
-Web IDL W3C Editor's Draft 3 May 2011,
-<a href=""
-</p>
-
Deleted: trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/examples/spectowidl.xsl.orig (215418 => 215419)
--- trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/examples/spectowidl.xsl.orig 2017-04-17 17:00:52 UTC (rev 215418)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/examples/spectowidl.xsl.orig 2017-04-17 17:58:32 UTC (rev 215419)
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--====================================================================
-$Id$
-Copyright 2009 Aplix Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
- http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-XSLT stylesheet to extract Web IDL snippets from Web IDL spec.
-=====================================================================-->
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-<xsl:output method="text" encoding="utf-8"/>
-
-<xsl:template match="code[@class='idl-code']">
- <xsl:value-of select="."/><xsl:text>
-</xsl:text>
-</xsl:template>
-
-<xsl:template match="text()"/>
-
-</xsl:stylesheet>
Deleted: trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/src/widlprocxmltohtml.xsl.orig (215418 => 215419)
--- trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/src/widlprocxmltohtml.xsl.orig 2017-04-17 17:00:52 UTC (rev 215418)
+++ trunk/LayoutTests/imported/w3c/web-platform-tests/resources/webidl2/test/widlproc/src/widlprocxmltohtml.xsl.orig 2017-04-17 17:58:32 UTC (rev 215419)
@@ -1,828 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--====================================================================
-$Id: widlprocxmltohtml.xsl 407 2009-10-26 13:48:48Z tpr $
-Copyright 2009 Aplix Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
- http://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-XSLT stylesheet to convert widlprocxml into html documentation.
-=====================================================================-->
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-<xsl:output method="html" encoding="utf-8" indent="yes" doctype-public="html"/>
-
-<xsl:param name="date" select="'error: missing date'"/>
-
-<xsl:variable name="title" select="concat('The ',/Definitions/descriptive/name,' Module - Version ',/Definitions/descriptive/version)"/>
-
-<!--Root of document.-->
-<xsl:template match="/">
- <html>
- <head>
- <link rel="stylesheet" type="text/css" href="" media="screen"/>
- <title>
- <xsl:value-of select="$title"/>
- </title>
- </head>
- <body>
- <xsl:apply-templates/>
- </body>
- </html>
-</xsl:template>
-
-<!--Root of Definitions.-->
-<xsl:template match="Definitions">
- <div class="api" id="{@id}">
- <a href="" src="" alt="Bondi logo"/></a>
- <h1><xsl:value-of select="$title"/></h1>
- <h3>12 May 2009</h3>
-
- <h2>Authors</h2>
- <ul class="authors">
- <xsl:apply-templates select="descriptive/author"/>
- </ul>
-
- <p class="copyright"><small>© The authors, 2012. All rights reserved.</small></p>
-
- <hr/>
-
- <h2>Abstract</h2>
-
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="descriptive/description"/>
- <xsl:apply-templates select="descriptive/Code"/>
-
- <h2>Table of Contents</h2>
- <ul class="toc">
- <li><a href=""
- <ul>
- <xsl:if test="descriptive/def-api-feature-set">
- <li><a href="" set</a></li>
- </xsl:if>
- <xsl:if test="descriptive/def-api-feature">
- <li><a href=""
- </xsl:if>
- <xsl:if test="descriptive/def-device-cap">
- <li><a href="" Capabilities</a></li>
- </xsl:if>
- </ul>
- </li>
- <xsl:if test="Typedef">
- <li><a href="" Definitions</a>
- <ul class="toc">
- <xsl:for-each select="Typedef[descriptive]">
- <li><a href="" select="@name"/></code></a></li>
- </xsl:for-each>
- </ul>
- </li>
- </xsl:if>
- <xsl:if test="Interface">
- <li><a href=""
- <ul class="toc">
- <xsl:for-each select="Interface[descriptive]">
- <li><a href="" select="@name"/></code></a></li>
- </xsl:for-each>
- </ul>
- </li>
- </xsl:if>
- <xsl:if test="Dictionary">
- <li><a href="" types</a>
- <ul class="toc">
- <xsl:for-each select="Dictionary[descriptive]">
- <li><a href="" select="@name"/></code></a></li>
- </xsl:for-each>
- </ul>
- </li>
- </xsl:if>
- <xsl:if test="Callback">
- <li><a href=""
- <ul class="toc">
- <xsl:for-each select="Callback[descriptive]">
- <li><a href="" select="@name"/></code></a></li>
- </xsl:for-each>
- </ul>
- </li>
- </xsl:if>
- <xsl:if test="Enum">
- <li><a href=""
- <ul class="toc">
- <xsl:for-each select="Enum[descriptive]">
- <li><a href="" select="@name"/></code></a></li>
- </xsl:for-each>
- </ul>
- </li>
- </xsl:if>
- </ul>
-
- <hr/>
-
- <h2>Summary of Methods</h2>
- <xsl:call-template name="summary"/>
-
- <h2 id="intro">Introduction</h2>
-
- <xsl:apply-templates select="descriptive/description"/>
- <xsl:apply-templates select="descriptive/Code"/>
-
- <xsl:if test="descriptive/def-api-feature-set">
- <div id="def-api-feature-sets" class="def-api-feature-sets">
- <h3 id="features">Feature set</h3>
- <p>This is the URI used to declare this API's feature set, for use in bondi.requestFeature. For the URL, the list of features included by the feature set is provided.</p>
- <xsl:apply-templates select="descriptive/def-api-feature-set"/>
- </div>
- </xsl:if>
- <xsl:if test="descriptive/def-api-feature">
- <div id="def-api-features" class="def-api-features">
- <h3 id="features">Features</h3>
- <p>This is the list of URIs used to declare this API's features, for use in bondi.requestFeature. For each URL, the list of functions covered is provided.</p>
- <xsl:apply-templates select="Interface/descriptive/def-instantiated"/>
- <xsl:apply-templates select="descriptive/def-api-feature"/>
- </div>
- </xsl:if>
- <xsl:if test="descriptive/def-device-cap">
- <div class="def-device-caps" id="def-device-caps">
- <h3>Device capabilities</h3>
- <dl>
- <xsl:apply-templates select="descriptive/def-device-cap"/>
- </dl>
- </div>
- </xsl:if>
- <xsl:if test="Typedef">
- <div class="typedefs" id="typedefs">
- <h2>Type Definitions</h2>
- <xsl:apply-templates select="Typedef[descriptive]"/>
- </div>
- </xsl:if>
- <xsl:if test="Interface">
- <div class="interfaces" id="interfaces">
- <h2>Interfaces</h2>
- <xsl:apply-templates select="Interface"/>
- </div>
- </xsl:if>
- <xsl:if test="Dictionary">
- <div class="dictionaries" id="dictionaries">
- <h2>Dictionary types</h2>
- <xsl:apply-templates select="Dictionary"/>
- </div>
- </xsl:if>
- <xsl:if test="Callback">
- <div class="callbacks" id="callbacks">
- <h2>Callbacks</h2>
- <xsl:apply-templates select="Callback"/>
- </div>
- </xsl:if>
- <xsl:if test="Enum">
- <div class="enums" id="enums">
- <h2>Enums</h2>
- <xsl:apply-templates select="Enum"/>
- </div>
- </xsl:if>
- </div>
-</xsl:template>
-
-<!--def-api-feature-set-->
-<xsl:template match="def-api-feature-set">
- <dl class="def-api-feature-set">
- <dt><xsl:value-of select="@identifier"/></dt>
- <dd>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="descriptive/Code"/>
- <xsl:if test="descriptive/api-feature">
- <div class="api-features">
- <p>
- Includes API features:
- </p>
- <ul>
- <xsl:for-each select="descriptive/api-feature">
- <li><code><xsl:value-of select="@identifier"/></code></li>
- </xsl:for-each>
- </ul>
- </div>
- </xsl:if>
- </dd>
- </dl>
-</xsl:template>
-
-<!--def-api-feature-->
-<xsl:template match="def-api-feature">
- <dl class="def-api-feature">
- <dt><xsl:value-of select="@identifier"/></dt>
- <dd>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="descriptive/Code"/>
- <xsl:if test="descriptive/device-cap">
- <div class="device-caps">
- <p>
- Device capabilities:
- </p>
- <ul>
- <xsl:for-each select="descriptive/device-cap">
- <li><code><xsl:value-of select="@identifier"/></code></li>
- </xsl:for-each>
- </ul>
- </div>
- </xsl:if>
- </dd>
- </dl>
-</xsl:template>
-
-<!--def-device-cap-->
-<xsl:template match="def-device-cap">
- <dt class="def-device-cap"><code><xsl:value-of select="@identifier"/></code></dt>
- <dd>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="descriptive/Code"/>
- <xsl:if test="descriptive/param">
- <div class="device-caps">
- <p>Security parameters:</p>
- <ul>
- <xsl:apply-templates select="descriptive/param"/>
- </ul>
- </div>
- </xsl:if>
- </dd>
-</xsl:template>
-
-<!--Exception: not implemented-->
-<!--Valuetype: not implemented-->
-<xsl:template match="Exception|Valuetype|Const">
- <xsl:if test="descriptive">
- <xsl:message terminate="yes">element <xsl:value-of select="name()"/> not supported</xsl:message>
- </xsl:if>
-</xsl:template>
-
-<!--Typedef.-->
-<xsl:template match="Typedef[descriptive]">
- <div class="typedef" id="{@id}">
- <h3>2.<xsl:number value="position()"/>. <code><xsl:value-of select="@name"/></code></h3>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="webidl"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="descriptive/Code"/>
- </div>
-</xsl:template>
-
-<!--Interface.-->
-<xsl:template match="Interface[descriptive]">
- <xsl:variable name="name" select="@name"/>
- <div class="interface" id="{@id}">
- <h3><code><xsl:value-of select="@name"/></code></h3>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="webidl"/>
- <xsl:apply-templates select="../Implements[@name2=$name]/webidl"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="descriptive/Code"/>
- <xsl:apply-templates select="InterfaceInheritance"/>
- <xsl:if test="Const/descriptive">
- <div class="consts">
- <h4>Constants</h4>
- <dl>
- <xsl:apply-templates select="Const"/>
- </dl>
- </div>
- </xsl:if>
- <xsl:if test="ExtendedAttributeList/ExtendedAttribute/descriptive">
- <div class="constructors">
- <h4>Constructors</h4>
- <dl>
- <xsl:apply-templates select="ExtendedAttributeList/ExtendedAttribute"/>
- </dl>
- </div>
- </xsl:if>
- <xsl:if test="Attribute/descriptive">
- <div class="attributes">
- <h4>Attributes</h4>
- <dl>
- <xsl:apply-templates select="Attribute"/>
- </dl>
- </div>
- </xsl:if>
- <xsl:if test="Operation/descriptive">
- <div class="methods">
- <h4>Methods</h4>
- <dl>
- <xsl:apply-templates select="Operation"/>
- </dl>
- </div>
- </xsl:if>
- </div>
-</xsl:template>
-<xsl:template match="Interface[not(descriptive)]">
-</xsl:template>
-
-<!--Dictionary.-->
-<xsl:template match="Dictionary[descriptive]">
- <xsl:variable name="name" select="@name"/>
- <div class="dictionary" id="{@id}">
- <h3><code><xsl:value-of select="@name"/></code></h3>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="webidl"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="descriptive/Code"/>
- <xsl:apply-templates select="InterfaceInheritance"/>
- <xsl:if test="Const/descriptive">
- <div class="consts">
- <h4>Constants</h4>
- <dl>
- <xsl:apply-templates select="Const"/>
- </dl>
- </div>
- </xsl:if>
- <xsl:if test="Attribute/descriptive">
- <div class="attributes">
- <h4>Attributes</h4>
- <dl>
- <xsl:apply-templates select="Attribute"/>
- </dl>
- </div>
- </xsl:if>
- </div>
-</xsl:template>
-<xsl:template match="Dictionary[not(descriptive)]">
-</xsl:template>
-
-<xsl:template match="InterfaceInheritance/ScopedNameList">
- <p>
- <xsl:text>This interface inherits from: </xsl:text>
- <xsl:for-each select="Name">
- <code><xsl:value-of select="@name"/></code>
- <xsl:if test="position!=last()">, </xsl:if>
- </xsl:for-each>
- </p>
-</xsl:template>
-
-<!--Attribute-->
-<xsl:template match="Attribute">
- <dt class="attribute" id="{@name}">
- <code>
- <xsl:if test="@stringifier">
- stringifier
- </xsl:if>
- <xsl:if test="@readonly">
- readonly
- </xsl:if>
- <xsl:apply-templates select="Type"/>
- <xsl:text> </xsl:text>
- <xsl:value-of select="@name"/>
- </code></dt>
- <dd>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="GetRaises"/>
- <xsl:apply-templates select="SetRaises"/>
- <xsl:apply-templates select="descriptive/Code"/>
- </dd>
-</xsl:template>
-
-<!--Const-->
-<xsl:template match="Const">
- <dt class="const" id="{@id}">
- <code>
- <xsl:apply-templates select="Type"/>
- <xsl:text> </xsl:text>
- <xsl:value-of select="@name"/>
- </code>
- </dt>
- <dd>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="descriptive/Code"/>
- </dd>
-</xsl:template>
-
-<!--ExtendedAttribute name==Constructor || name==NamedConstructor-->
-<xsl:template match="ExtendedAttributeList/ExtendedAttribute">
- <dt class="constructor" id="{concat(@name,generate-id(.))}">
- <code>
- <xsl:value-of select="../../@name"/>
- <xsl:text>(</xsl:text>
- <xsl:apply-templates select="ArgumentList">
- <xsl:with-param name="nodesc" select="1"/>
- </xsl:apply-templates>
- <xsl:text>);</xsl:text>
- </code>
- </dt>
- <dd>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="ArgumentList"/>
- <xsl:apply-templates select="Raises"/>
- <xsl:if test="descriptive/api-feature">
- <div class="api-features">
- <h6>API features</h6>
- <dl>
- <xsl:apply-templates select="descriptive/api-feature"/>
- </dl>
- </div>
- </xsl:if>
- <xsl:apply-templates select="webidl"/>
- <xsl:apply-templates select="descriptive/Code"/>
- </dd>
-</xsl:template>
-
-<!--Operation-->
-<xsl:template match="Operation">
- <dt class="method" id="{concat(@name,generate-id(.))}">
- <code>
- <xsl:if test="@stringifier">
- <xsl:value-of select="concat(@stringifier, ' ')"/>
- </xsl:if>
- <xsl:if test="@omittable">
- <xsl:value-of select="concat(@omittable, ' ')"/>
- </xsl:if>
- <xsl:if test="@getter">
- <xsl:value-of select="concat(@getter, ' ')"/>
- </xsl:if>
- <xsl:if test="@setter">
- <xsl:value-of select="concat(@setter, ' ')"/>
- </xsl:if>
- <xsl:if test="@creator">
- <xsl:value-of select="concat(@creator, ' ')"/>
- </xsl:if>
- <xsl:if test="@deleter">
- <xsl:value-of select="concat(@deleter, ' ')"/>
- </xsl:if>
- <xsl:if test="@caller">
- <xsl:value-of select="concat(@caller, ' ')"/>
- </xsl:if>
- <xsl:apply-templates select="Type"/>
- <xsl:text> </xsl:text>
- <xsl:value-of select="@name"/>
- <xsl:text>(</xsl:text>
- <xsl:apply-templates select="ArgumentList">
- <xsl:with-param name="nodesc" select="1"/>
- </xsl:apply-templates>
- <xsl:text>);</xsl:text>
- </code>
- </dt>
- <dd>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="webidl"/>
- <xsl:apply-templates select="descriptive/Code"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="ArgumentList"/>
- <xsl:if test="Type/descriptive">
- <div class="returntype">
- <h5>Return value</h5>
- <xsl:apply-templates select="Type/descriptive"/>
- </div>
- </xsl:if>
- <xsl:apply-templates select="Raises"/>
- <xsl:if test="descriptive/api-feature">
- <div class="api-features">
- <h6>API features</h6>
- <dl>
- <xsl:apply-templates select="descriptive/api-feature"/>
- </dl>
- </div>
- </xsl:if>
- <xsl:apply-templates select="descriptive/Code"/>
- </dd>
-</xsl:template>
-
-<!--Callback-->
-<xsl:template match="Callback">
- <xsl:variable name="name" select="@name"/>
- <div class="callback" id="{@id}">
- <h3><code><xsl:value-of select="@name"/></code></h3>
-
- <dd>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="webidl"/>
- <xsl:apply-templates select="descriptive"/>
- <div class="synopsis">
- <h6>Signature</h6>
- <pre>
- <xsl:apply-templates select="Type"/>
- <xsl:text> </xsl:text>
- <xsl:value-of select="@name"/>
- <xsl:text>(</xsl:text>
- <xsl:apply-templates select="ArgumentList">
- <xsl:with-param name="nodesc" select="1"/>
- </xsl:apply-templates>
- <xsl:text>);
-</xsl:text></pre>
- </div>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="ArgumentList"/>
- <xsl:if test="Type/descriptive">
- <div class="returntype">
- <h5>Return value</h5>
- <xsl:apply-templates select="Type/descriptive"/>
- </div>
- </xsl:if>
- <xsl:apply-templates select="descriptive/Code"/>
- </dd>
- </div>
-</xsl:template>
-
-<!--ArgumentList. This is passed $nodesc=true to output just the argument
- types and names, and not any documentation for them.-->
-<xsl:template match="ArgumentList">
- <xsl:param name="nodesc"/>
- <xsl:choose>
- <xsl:when test="$nodesc">
- <!--$nodesc is true: just output the types and names-->
- <xsl:apply-templates select="Argument[1]">
- <xsl:with-param name="nodesc" select="'nocomma'"/>
- </xsl:apply-templates>
- <xsl:apply-templates select="Argument[position() != 1]">
- <xsl:with-param name="nodesc" select="'comma'"/>
- </xsl:apply-templates>
- </xsl:when>
- <xsl:when test="Argument">
- <!--$nodesc is false: output the documentation-->
- <div class="parameters">
- <h6>Parameters</h6>
- <ul>
- <xsl:apply-templates/>
- </ul>
- </div>
- </xsl:when>
- </xsl:choose>
-</xsl:template>
-
-<!--Argument. This is passed $nodesc=false to output the documentation,
- or $nodesc="nocomma" to output the type and name, or $nodesc="comma"
- to output a comma then the type and name. -->
-<xsl:template match="Argument">
- <xsl:param name="nodesc"/>
- <xsl:choose>
- <xsl:when test="$nodesc">
- <!--$nodesc is true: just output the types and names-->
- <xsl:if test="$nodesc = 'comma'">
- <!--Need a comma first.-->
- <xsl:text>, </xsl:text>
- </xsl:if>
- <xsl:if test="@in"><xsl:value-of select="concat(@in, ' ')"/></xsl:if>
- <xsl:if test="@optional"><xsl:value-of select="concat(@optional, ' ')"/></xsl:if>
- <xsl:apply-templates select="Type"/>
- <xsl:if test="@ellipsis"><xsl:text>...</xsl:text></xsl:if>
- <xsl:text> </xsl:text>
- <xsl:value-of select="@name"/>
- <xsl:if test="@value">
- <xsl:text>Default value: </xsl:text><xsl:value-of select="@value"/>
- </xsl:if>
- <xsl:if test="@stringvalue">
- <xsl:text>Default value: "</xsl:text><xsl:value-of select="@stringvalue"/><xsl:text>"</xsl:text>
- </xsl:if>
- </xsl:when>
- <xsl:otherwise>
- <!--$nodesc is false: output the documentation-->
- <li class="param">
- <xsl:value-of select="@name"/>:
- <xsl:apply-templates select="descriptive"/>
- </li>
- </xsl:otherwise>
- </xsl:choose>
-</xsl:template>
-
-<!--Raises (for an Operation). It is already known that the list
- is not empty.-->
-<xsl:template match="Raises">
- <div class="exceptionlist">
- <h5>Exceptions</h5>
- <ul>
- <xsl:apply-templates/>
- </ul>
- </div>
-</xsl:template>
-
-<!--RaiseException, the name of an exception in a Raises.-->
-<xsl:template match="RaiseException">
- <li class="exception">
- <xsl:value-of select="@name"/>:
- <xsl:apply-templates select="descriptive"/>
- </li>
-</xsl:template>
-
-<!--Type.-->
-<xsl:template match="Type">
- <xsl:choose>
- <xsl:when test="Type">
- <xsl:text>sequence <</xsl:text>
- <xsl:apply-templates/>
- <xsl:text>></xsl:text>
- </xsl:when>
- <xsl:otherwise>
- <xsl:value-of select="@name"/>
- <xsl:value-of select="@type"/>
- <xsl:if test="@nullable">
- <xsl:text>?</xsl:text>
- </xsl:if>
- </xsl:otherwise>
- </xsl:choose>
-</xsl:template>
-
-<!--Enum.-->
-<xsl:template match="Enum[descriptive]">
- <xsl:variable name="name" select="@name"/>
- <div class="enum" id="{@id}">
- <h3><code><xsl:value-of select="@name"/></code></h3>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="webidl"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="descriptive/Code"/>
- <div class="enumvalues">
- <h4>Values</h4>
- <dl>
- <xsl:apply-templates select="EnumValue"/>
- </dl>
- </div>
- </div>
-</xsl:template>
-<xsl:template match="Enum[not(descriptive)]">
-</xsl:template>
-
-<!--EnumValue-->
-<xsl:template match="EnumValue">
- <dt class="enumvalue" id="{@id}">
- <code>
- <xsl:value-of select="@stringvalue"/>
- </code>
- </dt>
- <dd>
- <xsl:apply-templates select="descriptive/brief"/>
- <xsl:apply-templates select="descriptive"/>
- <xsl:apply-templates select="descriptive/Code"/>
- </dd>
-</xsl:template>
-
-<xsl:template match="descriptive[not(author)]">
- <xsl:apply-templates select="version"/>
- <xsl:if test="author">
- </xsl:if>
- <xsl:apply-templates select="description"/>
-</xsl:template>
-
-<!--brief-->
-<xsl:template match="brief">
- <div class="brief">
- <p>
- <xsl:apply-templates/>
- </p>
- </div>
-</xsl:template>
-
-<!--description in ReturnType or Argument or ScopedName-->
-<xsl:template match="Type/descriptive/description|Argument/descriptive/description|Name/descriptive/description">
- <!--If the description contains just a single <p> then we omit
- the <p> and just do its contents.-->
- <xsl:choose>
- <xsl:when test="p and count(*) = 1">
- <xsl:apply-templates select="p/*|p/text()"/>
- </xsl:when>
- <xsl:otherwise>
- <div class="description">
- <xsl:apply-templates/>
- </div>
- </xsl:otherwise>
- </xsl:choose>
-</xsl:template>
-
-<!--Other description-->
-<xsl:template match="description">
- <div class="description">
- <xsl:apply-templates/>
- </div>
-</xsl:template>
-
-<!--Code-->
-<xsl:template match="Code">
- <div class="example">
- <xsl:choose>
- <xsl:when test="@lang">
- <h5><xsl:value-of select="@lang"/></h5>
- </xsl:when>
- <xsl:otherwise>
- <h5>Code example</h5>
- </xsl:otherwise>
- </xsl:choose>
- <pre class="examplecode"><xsl:apply-templates/></pre>
- </div>
-</xsl:template>
-
-<!--webidl : literal Web IDL from input-->
-<xsl:template match="webidl">
- <h5>WebIDL</h5>
- <pre class="webidl"><xsl:apply-templates/></pre>
-</xsl:template>
-
-<!--author-->
-<xsl:template match="author">
- <li class="author"><xsl:apply-templates/></li>
-</xsl:template>
-
-<!--version-->
-<xsl:template match="version">
- <div class="version">
- <h2>
- Version: <xsl:apply-templates/>
- </h2>
- </div>
-</xsl:template>
-
-<!--api-feature-->
-<xsl:template match="api-feature">
- <dt>
- <xsl:value-of select="@identifier"/>
- </dt>
- <dd>
- <xsl:apply-templates/>
- </dd>
-</xsl:template>
-
-<!--param-->
-<xsl:template match="param">
- <li>
- <code><xsl:value-of select="@identifier"/></code>:
- <xsl:apply-templates/>
- </li>
-</xsl:template>
-
-<!--def-instantiated.
- This assumes that only one interface in the module has a def-instantiated,
- and that interface contains just one attribute.-->
-<xsl:template match="def-instantiated">
- <xsl:variable name="ifacename" select="../../@name"/>
- <p>
- <xsl:choose>
- <xsl:when test="count(descriptive/api-feature)=1">
- When the feature
- </xsl:when>
- <xsl:otherwise>
- When any of the features
- </xsl:otherwise>
- </xsl:choose>
- </p>
- <ul>
- <xsl:for-each select="descriptive/api-feature">
- <li><code>
- <xsl:value-of select="@identifier"/>
- </code></li>
- </xsl:for-each>
- </ul>
- <p>
- is successfully requested, the interface
- <code><xsl:apply-templates select="../../Attribute/Type"/></code>
- is instantiated, and the resulting object appears in the global
- namespace as
- <code><xsl:value-of select="../../../Implements[@name2=$ifacename]/@name1"/>.<xsl:value-of select="../../Attribute/@name"/></code>.
- </p>
-</xsl:template>
-
-
-
-<!--html elements-->
-<xsl:template match="a|b|br|dd|dl|dt|em|li|p|table|td|th|tr|ul">
- <xsl:element name="{name()}"><xsl:for-each select="@*"><xsl:attribute name="{name()}"><xsl:value-of select="."/></xsl:attribute></xsl:for-each><xsl:apply-templates/></xsl:element>
-</xsl:template>
-
-<xsl:template name="summary">
- <table class="summary">
- <thead>
- <tr><th>Interface</th><th>Method</th></tr>
- </thead>
- <tbody>
- <xsl:for-each select="Interface[descriptive]">
- <tr><td><a href="" select="@name"/></a></td>
- <td>
- <xsl:for-each select="Operation">
-
- <xsl:apply-templates select="Type"/>
- <xsl:text> </xsl:text>
- <a href="" select="@name"/></a>
- <xsl:text>(</xsl:text>
- <xsl:for-each select="ArgumentList/Argument">
- <xsl:variable name="type"><xsl:apply-templates select="Type"/></xsl:variable>
- <xsl:value-of select="concat(normalize-space($type),' ',@name)"/>
- <xsl:if test="position() != last()">, </xsl:if>
- </xsl:for-each>
- <xsl:text>)</xsl:text>
- <xsl:if test="position()!=last()"><br/></xsl:if>
- </xsl:for-each>
- </td>
- </tr>
- </xsl:for-each>
- </tbody>
- </table>
-</xsl:template>
-
-<!--<ref> element in literal Web IDL.-->
-<xsl:template match="ref[@ref]">
- <a href=""
- <xsl:apply-templates/>
- </a>
-</xsl:template>
-
-</xsl:stylesheet>
-
