Add PluginMessageLoopProxy and use it for Host plugin UI thread.

remoting/host/plugin/host_plugin.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 <stdio.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/stringize_macros.h"
+#include "remoting/base/plugin_message_loop_proxy.h"
 #include "remoting/host/plugin/host_plugin_utils.h"
 #include "remoting/host/plugin/host_script_object.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npfunctions.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
 // Symbol export is handled with a separate def file on Windows.
 #if defined (__GNUC__) && __GNUC__ >= 4
 #define EXPORT __attribute__((visibility("default")))
 #else
@@ skipping 26 matching lines @@
 
 // The name and description are returned by GetValue, but are also
 // combined with the MIME type to satisfy GetMIMEDescription, so we
 // use macros here to allow that to happen at compile-time.
 #define HOST_PLUGIN_NAME "Remoting Host Plugin"
 #define HOST_PLUGIN_DESCRIPTION "Remoting Host Plugin"
 
 // NPAPI plugin implementation for remoting host.
 // Documentation for most of the calls in this class can be found here:
 // https://developer.mozilla.org/en/Gecko_Plugin_API_Reference/Scripting_plugins
-class HostNPPlugin {
+class HostNPPlugin : public remoting::PluginMessageLoopProxy::Delegate {
  public:
   // |mode| is the display mode of plug-in. Values:
   // NP_EMBED: (1) Instance was created by an EMBED tag and shares the browser
   //               window with other content.
   // NP_FULL: (2) Instance was created by a separate file and is the primary
   //              content in the window.
   HostNPPlugin(NPP instance, uint16 mode)
-    : instance_(instance), scriptable_object_(NULL) {}
+      : instance_(instance),
+        scriptable_object_(NULL),
+        np_thread_id_(base::PlatformThread::CurrentId()) {
+  }
 
   ~HostNPPlugin() {
     if (scriptable_object_) {
       g_npnetscape_funcs->releaseobject(scriptable_object_);
       scriptable_object_ = NULL;
     }
   }
 
   bool Init(int16 argc, char** argn, char** argv, NPSavedData* saved) {
 #if defined(OS_MACOSX)
@@ skipping 59 matching lines @@
         &RemoveProperty,
         &Enumerate,
         NULL
       };
       scriptable_object_ = g_npnetscape_funcs->createobject(instance_,
                                                             &npc_ref_object);
     }
     return scriptable_object_;
   }
 
+  // PluginMessageLoopProxy::Delegate implementation.
+  virtual bool RunOnPluginThread(
+      int delay_ms, void(function)(void*), void* data) OVERRIDE {
+    if (delay_ms == 0) {
+      g_npnetscape_funcs->pluginthreadasynccall(instance_, function, data);
+    } else {
+      base::AutoLock auto_lock(timers_lock_);
+      uint32_t timer_id = g_npnetscape_funcs->scheduletimer(
+          instance_, delay_ms, false, &NPDelayedTaskSpringboard);
+      DelayedTask task = {function, data};
+      timers_[timer_id] = task;
+    }
+    return true;
+  }
+
+  virtual bool IsPluginThread() OVERRIDE {
+    return np_thread_id_ == base::PlatformThread::CurrentId();
+  }
+
+  static void NPDelayedTaskSpringboard(NPP npp, uint32_t timer_id) {
+    HostNPPlugin* self = reinterpret_cast<HostNPPlugin*>(npp->pdata);
+    DelayedTask task;
+    {
+      base::AutoLock auto_lock(self->timers_lock_);
+      std::map<uint32_t, DelayedTask>::iterator it =
+          self->timers_.find(timer_id);
+      CHECK(it != self->timers_.end());
+      DelayedTask task = it->second;
+      self->timers_.erase(it);
+    }
+    task.function(task.data);
+  }
+
  private:
   struct ScriptableNPObject : public NPObject {
     HostNPScriptObject* scriptable_object;
   };
 
+  struct DelayedTask {
+    void (*function)(void*);
+    void* data;
+  };
+
   static HostNPScriptObject* ScriptableFromObject(NPObject* obj) {
     return reinterpret_cast<ScriptableNPObject*>(obj)->scriptable_object;
   }
 
   static NPObject* Allocate(NPP npp, NPClass* aClass) {
     VLOG(2) << "static Allocate";
     ScriptableNPObject* object =
         reinterpret_cast<ScriptableNPObject*>(
             g_npnetscape_funcs->memalloc(sizeof(ScriptableNPObject)));
+    HostNPPlugin* plugin = reinterpret_cast<HostNPPlugin*>(npp->pdata);
 
     object->_class = aClass;
     object->referenceCount = 1;
-    object->scriptable_object = new HostNPScriptObject(npp, object);
+    object->scriptable_object = new HostNPScriptObject(npp, object, plugin);
     if (!object->scriptable_object->Init()) {
       Deallocate(object);
       object = NULL;
     }
     return object;
   }
 
   static void Deallocate(NPObject* npobj) {
     VLOG(2) << "static Deallocate";
     if (npobj) {
@@ skipping 106 matching lines @@
       for (uint32_t i = 0; i < *count; ++i) {
         (*value)[i] =
             g_npnetscape_funcs->getstringidentifier(values[i].c_str());
       }
     }
     return is_good;
   }
 
   NPP instance_;
   NPObject* scriptable_object_;
+
+  base::PlatformThreadId np_thread_id_;
+  std::map<uint32_t, DelayedTask> timers_;
+  base::Lock timers_lock_;
 };
 
 // Utility functions to map NPAPI Entry Points to C++ Objects.
 HostNPPlugin* PluginFromInstance(NPP instance) {
   return reinterpret_cast<HostNPPlugin*>(instance->pdata);
 }
 
 NPError CreatePlugin(NPMIMEType pluginType,
                      NPP instance,
                      uint16 mode,
@@ skipping 142 matching lines @@
 }
 
 EXPORT NPError API_CALL NP_GetValue(void* npp,
                                     NPPVariable variable,
                                     void* value) {
   return GetValue((NPP)npp, variable, value);
 }
 #endif
 
 }  // extern "C"