s patch tries to remove most of the manual registration for Pepper interfaces, and replaces it with a list of macros. When files want to know which Pepper interface names and structs there are, they define what they want to do with the macros, and then include the relevant files for the classes of interfaces they want (stable, private, dev).

This re-lands my previous change.
Original Review URL: http://codereview.chromium.org/7874002

This does not convert all the dev interfaces. I just did a few to keep the patch smaller. So there is still a lot of manual registration.

This fixes the previous design problem where we assumed one *_Proxy object == one interface. We have been hacking around this lately with duplicate GetInfo calls, but this doesn't work for PPP interfaces.

Now, a _Proxy object is just there to help keep things organized. One proxy can handle zero, one, or many interfaces, and this mapping is controlled by just one line in the interfaces file.

So for example, to add a new function to a new version of an interface with backward compatibility, you would add that function to the _api.h file, and write a thunk for the new interface. Then you only need to add one line to the interfaces_ppb_public_stable.h file and that will be hooked up with the proxy and the implementation.

This removes some _proxy objects/files that were used only to declare that the interfaces existed, since they're no longer necessary.

I folded Console into the Instance API which removed a bunch of code.

I removed FileChooser 0.4. I think everybody has converted to the new one, and I think parts of it weren't even hooked up properly anymore.
Review URL: http://codereview.chromium.org/7887001

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@100936 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 8 insertions, 13 deletions

diff --git a/ppapi/proxy/interface_proxy.h b/ppapi/proxy/interface_proxy.h
index 1fed704..795944b 100644
--- a/ppapi/proxy/interface_proxy.h
+++ b/ppapi/proxy/interface_proxy.h
@@ -12,6 +12,7 @@
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/proxy/interface_id.h"
+#include "ppapi/shared_impl/function_group_base.h"
 
 namespace ppapi {
 namespace proxy {
@@ -19,13 +20,16 @@ namespace proxy {
 class Dispatcher;
 
 class InterfaceProxy : public IPC::Channel::Listener,
-                       public IPC::Message::Sender {
+                       public IPC::Message::Sender,
+                       public FunctionGroupBase {
  public:
   // Factory function type for interfaces. Ownership of the returned pointer
   // is transferred to the caller.
-  typedef InterfaceProxy* (*Factory)(Dispatcher* dispatcher,
-                                     const void* target_interface);
+  typedef InterfaceProxy* (*Factory)(Dispatcher* dispatcher);
 
+  // DEPRECATED: New classes should be registered directly in the interface
+  // list. This is kept around until we convert all the existing code.
+  //
   // Information about the interface. Each interface has a static function to
   // return its info, which allows either construction on the target side, and
   // getting the proxied interface on the source side (see dispatcher.h for
@@ -43,9 +47,6 @@ class InterfaceProxy : public IPC::Channel::Listener,
 
   virtual ~InterfaceProxy();
 
-  // The actual implementation of the given interface in the current process.
-  const void* target_interface() const { return target_interface_; }
-
   Dispatcher* dispatcher() const { return dispatcher_; }
 
   // IPC::Message::Sender implementation.
@@ -57,19 +58,13 @@ class InterfaceProxy : public IPC::Channel::Listener,
  protected:
   // Creates the given interface associated with the given dispatcher. The
   // dispatcher manages our lifetime.
-  //
-  // The target interface pointer, when non-NULL, indicates that this is a
-  // target proxy (see dispatcher.h for a definition).  In this case, the proxy
-  // will interpret this pointer to the actual implementation of the interface
-  // in the local process.
-  InterfaceProxy(Dispatcher* dispatcher, const void* target_interface);
+  InterfaceProxy(Dispatcher* dispatcher);
 
   uint32 SendCallback(PP_CompletionCallback callback);
   PP_CompletionCallback ReceiveCallback(uint32 serialized_callback);
 
  private:
   Dispatcher* dispatcher_;
-  const void* target_interface_;
 };
 
 }  // namespace proxy