html5/spec-ja/.workers-spec.en.html


<html lang=en-US-x-hixie>
 <head>
  <title>Web Workers</title>
  <link href="/style/specification" rel=stylesheet>
  <link href="/images/icon" rel=icon>

  <style>
   p > span:not([title=""]):not([class="big-issue"]), li > span:not([title=""]):not([class="big-issue"]) { border-bottom: solid #99CC99; }
  </style>

 <body class=draft>
  <div class=head>
   <p><a class=logo href="http://www.whatwg.org/" rel=home><img alt=WHATWG
    src="/images/logo"></a></p>

   <h1 id=web-workers>Web Workers</h1>

   <h2 class="no-num no-toc" id=draft>Draft Recommendation &mdash; 18 July
    2008</h2>

   <p>You can take part in this work. <a
    href="http://www.whatwg.org/mailing-list">Join the working group's
    discussion list.</a></p>

   <p><strong>Web designers!</strong> We have a <a
    href="http://blog.whatwg.org/faq/">FAQ</a>, a <a
    href="http://forums.whatwg.org/">forum</a>, and a <a
    href="http://www.whatwg.org/mailing-list#help">help mailing list</a> for
    you!</p>

   <dl>
    <dt>This version:

    <dd><a
     href="http://www.whatwg.org/specs/web-workers/current-work/">http://whatwg.org/ww</a>

    <dt>Version history:

    <dd>Twitter messages (non-editorial changes only): <a
     href="http://twitter.com/WHATWG">http://twitter.com/WHATWG</a>

    <dd>Commit-Watchers mailing list: <a
     href="http://lists.whatwg.org/listinfo.cgi/commit-watchers-whatwg.org">http://lists.whatwg.org/listinfo.cgi/commit-watchers-whatwg.org</a>

    <dd>Interactive Web interface: <a
     href="http://html5.org/tools/web-workers-tracker">http://html5.org/tools/web-workers-tracker</a>

    <dd>Subversion interface: <a
     href="http://svn.whatwg.org/webworkers/">http://svn.whatwg.org/webworkers/</a>

    <dt>Issues:

    <dd>To send feedback: <a
     href="http://www.whatwg.org/mailing-list">whatwg@whatwg.org</a>

    <dd>To view and vote on feedback: <a
     href="http://www.whatwg.org/issues/">http://www.whatwg.org/issues/</a>

    <dt>Editor:

    <dd>Ian Hickson, Google, ian@hixie.ch
   </dl>

   <p class=copyright>&copy; Copyright 2004-2008 Apple Computer, Inc.,
    Mozilla Foundation, and Opera Software ASA.</p>

   <p class=copyright>You are granted a license to use, reproduce and create
    derivative works of this document.</p>
  </div>

  <hr>

  <h2 class="no-num no-toc" id=abstract>Abstract</h2>

  <p>This specification defines an API that allows Web application authors to
   spawn background workers running scripts in parallel to their main page.
   This allows for thread-like operation with message-passing as the
   coordination mechanism.

  <h2 class="no-num no-toc" id=status>Status of this document</h2>

  <p><strong>This is a work in progress!</strong> This document is changing
   on a daily if not hourly basis in response to comments and as a general
   part of its development process. Comments are very welcome, please send
   them to <a href="mailto:whatwg@whatwg.org">whatwg@whatwg.org</a>. Thank
   you.

  <p>The current focus is in developing a first draft proposal.

  <p>Implementors should be aware that this specification is not stable.
   <strong>Implementors who are not taking part in the discussions are likely
   to find the specification changing out from under them in incompatible
   ways.</strong> Vendors interested in implementing this specification
   before it eventually reaches the call for implementations should join the
   <a href="/mailing-list">WHATWG mailing list</a> and take part in the
   discussions.

  <p>This specification is also being produced by the <a
   href="http://www.w3.org/html/wg">W3C HTML WG</a>. The two specifications
   are identical from the table of contents onwards.

  <h2 class="no-num no-toc" id=contents>Table of contents</h2>
  <!--begin-toc-->

  <ul class=toc>
   <li><a href="#introduction"><span class=secno>1. </span>Introduction</a>
    <ul class=toc>
     <li><a href="#tutorial"><span class=secno>1.1 </span>Tutorial</a>

     <li><a href="#conformance"><span class=secno>1.2 </span>Conformance
      requirements</a>
      <ul class=toc>
       <li><a href="#dependencies"><span class=secno>1.2.1
        </span>Dependencies</a>
      </ul>

     <li><a href="#terminology"><span class=secno>1.3 </span>Terminology</a>
    </ul>

   <li><a href="#infrastructure"><span class=secno>2.
    </span>Infrastructure</a>
    <ul class=toc>
     <li><a href="#the-windowworker"><span class=secno>2.1 </span>The
      <code>WindowWorker</code> interface</a>

     <li><a href="#base-urls"><span class=secno>2.2 </span>Base URLs and
      origins of workers</a>

     <li><a href="#the-queue"><span class=secno>2.3 </span>The queue of
      events</a>

     <li><a href="#the-workers"><span class=secno>2.4 </span>The worker's
      ports</a>

     <li><a href="#processing"><span class=secno>2.5 </span>Processing
      model</a>

     <li><a href="#creating"><span class=secno>2.6 </span>Creating
      workers</a>
    </ul>

   <li><a href="#apis-available"><span class=secno>3. </span>APIs available
    to workers</a>

   <li class=no-num><a href="#references">References</a>

   <li class=no-num><a href="#acknowledgements">Acknowledgements</a>
  </ul>
  <!--end-toc-->

  <hr>

  <h2 id=introduction><span class=secno>1. </span>Introduction</h2>

  <h3 id=tutorial><span class=secno>1.1 </span>Tutorial</h3>

  <p><em>This section is non-normative.</em>

  <p class=big-issue>This section is missing.

  <h3 id=conformance><span class=secno>1.2 </span>Conformance requirements</h3>

  <p>All diagrams, examples, and notes in this specification are
   non-normative, as are all sections explicitly marked non-normative.
   Everything else in this specification is normative.

  <p>The key words "MUST", "MUST NOT", "REQUIRED", <!--"SHALL", "SHALL
  NOT",-->
   "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in the
   normative parts of this document are to be interpreted as described in
   RFC2119. For readability, these words do not appear in all uppercase
   letters in this specification. <a href="#refsRFC2119">[RFC2119]</a></p>
  <!-- XXX but they should be
  marked up -->

  <p>Requirements phrased in the imperative as part of algorithms (such as
   "strip any leading space characters" or "return false and abort these
   steps") are to be interpreted with the meaning of the key word ("must",
   "should", "may", etc) used in introducing the algorithm.

  <p>Some conformance requirements are phrased as requirements on attributes,
   methods or objects. Such requirements are to be interpreted as
   requirements on user agents.

  <p>Conformance requirements phrased as algorithms or specific steps may be
   implemented in any manner, so long as the end result is equivalent. (In
   particular, the algorithms defined in this specification are intended to
   be easy to follow, and not intended to be performant.)

  <p>The only conformance class defined by this specification is user agents.

  <p>User agents may impose implementation-specific limits on otherwise
   unconstrained inputs, e.g. to prevent denial of service attacks, to guard
   against running out of memory, or to work around platform-specific
   limitations.

  <h4 id=dependencies><span class=secno>1.2.1 </span>Dependencies</h4>

  <p>This specification relies on several other underlying specifications.

  <dl>
   <dt>HTML5

   <dd>
    <p>Many fundamental concepts from HTML5 are used by this specification.
     <a href="#refsHTML5">[HTML5]</a></p>

   <dt>ECMAScript

   <dd>
    <p>This specification is intended to be used with JavaScript as the
     scripting language. <a href="#refsJS">[JS]</a></p>

   <dt>WebIDL

   <dd>
    <p>The IDL blocks in this specification use the semantics of the WebIDL
     specification. <a href="#refsWebIDL">[WebIDL]</a></p>
  </dl>

  <h3 id=terminology><span class=secno>1.3 </span>Terminology</h3>

  <p>For simplicity, terms such as <em>shown</em>, <em>displayed</em>, and
   <em>visible</em> might sometimes be used when referring to the way a
   document is rendered to the user. These terms are not meant to imply a
   visual medium; they must be considered to apply to other media in
   equivalent ways.

  <p>The construction "a <code title="">Foo</code> object", where <code
   title="">Foo</code> is actually an interface, is sometimes used instead of
   the more accurate "an object implementing the interface <code
   title="">Foo</code>".

  <p>The term DOM is used to refer to the API set made available to scripts
   in Web applications, and does not necessarily imply the existence of an
   actual <code>Document</code> object or of any other <code>Node</code>
   objects as defined in the DOM Core specifications. <a
   href="#refsDOM3CORE">[DOM3CORE]</a>

  <p>A DOM attribute is said to be <em>getting</em> when its value is being
   retrieved (e.g. by author script), and is said to be <em>setting</em> when
   a new value is assigned to it.

  <p>If a DOM object is said to be <dfn id=live>live</dfn>, then that means
   that any attributes returning that object must always return the same
   object (not a new object each time), and the attributes and methods on
   that object must operate on the actual underlying data, not a snapshot of
   the data.

  <h2 id=infrastructure><span class=secno>2. </span>Infrastructure</h2>

  <h3 id=the-windowworker><span class=secno>2.1 </span>The <code><a
   href="#windowworker">WindowWorker</a></code> interface</h3>

  <pre
   class=idl>[NoInterfaceObject] interface <dfn id=windowworker>WindowWorker</dfn> {
  readonly attribute DOMString <a href="#url" title=dom-WindowWorker-URL>URL</a>;
  readonly attribute DOMString <a href="#name" title=dom-WindowWorker-name>name</a>;
  readonly attribute boolean <a href="#closing" title=dom-WindowWorker-closing>closing</a>;
  boolean <a href="#import" title=dom-WindowWorker-import>import</a>(in DOMString url);
  void <a href="#close" title=dom-WindowWorker-close>close</a>();

  // event handler attributes
           attribute <span>EventListener</span> <a href="#onconnect" title=handler-WindowWorker-onconnect>onconnect</a>;
           attribute <span>EventListener</span> <a href="#onunload" title=handler-WindowWorker-onunload>onunload</a>;
};</pre>

  <p>The <dfn id=url title=dom-WindowWorker-URL><code>URL</code></dfn>
   attribute must return the value it was assigned when the <code><a
   href="#windowworker">WindowWorker</a></code> object was created by the "<a
   href="#run-a">run a worker</a>" algorithm. It gives the <span>absolute
   URL</span> of the script that was used to initialize the worker.

  <p>The <dfn id=name title=dom-WindowWorker-name><code>name</code></dfn>
   attribute must return the value it was assigned when the <code><a
   href="#windowworker">WindowWorker</a></code> object was created by the "<a
   href="#run-a">run a worker</a>" algorithm. If it has a value that isn't
   the empty string, its value represents the name that can be used to obtain
   a reference to the worker using the <code
   title=dom-WindowWorkerCreators-createNamedWorker><a
   href="#createnamedworker">createNamedWorker()</a></code> method.

  <p>The <dfn id=closing
   title=dom-WindowWorker-closing><code>closing</code></dfn> attribute must
   return false until it is set to true by one of the algorithms in the
   processing model section below.

  <p>The following are the <span>event handler DOM attributes</span> that
   must be supported by objects implementing the <code><a
   href="#windowworker">WindowWorker</a></code> interface:

  <dl>
   <dt><dfn id=onconnect
    title=handler-WindowWorker-onconnect><code>onconnect</code></dfn>

   <dd>
    <p>Must be invoked whenever a <code
     title=event-WindowWorker-connect>connect</code> event is targeted at or
     bubbles through the <code><a
     href="#windowworker">WindowWorker</a></code> object.

   <dt><dfn id=onunload
    title=handler-WindowWorker-onunload><code>onunload</code></dfn>

   <dd>
    <p>Must be invoked whenever a <code title=event-unload>unload</code>
     event is targeted at or bubbles through the <code><a
     href="#windowworker">WindowWorker</a></code> object.
  </dl>

  <h3 id=base-urls><span class=secno>2.2 </span>Base URLs and origins of
   workers</h3>

  <p>The <span>base URL</span> of a <span>URL</span> passed to an API in a
   worker is the <span>absolute URL</span> given by the value of the <code
   title=dom-WindowWorker-URL><a href="#url">URL</a></code> attribute of the
   worker's <code><a href="#windowworker">WindowWorker</a></code> object.

  <p>The <span>origin</span> and <span>effective script origin</span> of
   scripts running in workers are both the <span>origin</span> of the
   <span>absolute URL</span> given by the value of the <code
   title=dom-WindowWorker-URL><a href="#url">URL</a></code> attribute of the
   worker's <code><a href="#windowworker">WindowWorker</a></code> object.

  <h3 id=the-queue><span class=secno>2.3 </span>The queue of events</h3>

  <p>Each <code><a href="#windowworker">WindowWorker</a></code> object is
   asssociated with a <dfn id=queue>queue of events</dfn>, which is initially
   empty.

  <p>An event in the queue can be a DOM event or a timeout callback.

  <p>All asynchronous callbacks and events that would be called or dispatched
   in the worker must be added to the worker's queue, with the "<a
   href="#run-a">run a worker</a>" processing model below taking care of
   actually calling the callbacks or dispatching the events.

  <p>Once the <code><a href="#windowworker">WindowWorker</a></code>'s <code
   title=dom-WindowWorker-closing><a href="#closing">closing</a></code>
   attribute is set to true, the queue must discard anything else that would
   be added to it. Effectively, once the <code
   title=dom-WindowWorker-closing><a href="#closing">closing</a></code>
   attribute is true, timers stop firing, notifications for all pending
   asynchronous operations are dropped, etc.

  <h3 id=the-workers><span class=secno>2.4 </span>The worker's ports</h3>

  <p>Workers communicate with other workers and with <span title="browsing
   context">browsing contexts</span> through <span title="channel
   messaging">message channels</span> and their <code>MessagePort</code>
   objects.

  <p>Each <code><a href="#windowworker">WindowWorker</a></code> <var
   title="">worker</var> has a list of <dfn id=the-workers0>the worker's
   ports</dfn>, which consists of all the <code>MessagePort</code> objects
   that are entangled with another port and that have one (but only one) port
   whose <code title=dom-MessagePort-ownerWindow>ownerWindow</code> is <var
   title="">worker</var>. This list includes all the <code>MessagePort</code>
   objects that are in events pending in the <a href="#queue">queue of
   events</a>.

  <hr>

  <p>A worker is said to be a <dfn id=front-line>front-line worker</dfn> if
   at least one of the <a href="#the-workers0">the worker's ports</a> has an
   entangled <code>MessagePort</code> whose <code
   title=dom-MessagePort-ownerWindow>ownerWindow</code> is a
   <code>WindowBrowsingContext</code> object.

  <p>A worker is said to be a <dfn id=needed>needed worker</dfn> if either:

  <ul>
   <li>it is a <a href="#front-line">front-line worker</a>, or

   <li>at least one of the <a href="#the-workers0">the worker's ports</a> has
    an entangled <code>MessagePort</code> whose <code
    title=dom-MessagePort-ownerWindow>ownerWindow</code> is a <code><a
    href="#windowworker">WindowWorker</a></code> object that is itself a <a
    href="#needed">needed worker</a>.
  </ul>

  <hr>

  <p>A worker is said to be an <dfn id=active>active front-line worker</dfn>
   if at least one of the <a href="#the-workers0">the worker's ports</a> has
   both an <code title=dom-MessagePort-active>active</code> attribute whose
   value is true and an entangled <code>MessagePort</code> whose <code
   title=dom-MessagePort-ownerWindow>ownerWindow</code> is a
   <code>WindowBrowsingContext</code> object.

  <p>A worker is said to be an <dfn id=active0>active needed worker</dfn> if
   either:

  <ul>
   <li>it is an <a href="#active">active front-line worker</a>, or

   <li>at least one of the <a href="#the-workers0">the worker's ports</a> has
    an entangled <code>MessagePort</code> whose <code
    title=dom-MessagePort-ownerWindow>ownerWindow</code> is a <code><a
    href="#windowworker">WindowWorker</a></code> object that is itself an <a
    href="#active0">active needed worker</a>.
  </ul>

  <h3 id=processing><span class=secno>2.5 </span>Processing model</h3>

  <p>When a user agent is to <dfn id=run-a>run a worker</dfn> named <var
   title="">name</var> for a script with <span>URL</span> <var
   title="">url</var>, a browsing context <var title="">owner browsing
   context</var> and a <code>Document</code> <var title="">owner
   document</var>, it must run the following steps in a completely separate
   and parallel execution environment:

  <ol>
   <li>
    <p>Attempt to <span>fetch</span><!-- XXX --> the resource identified by
     <var title="">url</var>.</p>

    <p>If the attempt fails, then abort these steps and invoke the <a
     href="#worker" title="worker creation failed">error handling steps</a>
     defined by the algorithm that called this one.</p>

    <p>If the attempt succeeds, then let <var title="">script</var> be the
     resource that was obtained.</p>

    <p class=note>As with <code>script</code> elements, the MIME type of the
     script is ignored. Unlike with <code>script</code> elements, there is no
     way to override the type. It's always assumed to be JavaScript.</p>
    <!-- XXX people will complain about
    this. I guess we might want to examine the MIME type... -->
    

   <li>
    <p>Create a new <code><a href="#windowworker">WindowWorker</a></code>
     object, <var title="">worker</var>.</p>

   <li>
    <p>Set the <code title=dom-WindowWorker-URL><a href="#url">URL</a></code>
     attribute of <var title="">worker</var> to the value of <var
     title="">url</var>.</p>

   <li>
    <p>Set the <code title=dom-WindowWorker-name><a
     href="#name">name</a></code> attribute of <var title="">worker</var> to
     the value of <var title="">name</var>.</p>

   <li>
    <p>Let <var title="">script</var>'s <span>script execution context</span>
     (and thus also <span>global object</span>) be <var
     title="">worker</var>.</p>

   <li>
    <p>Let <var title="">script</var>'s <span>script browsing context</span>
     be <var title="">owner browsing context</var>.</p>

   <li>
    <p>Let <var title="">script</var>'s <span>script document context</span>
     be <var title="">owner document</var>.</p>

   <li>
    <p>Invoke the <a href="#success" title="worker creation
     succeeded">success steps</a> defined by the algorithm that called this
     one.</p>

    <p class=note>This will usually add an event to the <a
     href="#queue">queue of events</a>. If it does, that event will have a
     <code>MessagePort</code> and thus the list of <a
     href="#the-workers0">the worker's ports</a> will not be empty. If it
     doesn't, then the next step will set the <var title="">worker</var>
     object's <code title=dom-WindowWorker-closing><a
     href="#closing">closing</a></code> attribute to true.</p>

   <li>
    <p>Start monitoring <var title="">worker</var>, such that as soon as the
     worker stops being a <a href="#needed">needed worker</a>, the <var
     title="">worker</var> object's <code title=dom-WindowWorker-closing><a
     href="#closing">closing</a></code> attribute is set to true.</p>

   <li>
    <p>Start monitoring <var title="">worker</var>, such that whenever the
     <var title="">worker</var> object's <code
     title=dom-WindowWorker-closing><a href="#closing">closing</a></code>
     attribute is false and the worker is not an <a href="#active0">active
     needed worker</a>, the user agent suspends execution of script in that
     worker until such time as either the <code
     title=dom-WindowWorker-closing><a href="#closing">closing</a></code>
     attribute switches to true or the worker becomes an <a
     href="#active0">active needed worker</a>.</p>

   <li>
    <p>Run <var title="">script</var> until it either returns, fails to catch
     an exception, or gets prematurely aborted by the "<a href="#kill-a">kill
     a worker</a>" algorithm below.</p>

    <p class=note>If the script gets aborted by the "<a href="#kill-a">kill a
     worker</a>" algorithm, then that same algorithm will cause there to only
     be a single event in the <a href="#queue">queue of events</a> at the
     next step, namely the <code title=message-unload>unload</code> event.
     However, if the event is ignored then it will become true as soon as
     that port is garbage collected.</p>

   <li>
    <p><i>Event loop</i>: Wait until either there is an event in the <a
     href="#queue">queue of events</a> associated with <var
     title="">worker</var> or the <var title="">worker</var> object's <code
     title=dom-WindowWorker-closing><a href="#closing">closing</a></code>
     attribute is set to true.</p>

   <li>
    <p>Dispatch the oldest event or callback in the <a href="#queue">queue of
     events</a>, if any. The handling of this event or the execution of this
     callback might get prematurely aborted by the "<a href="#kill-a">kill a
     worker</a>" algorithm below.</p>

   <li>
    <p>If there are any more events in the <a href="#queue">queue of
     events</a> or if the <var title="">worker</var> object's <code
     title=dom-WindowWorker-closing><a href="#closing">closing</a></code>
     attribute is set to false, then jump back to the step above labeled
     <i>event loop</i>.</p>

   <li>
    <p class=big-issue>timers, intervals, XMLHttpRequests, database
     transactions, etc, must be killed; ports must be deactivated and
     unentangled (do not send unload)</p>
  </ol>

  <hr>

  <p>When a user agent is to <dfn id=kill-a>kill a worker</dfn>, it must run
   the following steps in parallel with the worker's main loop (the "<a
   href="#run-a">run a worker</a>" processing model defined above):

  <ol>
   <li>
    <p>Create an <code>Event</code> object with the event name <code
     title=event-unload>unload</code>, which does not bubble and is not
     cancelable, and add it to the worker's <code><a
     href="#windowworker">WindowWorker</a></code> object's <a
     href="#queue">queue of events</a>, targetted at the <code><a
     href="#windowworker">WindowWorker</a></code> object itself.

   <li>
    <p>Set the worker's <code><a href="#windowworker">WindowWorker</a></code>
     object's <code title=dom-WindowWorker-closing><a
     href="#closing">closing</a></code> attribute to true.

   <li>
    <p>Wait a user-agent-defined amount of time. If the "<a href="#run-a">run
     a worker</a>" processing model defined above immediately starts running
     event listeners registered for <code title=event-unload>unload</code>
     event, this time should not be zero &mdash; the idea is that the <code
     title=event-unload>unload</code> event can be used to clean up when
     shutting down unexpectedly.

   <li>
    <p>If there are any events in the <a href="#queue">queue of events</a>
     other than the <code title=event-unload>unload</code> event that this
     algorithm just added, discard them without dispatching them.

   <li>
    <p>If the <code title=event-unload>unload</code> event that this
     algorithm just added hasn't yet been dispatched, then abort the script
     currently running in the worker.

   <li>
    <p>Wait a user-agent-defined amount of time.

   <li>
    <p>Abort the script currently running in the worker (if any script is
     running, then it will be a handler for the <code
     title=event-unload>unload</code> event).
  </ol>

  <p>User agents may invoke the "<a href="#kill-a">kill a worker</a>"
   processing model on a worker at any time, e.g. in response to user
   requests, in response to CPU quota management, or when a worker stops
   being a <a href="#needed">needed worker</a> if the worker continues
   executing even after its <code title=dom-WindowWorker-closing><a
   href="#closing">closing</a></code> attribute was set to true.

  <hr>

  <p>When a script invokes the <dfn id=import
   title=dom-WindowWorker-import><code>import(<var
   title="">url</var>)</code></dfn> method on a <code><a
   href="#windowworker">WindowWorker</a></code> object, the user agent must
   run the following steps:

  <ol>
   <li>
    <p><span title="resolve a url">Resolve</span> the <var title="">url</var>
     argument.

   <li>
    <p>If this fails, throw a <code>SYNTAX_ERR</code> exception.

   <li>
    <p>If the <span>origin</span> of the resulting <span>absolute URL</span>
     is not the <span title="same origin">same</span> as the origin of the
     script that invoked the method, then throw a <span>security
     exception</span>.

   <li>
    <p>Attempt to <span>fetch</span><!-- XXX --> the resource identified by
     the resulting <span>absolute URL</span>.</p>

    <p>If the attempt fails, return false and abort these steps.</p>

    <p>If the attempt succeeds, then let <var title="">script</var> be the
     resource that was obtained.</p>

    <p class=note>As with the initial script, the script here is always
     assumed to be JavaScript, regardless of the MIME type.</p>
    <!-- XXX -->

   <li>
    <p>Let <var title="">script</var>'s <span>script execution
     context</span>, <span>script browsing context</span>, and <span>script
     document context</span> be the same as for the script that was executed
     by the <a href="#run-a">run a worker</a> processing model for this
     worker.</p>

   <li>
    <p>Run <var title="">script</var> until it either returns, fails to catch
     an exception, or gets prematurely aborted by the "<a href="#kill-a">kill
     a worker</a>" algorithm below.</p>

    <p>If an exception was raised or if the script was prematurely aborted,
     then abort these steps, letting the exception or aborting continue to be
     processed by the script that called the <code
     title=dom-WindowWorker-import><a href="#import">import()</a></code>
     method.</p>

    <p>Otherwise, return true.</p>
  </ol>

  <hr>

  <p>When a script invokes the <dfn id=close
   title=dom-WindowWorker-close><code>close()</code></dfn> method on a
   <code><a href="#windowworker">WindowWorker</a></code> object, the user
   agent must run the following steps:

  <ol>
   <li>
    <p>Create an <code>Event</code> object with the event name <code
     title=event-unload>unload</code>, which does not bubble and is not
     cancelable, and add it to the <code><a
     href="#windowworker">WindowWorker</a></code> object's <a
     href="#queue">queue of events</a>, targetted at the <code><a
     href="#windowworker">WindowWorker</a></code> object itself.

   <li>
    <p>Set the worker's <code><a href="#windowworker">WindowWorker</a></code>
     object's <code title=dom-WindowWorker-closing><a
     href="#closing">closing</a></code> attribute to true.

   <li>
    <p>For each <code>MessagePort</code> object that is entangled with
     another port and that has one (but only one) port whose <code
     title=dom-MessagePort-ownerWindow>ownerWindow</code> is the <code><a
     href="#windowworker">WindowWorker</a></code> object on which the method
     was invoked, run the following substeps:</p>

    <ol>
     <li>
      <p>Unentangle the two ports.

     <li>
      <p>Set both ports' <code title=dom-MessagePort-active>active</code>
       attribute to false.

     <li>
      <p>At the next available opportunity, after any scripts have finished
       executing<!-- XXX queue -->, <span>fire a simple event</span> called
       <code title=event-unload>unload</code> at the other port (the one
       whose <code title=dom-MessagePort-ownerWindow>ownerWindow</code> is
       not the <code><a href="#windowworker">WindowWorker</a></code> object
       on which the <code title=dom-WindowWorker-close><a
       href="#close">close()</a></code> method was called).
    </ol>
  </ol>

  <h3 id=creating><span class=secno>2.6 </span>Creating workers</h3>

  <pre
   class=idl>[NoInterfaceObject] interface <dfn id=windowworkercreators>WindowWorkerCreators</dfn> {
  <span>MessagePort</span> <a href="#createworker" title=dom-WindowWorkerCreators-createWorker>createWorker</a>(in DOMString scriptURL);
  <span>MessagePort</span> <a href="#createnamedworker" title=dom-WindowWorkerCreators-createNamedWorker>createNamedWorker</a>(in DOMString name, in DOMString scriptURL);
};</pre>

  <p>Objects that implement the <code>Window</code> interface must also
   implement the <code><a
   href="#windowworkercreators">WindowWorkerCreators</a></code> interface.

  <hr>

  <p>When the <dfn id=createworker
   title=dom-WindowWorkerCreators-createWorker><code>createWorker(<var
   title="">scriptURL</var>)</code></dfn> method is invoked, the user agent
   must run the following steps:

  <ol>
   <li>
    <p><span title="resolve a url">Resolve</span> the <var
     title="">scriptURL</var> argument.

   <li>
    <p>If this fails, throw a <code>SYNTAX_ERR</code> exception.

   <li>
    <p>If the <span>origin</span> of the resulting <span>absolute URL</span>
     is not the <span title="same origin">same</span> as the origin of the
     script that invoked the method, then throw a <span>security
     exception</span>.

   <li>
    <p><a href="#create">Create a worker</a> from the resulting
     <span>absolute URL</span> whose name is the empty string.

   <li>
    <p>Return the <code>MessagePort</code> object returned from the <a
     href="#create">create a worker</a> algorithm.
  </ol>

  <hr>

  <p>When the <dfn id=createnamedworker
   title=dom-WindowWorkerCreators-createNamedWorker><code>createNamedWorker(<var
   title="">name</var>, <var title="">scriptURL</var>)</code></dfn> method is
   invoked, the user agent must run the following steps:

  <ol>
   <li>
    <p><span title="resolve a url">Resolve</span> the <var
     title="">scriptURL</var> argument.

   <li>
    <p>If this fails, throw a <code>SYNTAX_ERR</code> exception.

   <li>
    <p>If the <span>origin</span> of the resulting <span>absolute URL</span>
     is not the <span title="same origin">same</span> as the origin of the
     script that invoked the method, then throw a <span>security
     exception</span>.

   <li>
    <p>If the <var title="">name</var> argument is the empty string, <a
     href="#create">create a worker</a> from the resulting <span>absolute
     URL</span>, whose name is the empty string, and return the
     <code>MessagePort</code> object returned from the <a
     href="#create">create a worker</a> algorithm. Then, abort these steps.

   <li>
    <p>If there exists a worker whose <code title=dom-WindowWorker-closing><a
     href="#closing">closing</a></code> attribute is false, whose <code
     title=dom-WindowWorker-name><a href="#name">name</a></code> attribute is
     exactly equal to the <var title="">name</var> argument, and whose <code
     title=dom-WindowWorker-URL><a href="#url">URL</a></code> attribute has
     the <span>same origin</span> as the resulting <span>absolute URL</span>,
     then run these substeps:</p>

    <ol>
     <li>
      <p>If that worker's <code title=dom-WindowWorker-URL><a
       href="#url">URL</a></code> attribute is not exactly equal to the
       resulting <span>absolute URL</span>, then throw a
       <code>URL_MISMATCH_ERR</code> exception and abort these steps. <span
       class=big-issue>code 19</span>

     <li>
      <p><span>Create a new <code>MessagePort</code> object</span> owned by
       the <span>script execution context</span> of the script that invoked
       the method.

     <li>
      <p>Return that port.

     <li>
      <p>Asynchronously, <a href="#connect" title="connect to a
       worker">connect</a> to this preexisting worker, with the newly created
       port.
    </ol>

    <p>Otherwise, <a href="#create">create a worker</a> from the resulting
     <span>absolute URL</span>, whose name is the value of the <var
     title="">name</var> argument, and return the <code>MessagePort</code>
     object returned from the <a href="#create">create a worker</a>
     algorithm.</p>
  </ol>

  <hr>

  <p>The steps to <dfn id=create>create a worker</dfn> from a
   <span>URL</span> <var title="">url</var> and whose name is <var
   title="">name</var>, in the context of a method call, are as follows:

  <ol>
   <li>
    <p><span>Create a new <code>MessagePort</code> object</span> owned by the
     <span>script execution context</span> of the script that invoked the
     method.

   <li>
    <p>Return that port.

   <li>
    <p>In a parallel execution context (i.e. a separate thread or process or
     equivalent construct), <a href="#run-a">run a worker</a> named <var
     title="">name</var> for the script with <span>URL</span> <var
     title="">url</var>, with the <span>script browsing context</span> of the
     script that invoked the method as the <var title="">owner browsing
     context</var> and with the <span>script document context</span> of the
     script that invoked the method as the <var title="">owner
     document</var>.</p>

    <p>If that algorithm invokes the steps for <dfn id=success title="worker
     creation succeeded">success steps</dfn>, then <a href="#connect"
     title="connect to a worker">connect</a> to this new worker, with the
     newly created port.</p>

    <p>Otherwise, if the <dfn id=worker>worker creation failed</dfn>, then at
     the next available opportunity, after any scripts have finished
     executing<!-- XXX queue -->, <span>fire a simple event</span> called
     <code title=event-error>error</code> at the newly created port.</p>
  </ol>

  <hr>

  <p>The steps to <dfn id=connect>connect to a worker</dfn> given a
   <code>MessagePort</code> object <var title="">port</var> are as follows:

  <ol>
   <li>
    <p>If <var title="">port</var> would have been garbage collected, or if
     the <span>active document</span> of the <code
     title=dom-MessagePort-ownerWindow>ownerWindow</code> of <var
     title="">port</var> is no longer the same <code>Document</code> object
     as when <var title="">port</var> was created, then do nothing. Abort
     these steps. If the worker was just created, it'll get killed
     immediately.</p>

   <li>
    <p><span>Create a new <code>MessagePort</code> object</span> owned by the
     <code><a href="#windowworker">WindowWorker</a></code> of the worker.

   <li>
    <p><span>Entangle</span> this newly created port and the port <var
     title="">port</var> that was passed to these steps.

   <li>
    <p>Set the <code title=dom-MessagePort-active>active</code> attribute of
     both ports to true.

   <li>
    <p>At the next available opportunity, after any scripts have finished
     executing<!-- XXX queue -->, <span>fire a simple event</span> called
     <code title=event-load>load</code> at <var title="">port</var>.

   <li>
    <p>Create an event that uses the <code>MessageEvent</code> interface,
     with the name <code title=event-connect>connect</code>, which does not
     bubble, is cancelable, has no default action, has a <code
     title=dom-MessageEvent-data>data</code> attribute whose value is the
     empty string and has a <code
     title=dom-MessageEvent-messagePort>messagePort</code> attribute whose
     value is the newly created port, and add it to the worker's <code><a
     href="#windowworker">WindowWorker</a></code> object's <a
     href="#queue">queue of events</a>, targetted at the <code><a
     href="#windowworker">WindowWorker</a></code> object itself.
  </ol>

  <h2 id=apis-available><span class=secno>3. </span>APIs available to workers</h2>

  <p>There must be no interface objects and constructors available in the
   global scope of scripts whose <span>script execution context</span> is a
   <code><a href="#windowworker">WindowWorker</a></code> object except for
   the following:

  <ul>
   <li>
    <p><code>XMLHttpRequest</code> and all interface objects and constructors
     defined by the XMLHttpRequest specifications, except that the
     <span>document response entity body</span> must always be null. <a
     href="#refsXHR">[XHR]</a>

   <li>
    <p>The <code>WebSocket</code> interface object and constructor.

   <li>
    <p>The <code>MessageChannel</code> interface object and constructor.
  </ul>

  <hr>

  <p>Objects that implement the <code><a
   href="#windowworker">WindowWorker</a></code> interface must also implement
   the following interfaces:

  <ul>
   <li>
    <p>The <code>Window</code> interface, and interfaces that are required to
     be implemented by objects implementing that interface, including:</p>

    <ul>
     <li>The <code>WindowTimers</code> interface

     <li>The <code><a
      href="#windowworkercreators">WindowWorkerCreators</a></code> interface
    </ul>

   <li>The <code>EventTarget</code> interface.
  </ul>

  <div class=note>
   <p>The following APIs are available in workers due to their being defined
    on the <code>Window</code> object or one of the interfaces that are
    required to be implemented by objects implementing that interface:</p>

   <ul>
    <li>The <code title=dom-showNotification>showNotification()</code> APIs.

    <li>The <code title=dom-localStorage>localStorage</code> object and
     related name/value pair storage APIs.

    <li>The <code title=dom-openDatabase>openDatabase()</code> method and the
     related SQL database API.
   </ul>
  </div>

  <p class=big-issue>Need to define a sync database API.

  <p class=big-issue>May need to define a browser sniffing API (like
   window.navigator).</p>
  <!-- XXX ApplicationCache -->
  <!-- XXX a way to set cookies on the URL for the script -->
  <!-- XXX debugging: void log(in DOMString s); // log to console -->
  <!-- XXX debugging: onerror -->

  <hr>

  <p>The DOM APIs (<code>Node</code> objects, <code>Document</code> objects,
   etc) are not available to workers in this version of this specification.

  <h2 class=no-num id=references>References</h2>

  <p class=big-issue>This section will be written in a future
   draft.<!--XXX-->

  <h2 class=no-num id=acknowledgements>Acknowledgements</h2>
  <!-- ACKS -->

  <p>Thanks to Maciej Stachowiak, Mike Smith, and Philip Taylor for their
   useful and substantial comments.

  <p>Huge thanks to the whole Gears team, who pioneered this technology and
   whose experience has been a huge influence on this specification.