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

src/trusted/plugin/plugin.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/plugin.h"
 
 #include <assert.h>
 #include <fcntl.h>
@@ skipping 310 matching lines @@
   }
   return socket_->handle()->InitParams(method_id, call_type, params);
 }
 
 
 bool Plugin::SetNexesPropertyImpl(const char* nexes_attr) {
   PLUGIN_PRINTF(("Plugin::SetNexesPropertyImpl (nexes_attr='%s')\n",
                  nexes_attr));
   nacl::string result;
   if (!GetNexeURL(nexes_attr, &result)) {
-    // TODO(adonovan): Ideally we would print to the browser's
-    // JavaScript console: alert popups are annoying, and no-one can
-    // be expected to read stderr.
     PLUGIN_PRINTF(("Plugin::SetNexesPropertyImpl (result='%s')\n",
                    result.c_str()));
-    browser_interface()->Alert(instance_id(), result);
+    browser_interface()->AddToConsole(instance_id(), result);
     return false;
   } else {
     return SetSrcPropertyImpl(result);
   }
 }
 
 bool Plugin::SetSrcPropertyImpl(const nacl::string& url) {
   PLUGIN_PRINTF(("Plugin::SetSrcPropertyImpl (unloading previous)\n"));
   // We do not actually need to shut down the process here when
   // initiating the (asynchronous) download.  It is more important to
@@ skipping 187 matching lines @@
                  nacl_module_origin_.c_str(), nacl_module_origin_valid));
   // If the page origin where the EMBED/OBJECT tag occurs is not in
   // the whitelist, refuse to load.  If the NaCl module's origin is
   // not in the whitelist, also refuse to load.
   // TODO(adonovan): JavaScript permits cross-origin loading, and so
   // does Chrome ; why don't we?
   if (!origin_valid_ || !nacl_module_origin_valid) {
     nacl::string message = nacl::string("Load failed: NaCl module ") +
         logical_url + " does not come ""from a whitelisted source. "
         "See native_client/src/trusted/plugin/origin.cc for the list.";
-    browser_interface->Alert(instance_id(), message.c_str());
+    browser_interface->AddToConsole(instance_id(), message.c_str());
     PLUGIN_PRINTF(("Plugin::Load (return 0)"));
     return false;
   }
   // Catch any bad accesses, etc., while loading.
   ScopedCatchSignals sigcatcher(
       (ScopedCatchSignals::SigHandlerType) SignalHandler);
   if (PLUGIN_SETJMP(g_LoaderEnv, 1)) {
     return false;
   }
 
@@ skipping 10 matching lines @@
     ssize_t result;
     result = shmbufp->read(0, sizeof elf_hdr_buf, elf_hdr_buf);
     if (sizeof elf_hdr_buf == result) {  // (const char*)(elf_hdr_buf)
       success = browser_interface->MightBeElfExecutable(elf_hdr_buf,
                                                         sizeof elf_hdr_buf,
                                                         &error_string);
     }
   }
   if (!success) {
     PLUGIN_PRINTF(("Plugin::Load (error_string='%s')\n", error_string.c_str()));
-    browser_interface->Alert(instance_id(), error_string);
+    browser_interface->AddToConsole(instance_id(), error_string);
     return false;
   }
 
   // Ensure that we do not leak the ServiceRuntime object for an
   // existing subprocess.  Ensure that any associated listener threads
   // do not go unjoined, because if they outlive the Plugin object,
   // they will not be memory safe.
   ShutDownSubprocess();
 
   // Load a file via a forked sel_ldr process.
   service_runtime_ = new(std::nothrow) ServiceRuntime(browser_interface, this);
   if (NULL == service_runtime_) {
     PLUGIN_PRINTF(("Plugin::Load (ServiceRuntime Ctor failed)\n"));
-    browser_interface->Alert(instance_id(), "ServiceRuntime Ctor failed");
+    browser_interface->AddToConsole(instance_id(),
+                                    "ServiceRuntime Ctor failed");
     return false;
   }
   bool service_runtime_started = false;
   if (NULL == shmbufp) {
     service_runtime_started = service_runtime_->Start(local_url_);
   } else {
     int32_t size;
     NaClDesc* raw_desc = shmbufp->shm(&size);
     if (NULL == raw_desc) {
       PLUGIN_PRINTF(("Plugin::Load (extracting shm failed)\n"));
       return false;
     }
     nacl::DescWrapper* wrapped_shm =
         wrapper_factory_->MakeGeneric(NaClDescRef(raw_desc));
     service_runtime_started =
         service_runtime_->StartUnderChromium(local_url_, wrapped_shm);
     // Start consumes the wrapped_shm.
   }
   if (!service_runtime_started) {
     PLUGIN_PRINTF(("Plugin::Load (failed to start service runtime)\n"));
-    browser_interface->Alert(instance_id(),
-                             "Load: FAILED to start service runtime");
+    browser_interface->AddToConsole(instance_id(),
+                                    "Load: FAILED to start service runtime");
     return false;
   }
 
   PLUGIN_PRINTF(("Plugin::Load (started sel_ldr)\n"));
   // Plugin takes ownership of socket_address_ from service_runtime_,
   // so we do not need to call AddRef().
   socket_address_ = service_runtime_->default_socket_address();
   PLUGIN_PRINTF(("Plugin::Load (established socket address %p)\n",
                  static_cast<void*>(socket_address_)));
   if (!StartSrpcServices(&error_string)) {
     browser_interface_->Alert(instance_id(), error_string);

[polina, 2010/08/26 02:45:15]

This is still an Alert. Is that on purpose?

     return false;
   }
   return true;
 }
 
 bool Plugin::StartSrpcServices(nacl::string* error) {
   if (socket_ != NULL) {
     socket_->Unref();
     socket_ = NULL;
   }
@@ skipping 66 matching lines @@
 
 void VideoGlobalLock() {
   g_VideoMutex.Lock();
 }
 
 void VideoGlobalUnlock() {
   g_VideoMutex.Unlock();
 }
 
 }  // namespace plugin