Create a public API around webkit::ppapi::PluginInstance and use it in chrome. After this, webkit/p…

webkit/plugins/ppapi/npapi_glue.h

 // 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.
 
 #ifndef WEBKIT_PLUGINS_PPAPI_NPAPI_GLUE_H_
 #define WEBKIT_PLUGINS_PPAPI_NPAPI_GLUE_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "ppapi/c/pp_module.h"
 #include "ppapi/c/pp_var.h"
 #include "webkit/plugins/webkit_plugins_export.h"
 
 struct NPObject;
 typedef struct _NPVariant NPVariant;
 typedef void* NPIdentifier;
 
 namespace webkit {
 namespace ppapi {
 
-class PluginInstance;
+class PluginInstanceImpl;
 class PluginObject;
 
 // Utilities -------------------------------------------------------------------
 
 // Converts the given PP_Var to an NPVariant, returning true on success.
 // False means that the given variant is invalid. In this case, the result
 // NPVariant will be set to a void one.
 //
 // The contents of the PP_Var will be copied unless the PP_Var corresponds to
 // an object.
 bool PPVarToNPVariant(PP_Var var, NPVariant* result);
 
 // Returns a PP_Var that corresponds to the given NPVariant. The contents of
 // the NPVariant will be copied unless the NPVariant corresponds to an
 // object. This will handle all Variant types including POD, strings, and
 // objects.
 //
 // The returned PP_Var will have a refcount of 1, this passing ownership of
 // the reference to the caller. This is suitable for returning to a plugin.
-WEBKIT_PLUGINS_EXPORT PP_Var NPVariantToPPVar(PluginInstance* instance,
+WEBKIT_PLUGINS_EXPORT PP_Var NPVariantToPPVar(PluginInstanceImpl* instance,
                                               const NPVariant* variant);
 
 // Returns a NPIdentifier that corresponds to the given PP_Var. The contents
 // of the PP_Var will be copied. Returns 0 if the given PP_Var is not a a
 // string or integer type.
 NPIdentifier PPVarToNPIdentifier(PP_Var var);
 
 // Returns a PP_Var corresponding to the given identifier. In the case of
 // a string identifier, the returned string will have a reference count of 1.
 PP_Var NPIdentifierToPPVar(NPIdentifier id);
 
 // Helper function to create a PP_Var of type object that contains the given
 // NPObject for use byt he given module. Calling this function multiple times
 // given the same module + NPObject results in the same PP_Var, assuming that
 // there is still a PP_Var with a reference open to it from the previous
 // call.
 //
 // The instance is necessary because we can have different instances pointing to
 // the same NPObject, and we want to keep their refs separate.
 //
 // If no ObjectVar currently exists corresponding to the NPObject, one is
 // created associated with the given module.
 //
 // Note: this could easily be changed to take a PP_Instance instead if that
 // makes certain calls in the future easier. Currently all callers have a
 // PluginInstance so that's what we use here.
-WEBKIT_PLUGINS_EXPORT PP_Var NPObjectToPPVar(PluginInstance* instance,
+WEBKIT_PLUGINS_EXPORT PP_Var NPObjectToPPVar(PluginInstanceImpl* instance,
                                              NPObject* object);
 
 // This version creates a default v8::Context rather than using the one from
 // the container of |instance|. It is only for use in unit tests, where we don't
 // have a real container for |instance|.
-WEBKIT_PLUGINS_EXPORT PP_Var NPObjectToPPVarForTest(PluginInstance* instance,
-                                                    NPObject* object);
+WEBKIT_PLUGINS_EXPORT PP_Var NPObjectToPPVarForTest(
+    PluginInstanceImpl* instance,
+    NPObject* object);
 
 // PPResultAndExceptionToNPResult ----------------------------------------------
 
 // Convenience object for converting a PPAPI call that can throw an exception
 // and optionally return a value, back to the NPAPI layer which expects a
 // NPVariant as a result.
 //
 // Normal usage is that you will pass the result of exception() to the
 // PPAPI function as the exception output parameter. Then you will either
 // call SetResult with the result of the PPAPI call, or
@@ skipping 60 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PPResultAndExceptionToNPResult);
 };
 
 // PPVarArrayFromNPVariantArray ------------------------------------------------
 
 // Converts an array of NPVariants to an array of PP_Var, and scopes the
 // ownership of the PP_Var. This is used when converting argument lists from
 // WebKit to the plugin.
 class PPVarArrayFromNPVariantArray {
  public:
-  PPVarArrayFromNPVariantArray(PluginInstance* instance,
+  PPVarArrayFromNPVariantArray(PluginInstanceImpl* instance,
                                size_t size,
                                const NPVariant* variants);
   ~PPVarArrayFromNPVariantArray();
 
   PP_Var* array() { return array_.get(); }
 
  private:
   size_t size_;
   scoped_ptr<PP_Var[]> array_;
 
   DISALLOW_COPY_AND_ASSIGN(PPVarArrayFromNPVariantArray);
 };
 
 // PPVarFromNPObject -----------------------------------------------------------
 
 // Converts an NPObject tp PP_Var, and scopes the ownership of the PP_Var. This
 // is used when converting 'this' pointer from WebKit to the plugin.
 class PPVarFromNPObject {
  public:
-  PPVarFromNPObject(PluginInstance* instance, NPObject* object);
+  PPVarFromNPObject(PluginInstanceImpl* instance, NPObject* object);
   ~PPVarFromNPObject();
 
   PP_Var var() const { return var_; }
 
  private:
   const PP_Var var_;
 
   DISALLOW_COPY_AND_ASSIGN(PPVarFromNPObject);
 };
 
@@ skipping 70 matching lines @@
   bool has_exception_;
 
   // May be null if the consumer isn't interesting in catching exceptions.
   PP_Var* exception_;
 };
 
 }  // namespace ppapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_PPAPI_NPAPI_GLUE_H_