A proposal for an initial postMessage interface. This will allow JavaScript ...

webkit/plugins/ppapi/plugin_module.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 "webkit/plugins/ppapi/plugin_module.h"
 
 #include <set>
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 252 matching lines @@
   if (strcmp(name, PPB_FONT_DEV_INTERFACE) == 0)
     return PPB_Font_Impl::GetInterface();
   if (strcmp(name, PPB_FULLSCREEN_DEV_INTERFACE) == 0)
     return PluginInstance::GetFullscreenInterface();
   if (strcmp(name, PPB_GRAPHICS_2D_INTERFACE) == 0)
     return PPB_Graphics2D_Impl::GetInterface();
   if (strcmp(name, PPB_IMAGEDATA_INTERFACE) == 0)
     return PPB_ImageData_Impl::GetInterface();
   if (strcmp(name, PPB_IMAGEDATA_TRUSTED_INTERFACE) == 0)
     return PPB_ImageData_Impl::GetTrustedInterface();
-  if (strcmp(name, PPB_INSTANCE_INTERFACE) == 0)
-    return PluginInstance::GetInterface();
   if (strcmp(name, PPB_PDF_INTERFACE) == 0)
     return PPB_PDF_Impl::GetInterface();
   if (strcmp(name, PPB_PROXY_PRIVATE_INTERFACE) == 0)
     return PPB_Proxy_Impl::GetInterface();
   if (strcmp(name, PPB_SCROLLBAR_DEV_INTERFACE) == 0)
     return PPB_Scrollbar_Impl::GetInterface();
   if (strcmp(name, PPB_TRANSPORT_DEV_INTERFACE) == 0)
     return PPB_Transport_Impl::GetInterface();
   if (strcmp(name, PPB_URLLOADER_INTERFACE) == 0)
     return PPB_URLLoader_Impl::GetInterface();
@@ skipping 32 matching lines @@
     if (strcmp(name, PPB_SURFACE_3D_DEV_INTERFACE) == 0)
       return PPB_Surface3D_Impl::GetInterface();
   }
 #endif  // ENABLE_GPU
 
 #ifdef ENABLE_FLAPPER_HACKS
   if (strcmp(name, PPB_FLASH_NETCONNECTOR_INTERFACE) == 0)
     return PPB_Flash_NetConnector_Impl::GetInterface();
 #endif  // ENABLE_FLAPPER_HACKS
 
+  // PluginInstance supports multiple PPB_Instance interfaces.  Get the right
+  // one, if supports one.
+  const void* interface = PluginInstance::GetInterface(name);
+  if (interface != NULL)
+    return interface;
+
   // Only support the testing interface when the command line switch is
   // specified. This allows us to prevent people from (ab)using this interface
   // in production code.
   if (strcmp(name, PPB_TESTING_DEV_INTERFACE) == 0) {
     if (CommandLine::ForCurrentProcess()->HasSwitch("enable-pepper-testing"))
       return &testing_interface;
   }
   return NULL;
 }
 
@@ skipping 104 matching lines @@
 const PPB_Core* PluginModule::GetCore() {
   return &core_interface;
 }
 
 // static
 PluginModule::GetInterfaceFunc PluginModule::GetLocalGetInterfaceFunc() {
   return &GetInterface;
 }
 
 PluginInstance* PluginModule::CreateInstance(PluginDelegate* delegate) {
+  PluginInstance* instance(NULL);
   const PPP_Instance* plugin_instance_interface =
       reinterpret_cast<const PPP_Instance*>(GetPluginInterface(
           PPP_INSTANCE_INTERFACE));
-  if (!plugin_instance_interface) {
+  if (plugin_instance_interface != NULL) {
+    instance = new PluginInstance(delegate, this, plugin_instance_interface,

[brettw, 2011/03/16 21:34:11]

What about just passing the instance interface object by value? It should be
fairly small and reasonable to copy, and then you don't need to worry about the
ownership complexity.

[dmichael(do not use this one), 2011/03/21 21:43:35]

Good idea.  But since I'm going to follow Neb's suggestion, I'm not going to
have to worry about backwards compatibility.  Somebody (maybe Neb or I?) will
have to deal with it later when we hack functions out of PPP_Instance.

+                                  PluginInstance::PLUGIN_OWNS_INTERFACE);
+  } else {
+    // If the current version failed, try versions we currently support.
+    const void* ppp_instance_if_0_4(
+        GetPluginInterface(PPP_INSTANCE_INTERFACE_0_4));
+    if (ppp_instance_if_0_4 != NULL) {
+      PPP_Instance* ppp_instance_interface = new PPP_Instance;
+      std::memset(ppp_instance_interface, 0,
+                  sizeof(*plugin_instance_interface));
+      std::memcpy(ppp_instance_interface, ppp_instance_if_0_4,
+                  sizeof(PPP_Instance_0_4));
+      instance = new PluginInstance(delegate, this, ppp_instance_interface,
+                                    PluginInstance::BROWSER_OWNS_INTERFACE);
+    }
+  }
+  if (!instance) {
     LOG(WARNING) << "Plugin doesn't support instance interface, failing.";
     return NULL;
   }
-  PluginInstance* instance = new PluginInstance(delegate, this,
-                                                plugin_instance_interface);
   if (out_of_process_proxy_.get())
     out_of_process_proxy_->AddInstance(instance->pp_instance());
   return instance;
 }
 
 PluginInstance* PluginModule::GetSomeInstance() const {
   // This will generally crash later if there is not actually any instance to
   // return, so we force a crash now to make bugs easier to track down.
   CHECK(!instances_.empty());
   return *instances_.begin();
@@ skipping 41 matching lines @@
   if (retval != 0) {
     LOG(WARNING) << "PPP_InitializeModule returned failure " << retval;
     return false;
   }
   return true;
 }
 
 }  // namespace ppapi
 }  // namespace webkit