Revert 97050 - Add PluginMessageLoopProxy and use it for Host plugin UI thread.

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/message_loop_proxy.h"
 #include "base/threading/platform_thread.h"
@@ skipping 60 matching lines @@
 
 }  // namespace
 
 // This flag blocks LOGs to the UI if we're already in the middle of logging
 // to the UI. This prevents a potential infinite loop if we encounter an error
 // while sending the log message to the UI.
 static bool g_logging_to_plugin = false;
 static HostNPScriptObject* g_logging_scriptable_object = NULL;
 static logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
-HostNPScriptObject::HostNPScriptObject(
-    NPP plugin,
-    NPObject* parent,
-    PluginMessageLoopProxy::Delegate* plugin_thread_delegate)
+HostNPScriptObject::HostNPScriptObject(NPP plugin, NPObject* parent)
     : plugin_(plugin),
       parent_(parent),
       state_(kDisconnected),
       np_thread_id_(base::PlatformThread::CurrentId()),
-      plugin_message_loop_proxy_(
-          new PluginMessageLoopProxy(plugin_thread_delegate)),
-      host_context_(plugin_message_loop_proxy_),
       failed_login_attempts_(0),
       disconnected_event_(true, false),
       nat_traversal_enabled_(false),
       policy_received_(false) {
   // Set up log message handler.
   // Note that this approach doesn't quite support having multiple instances
   // of Chromoting running. In that case, the most recently opened tab will
   // grab all the debug log messages, and when any Chromoting tab is closed
   // the logging handler will go away.
   // Since having multiple Chromoting tabs is not a primary use case, and this
   // is just debug logging, we're punting improving debug log support for that
   // case.
   if (g_logging_old_handler == NULL)
     g_logging_old_handler = logging::GetLogMessageHandler();
   logging::SetLogMessageHandler(&LogToUI);
   g_logging_scriptable_object = this;
+
+  VLOG(2) << "HostNPScriptObject";
+  host_context_.SetUITaskPostFunction(base::Bind(
+      &HostNPScriptObject::PostTaskToNPThread, base::Unretained(this)));
 }
 
 HostNPScriptObject::~HostNPScriptObject() {
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
 
   // Shutdown DesktopEnvironment first so that it doesn't try to post
   // tasks on the UI thread while we are stopping the host.
   desktop_environment_->Shutdown();
 
   logging::SetLogMessageHandler(g_logging_old_handler);
   g_logging_old_handler = NULL;
   g_logging_scriptable_object = NULL;
 
-  plugin_message_loop_proxy_->Detach();
-
   // Stop listening for policy updates.
   if (nat_policy_.get()) {
     base::WaitableEvent nat_policy_stopped_(true, false);
     nat_policy_->StopWatching(&nat_policy_stopped_);
     nat_policy_stopped_.Wait();
     nat_policy_.reset();
   }
 
   // Disconnect synchronously. We cannot disconnect asynchronously
   // here because |host_context_| needs to be stopped on the plugin
   // thread, but the plugin thread may not exist after the instance
   // is destroyed.
+  destructing_.Set();
   disconnected_event_.Reset();
   DisconnectInternal();
   disconnected_event_.Wait();
 
   // Stop all threads.
   host_context_.Stop();
 }
 
 bool HostNPScriptObject::Init() {
   VLOG(2) << "Init";
@@ skipping 428 matching lines @@
   access_code_lifetime_ = lifetime;
 
   // Tell the ChromotingHost the access code, to use as shared-secret.
   host_->set_access_code(access_code_);
 
   // Let the caller know that life is good.
   OnStateChanged(kReceivedAccessCode);
 }
 
 void HostNPScriptObject::OnStateChanged(State state) {
-  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
-    plugin_message_loop_proxy_->PostTask(
+  if (destructing_.IsSet())
+    return;
+
+  if (!host_context_.IsUIThread()) {
+    host_context_.PostTaskToUIThread(
         FROM_HERE, base::Bind(&HostNPScriptObject::OnStateChanged,
                               base::Unretained(this), state));
     return;
   }
   state_ = state;
   if (on_state_changed_func_.get()) {
     VLOG(2) << "Calling state changed " << state;
     bool is_good = InvokeAndIgnoreResult(on_state_changed_func_.get(), NULL, 0);
     LOG_IF(ERROR, !is_good) << "OnStateChanged failed";
   }
@@ skipping 13 matching lines @@
     message += (str.c_str() + message_start);
     g_logging_scriptable_object->LogDebugInfo(message);
     g_logging_to_plugin = false;
   }
   if (g_logging_old_handler)
     return (g_logging_old_handler)(severity, file, line, message_start, str);
   return false;
 }
 
 void HostNPScriptObject::LogDebugInfo(const std::string& message) {
-  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
-    plugin_message_loop_proxy_->PostTask(
+  if (destructing_.IsSet())
+    return;
+
+  if (!host_context_.IsUIThread()) {
+    host_context_.PostTaskToUIThread(
         FROM_HERE, base::Bind(&HostNPScriptObject::LogDebugInfo,
                               base::Unretained(this), message));
     return;
   }
 
   if (log_debug_info_func_.get()) {
     NPVariant log_message;
     STRINGZ_TO_NPVARIANT(message.c_str(), log_message);
     bool is_good = InvokeAndIgnoreResult(log_debug_info_func_.get(),
                                          &log_message, 1);
@@ skipping 64 matching lines @@
                                                const NPVariant* args,
                                                uint32_t argCount) {
   NPVariant np_result;
   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, const base::Closure& 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.
+
+  // Copy task to the heap so that we can pass it to NPTaskSpringboard().
+  base::Closure* task_in_heap = new base::Closure(task);
+
+  // Can be called from any thread.
+  g_npnetscape_funcs->pluginthreadasynccall(plugin_, &NPTaskSpringboard,
+                                            task_in_heap);
+}
+
+// static
+void HostNPScriptObject::NPTaskSpringboard(void* task) {
+  base::Closure* real_task = reinterpret_cast<base::Closure*>(task);
+  real_task->Run();
+  delete real_task;
+}
+
 }  // namespace remoting