Add PluginMessageLoopProxy and use it for Host plugin UI thread.

remoting/host/plugin/host_script_object.h

 // 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.
 
 #ifndef REMOTING_HOST_PLUGIN_HOST_SCRIPT_OBJECT_H_
 #define REMOTING_HOST_PLUGIN_HOST_SCRIPT_OBJECT_H_
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
+#include "remoting/base/plugin_message_loop_proxy.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/host_status_observer.h"
 #include "remoting/host/plugin/host_plugin_utils.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npfunctions.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
@@ skipping 10 matching lines @@
 namespace policy_hack {
 class NatPolicy;
 }  // namespace policy_hack
 
 // NPAPI plugin implementation for remoting host script object.
 // HostNPScriptObject creates threads that are required to run
 // ChromotingHost and starts/stops the host on those threads. When
 // destroyed it sychronously shuts down the host and all threads.
 class HostNPScriptObject : public HostStatusObserver {
  public:
-  HostNPScriptObject(NPP plugin, NPObject* parent);
+  HostNPScriptObject(NPP plugin, NPObject* parent,
+                     PluginMessageLoopProxy::Delegate* plugin_thread_delegate);
   virtual ~HostNPScriptObject();
 
   bool Init();
 
   bool HasMethod(const std::string& method_name);
   bool InvokeDefault(const NPVariant* args,
                      uint32_t argCount,
                      NPVariant* result);
   bool Invoke(const std::string& method_name,
               const NPVariant* args,
@@ skipping 76 matching lines @@
   // unchanged and returns false on failure.
   bool LocalizeString(const char* tag, const char* substitution,
                       std::string* result);
 
   // Helper function for executing InvokeDefault on an NPObject, and ignoring
   // the return value.
   bool InvokeAndIgnoreResult(NPObject* func,
                              const NPVariant* args,
                              uint32_t argCount);
 
-  // Posts a task on the main NP thread.
-  void PostTaskToNPThread(
-      const tracked_objects::Location& from_here, const base::Closure& task);
-
-  // Utility function for PostTaskToNPThread.
-  static void NPTaskSpringboard(void* task);
-
   // Set an exception for the current call.
   void SetException(const std::string& exception_string);
 
   NPP plugin_;
   NPObject* parent_;
   int state_;
   std::string access_code_;
   std::string client_username_;
   base::TimeDelta access_code_lifetime_;
   ScopedRefNPObject localize_func_;
   ScopedRefNPObject log_debug_info_func_;
   ScopedRefNPObject on_state_changed_func_;
   base::PlatformThreadId np_thread_id_;
+  scoped_refptr<PluginMessageLoopProxy> plugin_message_loop_proxy_;
 
   scoped_ptr<RegisterSupportHostRequest> register_request_;
   scoped_refptr<MutableHostConfig> host_config_;
   ChromotingHostContext host_context_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
 
   scoped_refptr<ChromotingHost> host_;
   int failed_login_attempts_;
 
   base::WaitableEvent disconnected_event_;
-  base::CancellationFlag destructing_;
 
   scoped_ptr<policy_hack::NatPolicy> nat_policy_;
 
   // Host the current nat traversal policy setting.
   bool nat_traversal_enabled_;
 
   // Indiciates whether or not a policy has ever been read. This is to ensure
   // that on startup, we do not accidentally start a connection before we have
   // queried our policy restrictions.
   bool policy_received_;
 
   // On startup, it is possible to have Connect() called before the policy read
   // is completed.  Rather than just failing, we thunk the connection call so
   // it can be executed after at least one successful policy read. This
   // variable contains the thunk if it is necessary.
   base::Closure pending_connect_;
 };
 
 }  // namespace remoting
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::HostNPScriptObject);
 
 #endif  // REMOTING_HOST_HOST_SCRIPT_OBJECT_H_