Chrome-side change to support stdout/err to postmessage debug hookup.

ppapi/native_client/src/trusted/plugin/service_runtime.cc

 /*
  * 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.
  */
 
 #define NACL_LOG_MODULE_NAME "Plugin::ServiceRuntime"
 
 #include "native_client/src/trusted/plugin/service_runtime.h"
 
@@ skipping 33 matching lines @@
 
 #include "native_client/src/trusted/weak_ref/call_on_main_thread.h"
 
 #include "native_client/src/trusted/service_runtime/nacl_error_code.h"
 #include "native_client/src/trusted/service_runtime/include/sys/nacl_imc_api.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/core.h"
 #include "ppapi/cpp/completion_callback.h"
 
+// This is here due to a Windows API collision.
+#ifdef PostMessage
+#undef PostMessage
+#endif

[dmichael (off chromium), 2011/12/07 19:02:13]

Wouldn't it have worked to just move this above the includes?

I'd like to avoid having this kind of thing in our public API headers if we can.
I think a small style violation (having stuff before the includes) is worth it
in this case.

[bsy, 2011/12/07 21:18:32]

you were looking at an old change set.  this change is now in instance.h.

because of our policy wrt sorting headers and including-what-you-use rather than
requiring users of headers to know header dependencies, do the partial order
sort, and include headers themselves, it was impossible to undef PostMessage
here or even just before the include of instance_private.h from plugin.h.

+
 using std::vector;
 
 namespace plugin {
 
 PluginReverseInterface::PluginReverseInterface(
     nacl::WeakRefAnchor* anchor,
     Plugin* plugin,
     ServiceRuntime* service_runtime,
     pp::CompletionCallback init_done_cb,
     pp::CompletionCallback crash_cb)
@@ skipping 26 matching lines @@
   CHECK(continuation != NULL);
   NaClLog(4, "PluginReverseInterface::Log(%s)\n", message.c_str());
   plugin::WeakRefCallOnMainThread(
       anchor_,
       0,  /* delay in ms */
       ALLOW_THIS_IN_INITIALIZER_LIST(this),
       &plugin::PluginReverseInterface::Log_MainThreadContinuation,
       continuation);
 }
 
+void PluginReverseInterface::DoPostMessage(nacl::string message) {
+  PostMessageResource* continuation = new PostMessageResource(message);
+  CHECK(continuation != NULL);
+  NaClLog(4, "PluginReverseInterface::DoPostMessage(%s)\n", message.c_str());
+  plugin::WeakRefCallOnMainThread(
+      anchor_,
+      0,  /* delay in ms */
+      ALLOW_THIS_IN_INITIALIZER_LIST(this),
+      &plugin::PluginReverseInterface::PostMessage_MainThreadContinuation,
+      continuation);
+}
+
 void PluginReverseInterface::StartupInitializationComplete() {
   NaClLog(0, "PluginReverseInterface::StartupInitializationComplete\n");
   if (init_done_cb_.pp_completion_callback().func != NULL) {
     NaClLog(0,
             "PluginReverseInterface::StartupInitializationComplete:"
             " invoking CB\n");
     pp::Module::Get()->core()->CallOnMainThread(0, init_done_cb_, PP_OK);
   } else {
     NaClLog(0,
             "PluginReverseInterface::StartupInitializationComplete:"
             " init_done_cb_ not valid, skipping.\n");
   }
 }
 
 void PluginReverseInterface::Log_MainThreadContinuation(
     LogToJavaScriptConsoleResource* p,
     int32_t err) {
   UNREFERENCED_PARAMETER(err);
   NaClLog(4,
           "PluginReverseInterface::Log_MainThreadContinuation(%s)\n",
           p->message.c_str());
   plugin_->browser_interface()->AddToConsole(static_cast<Plugin*>(plugin_),
                                              p->message);
 }
+void PluginReverseInterface::PostMessage_MainThreadContinuation(
+    PostMessageResource* p,
+    int32_t err) {
+  UNREFERENCED_PARAMETER(err);
+  NaClLog(4,
+          "PluginReverseInterface::PostMessage_MainThreadContinuation(%s)\n",
+          p->message.c_str());
+  plugin_->PostMessage(std::string("DEBUG_POSTMESSAGE:") + p->message);
+}
 
 bool PluginReverseInterface::EnumerateManifestKeys(
     std::set<nacl::string>* out_keys) {
   Manifest const* mp = plugin_->manifest();
 
   if (!mp->GetFileKeys(out_keys)) {
     return false;
   }
 
   return true;
@@ skipping 446 matching lines @@
   nacl::MutexLocker take(&mu_);
   return exit_status_;
 }
 
 void ServiceRuntime::set_exit_status(int exit_status) {
   nacl::MutexLocker take(&mu_);
   exit_status_ = exit_status & 0xff;
 }
 
 }  // namespace plugin