html5/spec-ja/workers-non-normative.ja.html.u8


<html lang=en-US-x-hixie>
 <head>
  <title>Web Workers</title>
  <link href="http://www.whatwg.org/style/specification" rel=stylesheet>
<!-- Japanese-translation-only style rules -->
<style>
  em, i {
    font-style: normal;
    text-decoration: underline;
  }

  .note, .warning {
    font-style: normal;
  }
  p.note:before {
    content: '注意: ';
  }
  p.warning:before {
    content: '\26A0 警告! ';
  }

  ins.ja-note {
    background-color: #EEFFFF;
    color: black;
  }
  span.ja-translation {
    border-style: none !important;
  }

  /* From Web Workers <style>, modified for Japanese texts */
  p > span.ja-translation > span:not([title=""]):not([class="big-issue"]),
  li > span.ja-translation > span:not([title=""]):not([class="big-issue"]) {
    border-bottom: solid #99CC99;
  }

</style>
  <link href="http://www.whatwg.org/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><span class=ja-translation lang=ja><a class=logo href="http://www.whatwg.org/" rel=home><img lang=en alt=WHATWG
    src="http://www.whatwg.org/images/logo"></a></span></p>

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

   <h2 class="no-num no-toc" id=draft><span class=ja-translation lang=ja>勧告案<ins class=ja-note>の非公式和訳</ins> &mdash; 
<ins class=ja-note>(原文出版日)</ins> 2008年8月14日</span></h2>

   <p><span class=ja-translation lang=ja>みなさんにも作業にご参加いただけます。 <a
    href="http://www.whatwg.org/mailing-list">作業部会の議論用メイリング・リストに参加してください。</a></span></p>

   <p><span class=ja-translation lang=ja><strong>Web デザイナー!</strong> みなさんのための <a
    href="http://blog.whatwg.org/faq/" lang=en>FAQ</a>、<a
    href="http://forums.whatwg.org/">掲示板</a>、<a
    href="http://www.whatwg.org/mailing-list#help">ヘルプ用メイリング・リスト</a>があります!

</span><p>

<!-- Japanese-translation-only notes -->
<ins class=ja-note style="display: block" lang=ja>
<p>この文書は、 WHATWG HTML5 仕様書の日本語訳です。
HTML5 の正式な仕様書は英語版だけであり、
この日本語訳はあくまで参考としてご利用ください。

<p lang=en>This document is a Japanese translation of
the WHATWG HTML5 specification.  Note that the only normative specification
for the HTML5 is the original English version and this Japanese
translation is non‐normative.

<p>日本語訳は <a href="edit/" rel=edit>Web 界面</a>を使って編集できます。
編集結果はおよそ3時間おきに反映されます。
また、原文の変更には毎日自動的に追随しています。

<p lang=en>The Japanese text can be edited using the <a href="edit/" rel=edit>Web
interface</a>.  Any modifications will be reflected to this translation
in about three hours.  Note that any changes to the original specification
will automatically be incorporated to this translation every day.
</ins>

<p><span><!-- dummy --></span></p>

   <dl>
    <dt><span class=ja-translation lang=ja><ins class=ja-note>原文の</ins>この版</span><dd><a
     href="http://www.whatwg.org/specs/web-workers/current-work/">http://whatwg.org/ww</a>

    <dt><span class=ja-translation lang=ja><ins class=ja-note>原文の</ins>改版履歴:</span><dd><span class=ja-translation lang=ja><span lang=en>Twitter</span> メッセージ (編集上の変更以外): <a
     href="http://twitter.com/WHATWG">http://twitter.com/WHATWG</a></span><dd><span class=ja-translation lang=ja>Commit-Watchers メイリング・リスト: <a
href="http://lists.whatwg.org/listinfo.cgi/commit-watchers-whatwg.org">http://lists.whatwg.org/listinfo.cgi/commit-watchers-whatwg.org</a></span><dd><span class=ja-translation lang=ja>対話的 <span lang=en>Web</span> 界面: <a href="http://html5.org/tools/web-workers-tracker">http://html5.org/tools/web-workers-tracker</a></span><dd><span class=ja-translation lang=ja><span lang=en>Subversion</span> 界面: <a href="http://svn.whatwg.org/webworkers/">http://svn.whatwg.org/webworkers/</a></span><dt><span class=ja-translation lang=ja>問題:</span><dd><span class=ja-translation lang=ja>フィードバックの送信先: <a
     href="http://www.whatwg.org/mailing-list">[email protected]</a></span><dd><span class=ja-translation lang=ja>フィードバックの閲覧・投票: <a
     href="http://www.whatwg.org/issues/">http://www.whatwg.org/issues/</a></span><dt><span class=ja-translation lang=ja>編集者:</span><dd>Ian Hickson, Google, [email protected]
   </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><span class=ja-translation lang=ja>概要</span></h2>

  <p><span class=ja-translation lang=ja>この仕様書は、 Web アプリケーションで、主たる頁とは並列に、
背景労働者スクリプトを走らせるための API を定義します。
これにより、メッセージ・パッシングによるスレッド的操作を協調機構として利用できるようになります。</span><h2 class="no-num no-toc" id=status><span class=ja-translation lang=ja>この文書の状態</span></h2>

  <p><span class=ja-translation lang=ja><strong>この文書は作業中です!</strong>
この文書は、コメントへの対応や通常の開発の過程として、
毎時毎分とは言い過ぎですが毎日のペースで変更されています。
コメントは非常に歓迎していますので、
<a href="mailto:[email protected]">[email protected]</a>
へお送りください。よろしくお願いします。</span><p><span class=ja-translation lang=ja>現在の焦点は、第1案の開発です。</span><p><span class=ja-translation lang=ja>実装者は、この仕様書が安定していないことに注意するべきです。
<strong>実装者は議論に参加しておかないと、
仕様がその実装とは非互換に変更されてしまうかもしれません。</strong>
この仕様書がいずれ実装呼び掛けの段階に達するのよりも前にこの仕様を実装したい販売者は、
<a href="http://www.whatwg.org/mailing-list">WHATWG メイリング・リスト</a>に参加し、
議論に加わるべきです。</span><p><span class=ja-translation lang=ja>この仕様書は <a
   href="http://www.w3.org/html/wg">W3C HTML WG</a>
によっても出版されています。2つの仕様書の目次以降は同一です。</span><h2 class="no-num no-toc" id=contents><span class=ja-translation lang=ja>目次
</span></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>
      <ul class=toc>
       <li><a href="#a-background"><span class=secno>1.1.1 </span>A
        background number-crunching worker</a>

       <li><a href="#a-worker"><span class=secno>1.1.2 </span>A worker for
        updating a client-side database</a>

       <li><a href="#worker"><span class=secno>1.1.3 </span>Worker used for
        backgroud I/O</a>

       <li><a href="#shared"><span class=secno>1.1.4 </span>Shared
        workers</a>

       <li><a href="#delegation"><span class=secno>1.1.5
        </span>Delegation</a>

       <li><a href="#providing"><span class=secno>1.1.6 </span>Providing
        libraries</a>

       <li><a href="#granting"><span class=secno>1.1.7 </span>Granting
        capabilities</a>
      </ul>

     <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-workerglobalscope"><span class=secno>2.1 </span>The
      <code>WorkerGlobalScope</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>
    <ul class=toc>
     <li><a href="#importing"><span class=secno>3.1 </span>Importing scripts
      and libraries</a>

     <li><a href="#apis-defined"><span class=secno>3.2 </span>APIs defined in
      other specifications</a>

     <li><a href="#interface"><span class=secno>3.3 </span>Interface objects
      and constructors</a>

     <li><a href="#worker0"><span class=secno>3.4 </span>Worker locations</a>
      
    </ul>

   <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=ja-translation lang=ja><span class=secno>1. </span>はじめに</span></h2>

  <h3 id=tutorial><span class=ja-translation lang=ja><span class=secno>1.1 </span>解説</span></h3>

  <p><span class=ja-translation lang=ja><em>この節は規定の一部ではありません。</em></span><p><span class=ja-translation lang=ja>労働者は色々なことに使えます。次の各節では、色々な使い方の例を示します。</span><h4 id=a-background><span class=ja-translation lang=ja><span class=secno>1.1.1 </span>数値処理背景労働者</span></h4>

  <p><span class=ja-translation lang=ja><em>この節は規定の一部ではありません。</em></span><p><span class=ja-translation lang=ja>労働者の一番単純な用法は、計算的に高価な仕事を利用者界面を中断させずに実行することです。</span><p><span class=ja-translation lang=ja>この例では、主たる文書が労働者を作って素数を (素朴な方法で) 計算させ、
新しく見つかった素数を順番に表示してゆきます。</span><p><span class=ja-translation lang=ja>主たる頁は次の通りです。</span><pre>&lt;!DOCTYPE HTML>
&lt;html>
 &lt;head>
  &lt;title>Worker example: One-core computation&lt;/title>
 &lt;/head>
 &lt;body>
  &lt;p>The highest prime number discovered so far is: &lt;output id="result">&lt;/output>&lt;/p>
  &lt;script>
   var worker = createWorker('worker.js');
   worker.port.onmessage = function (event) {
     document.getElementById('result').textContent = event.message;
   };
  &lt;/script>
 &lt;/body>
