Refactoring of new IPC-only pepper implementation

webkit/plugins/ppapi/plugin_module.h

 // Copyright (c) 2012 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.
 
 #ifndef WEBKIT_PLUGINS_PPAPI_PLUGIN_MODULE_H_
 #define WEBKIT_PLUGINS_PPAPI_PLUGIN_MODULE_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 43 matching lines @@
 
   struct EntryPoints {
     // This structure is POD, with the constructor initializing to NULL.
     WEBKIT_PLUGINS_EXPORT EntryPoints();
 
     GetInterfaceFunc get_interface;
     PPP_InitializeModuleFunc initialize_module;
     PPP_ShutdownModuleFunc shutdown_module;  // Optional, may be NULL.
   };
 
+  // Allows the embedder to associate a class with this module. This is opaque
+  // from the PluginModule's perspective (see Set/GetEmbedderState below) but
+  // the module is in charge of deleting the class.
+  class EmbedderState {

[raymes, 2012/07/30 17:23:37]

Not sure if it makes sense to be more descriptive about what this is for (rather
than just calling it embedderstate).

+   public:
+    virtual ~EmbedderState() {}
+  };
+
   typedef std::set<PluginInstance*> PluginInstanceSet;
 
   // You must call one of the Init functions after the constructor to create a
   // module of the type you desire.
   //
   // The module lifetime delegate is a non-owning pointer that must outlive
   // all plugin modules. In practice it will be a global singleton that
   // tracks which modules are alive.
   PluginModule(const std::string& name,
                const FilePath& path,
                PluginDelegate::ModuleLifetime* lifetime_delegate,
                const ::ppapi::PpapiPermissions& perms);
 
   ~PluginModule();
 
+  // Sets the given class as being associated with this module. It will be
+  // deleted when the module is destroyed. You can only set it once, subsequent
+  // sets will assert.
+  //
+  // See EmbedderState above for more.
+  void SetEmbedderState(scoped_ptr<EmbedderState> state);
+  EmbedderState* GetEmbedderState();
+
   // Initializes this module as an internal plugin with the given entrypoints.
   // This is used for "plugins" compiled into Chrome. Returns true on success.
   // False means that the plugin can not be used.
   bool InitAsInternalPlugin(const EntryPoints& entry_points);
 
   // Initializes this module using the given library path as the plugin.
   // Returns true on success. False means that the plugin can not be used.
   bool InitAsLibrary(const FilePath& path);
 
   // Initializes this module for the given out of process proxy. This takes
@@ skipping 67 matching lines @@
 
  private:
   // Calls the InitializeModule entrypoint. The entrypoint must have been
   // set and the plugin must not be out of process (we don't maintain
   // entrypoints in that case).
   bool InitializeModule(const EntryPoints& entry_points);
 
   // Note: This may be null.
   PluginDelegate::ModuleLifetime* lifetime_delegate_;
 
+  // See EmbedderState above.
+  scoped_ptr<EmbedderState> embedder_state_;
+
   // Tracker for completion callbacks, used mainly to ensure that all callbacks
   // are properly aborted on module shutdown.
   scoped_refptr< ::ppapi::CallbackTracker> callback_tracker_;
 
   PP_Module pp_module_;
 
   // True when we're running in the destructor. This allows us to write some
   // assertions.
   bool is_in_destructor_;
 
@@ skipping 34 matching lines @@
 
   bool nacl_ipc_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginModule);
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_PPAPI_PLUGIN_MODULE_H_