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

webkit/plugins/ppapi/npapi_glue.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/npapi_glue.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_util.h"
 #include "ppapi/c/pp_var.h"
-#include "webkit/plugins/ppapi/host_array_buffer_var.h"
-#include "webkit/plugins/ppapi/host_globals.h"
-#include "webkit/plugins/ppapi/host_var_tracker.h"
-#include "webkit/plugins/ppapi/npobject_var.h"
-#include "webkit/plugins/ppapi/plugin_module.h"
-#include "webkit/plugins/ppapi/plugin_object.h"
-#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "v8/include/v8.h"
+#include "webkit/plugins/ppapi/host_array_buffer_var.h"
+#include "webkit/plugins/ppapi/host_globals.h"
+#include "webkit/plugins/ppapi/host_var_tracker.h"
+#include "webkit/plugins/ppapi/npobject_var.h"
+#include "webkit/plugins/ppapi/plugin_module.h"
+#include "webkit/plugins/ppapi/plugin_object.h"
+#include "webkit/plugins/ppapi/ppapi_plugin_instance_impl.h"
 
 using ppapi::NPObjectVar;
 using ppapi::PpapiGlobals;
 using ppapi::StringVar;
 using ppapi::Var;
 using WebKit::WebArrayBuffer;
 using WebKit::WebBindings;
 using WebKit::WebPluginContainer;
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 
 const char kInvalidPluginValue[] = "Error: Plugin returned invalid value.";
 
-PP_Var NPObjectToPPVarImpl(PluginInstance* instance,
+PP_Var NPObjectToPPVarImpl(PluginInstanceImpl* instance,
                            NPObject* object,
                            v8::Local<v8::Context> context) {
   DCHECK(object);
   if (context.IsEmpty())
     return PP_MakeUndefined();
   v8::Context::Scope context_scope(context);
 
   WebArrayBuffer buffer;
   // TODO(dmichael): Should I protect against duplicate Vars representing the
   // same array buffer? It's probably not worth the trouble, since it will only
@@ skipping 62 matching lines @@
     // if it becomes necessary.
     case PP_VARTYPE_ARRAY:
     case PP_VARTYPE_DICTIONARY:
     case PP_VARTYPE_ARRAY_BUFFER:
       VOID_TO_NPVARIANT(*result);
       break;
   }
   return true;
 }
 
-PP_Var NPVariantToPPVar(PluginInstance* instance, const NPVariant* variant) {
+PP_Var NPVariantToPPVar(PluginInstanceImpl* instance,
+                        const NPVariant* variant) {
   switch (variant->type) {
     case NPVariantType_Void:
       return PP_MakeUndefined();
     case NPVariantType_Null:
       return PP_MakeNull();
     case NPVariantType_Bool:
       return PP_MakeBool(PP_FromBool(NPVARIANT_TO_BOOLEAN(*variant)));
     case NPVariantType_Int32:
       return PP_MakeInt32(NPVARIANT_TO_INT32(*variant));
     case NPVariantType_Double:
@@ skipping 28 matching lines @@
   const NPUTF8* string_value = NULL;
   int32_t int_value = 0;
   bool is_string = false;
   WebBindings::extractIdentifierData(id, string_value, int_value, is_string);
   if (is_string)
     return StringVar::StringToPPVar(string_value);
 
   return PP_MakeInt32(int_value);
 }
 
-PP_Var NPObjectToPPVar(PluginInstance* instance, NPObject* object) {
+PP_Var NPObjectToPPVar(PluginInstanceImpl* instance, NPObject* object) {
   WebPluginContainer* container = instance->container();
   // It's possible that container() is NULL if the plugin has been removed from
   // the DOM (but the PluginInstance is not destroyed yet).
   if (!container)
     return PP_MakeUndefined();
   v8::HandleScope scope(instance->GetIsolate());
   v8::Local<v8::Context> context =
       container->element().document().frame()->mainWorldScriptContext();
   return NPObjectToPPVarImpl(instance, object, context);
 }
 
-PP_Var NPObjectToPPVarForTest(PluginInstance* instance, NPObject* object) {
+PP_Var NPObjectToPPVarForTest(PluginInstanceImpl* instance, NPObject* object) {
   v8::Isolate* test_isolate = v8::Isolate::New();
   PP_Var result = PP_MakeUndefined();
   {
     v8::HandleScope scope(test_isolate);
     v8::Isolate::Scope isolate_scope(test_isolate);
     v8::Local<v8::Context> context = v8::Context::New(test_isolate);
     result = NPObjectToPPVarImpl(instance, object, context);
   }
   test_isolate->Dispose();
   return result;
@@ skipping 75 matching lines @@
 // Throws the current exception to JS. The exception must be set.
 void PPResultAndExceptionToNPResult::ThrowException() {
   StringVar* string = StringVar::FromPPVar(exception_);
   if (string)
     WebBindings::setException(object_var_, string->value().c_str());
 }
 
 // PPVarArrayFromNPVariantArray ------------------------------------------------
 
 PPVarArrayFromNPVariantArray::PPVarArrayFromNPVariantArray(
-    PluginInstance* instance,
+    PluginInstanceImpl* instance,
     size_t size,
     const NPVariant* variants)
     : size_(size) {
   if (size_ > 0) {
     array_.reset(new PP_Var[size_]);
     for (size_t i = 0; i < size_; i++)
       array_[i] = NPVariantToPPVar(instance, &variants[i]);
   }
 }
 
 PPVarArrayFromNPVariantArray::~PPVarArrayFromNPVariantArray() {
   ::ppapi::VarTracker* var_tracker = PpapiGlobals::Get()->GetVarTracker();
   for (size_t i = 0; i < size_; i++)
     var_tracker->ReleaseVar(array_[i]);
 }
 
 // PPVarFromNPObject -----------------------------------------------------------
 
-PPVarFromNPObject::PPVarFromNPObject(PluginInstance* instance, NPObject* object)
+PPVarFromNPObject::PPVarFromNPObject(PluginInstanceImpl* instance,
+                                     NPObject* object)
     : var_(NPObjectToPPVar(instance, object)) {
 }
 
 PPVarFromNPObject::~PPVarFromNPObject() {
   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(var_);
 }
 
 // NPObjectAccessorWithIdentifier ----------------------------------------------
 
 NPObjectAccessorWithIdentifier::NPObjectAccessorWithIdentifier(
@@ skipping 34 matching lines @@
   }
 }
 
 // static
 void TryCatch::Catch(void* self, const char* message) {
   static_cast<TryCatch*>(self)->SetException(message);
 }
 
 }  // namespace ppapi
 }  // namespace webkit