&lt;/html></pre>

  <p>The <code title=dom-WorkerFactory-createWorker><a
   href="#createworker">createWorker()</a></code> method call creates a
   worker and returns a <code><a href="#worker1">Worker</a></code> object
   representing that worker and containing a <code>MessagePort</code> object,
   which is used to communicate with the worker. That object's <code
   title=dom-MessagePort-onmessage>onmessage</code> event handler attribute
   allows the code to receive messages from the worker.

  <p><span class=ja-translation lang=ja>労働者自体は次の通りです。</span><pre>var n = 1;
search: while (true) {
  n += 1;
  for (var i = 2; i &lt;= Math.sqrt(n); i += 1)
    if (n % i == 0)
     continue search;
  // found a prime!
  port.postMessage(n);
}</pre>

  <p>The bulk of this code is simply an unoptimised search for a prime
   number. To send a message back to the page, the <code
   title=dom-WorkerGlobalScope-port><a href="#port">port</a></code> variable
   (defined automatically when the worker is created) is used to post a
   message when a prime is found.

  <p><span class=ja-translation lang=ja><a href="http://www.whatwg.org/demos/workers/primes/page.html">この例をオンラインで見る</a>。</span><h4 id=a-worker><span class=secno>1.1.2 </span>A worker for updating a
   client-side database</h4>

  <p><span class=ja-translation lang=ja><em>この節は規定の一部ではありません。</em></span><p>In this example, the main document spawns a worker whose only task is to
   listen for notifications from the server, and, when appropriate, either
   add or remove data from the client-side database.

  <p>Since no communication occurs between the worker and the main page, the
   main page can start the worker by just doing:

  <pre>&lt;script>
 createWorker('worker.js');
&lt;/script></pre>

  <p><span class=ja-translation lang=ja>労働者自体は次の通りです。</span><pre>var server = new WebSocket('ws://whatwg.org/database');
var database = openDatabase('demobase', '1.0', 'Demo Database', 10240);
server.onmessage = function (event) {
  // data is in the format "command key value"
  var data = event.message.split(' ');
  switch (data[0]) {
    case '+':
     database.transaction(function(tx) {
       tx.executeSql('INSERT INTO pairs (key, value) VALUES (?, ?)', data[1], data[2]);
     });
    case '-':
     database.transaction(function(tx) {
       tx.executeSql('DELETE FROM pairs WHERE key=? AND value=?', data[1], data[2]);
     });
  }
};</pre>

  <p>This connects to the server using the <code>WebSocket</code> mechanism
   and opens the local database (which, we presume, has been created
   earlier). The worker then just listens for messages from the worker and
   acts on them as appropriate, forever (or until the main page is closed).

  <p><a
   href="http://www.whatwg.org/demos/workers/database-updater/page.html">View
   this example online</a>. (This example will not actually function, since
   the server does not actually exist and the database is not created by this
   sample code.)

  <h4 id=worker><span class=secno>1.1.3 </span>Worker used for backgroud I/O</h4>

  <p><span class=ja-translation lang=ja><em>この節は規定の一部ではありません。</em></span><p>In this example, the main document uses two workers, one for fetching
   stock updates for at regular intervals, and one for fetching performing
   search queries that the user requests.

  <p><span class=ja-translation lang=ja>主たる頁は次の通りです。</span><pre>&lt;!DOCTYPE HTML>
&lt;html>
 &lt;head>
  &lt;title>Worker example: Stock ticker&lt;/title>
  &lt;script>
   // TICKER
   var symbol = 'GOOG'; // default symbol to watch
   var ticker = createWorker('ticker.js');
   ticker.port.postMessage(symbol);

   // SEARCHER
   var searcher = createWorker('searcher.js');
   function search(query) {
     searcher.port.postMessage(query);
   }

   // SYMBOL SELECTION UI
   function select(newSymbol) {
     symbol = newSymbol;
     ticker.port.postMessage(symbol);
   }
  &lt;/script>
 &lt;/head>
 &lt;body>
  &lt;p>&lt;output id="symbol">&lt;/output> &lt;output id="value">&lt;/output>&lt;/p>
  &lt;script>
   ticker.port.onmessage = function (event) {
     var data = event.message.split(' ');
     document.getElementById('symbol').textContent = data[0];
     document.getElementById('value').textContent = data[1];
   };
  &lt;/script>
  &lt;p>&lt;label>Search: &lt;input type="text" oninput="search(this.value)">&lt;/label>&lt;/p>
  &lt;ul id="results">&lt;/ul>
  &lt;script>
   searcher.port.onmessage = function (event) {
     var data = event.message.split(' ');
     var results = document.getElementById('results');
     while (results.hasChildNodes()) // clear previous results
       results.removeChild(results.firstChild);
     for (var i = 0; i &lt; data.length; i += 1) {
       // add a list item with a button for each result
       var li = document.createElement('li');
       var button = document.createElement('button');
       button.value = data[i];
       button.type = 'button';
       button.onclick = function () { select(this.value); };
       button.textContent = data[i];
       li.appendChild(button);
       results.appendChild(li);
     }
   };
  &lt;/script>
  &lt;p>(The data in this example is not real. Try searching for "Google" or "Apple".)&lt;/p>
 &lt;/body>
&lt;/html></pre>

  <p>Messages are queued until the <code
   title=handler-MessagePort-onmessage>onmessage</code> handler is set, so
   even if it takes a while for the message handler to be attached, no data
   is lost.

  <p>The two workers use a common library for performing the actual network
   calls. This library is as follows:

  <pre>function get(url) {
   try {
     var xhr = new XMLHttpRequest();
     xhr.open('GET', url, false);
     xhr.send();
     return xhr.responseText;
   } catch (e) {
     return ''; // turn all errors into empty results
   }
}</pre>

  <p>The stock updater worker is as follows:

  <pre>importScripts('io.js');
var timer;
var symbol;
function update() {
  port.postMessage(symbol + ' ' + get('stock.cgi?' + symbol));
  timer = setTimeout(update, 10000);
}
port.onmessage = function (event) {
  if (timer)
    clearTimeout(timer);
  symbol = event.message;
  update();
};</pre>

  <p>The search query worker is as follows:

  <pre>importScripts('io.js');
port.onmessage = function (event) {
  port.postMessage(get('search.cgi?' + event.message));
};</pre>

  <p><span class=ja-translation lang=ja><a href="http://www.whatwg.org/demos/workers/stocks/page.html">この例をオンラインで見る</a>。</span><h4 id=shared><span class=secno>1.1.4 </span>Shared workers</h4>

  <p><span class=ja-translation lang=ja><em>この節は規定の一部ではありません。</em></span><p>In this example, multiple windows (viewers) can be opened that are all
   viewing the same map. All the windows share the same map information, with
   a single worker coordinating all the viewers. Each viewer can move around
   idependently, but if they set any data on the map, all the viewers are
   updated.

  <p>The main page isn't interesting, it merely provides a way to open the
   viewers:

  <pre>&lt;!DOCTYPE HTML>
&lt;html>
 &lt;head>
  &lt;title>Workers example: Multiviewer&lt;/title>
  &lt;script>
   function openViewer() {
     window.open('viewer.html');
   }
  &lt;/script>
 &lt;/head>
 &lt;body>
  &lt;p>&lt;button type=button onclick="openViewer()">Open a new
  viewer&lt;/button>&lt;/p>
  &lt;p>Each viewer opens in a new window. You can have as many viewers
  as you like, they all view the same data.&lt;/p>
 &lt;/body>
&lt;/html></pre>

  <p>The viewer is more involved:

  <pre>&lt;!DOCTYPE HTML>
