Use macros to define pepper interfaces

ppapi/proxy/plugin_dispatcher.cc

Index: ppapi/proxy/plugin_dispatcher.cc
diff --git a/ppapi/proxy/plugin_dispatcher.cc b/ppapi/proxy/plugin_dispatcher.cc
index 58a10174e1b476ff76dde7d19c15498e03839050..e23f9988c21d13e51e8c3c9339a6535f7838b320 100644
--- a/ppapi/proxy/plugin_dispatcher.cc
+++ b/ppapi/proxy/plugin_dispatcher.cc
@@ -13,6 +13,7 @@
 #include "ipc/ipc_sync_channel.h"
 #include "base/debug/trace_event.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/proxy/interface_list.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/plugin_message_filter.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
@@ -49,11 +50,6 @@ PluginDispatcher::PluginDispatcher(base::ProcessHandle remote_process_handle,
       received_preferences_(false),
       plugin_dispatcher_id_(0) {
   SetSerializationRules(new PluginVarSerializationRules);
-
-  // As a plugin, we always support the PPP_Class interface. There's no
-  // GetInterface call or name for it, so we insert it into our table now.
-  target_proxies_[INTERFACE_ID_PPP_CLASS].reset(new PPP_Class_Proxy(this));
-
   TrackerBase::Init(&PluginResourceTracker::GetTrackerBaseInstance);
 }
 
@@ -79,13 +75,19 @@ PluginDispatcher* PluginDispatcher::GetForResource(const Resource* resource) {
 }
 
 // static
-const void* PluginDispatcher::GetInterfaceFromDispatcher(
-    const char* interface) {
-  // All interfaces the plugin requests of the browser are "PPB".
-  const InterfaceProxy::Info* info = GetPPBInterfaceInfo(interface);
-  if (!info)
-    return NULL;
-  return info->interface_ptr;
+const void* PluginDispatcher::GetBrowserInterface(const char* interface) {
+  return InterfaceList::GetInstance()->GetInterfaceForPPB(interface);
+}
+
+const void* PluginDispatcher::GetPluginInterface(
+    const std::string& interface_name) {
+  InterfaceMap::iterator found = plugin_interfaces_.find(interface_name);
+  if (found == plugin_interfaces_.end()) {
+    const void* ret = local_get_interface()(interface_name.c_str());
+    plugin_interfaces_.insert(std::make_pair(interface_name, ret));
+    return ret;
+  }
+  return found->second;
 }
 
 bool PluginDispatcher::InitPluginWithChannel(
@@ -127,56 +129,18 @@ bool PluginDispatcher::OnMessageReceived(const IPC::Message& msg) {
   TRACE_EVENT2("ppapi proxy", "PluginDispatcher::OnMessageReceived",
                "Class", IPC_MESSAGE_ID_CLASS(msg.type()),
                "Line", IPC_MESSAGE_ID_LINE(msg.type()));
-  // Handle common control messages.
-  if (Dispatcher::OnMessageReceived(msg))
-    return true;
-
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     // Handle some plugin-specific control messages.
     bool handled = true;

[noelallen_use_chromium, 2011/09/07 21:16:57]

Observation, no need to change in this CL but, this logic is reversed, since at
the moment this is set to true, it is not yet handled.
  bool failed = false;
  IPC_MESSGAGE_UNHANDLED(failed = true);

[brettw, 2011/09/08 05:34:29]

This is normal Chrome style for these things so you don't have to set
handled=true for every message handler.

     IPC_BEGIN_MESSAGE_MAP(PluginDispatcher, msg)
       IPC_MESSAGE_HANDLER(PpapiMsg_SupportsInterface, OnMsgSupportsInterface)
       IPC_MESSAGE_HANDLER(PpapiMsg_SetPreferences, OnMsgSetPreferences)
+      IPC_MESSAGE_UNHANDLED(handled = false);
     IPC_END_MESSAGE_MAP()
-    return handled;
-  }
-
-  if (msg.routing_id() <= 0 || msg.routing_id() >= INTERFACE_ID_COUNT) {
-    // Host is sending us garbage. Since it's supposed to be trusted, this
-    // isn't supposed to happen. Crash here in all builds in case the renderer
-    // is compromised.
-    CHECK(false);
-    return true;
-  }
-
-  // There are two cases:
-  //
-  // * The first case is that the host is calling a PPP interface. It will
-  //   always do a check for the interface before sending messages, and this
-  //   will create the necessary interface proxy at that time. So when we
-  //   actually receive a message, we know such a proxy will exist.
-  //
-  // * The second case is that the host is sending a response to the plugin
-  //   side of a PPB interface (some, like the URL loader, have complex
-  //   response messages). Since the host is trusted and not supposed to be
-  //   doing silly things, we can just create a PPB proxy project on demand the
-  //   first time it's needed.
-
-  InterfaceProxy* proxy = target_proxies_[msg.routing_id()].get();
-  if (!proxy) {
-    // Handle the first time the host calls a PPB reply interface by
-    // autocreating it.
-    const InterfaceProxy::Info* info = GetPPBInterfaceInfo(
-        static_cast<InterfaceID>(msg.routing_id()));
-    if (!info) {
-      NOTREACHED();
+    if (handled)
       return true;
-    }
-    proxy = info->create_proxy(this, NULL);
-    target_proxies_[info->id].reset(proxy);
   }
-
-  return proxy->OnMessageReceived(msg);
+  return Dispatcher::OnMessageReceived(msg);
 }
 
 void PluginDispatcher::OnChannelError() {
@@ -234,23 +198,7 @@ WebKitForwarding* PluginDispatcher::GetWebKitForwarding() {
 }
 
 FunctionGroupBase* PluginDispatcher::GetFunctionAPI(InterfaceID id) {
-  scoped_ptr<FunctionGroupBase >& proxy = function_proxies_[id];
-
-  if (proxy.get())
-    return proxy.get();
-
-  if (id == INTERFACE_ID_PPB_CHAR_SET)
-    proxy.reset(new PPB_CharSet_Proxy(this, NULL));
-  else if(id == INTERFACE_ID_PPB_CURSORCONTROL)
-    proxy.reset(new PPB_CursorControl_Proxy(this, NULL));
-  else if (id == INTERFACE_ID_PPB_FONT)
-    proxy.reset(new PPB_Font_Proxy(this, NULL));
-  else if (id == INTERFACE_ID_PPB_INSTANCE)
-    proxy.reset(new PPB_Instance_Proxy(this, NULL));
-  else if (id == INTERFACE_ID_RESOURCE_CREATION)
-    proxy.reset(new ResourceCreationProxy(this));
-
-  return proxy.get();
+  return GetInterfaceProxy(id);
 }
 
 void PluginDispatcher::ForceFreeAllInstances() {
@@ -275,26 +223,7 @@ void PluginDispatcher::ForceFreeAllInstances() {
 void PluginDispatcher::OnMsgSupportsInterface(
     const std::string& interface_name,
     bool* result) {
-  *result = false;
-
-  // Setup a proxy for receiving the messages from this interface.
-  const InterfaceProxy::Info* info = GetPPPInterfaceInfo(interface_name);
-  if (!info)
-    return;  // Interface not supported by proxy.
-
-  // Check for a cached result.
-  if (target_proxies_[info->id].get()) {
-    *result = true;
-    return;
-  }
-
-  // Query the plugin & cache the result.
-  const void* interface_functions = GetLocalInterface(interface_name.c_str());
-  if (!interface_functions)
-    return;
-  target_proxies_[info->id].reset(
-      info->create_proxy(this, interface_functions));
-  *result = true;
+  *result = !!GetPluginInterface(interface_name);

[noelallen_use_chromium, 2011/09/07 21:16:57]

Would the style guide require this to be:
  *result = GetPluginInterface(interface_name) != NULL;

[brettw, 2011/09/08 05:34:29]

It's not, to my knowledge, disallowed, but I wouldn't say it's the preferred way
either. I use this sometimes, and it's used in other places as well to avoid
compiler warnings about implicit bool conversions.
http://codesearch.google.com/codesearch#search/&exact_package=chromium&q=!!&t...

 }
 
 void PluginDispatcher::OnMsgSetPreferences(const Preferences& prefs) {