Use console.log to report NaCl errors in Chrome instead of alerts

src/trusted/plugin/service_runtime.cc

 /*
  * Copyright 2008 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can
  * be found in the LICENSE file.
  */
 
 #include "native_client/src/trusted/plugin/service_runtime.h"
 
 #include <map>
 #include <vector>
@@ skipping 51 matching lines @@
   // GetSocketAddress implicitly invokes Close(bootstrap_socket).
   // Get service channel descriptor.
   default_socket_address_ = GetSocketAddress(plugin_, bootstrap_socket);
   PLUGIN_PRINTF(("ServiceRuntime::InitCommunication"
                  " (default_socket_address=%p)\n",
                  static_cast<void*>(default_socket_address_)));
 
   if (NULL == default_socket_address_) {
     const char* error = "service runtime: no valid socket address";
     PLUGIN_PRINTF(("ServiceRuntime::InitCommunication (%s)\n", error));
-    browser_interface_->Alert(plugin()->instance_id(), error);
+    browser_interface_->AddToConsole(plugin()->instance_id(), error);
     return false;
   }
   // The first connect on the socket address returns the service
   // runtime command channel.  This channel is created before the NaCl
   // module runs, and is private to the service runtime.  This channel
   // is used for a secure plugin<->service runtime communication path
   // that can be used to forcibly shut down the sel_ldr.
   PLUGIN_PRINTF(("ServiceRuntime::InitCommunication"
                  " (connecting for SrtSocket)\n"));
   PortableHandle* portable_socket_address = default_socket_address_->handle();
   ScriptableHandle* raw_channel = portable_socket_address->Connect();
   if (NULL == raw_channel) {
     const char* error = "service runtime connect failed";
     PLUGIN_PRINTF(("ServiceRuntime::InitCommuncation (%s)\n", error));
-    browser_interface_->Alert(plugin()->instance_id(), error);
+    browser_interface_->AddToConsole(plugin()->instance_id(), error);
     return false;
   }
   PLUGIN_PRINTF(("ServiceRuntime::InitCommunication"
                  " (constructing runtime channel)\n"));
   runtime_channel_ = new(std::nothrow) SrtSocket(raw_channel,
                                                  browser_interface_);
   if (NULL == runtime_channel_) {
     raw_channel->Unref();
     return false;
   }