&lt;html>
 &lt;head>
  &lt;title>Workers example: Multiviewer viewer&lt;/title>
  &lt;script>
   var worker = createNamedWorker('worker.js', 'core');

   // CONFIGURATION
   function configure(event) {
     if (event.message.substr(0, 4) != 'cfg ') return;
     var name = event.message.substr(4).split(' ', 1);
     // update display to mention our name is name
     document.getElementsByTagName('h1')[0].textContent += ' ' + name;
     // no longer need this listener
     worker.port.removeEventListener('message', configure, false);
   }
   worker.port.addEventListener('message', configure, false);

   // MAP
   function paintMap(event) {
     if (event.message.substr(0, 4) != 'map ') return;
     var data = event.message.substr(4).split(',');
     // display tiles data[0] .. data[8]
     var canvas = document.getElementById('map');
     var context = canvas.getContext('2d');
     for (var y = 0; y &lt; 3; y += 1) {
       for (var x = 0; x &lt; 3; x += 1) {
         var tile = data[y * 3 + x];
         if (tile == '0')
           context.fillStyle = 'green';
         else 
           context.fillStyle = 'maroon';
         fillRect(x * 50, y * 50, 50, 50);
       }
     }
   }
   worker.port.addEventListener('message', paintMap, false);

   // PUBLIC CHAT
   function updatePublicChat(event) {
     if (event.message.substr(0, 4) != 'txt ') return;
     var name = event.message.substr(4).split(' ', 1);
     var message = event.message.substr(4 + length(name) + 1);
     // display "&lt;name> message" in public chat
     var dialog = document.getElementById('public');
     var dt = document.createElement('dt');
     dt.textContent = name;
     dialog.appendChild(dt);
     var dd = document.createElement('dd');
     dd.textContent = message;
     dialog.appendChild(dd);
   }
   worker.port.addEventListener('message', updatePublicChat, false);

   // PRIVATE CHAT
   function startPrivateChat(event) {
     if (event.message.substr(0, 4) != 'msg ') return;
     var name = event.message.substr(4).split(' ', 1);
     var port = event.port;
     // display a private chat UI
     var ul = document.getElementById('private');
     var li = document.createElement('li');
     var h3 = document.createElement('h3');
     h3.textContent = 'Private chat with ' + name;
     li.appendChild(h3);
     var dialog = document.createElement('dialog');
     var addMessage = function(name, message) {
       var dt = document.createElement('dt');
       dt.textContent = name;
       dialog.appendChild(dt);
       var dd = document.createElement('dd');
       dd.textContent = message;
       dialog.appendChild(dd);
     };
     port.onmessage = function (event) {
       addMessage(name, event.message);
     };
     li.appendChild(dialog);
     var form = document.createElement('form');
     var p = document.createElement('p');
     var input = document.createElement('input');
     input.size = 50;
     p.appendChild(input);
     p.appendChild(document.createTextNode(' '));
     var button = document.createElement('button');
     button.textContent = 'Post';
     p.appendChild(button);
     form.onsubmit = function () {
       port.postMessage(input.value);
       addMessage('me', input.value);
       input.value = '';
       return false;
     };
     form.appendChild(p);
     li.appendChild(form);
   }
   worker.port.addEventListener('message', startPrivateChat, false);

   function init() {
     // begin receiving messages (messages are queued until you either
     // set worker.port.onmessage or call worker.port.start())
     worker.port.start();
   }
  &lt;/script>
 &lt;/head>
 &lt;body onload="init()">
  &lt;h1>Viewer&lt;/h1>
  &lt;h2>Map&lt;/h2>
  &lt;p>&lt;canvas id="map" height=150 width=150>&lt;/canvas>&lt;/p>
  &lt;p>
   &lt;button type=button onclick="worker.port.postMessage('mov left')">Left&lt;/button>
   &lt;button type=button onclick="worker.port.postMessage('mov up')">Up&lt;/button>
   &lt;button type=button onclick="worker.port.postMessage('mov down')">Down&lt;/button>
   &lt;button type=button onclick="worker.port.postMessage('mov right')">Right&lt;/button>
   &lt;button type=button onclick="worker.port.postMessage('set 0')">Set 0&lt;/button>
   &lt;button type=button onclick="worker.port.postMessage('set 1')">Set 1&lt;/button>
  &lt;/p>
  &lt;h2>Public Chat&lt;/h2>
  &lt;dialog id="public">&lt;/dialog>
  &lt;form onsubmit="worker.port.postMessage('txt ' + message.value); message.value = ''; return false;">
   &lt;p>
    &lt;input type="text" name="message" size="50">
    &lt;button>Post&lt;/button>
   &lt;/p>
  &lt;/form>
  &lt;h2>Private Chat&lt;/h2>
  &lt;ul id="private">&lt;/ul>
 &lt;/body>
&lt;/html>
</pre>

  <p>There are several key things worth noting about the way the viewer is
   written.

  <p><strong>Multiple listeners</strong>. Instead of a single message
   processing function, the code here attaches multiple event listeners, each
   one performing a quick check to see if it is relevant for the message. In
   this example it doesn't make much difference, but if multiple authors
   wanted to collaborate using a single port to communicate with a worker, it
   would allow for independent code instead of changes having to all be made
   to a single event handling function.

  <p>Because event listeners are registered using <code
   title="">addEventListener()</code> instead of <code
   title=handler-MessagePort-onmessage>onmessge</code>, the events remain
   queued until the <code title=dom-MessagePort-start>start()</code> method
   is called on the message port, in the <code title="">init()</code>
   function called from the <code title=handler-onload>onload</code> handler.

  <p>Registering event listeners in this way also allows you to unregister
   specific listeners when you are done with them, as is done with the <code
   title="">configure()</code> method in this example.

  <p>Finally, the worker:

  <pre>
var nextName = 0;
function getNextName() {
  // this could use more friendly names
  // but for now just return a number
  return nextName++;
}

var map = [
 [0, 0, 0, 0, 0, 0, 0],
 [1, 1, 0, 1, 0, 1, 1],
 [0, 1, 0, 1, 0, 0, 0],
 [0, 1, 0, 1, 0, 1, 1],
 [0, 0, 0, 1, 0, 0, 0],
 [1, 0, 0, 1, 1, 1, 1],
 [1, 1, 0, 1, 1, 0, 1],
];

function wrapX(x) {
  if (x &lt; 0) return wrapX(x + map[0].length);
  if (x >= map[0].length) return wrapX(x - map[0].length);
  return x;
}

function wrapY(y) {
  if (y &lt; 0) return wrapY(y + map.length);
  if (y >= map[0].length) return wrapY(y - map.length);
  return y;
}

function sendMapData(viewer) {
  var data = '';
  for (var y = viewer.y-1; y &lt;= viewer.y+1; y += 1) {
    for (var x = viewer.x-1; x &lt;= viewer.x+1; x += 1) {
      if (data != '')
        data += ',';
      data += map[y][x];
    }
  }
  viewer.port.postMessage('map ' + data);
}

var viewers = {};
onconnect = function (event) {
  event.port._name = getNextName();
  event.port._data = { port: event.port, x: 0, y: 0, };
  viewers[event.port._name] = event.port._data;
  event.port.postMessage('cfg ' + name);
  event.port.onmessage = getMessage;
  sendMapData(event.port._data);
};

function getMessage(event) {
  switch (event.message.substr(0, 4)) {
    case 'mov ':
      var direction = event.message.substr(4);
      var dx = 0;
      var dy = 0;
      switch (direction) {
        case 'up': dy = -1; break;
        case 'down': dy = 1; break;
        case 'left': dx = -1; break;
        case 'right': dx = 1; break;
      }
      event.target._data.x = wrapX(event.target._data.x + dx);
      event.target._data.y = wrapY(event.target._data.y + dy);
      sendMapData(event.target._data);
      break;
    case 'set ':
      var value = event.message.substr(4);
      map[event.target._data.y][event.target._data.x] = value;
      for (var viewer in viewers)
        sendMapData(viewers[viewer]);
      break;
    case 'txt ':
      var name = event.target._name;
      var message = event.message.substr(4);
      for (var viewer in viewers)
        viewers[viewer].port.postMessage('txt ' + name + ' ' + message);
      break;
    case 'msg ':
      var party1 = event._data;
      var party2 = viewers[event.message.substr(4).split(' ', 1)];
      if (party2) {
        var channel = new MessageChannel();
        party1.port.postMessage('msg ' + party2.name, channel.port1);
        party2.port.postMessage('msg ' + party1.name, channel.port2);
      }
      break;
  }
}</pre>

  <p><strong>Connecting to multiple pages</strong>. Instead of using the
   <code title=dom-WorkerGlobalScope-port><a href="#port">port</a></code>
   global variable in the worker, the script uses the <code
   title=handler-WorkerGlobalScope-onconnect><a
   href="#onconnect">onconnect</a></code> event listener to listen for
   multiple connections.

  <p><strong>Direct channels</strong>. When the worker receives a "msg"
   message from one viewer naming another viewer, it sets up a direct
   connection between the two, so that the two viewers can communicate
   directly without the worker having to proxy all the messages.

  <p><span class=ja-translation lang=ja><a href="http://www.whatwg.org/demos/workers/multiviewer/page.html">この例をオンラインで見る</a>。</span><h4 id=delegation><span class=secno>1.1.5 </span>Delegation</h4>

  <p><span class=ja-translation lang=ja><em>この節は規定の一部ではありません。</em></span><p>With multicore CPUs becoming prevalent, one way to obtain better
   performance is to split computationally expensive tasks amongst multiple
   workers. In this example, a computationally expensive task that is to be
   performed for every number from 1 to 10,000,000 is farmed out to ten
   subworkers.

  <p>The main page is as follows, it just reports the result:

  <pre>&lt;!DOCTYPE HTML>
&lt;html>
 &lt;head>
  &lt;title>Worker example: One-core computation&lt;/title>
 &lt;/head>
 &lt;body>
  &lt;p>The highest prime number discovered so far is: &lt;output id="result">&lt;/output>&lt;/p>
  &lt;script>
   var worker = createWorker('worker.js');
   worker.port.onmessage = function (event) {
     document.getElementById('result').textContent = event.message;
   };
  &lt;/script>
 &lt;/body>
&lt;/html></pre>

  <p><span class=ja-translation lang=ja>労働者自体は次の通りです。</span><pre>// settings
var num_workers = 10;
var items_per_worker = 1000000;

// start the workers
var result = 0;
var pending_workers = num_workers;
for (var i = 0; i &lt; num_workers; i += 1) {
  var worker = createWorker('core.js');
  worker.port.postMessage(i * items_per_worker);
  worker.port.postMessage((i+1) * items_per_worker);
  worker.port.onmessage = storeResult;
}

