Fix buglet calling out to JS from plugin.

remoting/host/plugin/host_script_object.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.
 
 #include "remoting/host/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/threading/platform_thread.h"
@@ skipping 445 matching lines @@
 
   if (!host_context_.IsUIThread()) {
     host_context_.PostToUIThread(
         FROM_HERE,
         NewRunnableMethod(this, &HostNPScriptObject::OnStateChanged, state));
     return;
   }
   state_ = state;
   if (on_state_changed_func_) {
     VLOG(2) << "Calling state changed " << state;
-    bool is_good = CallJSFunction(on_state_changed_func_, NULL, 0, NULL);
+    bool is_good = InvokeAndIgnoreResult(on_state_changed_func_, NULL, 0);
     LOG_IF(ERROR, !is_good) << "OnStateChanged failed";
   }
 }
 
 void HostNPScriptObject::LogDebugInfo(const std::string& message) {
   if (!host_context_.IsUIThread()) {
     host_context_.PostToUIThread(
         FROM_HERE,
         NewRunnableMethod(this, &HostNPScriptObject::LogDebugInfo, message));
     return;
   }
   if (log_debug_info_func_) {
     NPVariant* arg = new NPVariant();
     LOG(INFO) << "Logging: " << message;
     STRINGZ_TO_NPVARIANT(message.c_str(), *arg);
-    bool is_good = CallJSFunction(log_debug_info_func_, arg, 1, NULL);
+    bool is_good = InvokeAndIgnoreResult(log_debug_info_func_, arg, 1);
     LOG_IF(ERROR, !is_good) << "LogDebugInfo failed";
   }
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LogDebugInfo(exception_string);
 }
 
-bool HostNPScriptObject::CallJSFunction(NPObject* func,
-                                        const NPVariant* args,
-                                        uint32_t argCount,
-                                        NPVariant* result) {
+bool HostNPScriptObject::InvokeAndIgnoreResult(NPObject* func,
+                                               const NPVariant* args,
+                                               uint32_t argCount) {
   NPVariant np_result;
-  bool is_good = func->_class->invokeDefault(func, args, argCount, &np_result);
-  if (is_good) {
-    if (result) {
-      *result = np_result;
-    } else {
+  bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func, args,
+                                                   argCount, &np_result);
+  if (is_good)
       g_npnetscape_funcs->releasevariantvalue(&np_result);
-    }
-  }
   return is_good;
 }
 
 void HostNPScriptObject::PostTaskToNPThread(
     const tracked_objects::Location& from_here, Task* task) {
   // The NPAPI functions cannot make use of |from_here|, but this method is
   // passed as a callback to ChromotingHostContext, so it needs to have the
   // appropriate signature.
 
   // Can be called from any thread.
   g_npnetscape_funcs->pluginthreadasynccall(plugin_,
                                             &NPTaskSpringboard,
                                             task);
 }
 
 void HostNPScriptObject::NPTaskSpringboard(void* task) {
   Task* real_task = reinterpret_cast<Task*>(task);
   real_task->Run();
   delete real_task;
 }
 
 }  // namespace remoting