<!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").innerHTML = 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>