// handle the results
function storeResult(event) {
  result += 1*event.message;
  pending_workers -= 1;
  if (pending_workers &lt;= 0)
    port.postMessage(result); // finished!
}</pre>

  <p>It consists of a loop to start the subworkers, and then a handler that
   waits for all the subworkers to respond.

  <p>The subworkers are implemented as follows:

  <pre>var start;
onmessage = getStart;
function getStart(event) {
  start = 1*event.message;
  onmessage = getEnd;
}

var end;
function getEnd(event) {
  end = 1*event.message;
  onmessage = null;
  do();
}

function do() {
  var result = 0;
  for (var i = start; i &lt; end; i += 1) {
    // perform some complex calculation here
    result += 1;
  }
  port.postMessage(result);
}</pre>

  <p>They receive two numbers in two events, perform the computation for the
   range of numbers thus specified, and then report the result back to the
   parent.

  <p><span class=ja-translation lang=ja><a href="http://www.whatwg.org/demos/workers/multicore/page.html">この例をオンラインで見る</a>。</span><h4 id=providing><span class=secno>1.1.6 </span>Providing libraries</h4>

  <p><span class=ja-translation lang=ja><em>この節は規定の一部ではありません。</em></span><p>Suppose that a cryptography library is made available that provides
   three tasks:

  <dl>
   <dt>Generate a public/private key pair

   <dd>Takes a port, on which it will send two messages, first the public key
    and then the private key.

   <dt>Given a plaintext and a public key, return the corresponding
    cyphertext

   <dd>Takes a port, to which any number of messages can be sent, the first
    giving the public key, and the remainder giving the plaintext, each of
    which is encrypted and then sent on that same channel as the cyphertext.
    The user can close the port when it is done encrypting content.

   <dt>Given a cyphertext and a private key, return the corresponding
    plaintext

   <dd>Takes a port, to which any number of messages can be sent, the first
    giving the private key, and the remainder giving the cyphertext, each of
    which is decrypted and then sent on that same channel as the plaintext.
    The user can close the port when it is done decrypting content.
  </dl>

  <p>The library itself is as follows:

  <pre>function handleMessage(e) {
  if (e.message == "genkeys")
    genkeys(e.port);
  else if (e.message == "encrypt")
    encrypt(e.port);
  else if (e.message == "decrypt")
    decrypt(e.port);
}

function genkeys(p) {
  var keys = _generateKeyPair();
  p.postMessage(keys[0]);
  p.postMessage(keys[1]);
}

function encrypt(p) {
  var key, state = 0;
  p.onmessage = function (e) {
    if (state == 0) {
      key = e.message;
      state = 1;
    } else {
      p.postMessage(_encrypt(key, e.message));
    }
  };
}

function decrypt(p) {
  var key, state = 0;
  p.onmessage = function (e) {
    if (state == 0) {
      key = e.message;
      state = 1;
    } else {
      p.postMessage(_decrypt(key, e.message));
    }
  };
}

onconnect = function (e) { e.port.onmessage = handleMessage; }


// the "crypto" functions:

function _generateKeyPair() {
  return [Math.random(), Math.random()];
}

function _encrypt(k, s) {
  return 'encrypted-' + k + ' ' + s;
}

function _decrypt(k, s) {
  return s.substr(s.indexOf(' ')+1);
}</pre>

  <p>Note that the crypto functions here are just stubs and don't do real
   cryptography.

  <p>This library could be used as follows:

  <pre>&lt;!DOCTYPE HTML>
&lt;html>
 &lt;head>
  &lt;title>Worker example: Crypto library&lt;/title>
  &lt;script>
   var crytoLib = createWorker('libcrypto-v1.js'); // or could use 'libcrypto-v2.js'
   function getKeys() {
     var state = 0;
     cryptoLib.port.startConversation("genkeys").onmessage = function (e) {
       if (state == 0)
         document.getElementById('public').value = e.message;
       else if (state == 1)
         document.getElementById('private').value = e.message;
       state += 1;
     };
   }
   function enc() {
     var channel = new MessageChannel();
     cryptoLib.port.postMessage("encrypt", channel.port2);
     channel.port1.postMessage(document.getElementById('public').value);
     channel.port1.postMessage(document.getElementById('input').value);
     port1.onmessage = function (e) {
       document.getElementById('input').value = e.message;
       port1.close();
     };
   }
   function dec() {
     var channel = new MessageChannel();
     cryptoLib.port.postMessage("decrypt", channel.port2);
     channel.port1.postMessage(document.getElementById('private').value);
     channel.port1.postMessage(document.getElementById('input').value);
     port1.onmessage = function (e) {
       document.getElementById('input').value = e.message;
       port1.close();
     };
   }
  &lt;/script>
  &lt;style>
   textarea { display: block; }
  &lt;/style>
 &lt;/head>
 &lt;body onload="getKeys()">
  &lt;fieldset>
   &lt;legend>Keys&lt;/legend>
   &lt;p>&lt;label>Public Key: &lt;textarea id="public">&lt;/label>&lt;/p>
   &lt;p>&lt;label>Private Key: &lt;textarea id="private">&lt;/label>&lt;/p>
  &lt;/fieldset>
  &lt;p>&lt;label>Input: &lt;textarea id="input">&lt;/label>&lt;/p>
  &lt;p>&lt;button onclick="enc()">Encrypt&lt;/button> &lt;button onclick="dec()">Decrypt&lt;/button>&lt;/p>
 &lt;/body>
&lt;/html></pre>

  <p>A later version of the API, though, might want to offload all the crypto
   work onto subworkers. This could be done as follows:

  <pre>function handleMessage(e) {
  if (e.message == "genkeys")
    genkeys(e.port);
  else if (e.message == "encrypt")
    encrypt(e.port);
  else if (e.message == "decrypt")
    decrypt(e.port);
}

function genkeys(p) {
  var generator = createWorker('libcrypto-v2-generator.js');
  generator.postMessage('', p);
}

function encrypt(p) {
  p.onmessage = function (e) {
    var key = e.message;
    var encryptor = createWorker('libcrypto-v2-encryptor.js');
    encryptor.postMessage(key, p);
  };
}

function encrypt(p) {
  p.onmessage = function (e) {
    var key = e.message;
    var decryptor = createWorker('libcrypto-v2-decryptor.js');
    decryptor.postMessage(key, p);
  };
}

onconnect = function (e) { e.port.onmessage = handleMessage; }
</pre>

  <p>The little subworkers would then be as follows.

  <p>For generating key pairs:

  <pre>port.onmessage = function (e) {
  e.port.postMessage(Math.random());
  e.port.postMessage(Math.random());
  close();
}
</pre>

  <p>For encrypting:

  <pre>port.onmessage = function (e) {
  var key = e.message;
  e.port.onmessage = function (e) {
    var s = e.message;
    port.postMessage('encrypted-' + key + ' ' + s);
  }
  e.port.onunload = function (e) {
    close();
  }
}</pre>

  <p>For decrypting:

  <pre>port.onmessage = function (e) {
  var key = e.message;
  e.port.onmessage = function (e) {
    var s = e.message;
    port.postMessage(s.substr(s.indexOf(' ')+1));
  }
  e.port.onunload = function (e) {
    close();
  }
}</pre>

  <p>Notice how the users of the API don't have to even know that this is
   happening &mdash; the API hasn't changed; the library can delegate to
   subworkers without changing its API, even though it is accepting data
   using message channels.

  <p><span class=ja-translation lang=ja><a href="http://www.whatwg.org/demos/workers/crypto/page.html">この例をオンラインで見る</a>。</span><h4 id=granting><span class=secno>1.1.7 </span>Granting capabilities</h4>

  <p><span class=ja-translation lang=ja><em>この節は規定の一部ではありません。</em></span><p class=big-issue>...

  <h3 id=conformance><span class=ja-translation lang=ja><span class=secno>1.2 </span>適合性要件</span></h3>

  <p><span class=ja-translation lang=ja>この仕様書のすべての図、例示、注意書き、ならびに規定の一部ではないと明記したすべての節は、
規定の一部ではありません。
この仕様書のそれ以外の部分はすべて規定の一部です。</span><p><span class=ja-translation lang=ja>この文書の規定の部分にあるキーワード「<em class=rfc2119 title="MUST">しなければなりません</em>」、
「<em class=rfc2119 title="MUST NOT">してはなりません</em>」、
「<em class=rfc2119 title="REQUIRED">必須です</em>」、<!--"SHALL", "SHALL
  NOT",-->「<em class=rfc2119 title="SHOULD">するべきです</em>」、
「<em class=rfc2119 title="SHOULD NOT">するべきではありません</em>」、
「<em class=rfc2119 title="RECOMMENDED">推奨します</em>」、「<em class=rfc2119 title="MAY">して構いません</em>」、
「<em class=rfc2119 title="OPTIONAL">任意です</em>」は、 RFC 2119 で説明されているように解釈します。
この仕様書<ins class=ja-note>の原文</ins>では、
可読性の観点から、
これらの語<ins class=ja-note>の原語</ins>のすべて大文字による表記は行っていません。
<a href="#refsRFC2119">[RFC2119]</a></span></p>
  <!-- XXX but they should be
  marked up -->

  <p><span class=ja-translation lang=ja>算法の一部として<ins class=ja-note>動作の指示の形で (原文では</ins>命令形で<ins class=ja-note>) </ins>記述された要件
