<!DOCTYPE html>
<html>
  <!--
  Copyright (c) 2011 The Chromium Authors. All rights reserved.
  Use of this source code is governed by a BSD-style license that can be
  found in the LICENSE file.

  This example just uses postMessage to tell the plugin to fetch a file.
  The plugin will echo the contents of that file back to us and we'll display
  it on the page.
  -->
<head>
  <title>URLLoader Example</title>
</head>

<body>
  <script>

  function StartRequest() {
    var plugin = document.getElementById("plugin");
    var inputBox = document.getElementById("inputBox");
    plugin.postMessage("go");
  }

  </script>

  <p>This test must be run over HTTP. If you're a Chrome developer, see the
  README_chrome_developer.txt in this directory for how to run.</p>

  <button onclick="StartRequest()">Start request</button>
  <object id="plugin" type="application/x-ppapi-url-loader-example"
          width="1" height="1">
  </object>
  <hr>
  <div id="log_result" style="background-color:#EEE; border:1px solid black;">
  <i>Result will go here...</i>
  </div>

  <script>

  function HandleMessage(message_event) {
    document.getElementById("log_result").textContent = message_event.data;
  }

  // Attach a listener for the message event. This must happen after the plugin
  // object was created.
  var plugin = document.getElementById("plugin");
  plugin.addEventListener("message", HandleMessage, false);

  </script>
</body>
</html>

