Add in support for internal pepper plugins into the PepperPluginRegistry and pepper::PluginModule.

remoting/client/plugin/pepper_entrypoints.cc

+// Copyright (c) 2010 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/client/plugin/pepper_entrypoints.h"
+
+#include "remoting/client/plugin/chromoting_plugin.h"
+#include "third_party/ppapi/c/pp_instance.h"
+#include "third_party/ppapi/c/pp_module.h"
+#include "third_party/ppapi/c/ppp_instance.h"
+#include "third_party/ppapi/cpp/instance.h"
+#include "third_party/ppapi/cpp/module.h"
+
+static const int kModuleInitSuccess = 0;
+static const int kModuleInitFailure = 1;
+
+namespace remoting {
+
+// Fork of ppapi::Module
+//
+// TODO(ajwong): Generalize this into something that other internal plugins can
+// use.  Either that, or attempt to refactor the external ppapi C++ wrapper to
+// make it friendly for multiple Modules in one process.  I think we can do this
+// by:
+//    1) Moving the singleton Module instance + C-bindings into another class
+//       (eg., ModuleExporter) under a different gyp targe.
+//    2) Extracting the idea of a "Browser" out of the module that returns
+//       PPB_Core, etc.  This can be a singleton per process regardless of
+//       module.
+//    3) Migrate all PPB related objects to get data out of Browser interface
+//       instead of Module::Get().
+class ChromotingModule {
+ public:
+  ChromotingModule() {}
+
+  // This function will be automatically called after the object is created.
+  // This is where you can put functions that rely on other parts of the API,
+  // now that the module has been created.
+  virtual bool Init() { return true; }
+
+  PP_Module pp_module() const { return pp_module_; }
+  const PPB_Core& core() const { return *core_; }
+
+  // Implements GetInterface for the browser to get plugin interfaces. Override
+  // if you need to implement your own interface types that this wrapper
+  // doesn't support.
+  virtual const void* GetInstanceInterface(const char* interface_name) {
+    if (strcmp(interface_name, PPP_INSTANCE_INTERFACE) == 0)
+      return &instance_interface_;
+
+    return NULL;
+  }
+
+  // Returns an interface in the browser.
+  const void* GetBrowserInterface(const char* interface_name) {
+    return get_browser_interface_(interface_name);
+  }
+
+  // Returns the object associated with this PP_Instance, or NULL if one is
+  // not found.
+  ChromotingPlugin* InstanceForPPInstance(PP_Instance instance) {
+    InstanceMap::iterator found = current_instances_.find(instance);
+    if (found == current_instances_.end())
+      return NULL;
+    return found->second;
+  }
+
+  // Sets the browser interface and calls the regular init function that
+  // can be overridden by the base classes.
+  //
+  // TODO(brettw) make this private when I can figure out how to make the
+  // initialize function a friend.
+  bool InternalInit(PP_Module mod,
+                    PPB_GetInterface get_browser_interface) {
+    pp_module_ = mod;
+    get_browser_interface_ = get_browser_interface;
+    core_ = reinterpret_cast<const PPB_Core*>(GetBrowserInterface(
+        PPB_CORE_INTERFACE));
+    if (!core_)
+      return false;  // Can't run without the core interface.
+
+    return Init();
+  }
+
+  // Implementation of Global PPP functions ---------------------------------
+  static int PPP_InitializeModule(PP_Module module_id,
+                                  PPB_GetInterface get_browser_interface) {
+    ChromotingModule* module = new ChromotingModule();
+    if (!module)
+      return kModuleInitFailure;
+
+    if (!module->InternalInit(module_id, get_browser_interface)) {
+      delete module;
+      return kModuleInitFailure;
+    }
+
+    module_singleton_ = module;
+    return kModuleInitSuccess;
+  }
+
+  static void PPP_ShutdownModule() {
+    delete module_singleton_;
+    module_singleton_ = NULL;
+  }
+
+  static const void* PPP_GetInterface(const char* interface_name) {
+    if (!module_singleton_)
+      return NULL;
+    return module_singleton_->GetInstanceInterface(interface_name);
+  }
+
+ protected:
+  virtual ChromotingPlugin* CreateInstance(PP_Instance instance) {
+    const PPB_Instance* ppb_instance_funcs =
+        reinterpret_cast<const PPB_Instance *>(
+            module_singleton_->GetBrowserInterface(PPB_INSTANCE_INTERFACE));
+    return new ChromotingPlugin(instance, ppb_instance_funcs);
+  }
+
+ private:
+  static bool Instance_New(PP_Instance instance) {
+    if (!module_singleton_)
+      return false;
+    ChromotingPlugin* obj = module_singleton_->CreateInstance(instance);
+    if (obj) {
+      module_singleton_->current_instances_[instance] = obj;
+      return true;
+    }
+    return false;
+  }
+
+  static void Instance_Delete(PP_Instance instance) {
+    if (!module_singleton_)
+      return;
+    ChromotingModule::InstanceMap::iterator found =
+        module_singleton_->current_instances_.find(instance);
+    if (found == module_singleton_->current_instances_.end())
+      return;
+
+    // Remove it from the map before deleting to try to catch reentrancy.
+    ChromotingPlugin* obj = found->second;
+    module_singleton_->current_instances_.erase(found);
+    delete obj;
+  }
+
+  static bool Instance_Initialize(PP_Instance pp_instance,
+                                  uint32_t argc,
+                                  const char* argn[],
+                                  const char* argv[]) {
+    if (!module_singleton_)
+      return false;
+    ChromotingPlugin* instance =
+        module_singleton_->InstanceForPPInstance(pp_instance);
+    if (!instance)
+      return false;
+    return instance->Init(argc, argn, argv);
+  }
+
+  static bool Instance_HandleDocumentLoad(PP_Instance pp_instance,
+                                          PP_Resource url_loader) {
+    return false;
+  }
+
+  static bool Instance_HandleEvent(PP_Instance pp_instance,
+                                   const PP_Event* event) {
+    if (!module_singleton_)
+      return false;
+    ChromotingPlugin* instance =
+        module_singleton_->InstanceForPPInstance(pp_instance);
+    if (!instance)
+      return false;
+    return instance->HandleEvent(*event);
+  }
+
+  static PP_Var Instance_GetInstanceObject(PP_Instance pp_instance) {
+    PP_Var var;
+    var.type = PP_VarType_Void;
+    return var;
+  }
+
+  static void Instance_ViewChanged(PP_Instance pp_instance,
+                                   const PP_Rect* position,
+                                   const PP_Rect* clip) {
+    if (!module_singleton_)
+      return;
+    ChromotingPlugin* instance =
+        module_singleton_->InstanceForPPInstance(pp_instance);
+    if (!instance)
+      return;
+    instance->ViewChanged(*position, *clip);
+  }
+
+  // Bindings and identifiers to and from the browser.
+  PP_Module pp_module_;
+  PPB_GetInterface get_browser_interface_;
+  PPB_Core const* core_;
+
+  // Instance tracking.
+  typedef std::map<PP_Instance, ChromotingPlugin*> InstanceMap;
+  InstanceMap current_instances_;
+
+  // Static members for the ppapi C-bridge.
+  static PPP_Instance instance_interface_;
+  static ChromotingModule* module_singleton_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromotingModule);
+};
+
+ChromotingModule* ChromotingModule::module_singleton_ = NULL;
+
+PPP_Instance ChromotingModule::instance_interface_ = {
+  &ChromotingModule::Instance_New,
+  &ChromotingModule::Instance_Delete,
+  &ChromotingModule::Instance_Initialize,
+  &ChromotingModule::Instance_HandleDocumentLoad,
+  &ChromotingModule::Instance_HandleEvent,
+  &ChromotingModule::Instance_GetInstanceObject,
+  &ChromotingModule::Instance_ViewChanged,
+};
+
+// Implementation of Global PPP functions ---------------------------------
+//
+// TODO(ajwong): This is to get around friending issues. Fix it after we decide
+// whether or not ChromotingModule should be generalized.
+int PPP_InitializeModule(PP_Module module_id,
+                         PPB_GetInterface get_browser_interface) {
+  return ChromotingModule::PPP_InitializeModule(module_id,
+                                                get_browser_interface);
+}
+
+void PPP_ShutdownModule() {
+  return ChromotingModule::PPP_ShutdownModule();
+}
+
+const void* PPP_GetInterface(const char* interface_name) {
+  return ChromotingModule::PPP_GetInterface(interface_name);
+}
+
+}  // namespace remoting