(例えば「先頭の間隔文字をすべて除去します」や「偽を返し、これらの段階を停止します」)
は、算法を紹介するに当たって使われたキーワード (<em class=rfc2119 title="MUST">しなければなりません</em>、
<em class=rfc2119 title="SHOULD">するべきです</em>、<em class=rfc2119 title="MAY">して構いません</em>など) の意味により解釈します。</span><p><span class=ja-translation lang=ja>いくつかの適合性要件は属性やメソッドやオブジェクトの要件として説明されています。
そのような要件は、利用者エージェントに関する要件として解釈します。</span><p><span class=ja-translation lang=ja>算法や特定の段階として説明されている適合性要件は、
最終的な結果が等価である限り、任意の方法で実装して<em class=rfc2119 title="MAY">構いません</em>。
(特に、この仕様書で定義されている算法は追うのを簡単にしており、
高性能であることを目指してはいません。)</span><p><span class=ja-translation lang=ja>この仕様書で定義する唯一の適合性の級は利用者エージェントです。</span><p><span class=ja-translation lang=ja>利用者エージェントは、サービス拒否攻撃を防ぐため、
記憶容量を使い尽くすことを防ぐため、
あるいは環境特有の制限に対応するためなどの目的で、
別段の制約のない入力に対して実装特有の制限を設けて<em class=rfc2119 title="MAY">構いません</em>。</span><h4 id=dependencies><span class=ja-translation lang=ja><span class=secno>1.2.1 </span>依存性</span></h4>

  <p><span class=ja-translation lang=ja>この仕様書は、他のいくつかの下位の仕様書に依存しています。</span><dl>
   <dt>HTML5

   <dd>
    <p><span class=ja-translation lang=ja>この仕様書では、 HTML5 の多くの基礎的な概念を使用します。
<a href="#refsHTML5">[HTML5]</a></span></p>

   <dt>ECMAScript

   <dd>
    <p><span class=ja-translation lang=ja>この仕様書は、スクリプト言語として JavaScript
を使うことを想定しています。 <a href="#refsJS">[JS]</a></span></p>

   <dt>WebIDL

   <dd>
    <p><span class=ja-translation lang=ja>この仕様書の IDL ブロックは、WebIDL 仕様書における意味を用います。 <a href="#refsWebIDL">[WebIDL]</a></span></p>
  </dl>

  <h3 id=terminology><span class=ja-translation lang=ja><span class=secno>1.3 </span>用語</span></h3>

  <p><span class=ja-translation lang=ja>簡単のため、文書が利用者に対してレンダリングされる方法に言及する時に<em>示す</em>、
<em>表示する</em>、<em>可視</em>などの用語を使うことがあります。
このような用語は特に視覚媒体を暗示しているわけではありません。
他の媒体であってもこれらの用語が等価な方法で適用されるものと考えなければ<em class=rfc2119 title="MUST">なりません</em>。</span><p><span class=ja-translation lang=ja>「<code title="">Foo</code> オブジェクト」という構文 (<code title="">Foo</code>
は実際には界面) を時々使いますが、より正確な「界面 <code title="">Foo</code>
を実装しているオブジェクト」の代わりに用いています。</span><p><span class=ja-translation lang=ja>DOM という語は、 Web アプリケーションでスクリプトに利用可能とされている API
の集合を指して用い、必ずしも DOM 中核仕様書で定義されている実際の 
<code>Document</code> オブジェクトその他の <code>Node</code>
オブジェクトの存在を暗示してはいません。<a
   href="#refsDOM3CORE">[DOM3CORE]</a></span><p><span class=ja-translation lang=ja>DOM 属性は、その値が (例えば著者のスクリプトにより) 取り出される時<em>取得される</em>といい、
