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

webkit/plugins/ppapi/plugin_object.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_object.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/dev/ppp_class_deprecated.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/resource_tracker.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 #include "webkit/plugins/ppapi/npapi_glue.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
-#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
+#include "webkit/plugins/ppapi/ppapi_plugin_instance_impl.h"
 
 using ppapi::PpapiGlobals;
 using ppapi::StringVar;
 using ppapi::Var;
 using WebKit::WebBindings;
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
@@ skipping 222 matching lines @@
 // PluginObject ----------------------------------------------------------------
 
 struct PluginObject::NPObjectWrapper : public NPObject {
   // Points to the var object that owns this wrapper. This value may be NULL
   // if there is no var owning this wrapper. This can happen if the plugin
   // releases all references to the var, but a reference to the underlying
   // NPObject is still held by script on the page.
   PluginObject* obj;
 };
 
-PluginObject::PluginObject(PluginInstance* instance,
+PluginObject::PluginObject(PluginInstanceImpl* instance,
                            NPObjectWrapper* object_wrapper,
                            const PPP_Class_Deprecated* ppp_class,
                            void* ppp_class_data)
     : instance_(instance),
       object_wrapper_(object_wrapper),
       ppp_class_(ppp_class),
       ppp_class_data_(ppp_class_data) {
   // Make the object wrapper refer back to this class so our NPObject
   // implementation can call back into the Pepper layer.
   object_wrapper_->obj = this;
   instance_->AddPluginObject(this);
 }
 
 PluginObject::~PluginObject() {
   // The wrapper we made for this NPObject may still have a reference to it
   // from JavaScript, so we clear out its ObjectVar back pointer which will
   // cause all calls "up" to the plugin to become NOPs. Our ObjectVar base
   // class will release our reference to the object, which may or may not
   // delete the NPObject.
   DCHECK(object_wrapper_->obj == this);
   object_wrapper_->obj = NULL;
   instance_->RemovePluginObject(this);
 }
 
-PP_Var PluginObject::Create(PluginInstance* instance,
+PP_Var PluginObject::Create(PluginInstanceImpl* instance,
                             const PPP_Class_Deprecated* ppp_class,
                             void* ppp_class_data) {
   // This will internally end up calling our AllocateObjectWrapper via the
   // WrapperClass_Allocated function which will have created an object wrapper
   // appropriate for this class (derived from NPObject).
   NPObjectWrapper* wrapper = static_cast<NPObjectWrapper*>(
       WebBindings::createObject(instance->instanceNPP(),
       const_cast<NPClass*>(&wrapper_class)));
 
   // This object will register itself both with the NPObject and with the
@@ skipping 47 matching lines @@
 // static
 NPObject* PluginObject::AllocateObjectWrapper() {
   NPObjectWrapper* wrapper = new NPObjectWrapper;
   memset(wrapper, 0, sizeof(NPObjectWrapper));
   return wrapper;
 }
 
 }  // namespace ppapi
 }  // namespace webkit