@@ skipping 35 matching lines @@
   // would prevent the scenario where an evil module is hosted (e.g.,
   // in temporary upload directory that's visible, or as a gmail
   // attachment URL) at an innocent server to extract confidential
   // info and send it to third party servers.  An explict network ACL
   // a la /robots.txt might be useful to serve as an ingress filter.z
 
   PLUGIN_PRINTF(("ServiceRuntime::InitCommuncation (invoking set_origin)\n"));
   if (!runtime_channel_->SetOrigin(plugin_->nacl_module_origin())) {
     const char* error = "could not set origin";
     PLUGIN_PRINTF(("ServiceRuntime::InitCommunication (%s)\n", error));
-    browser_interface_->Alert(plugin()->instance_id(), error);
+    browser_interface_->AddToConsole(plugin()->instance_id(), error);
     return false;
   }
 
   if (shm != NULL) {
     // This code is executed only if NaCl is running as a built-in plugin
     // in Chrome.
     // We now have an open communication channel to the sel_ldr process,
     // so we can send the nexe bits over
     if (!runtime_channel_->LoadModule(shm->desc())) {
       const char* error = "failed to send nexe";
       PLUGIN_PRINTF(("ServiceRuntime::InitCommunication (%s)\n", error));
-      browser_interface_->Alert(plugin()->instance_id(), error);
+      browser_interface_->AddToConsole(plugin()->instance_id(), error);
       shm->Delete();
       // TODO(gregoryd): close communication channels
       delete subprocess_;
       subprocess_ = NULL;
       return false;
     }
     /* LoadModule succeeded, proceed normally */
     shm->Delete();
 #if NACL_WINDOWS && !defined(NACL_STANDALONE)
     // Establish the communication for handle passing protocol
     struct NaClDesc* desc = NaClHandlePassBrowserGetSocketAddress();
     if (!runtime_channel_->InitHandlePassing(desc, subprocess_->child())) {
       delete subprocess_;
       subprocess_ = NULL;
       return false;
     }
 #endif
   }
 
   // start the module.  otherwise we cannot connect for multimedia
   // subsystem since that is handled by user-level code (not secure!)
   // in libsrpc.
   int load_status;
 
   PLUGIN_PRINTF(("ServiceRuntime::InitCommunication"
                  " (invoking start_module RPC)\n"));
   if (!runtime_channel_->StartModule(&load_status)) {
     const char* error = "could not start nacl module";
     PLUGIN_PRINTF(("ServiceRuntime::InitCommunication (%s)\n", error));
-    browser_interface_->Alert(plugin()->instance_id(), error);
+    browser_interface_->AddToConsole(plugin()->instance_id(), error);
     return false;
   }
   PLUGIN_PRINTF((" start_module returned %d\n", load_status));
   if (LOAD_OK != load_status) {
     nacl::string error = "loading of module failed with status " + load_status;
     PLUGIN_PRINTF(("ServiceRuntime::InitCommunication (%s)\n", error.c_str()));
-    browser_interface_->Alert(plugin()->instance_id(), error.c_str());
+    browser_interface_->AddToConsole(plugin()->instance_id(), error.c_str());
     return false;
   }
   return true;
 }
 
 bool ServiceRuntime::Start(const char* nacl_file) {
   PLUGIN_PRINTF(("ServiceRuntime::Start (nacl_file='%s')\n", nacl_file));
   // The arguments we want to pass to the service runtime are
   // "-P 5" sets the default SRPC channel to be over descriptor 5.  The 5 needs
   //      to match the 5 in the Launcher invocation below.
   // "-X 5" causes the service runtime to create a bound socket and socket
   //      address at descriptors 3 and 4.  The socket address is transferred as
   //      the first IMC message on descriptor 5.  This is used when connecting
   //      to socket addresses.
   // "-d" (not default) invokes the service runtime in debug mode.
   // const char* kSelLdrArgs[] = { "-P", "5", "-X", "5" };
   const char* kSelLdrArgs[] = { "-P", "5", "-X", "5" };
   // TODO(sehr): remove -P support and default channels.
   const int kSelLdrArgLength = NACL_ARRAY_SIZE(kSelLdrArgs);
   vector<nacl::string> kArgv(kSelLdrArgs, kSelLdrArgs + kSelLdrArgLength);
   vector<nacl::string> kEmpty;
 
   PLUGIN_PRINTF(("ServiceRuntime::Start (this=%p, plugin=%p)\n",
                  static_cast<void*>(this), static_cast<void*>(plugin())));
 
   subprocess_ = new(std::nothrow) nacl::SelLdrLauncher();
   if (NULL == subprocess_) {
     const char* error = "could not create SelLdrLauncher";
     PLUGIN_PRINTF(("ServiceRuntime::Start (%s)\n", error));
-    browser_interface_->Alert(plugin()->instance_id(), error);
+    browser_interface_->AddToConsole(plugin()->instance_id(), error);
     return false;
   }
   subprocess_->Init(nacl_file, -1, kArgv, kEmpty);
 
   nacl::Handle receive_handle = subprocess_->ExportImcFD(6);
   if (receive_handle == nacl::kInvalidHandle) {
-    browser_interface_->Alert(plugin()->instance_id(),
-                              "Failed to create async receive handle");
+    browser_interface_->AddToConsole(plugin()->instance_id(),
+                                     "Failed to create async receive handle");
     return false;
   }
   async_receive_desc = plugin()->wrapper_factory()->MakeImcSock(receive_handle);
 
   nacl::Handle send_handle = subprocess_->ExportImcFD(7);
   if (send_handle == nacl::kInvalidHandle) {
-    browser_interface_->Alert(plugin()->instance_id(),
-                              "Failed to create async send handle");
+    browser_interface_->AddToConsole(plugin()->instance_id(),
+                                     "Failed to create async send handle");
     return false;
   }
   async_send_desc = plugin()->wrapper_factory()->MakeImcSock(send_handle);
 
   nacl::Handle bootstrap_socket = subprocess_->ExportImcFD(5);
   if (bootstrap_socket == nacl::kInvalidHandle) {
-    browser_interface_->Alert(plugin()->instance_id(),
-                              "Failed to create socket handle");
+    browser_interface_->AddToConsole(plugin()->instance_id(),
+                                     "Failed to create socket handle");
     return false;
   }
 
   if (!subprocess_->Launch()) {
     const char* error = "could not start SelLdrLauncher";
     PLUGIN_PRINTF(("ServiceRuntime::Start (%s)\n", error));
-    browser_interface_->Alert(plugin()->instance_id(), error);
+    browser_interface_->AddToConsole(plugin()->instance_id(), error);
     delete subprocess_;
     subprocess_ = NULL;
     return false;
   }
 
   // TODO(gregoryd) - this should deal with buffer and size correctly
   // - do we need to send the load command from here?
   if (!InitCommunication(bootstrap_socket, NULL)) {
     return false;
   }
@@ skipping 114 matching lines @@
   retval = browser_interface_->NewScriptableHandle(
       SocketAddress::New(plugin, descs[0]));
  cleanup:
   imc_desc->Delete();
   PLUGIN_PRINTF(("ServiceRuntime::GetSocketAddress (return %p)\n",
                  static_cast<void*>(retval)));
   return retval;
 }
 
 }  // namespace plugin