新しい値がその属性に割り当てられる時<em>設定される</em>といいます。</span><p><span class=ja-translation lang=ja>DOM オブジェクトが<dfn id=live>生きている</dfn>という場合、
そのオブジェクトを返す属性は常に同じオブジェクトを返さなければ<em class=rfc2119 title="MUST">ならない</em>
(毎回新しいオブジェクトを返すのではなく) 上に、
そのオブジェクトの属性やメソッドがそのオブジェクトの裏にある実際のデータのスナップ写真ではなく、
データそのものに対して操作されなければ<em class=rfc2119 title="MUST">ならない</em>ことを意味します。</span><h2 id=infrastructure><span class=ja-translation lang=ja><span class=secno>2. </span>基盤</span></h2>

  <h3 id=the-workerglobalscope><span class=ja-translation lang=ja><span class=secno>2.1 </span><code><a href="#workerglobalscope">WorkerGlobalScope</a></code> 界面</span></h3>

  <pre
   class=idl>[NoInterfaceObject] interface <dfn id=workerglobalscope>WorkerGlobalScope</dfn> {
  // core worker features
  readonly attribute <a href="#workerglobalscope">WorkerGlobalScope</a> <a href="#self" title=dom-WorkerGlobalScope-self>self</a>;
  readonly attribute <a href="#workerlocation">WorkerLocation</a> <a href="#location" title=dom-WorkerGlobalScope-location>location</a>;
  readonly attribute DOMString <a href="#name" title=dom-WorkerGlobalScope-name>name</a>;
  readonly attribute boolean <a href="#closing" title=dom-WorkerGlobalScope-closing>closing</a>;
  void <a href="#close" title=dom-WorkerGlobalScope-close>close</a>();

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

  <p>Objects implementing the <code><a
   href="#workerglobalscope">WorkerGlobalScope</a></code> interface must also
   implement the <code>EventTarget</code> interface.

  <p>The <dfn id=self
   title=dom-WorkerGlobalScope-self><code>self</code></dfn> attribute must
   return the <code><a href="#workerglobalscope">WorkerGlobalScope</a></code>
   object itself.

  <p>The <dfn id=location
   title=dom-WorkerGlobalScope-location><code>location</code></dfn> attribute
   must return the <code><a href="#workerlocation">WorkerLocation</a></code>
   object created for the <code><a
   href="#workerglobalscope">WorkerGlobalScope</a></code> object when the
   worker was created. It represents the <span>absolute URL</span> of the
   script that was used to initialize the worker.

  <p>The <dfn id=name
   title=dom-WorkerGlobalScope-name><code>name</code></dfn> attribute must
   return the value it was assigned when the <code><a
   href="#workerglobalscope">WorkerGlobalScope</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-WorkerFactory-createSharedWorker><a
   href="#createsharedworker">createSharedWorker()</a></code> method.

  <p>The <dfn id=closing
   title=dom-WorkerGlobalScope-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="#workerglobalscope">WorkerGlobalScope</a></code> interface:

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

   <dd>
    <p><span class=ja-translation lang=ja><code title=event-WorkerGlobalScope-connect>connect</code> 事象が当該 <code><a href="#workerglobalscope">WorkerGlobalScope</a></code> オブジェクトを対象としているか、泡立って当該オブジェクトを通過する時に、
呼び出されなければなりません。</span><dt><dfn id=onunload
    title=handler-WorkerGlobalScope-onunload><code>onunload</code></dfn>

   <dd>
    <p><span class=ja-translation lang=ja><code title=event-unload>unload</code> 事象が当該 <code><a href="#workerglobalscope">WorkerGlobalScope</a></code> オブジェクトを対象としているか、泡立って当該オブジェクトを通過する時に、
呼び出されなければなりません。</span></dl>

  <p>In addition to the above members, the <a href="#success" title="worker
   creation succeeded">worker creation success steps</a> add a <dfn id=port
   title=dom-WorkerGlobalScope-port><code>port</code></dfn> property to the
   object.

  <h3 id=base-urls><span class=ja-translation lang=ja><span class=secno>2.2 </span>労働者の基底 URL と起源</span></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 that the worker's <code
   title=dom-WorkerGlobalScope-location><a
   href="#location">location</a></code> attribute represents.

  <p>Both the <span>origin</span> and <span>effective script origin</span> of
   scripts running in workers are the <span>origin</span> of the
   <span>absolute URL</span> given that the worker's <code
   title=dom-WorkerGlobalScope-location><a
   href="#location">location</a></code> attribute represents.

  <h3 id=the-queue><span class=ja-translation lang=ja><span class=secno>2.3 </span>事象の待ち行列</span></h3>

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

  <p><span class=ja-translation lang=ja>待ち行列中の事象は、 DOM 事象か小休止呼び戻しのいずれかです。</span><p><span class=ja-translation lang=ja>労働者中で呼び出しまたは発送されるすべての非同期の呼び戻しと事象は、
労働者の待ち行列に追加されなければなりません。
ただし、実際の呼び戻しの呼び出しや事象の発送は、後述の「<a
   href="#run-a">労働者を走らせる</a>」処理モデルに従い処理されます。</span><p>Once the <code><a
   href="#workerglobalscope">WorkerGlobalScope</a></code>'s <code
   title=dom-WorkerGlobalScope-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-WorkerGlobalScope-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=ja-translation lang=ja><span class=secno>2.4 </span>労働者のポート</span></h3>

  <p><span class=ja-translation lang=ja>労働者は、メッセージ通信路とその <code>MessagePort</code>
オブジェクトを通じて、他の労働者や閲覧文脈と通信します。</span><p>Each <code><a href="#workerglobalscope">WorkerGlobalScope</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
   owned by <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=permissible>permissible worker</dfn> if
   either:

  <ul>
   <li>at some point past or present a <code>MessagePort</code> owned by the
    worker was entangled with a <code>MessagePort</code> <var
    title="">p</var> whose owner is a <code>Window</code> object whose
    <span>active document</span> is the <code>Document</code> that was that
    <span>browsing context</span>'s <span>active document</span> when <var
    title="">p</var> was created, and that <code>Document</code> is
    <span>fully active</span>, or

   <li>at some point past or present a <code>MessagePort</code> owned by the
    worker was entangled with a <code>MessagePort</code> owned by another
    worker that is currently a <a href="#permissible">permissible worker</a>.
  </ul>

  <hr>

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

  <ul>
   <li>it has outstanding timers, database transactions, or network
    connections, and is a <a href="#permissible">permissible worker</a>, or:

   <li>there is a <a href="#protected">protected worker</a> that at some
    point past or present owned a <code>MessagePort</code> that was entangled
    with a <code>MessagePort</code> owned by this worker.
  </ul>

  <hr>

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

  <ul>
   <li>the worker is a <a href="#protected">protected worker</a>, or

   <li>at least one of the <a href="#the-workers0">the worker's ports</a> is
    entangled with a <code>MessagePort</code> <var title="">p</var> whose
    owner is a <code>Window</code> object whose <span>active document</span>
    is the <code>Document</code> that was that <span>browsing
    context</span>'s <span>active document</span> when that
    <code>MessagePort</code> <var title="">p</var> was created, and that
    <code>Document</code> is <span>fully active</span>, or

   <li>at least one of the <a href="#the-workers0">the worker's ports</a> has
    an entangled <code>MessagePort</code> owned by a <code><a
    href="#workerglobalscope">WorkerGlobalScope</a></code> object that is
    itself an <a href="#active">active needed worker</a>.
  </ul>

  <hr>

  <p>A worker is said to be a <dfn id=suspendable>suspendable worker</dfn> if
   it is not an <a href="#active">active needed worker</a> but either:

  <ul>
   <li>at least one of the <a href="#the-workers0">the worker's ports</a> has
    an entangled <code>MessagePort</code> owned by a <code>Window</code>
    object, or

   <li>at least one of the <a href="#the-workers0">the worker's ports</a> has
    an entangled <code>MessagePort</code> owned by a <code><a
    href="#workerglobalscope">WorkerGlobalScope</a></code> object that is
    itself a <span>needed worker</span>.
  </ul>

  <h3 id=processing><span class=ja-translation lang=ja><span class=secno>2.5 </span>処理モデル</span></h3>

  <p><span class=ja-translation lang=ja>利用者エージェントが、<span>URL</span> <var
   title="">url</var>、閲覧文脈 <var title="">owner browsing
   context</var>、<code>Document</code> <var title="">owner
   document</var> のスクリプトに対する、 <var
   title="">name</var> と名付けられた<dfn id=run-a>労働者を走らせる</dfn>、
という時には、利用者エージェントは、次の段階を、完全に分離された並列実行環境で実行しなければ<em class=rfc2119 title="MUST">なりません</em>。</span><ol>
   <li>
    <p><span class=ja-translation lang=ja><var title="">url</var> で識別される資源を取って来ようと試みます。</span></p>

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

    <p><span class=ja-translation lang=ja>この試みが成功した場合、 <var title="">script</var>
を得られた資源とします。</span></p>

    <p class=note><span class=ja-translation lang=ja><code>script</code> 要素と同様に、スクリプトの MIME 型は無視します。
<code>script</code> 要素とは異なり、
型を上書きする方法はありません。スクリプトは常に JavaScript
と仮定します。</span></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="#workerglobalscope">WorkerGlobalScope</a></code> object, <var
     title="">worker</var>.</p>

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

   <li>
    <p>Create a new <code><a href="#workerlocation">WorkerLocation</a></code>
     object for the <code title=dom-WorkerGlobalScope-location><a
     href="#location">location</a></code> attribute of <var
     title="">worker</var>, representing <var title="">url</var>.</p>

   <li>
    <p><span class=ja-translation lang=ja><var title="">script</var> のスクリプト実行文脈を (ひいては大域オブジェクトをも)
<var
     title="">worker</var> とします。</span></p>

   <li>
    <p><span class=ja-translation lang=ja><var title="">script</var> のスクリプト閲覧文脈を <var title="">owner browsing context</var>
とします。</span></p>

   <li>
    <p><span class=ja-translation lang=ja><var title="">script</var> のスクリプト文書文脈を <var title="">owner document</var>
とします。</span></p>

   <li>
    <p><span class=ja-translation lang=ja>この段階を呼び出す算法が定義する<a href="#success" title="worker creation
     succeeded">成功段階</a>を呼び出します。</span></p>

    <p class=note>This will usually add an event to the <a
     href="#queue">queue of events</a> and set the <code
     title=dom-WorkerGlobalScope-port><a href="#port">port</a></code>
     property on the <var title="">worker</var> object. 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-WorkerGlobalScope-closing><a
     href="#closing">closing</a></code> attribute to true.</p>

   <li>
    <p><strong>Closing orphan workers</strong>: Start monitoring <var
     title="">worker</var>, such that as soon as the worker stops being
     either an <a href="#active">active needed worker</a> or a <a
     href="#suspendable">suspendable worker</a>, the <var
     title="">worker</var> object's <code
     title=dom-WorkerGlobalScope-closing><a
     href="#closing">closing</a></code> attribute is set to true and an event
     named <code title=event-unload>unload</code>, which uses the
     <code>Event</code> object, which does not bubble, and which is not
     cancelable, is added it to the worker's <code><a
     href="#workerglobalscope">WorkerGlobalScope</a></code> object's <a
     href="#queue">queue of events</a>, targetted at the <code><a
     href="#workerglobalscope">WorkerGlobalScope</a></code> object.</p>

   <li>
    <p><strong>Suspending workers</strong>: Start monitoring <var
     title="">worker</var>, such that whenever the <var title="">worker</var>
     object's <code title=dom-WorkerGlobalScope-closing><a
     href="#closing">closing</a></code> attribute is false and the worker is
     a <a href="#suspendable">suspendable worker</a>, the user agent suspends
     execution of script in that worker until such time as either the <code
     title=dom-WorkerGlobalScope-closing><a
     href="#closing">closing</a></code> attribute switches to true or the
     worker stops being a <a href="#suspendable">suspendable worker</a>.</p>

   <li>
    <p><span class=ja-translation lang=ja><var title="">script</var> を、返るか、例外の捕獲に失敗するか、後述の「<a href="#kill-a">労働者を殺す</a>」算法により早々に停止させられるかのいずれかまで走らせます。</span></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.</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-WorkerGlobalScope-closing><a
     href="#closing">closing</a></code> attribute is set to true.</p>

   <li>
    <p><span class=ja-translation lang=ja><a href="#queue">事象の待ち行列</a>中で最古の事象か呼び戻しがあれば、
これを発送します。この事象の取扱いや呼び戻しの実行は、後述の「<a href="#kill-a">労働者を殺す</a>」
算法により、早々に停止させられるかもしれません。</span></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-WorkerGlobalScope-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 unentangled</p>

   <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 any <code><a
     href="#worker1">Worker</a></code> objects associated with this worker.</p>
  </ol>

  <hr>

  <p><span class=ja-translation lang=ja>利用者エージェントが<dfn id=kill-a>労働者を殺す</dfn>という時には、
利用者エージェントは、次の段階を労働者の主たるループ (先に定義した「<a
   href="#run-a">労働者を走らせる</a>」処理モデル) と並列に走らせなければ<em class=rfc2119 title="MUST">なりません</em>。</span><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="#workerglobalscope">WorkerGlobalScope</a></code> object's <a
     href="#queue">queue of events</a>, targetted at the <code><a
     href="#workerglobalscope">WorkerGlobalScope</a></code> object itself.
   </li>
   <!-- XXX shouldn't add one if closing is
   already true, assuming unload has already been added to the queue
   (?) -->

   <li>
    <p>Set the worker's <code><a
     href="#workerglobalscope">WorkerGlobalScope</a></code> object's <code
     title=dom-WorkerGlobalScope-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 the <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><span class=ja-translation lang=ja><a href="#queue">事象の待ち行列</a>中にこの算法が追加した 
<code title=event-unload>unload</code>
事象以外の事象が存在する場合には、それらを発送せずに捨てます。</span><li>
    <p><span class=ja-translation lang=ja>この算法が追加した <code title=event-unload>unload</code>
事象がまだ発送されていなければ、現在労働者中で走っているスクリプトを停止します。</span><li>
    <p><span class=ja-translation lang=ja>利用者エージェント定義の時間、待ちます。</span><li>
    <p><span class=ja-translation lang=ja>現在労働者中で走っているスクリプト (スクリプトが走っているとすると、
これは <code
     title=event-unload>unload</code>
事象の取扱器です。) を停止します。</span></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 an <a href="#active">active needed worker</a> if the worker
   continues executing even after its <code
   title=dom-WorkerGlobalScope-closing><a href="#closing">closing</a></code>
   attribute was set to true.

  <hr>

  <p>When a script invokes the <dfn id=close
   title=dom-WorkerGlobalScope-close><code>close()</code></dfn> method on a
   <code><a href="#workerglobalscope">WorkerGlobalScope</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="#workerglobalscope">WorkerGlobalScope</a></code> object's <a
     href="#queue">queue of events</a>, targetted at the <code><a
     href="#workerglobalscope">WorkerGlobalScope</a></code> object itself.

   <li>
    <p>Set the worker's <code><a
     href="#workerglobalscope">WorkerGlobalScope</a></code> object's <code
     title=dom-WorkerGlobalScope-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 owner is the
     <code><a href="#workerglobalscope">WorkerGlobalScope</a></code> object
     on which the method was invoked, run the following substeps:</p>

    <ol>
     <li>
      <p><span class=ja-translation lang=ja>2つのポートをほどきます。</span><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 owner is not the <code><a
       href="#workerglobalscope">WorkerGlobalScope</a></code> object on which
       the <code title=dom-WorkerGlobalScope-close><a
       href="#close">close()</a></code> method was called).
    </ol>
  </ol>

  <h3 id=creating><span class=ja-translation lang=ja><span class=secno>2.6 </span>労働者の作成</span></h3>

  <pre
   class=idl>[NoInterfaceObject] interface <dfn id=workerfactory>WorkerFactory</dfn> {
  <a href="#worker1">Worker</a> <a href="#createworker" title=dom-WorkerFactory-createWorker>createWorker</a>(in DOMString scriptURL);
  <a href="#worker1">Worker</a> <a href="#createsharedworker" title=dom-WorkerFactory-createSharedWorker>createSharedWorker</a>(in DOMString name, in DOMString scriptURL);
};

