Drop NaCl support for posting stdout/stderr to JS.

native_client_sdk/src/doc/devguide/devcycle/debugging.rst

 .. _devcycle-debugging:
 
 #########
 Debugging
 #########
 
 This document describes tools and techniques you can use to debug, monitor,
 and measure your application's performance.
 
 .. contents:: Table Of Contents
@@ skipping 50 matching lines @@
 ===============
 
 Writing messages to the JavaScript console
 ------------------------------------------
 
 You can send messages from your C/C++ code to JavaScript using the 
 ``PostMessage()`` call in the :doc:`Pepper messaging system 
 <../coding/message-system>`. When the JavaScript code receives a message, its 
 message event handler can call `console.log() 
 <https://developer.mozilla.org/en/DOM/console.log>`_ to write the message to the
 JavaScript `console </devtools/docs/console-api>`_ in Chrome's Developer Tools.

[JF, 2014/09/03 15:22:06]

Do we have an example of doing this? It's pretty much the same as the feature
you're removing, but without the helpful example.

[teravest, 2014/09/03 16:58:32]

There are examples of using PostMessage available in the linked document:
  https://developer.chrome.com/native-client/devguide/coding/message-system

But there's not a quick example of doing this for debugging in this document.

[JF, 2014/09/03 17:03:01]

Could you add one? This is a pretty basic functionality for porting code, so
having something that's simply copy/paste-able makes getting started much nicer
for our users IMO.

 
 Debugging with printf
 ---------------------
 
 Your C/C++ code can perform inline printf debugging to stdout and stderr by
 calling fprintf() directly, or by using cover functions like these:
 
 .. naclcode::
 
   #include <stdio.h>
@@ skipping 25 matching lines @@
 * ``NACLLOG=c:\nacl.log``
 
 .. Note::
   :class: note
 
   **Note:** If you set the ``NACL_EXE_STDOUT``, ``NACL_EXE_STDERR``, or
   ``NACLLOG`` variables to redirect output to a file, you must run Chrome with
   the ``--no-sandbox`` flag.  You must also be careful that each variable points
   to a different file.
 
-Redirecting output to the JavaScript console

[Mark Seaborn, 2014/09/03 15:16:39]

The generated HTML is checked in. :-(  You need to run "make chromesite_rst"
from native_client_sdk/src/doc/ to regenerate it.

-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-You can also cause output from printf statements in your C/C++ code to be
-relayed to the JavaScript side of your application through the Pepper messaging
-system, where you can then write the output to the JavaScript console. Follow
-these steps:
-
-#. Set the ``NACL_EXE_STDOUT`` and ``NACL_EXE_STDERR`` environment variables as
-   follows:
-
-   * ``NACL_EXE_STDOUT=DEBUG_ONLY:dev://postmessage``
-   * ``NACL_EXE_STDERR=DEBUG_ONLY:dev://postmessage``
-
-   These settings tell Native Client to use ``PostMessage()`` to send output
-   that your Native Client module writes to stdout and stderr to the JavaScript
-   side of your application.
-
-#. Register a JavaScript handler to receive messages from your Native Client
-   module:
-
-   .. naclcode::
-
-     <div id="nacl_container">
-       <script type="text/javascript">
-         var container = document.getElementById('nacl_container');
-         container.addEventListener('message', handleMessage, true);
-       </script>
-       <embed id="nacl_module"
-              src="my_application.nmf"
-              type="application/x-nacl" />
-     </div>
-
-#. Implement a simple JavaScript handler that logs the messages it receives to
-   the JavaScript console:
-
-   .. naclcode::
-
-     function handleMessage(message_event) {
-       console.log(message_event.data);
-     }
-
-   This handler works in the simple case where the only messages your Native
-   Client module sends to JavaScript are messages with the output from stdout
-   and stderr. If your Native Client module also sends other messages to
-   JavaScript, your handler will need to be more complex.
-
-   Once you've implemented a message handler and set up the environment
-   variables as described above, you can check the JavaScript console to see
-   output that your Native Client module prints to stdout and stderr. Keep in
-   mind that your module makes a call to ``PostMessage()`` every time it flushes
-   stdout or stderr.  Your application's performance will degrade considerably
-   if your module prints and flushes frequently, or if it makes frequent Pepper
-   calls to begin with (e.g., to render).
-
 Logging calls to Pepper interfaces
 ----------------------------------
 
 You can log all Pepper calls your module makes by passing the following flags
 to Chrome on startup::
 
   --vmodule=ppb*=4 --enable-logging=stderr
 
 
 The ``vmodule`` flag tells Chrome to log all calls to C Pepper interfaces that
@@ skipping 414 matching lines @@
 <http://www.chromium.org/nativeclient>`_ that describe how to do profiling on
 `64-bit Windows
 <https://sites.google.com/a/chromium.org/dev/nativeclient/how-tos/profiling-nacl-apps-on-64-bit-windows>`_
 and `Linux
 <http://www.chromium.org/nativeclient/how-tos/limited-profiling-with-oprofile-on-x86-64>`_
 machines.
 
 
 .. |menu-icon| image:: /images/menu-icon.png
 .. |puzzle| image:: /images/puzzle.png