interface <dfn id=worker1>Worker</dfn> {
  <span>MessagePort</span> <a href="#port0" title=dom-Worker-port>port</a>();

  // event handler attributes
           attribute <span>EventListener</span> <a href="#onload" title=handler-Worker-onload>onload</a>;
           attribute <span>EventListener</span> <a href="#onerror" title=handler-Worker-onerror>onerror</a>;
           attribute <span>EventListener</span> <a href="#onunload0" title=handler-Worker-onunload>onunload</a>;
};</pre>

  <p>Objects that implement the <code>Window</code> and <code><a
   href="#workerglobalscope">WorkerGlobalScope</a></code> interfaces must
   also implement the <code><a href="#workerfactory">WorkerFactory</a></code>
   interface.

  <hr>

  <p><span class=ja-translation lang=ja>利用者エージェントは、 <dfn id=createworker title=dom-WorkerFactory-createWorker><code>createWorker(<var title="">scriptURL</var>)</code></dfn> メソッドが呼び出された時、
次の段階を走らせなければ<em class=rfc2119 title="MUST">なりません</em>。</span><ol>
   <li>
    <p><span class=ja-translation lang=ja><var
     title="">scriptURL</var> 引数を<span title="resolve a url">解決</span>します。</span><li>
    <p><span class=ja-translation lang=ja>これが失敗した場合、 <code>SYNTAX_ERR</code>
例外を投げます。</span><li>
    <p><span class=ja-translation lang=ja>得られた絶対 URL の起源がメソッドを呼び出したスクリプトの起源と<span title="same origin">同じ</span>でない場合、
保安性例外を投げます。</span><li>
    <p><span class=ja-translation lang=ja>得られた絶対 URL から、名前が空文字列である<a href="#create">労働者を作成</a>します。</span><li>
    <p>Return the <code><a href="#worker1">Worker</a></code> object returned
     from the <a href="#create">create a worker</a> algorithm.
  </ol>

  <hr>

  <p><span class=ja-translation lang=ja>利用者エージェントは、 <dfn id=createsharedworker title=dom-WorkerFactory-createSharedWorker><code>createSharedWorker(<var title="">name</var>, <var title="">scriptURL</var>)</code></dfn> メソッドが呼び出された時、
次の段階を走らせなければ<em class=rfc2119 title="MUST">なりません</em>。</span><ol>
   <li>
    <p><span class=ja-translation lang=ja><var
     title="">scriptURL</var> 引数を<span title="resolve a url">解決</span>します。</span><li>
    <p><span class=ja-translation lang=ja>これが失敗した場合、 <code>SYNTAX_ERR</code>
例外を投げます。</span><li>
    <p><span class=ja-translation lang=ja>得られた絶対 URL の起源がメソッドを呼び出したスクリプトの起源と<span title="same origin">同じ</span>でない場合、
保安性例外を投げます。</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><a
     href="#worker1">Worker</a></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-WorkerGlobalScope-closing><a
     href="#closing">closing</a></code> attribute is false, whose <code
     title=dom-WorkerGlobalScope-name><a href="#name">name</a></code>
     attribute is exactly equal to the <var title="">name</var> argument, and
     whose <code title=dom-WorkerGlobalScope-location><a
     href="#location">location</a></code> attribute represents an
     <span>absolute URL</span> that 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-WorkerGlobalScope-location><a
       href="#location">location</a></code> attribute represents an
       <span>absolute URL</span> that 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 21</span>

     <li>
      <p><span class=ja-translation lang=ja>メソッドを呼び出したスクリプトのスクリプト実行文脈が所有する新しい <code>MessagePort</code>
オブジェクトを作成します。</span><li>
      <p><span>Create a new <code><a href="#worker1">Worker</a></code>
       object</span> associated with that worker, and assign the newly
       created port to its <code title=dom-Worker-port><a
       href="#port0">port</a></code> attribute.

     <li>
      <p>Return the newly created <code><a href="#worker1">Worker</a></code>
       object.

     <li>
      <p>Asynchronously, <a href="#connect" title="connect to a
       worker">connect</a> to this preexisting worker, with the newly created
       <code>MessagePort</code> and <code><a
       href="#worker1">Worker</a></code> objects.
    </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><a
     href="#worker1">Worker</a></code> object returned from the <a
     href="#create">create a worker</a> algorithm.</p>
  </ol>

  <hr>

  <p><span class=ja-translation lang=ja>メソッド呼び出しの文脈において、 URL <var title="">url</var> から名前 <var
   title="">name</var> の<dfn id=create>労働者を作成</dfn>する段階は、次の通りです。</span><ol>
   <li>
    <p><span class=ja-translation lang=ja>メソッドを呼び出したスクリプトのスクリプト実行文脈が所有する新しい <code>MessagePort</code>
オブジェクトを作成します。</span><li>
    <p><span>Create a new <code><a href="#worker1">Worker</a></code>
     object</span>, associated with the worker that will be created below,
     and assign the newly created port to its <code title=dom-Worker-port><a
     href="#port0">port</a></code> attribute.

   <li>
    <p>Return that <code><a href="#worker1">Worker</a></code> object.

   <li>
    <p><span class=ja-translation lang=ja>並列実行文脈において (つまり、別のスレッドやプロセスや同様の構造において)、 <var title="">owner browsing
     context</var> をメソッドを呼び出したスクリプトのスクリプト閲覧文脈、 <var title="">owner
     document</var> をメソッドを呼び出したスクリプトのスクリプト文書文脈として、
URL 
<var
     title="">url</var> のスクリプトのための <var
     title="">name</var> という名前の<a href="#run-a">労働者を走らせます</a>。</span></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, and if that algorithm returns a second new port,
     then add a new property <code title=dom-WorkerGlobalScope-port><a
     href="#port">port</a></code> on the new worker's <code><a
     href="#workerglobalscope">WorkerGlobalScope</a></code> object, whose
     value is the <code>MessagePort</code> object returned by the <a
     href="#connect">connect to a worker</a> algorithm.</p>

    <p>Otherwise, if the <dfn id=worker2>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 <code><a
     href="#worker1">Worker</a></code> object.</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> and a <code><a
   href="#worker1">Worker</a></code> object <var title="">worker</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 owner 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="#workerglobalscope">WorkerGlobalScope</a></code> of the
     worker.

   <li>
    <p><span class=ja-translation lang=ja>この新しく作成されたポートとこれらの段階に渡されたポート <var
     title="">port</var> を絡めます。</span><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="">worker</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="#workerglobalscope">WorkerGlobalScope</a></code> object's <a
     href="#queue">queue of events</a>, targetted at the <code><a
     href="#workerglobalscope">WorkerGlobalScope</a></code> object itself.

   <li>
    <p>Return the newly created port.
  </ol>

  <hr>

  <p><span class=ja-translation lang=ja><dfn id=port0 title=dom-Worker-port><code>port</code></dfn> attribute on a <code><a href="#worker1">Worker</a></code> object must return the value it was assigned when the <code><a href="#worker1">Worker</a></code> object was created by the methods on the <code><a href="#workerfactory">WorkerFactory</a></code> 界面。</span><p>The following are the <span>event handler DOM attributes</span> that
   must be supported by objects implementing the <code><a
   href="#worker1">Worker</a></code> interface:

  <dl>
   <dt><dfn id=onload title=handler-Worker-onload><code>onload</code></dfn>

   <dd>
    <p><span class=ja-translation lang=ja><code title=event-load>load</code> 事象が当該 <code><a href="#worker1">Worker</a></code> オブジェクトを対象としているか、泡立って当該オブジェクトを通過する時に、
呼び出されなければなりません。</span><dt><dfn id=onerror
    title=handler-Worker-onerror><code>onerror</code></dfn>

   <dd>
    <p>Must be invoked whenever an <code title=event-error>error</code> event
     is targeted at or bubbles through the <code><a
     href="#worker1">Worker</a></code> object.

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

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

  <h2 id=apis-available><span class=ja-translation lang=ja><span class=secno>3. </span>労働者が利用可能な API</span></h2>

  <pre
   class=idl>[NoInterfaceObject] interface <dfn id=workerutils>WorkerUtils</dfn> {
  void <a href="#importscripts" title=dom-WorkerGlobalScope-importScripts>importScripts</a>([Variadic] in DOMString urls);
  readonly attribute <span>Storage</span> <a href="#localstorage" title=dom-localStorage>localStorage</a>;
  <span>Database</span> <a href="#opendatabase" title=dom-opendatabase>openDatabase</a>(in DOMString name, in DOMString version, in DOMString displayName, in unsigned long estimatedSize);
  void <a href="#shownotification" title=dom-showNotification>showNotification</a>(in DOMString title, in DOMString subtitle, in DOMString description);
  void <a href="#shownotification" title=dom-showNotification>showNotification</a>(in DOMString title, in DOMString subtitle, in DOMString description, in VoidCallback onclick);
};</pre>

  <p><span class=ja-translation lang=ja><code><a href="#workerglobalscope">WorkerGlobalScope</a></code> 界面を実装するオブジェクトは、 <code><a href="#workerutils">WorkerUtils</a></code> 界面も実装しなければ<em class=rfc2119 title="MUST">なりません</em>。</span><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><span class=ja-translation lang=ja>DOM API (<code>Node</code> オブジェクト、 <code>Document</code>
オブジェクト、その他) は、この版のこの仕様書では労働者に利用可能ではありません。</span><h3 id=importing><span class=secno>3.1 </span>Importing scripts and
   libraries</h3>

  <p>When a script invokes the <dfn id=importscripts
   title=dom-WorkerGlobalScope-importScripts><code>importScripts(<var
   title="">urls</var>)</code></dfn> method on a <code><a
   href="#workerglobalscope">WorkerGlobalScope</a></code> object, the user
   agent must run the following steps:

  <ol>
   <li>
    <p>If there are no arguments, return without doing anything. Abort these
     steps.

   <li>
    <p><span title="resolve a url">Resolve</span> each argument.

   <li>
    <p>If any fail, throw a <code>SYNTAX_ERR</code> exception.

   <li>
    <p>If any of the resulting <span title="absolute URL">absolute
     URLs</span> have an <span>origin</span> that 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> each resource identified by the
     resulting <span title="absolute URLs">absolute URL</span>.</p>

   <li>
    <p>For each argument in turn, in the order given, starting with the first
     one, run these substeps:</p>

    <ol>
     <li>
      <p>Wait for the fetching attempt for the corresponding resource to
       complete.</p>

      <p>If the fetching attempt failed, throw a <code>NETWORK_ERR</code>
       exception and abort all these steps. <a
       href="#refsXHR">[XHR]</a><!-- XXX get DOM Core updated instead
      --></p>

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

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

     <li>
      <p><span class=ja-translation lang=ja><var title="">script</var> の<span>スクリプト実行文脈</span>、
<span>スクリプト閲覧文脈</span>、<span>スクリプト文書文脈</span>を、
この労働者についての<a href="#run-a">労働者を走らせる</a>処理モデルで実行されたスクリプトについてのものと同じとします。</span></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 above.</p>

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

      <p>If the "<a href="#kill-a">kill a worker</a>" algorithm aborts the
       script then abort all these steps.</p>
    </ol>
  </ol>

  <h3 id=apis-defined><span class=secno>3.2 </span>APIs defined in other
   specifications</h3>

  <p>The <dfn id=localstorage
   title=dom-localStorage><code>localStorage</code></dfn>, <dfn
   id=opendatabase title=dom-opendatabase><code>openDatabase()</code></dfn>
   must act as defined for the APIs with the same names on the
   <code>Window</code> object in the HTML5 specification, with the exception
   that where the API would use the <span>origin</span> of the <span>active
   document</span> of the <span>browsing context</span> of the
   <code>Window</code> object on which the method was supposedly invoked, it
   must instead use the <span>origin</span> of the script that invoked the
   method. <a href="#refsHTML5">[HTML5]</a>

  <p>The <dfn id=shownotification
   title=dom-showNotification><code>showNotification()</code></dfn> methods
   must act as defined for the APIs with the same names on the
   <code>Window</code> object in the HTML5 specification. <a
   href="#refsHTML5">[HTML5]</a>

  <h3 id=interface><span class=secno>3.3 </span>Interface objects and
   constructors</h3>

  <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="#workerglobalscope">WorkerGlobalScope</a></code> object
   except for the following:

  <ul>
   <li>
    <p><span class=ja-translation lang=ja>XMLHttpRequest 仕様書で定義されている
<code>XMLHttpRequest</code> とすべての界面オブジェクトと構築器、
ただし<span>文書応答実体本体</span>は常に null でなければ<em class=rfc2119 title="MUST">なりません</em>。 <a
     href="#refsXHR">[XHR]</a></span><li>
    <p><span class=ja-translation lang=ja><code>WebSocket</code> 界面オブジェクトと構築器</span><li>
    <p><span class=ja-translation lang=ja><code>MessageChannel</code> 界面オブジェクトと構築器</span></ul>

  <h3 id=worker0><span class=secno>3.4 </span>Worker locations</h3>

  <pre
   class=idl>[NoInterfaceObject] interface <dfn id=workerlocation>WorkerLocation</dfn> {
  readonly attribute DOMString <a href="#href" title=dom-WorkerLocation-href>href</a>;
  readonly attribute DOMString <a href="#protocol" title=dom-WorkerLocation-protocol>protocol</a>;
  readonly attribute DOMString <a href="#host" title=dom-WorkerLocation-host>host</a>;
  readonly attribute DOMString <a href="#hostname" title=dom-WorkerLocation-hostname>hostname</a>;
  readonly attribute DOMString <a href="#port1" title=dom-WorkerLocation-port>port</a>;
  readonly attribute DOMString <a href="#pathname" title=dom-WorkerLocation-pathname>pathname</a>;
  readonly attribute DOMString <a href="#search" title=dom-WorkerLocation-search>search</a>;
  readonly attribute DOMString <a href="#hash" title=dom-WorkerLocation-hash>hash</a>;
};</pre>

  <p>A <code><a href="#workerlocation">WorkerLocation</a></code> object
   represents an <span>absolute URL</span> set at its creation.

  <p>The <dfn id=href title=dom-WorkerLocation-href><code>href</code></dfn>
   attribute must return the <span>absolute URL</span> that the object
   represents.

  <p>The <code><a href="#workerlocation">WorkerLocation</a></code> interface
   also has the complement of <span>URL decomposition attributes</span>, <dfn
   id=protocol title=dom-WorkerLocation-protocol><code>protocol</code></dfn>,
   <dfn id=host title=dom-WorkerLocation-host><code>host</code></dfn>, <dfn
   id=port1 title=dom-WorkerLocation-port><code>port</code></dfn>, <dfn
   id=hostname title=dom-WorkerLocation-hostname><code>hostname</code></dfn>,
   <dfn id=pathname
   title=dom-WorkerLocation-pathname><code>pathname</code></dfn>, <dfn
   id=search title=dom-WorkerLocation-search><code>search</code></dfn>, and
   <dfn id=hash title=dom-WorkerLocation-hash><code>hash</code></dfn>. These
   must follow the rules given for URL decomposition attributes, with the
   <span title=concept-uda-input>input</span> being the <span>absolute
   URL</span> that the object represents (same as the <code
   title=dom-WorkerLocation-href><a href="#href">href</a></code> attribute),
   and the <span title=concept-uda-setter>common setter action</span> being a
   no-op, since the attributes are defined to be readonly. <a
   href="#refsHTML5">[HTML5]</a>

  <h2 class=no-num id=references><span class=ja-translation lang=ja>参考文献</span></h2>

  <p class=big-issue><span class=ja-translation lang=ja>この章は将来の仕様案で執筆します。</span><h2 class=no-num id=acknowledgements><span class=ja-translation lang=ja>謝辞</span></h2>
  <!-- ACKS -->

  <p><span class=ja-translation lang=ja>Aaron Boodman, Jonas Sicking, Maciej Stachowiak, Mike Smith, Philip Taylor の有用かつ重要なコメントに感謝します。</span><p><span class=ja-translation lang=ja>Gears チームの方々にも非常に感謝します。
Gears チームの方々はこの技術を開拓し、その経験はこの仕様書にも多大な影響を与えています。
</span>