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

webkit/plugins/ppapi/plugin_module.cc

 // 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.
 
 #include "webkit/plugins/ppapi/plugin_module.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 105 matching lines @@
 #include "ppapi/shared_impl/ppb_opengles2_shared.h"
 #include "ppapi/shared_impl/ppb_var_shared.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_graphics_2d_api.h"
 #include "ppapi/thunk/thunk.h"
 #include "webkit/plugins/plugin_switches.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/host_globals.h"
 #include "webkit/plugins/ppapi/ppapi_interface_factory.h"
-#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
+#include "webkit/plugins/ppapi/ppapi_plugin_instance_impl.h"
 #include "webkit/plugins/ppapi/ppb_gpu_blacklist_private_impl.h"
 #include "webkit/plugins/ppapi/ppb_image_data_impl.h"
 #include "webkit/plugins/ppapi/ppb_proxy_impl.h"
 #include "webkit/plugins/ppapi/ppb_scrollbar_impl.h"
 #include "webkit/plugins/ppapi/ppb_uma_private_impl.h"
 #include "webkit/plugins/ppapi/ppb_var_deprecated_impl.h"
 #include "webkit/plugins/ppapi/ppb_video_decoder_impl.h"
 
 using ppapi::InputEventData;
 using ppapi::PpapiGlobals;
@@ skipping 95 matching lines @@
 uint32_t GetLiveObjectsForInstance(PP_Instance instance_id) {
   return HostGlobals::Get()->GetResourceTracker()->GetLiveObjectsForInstance(
       instance_id);
 }
 
 PP_Bool IsOutOfProcess() {
   return PP_FALSE;
 }
 
 void SimulateInputEvent(PP_Instance instance, PP_Resource input_event) {
-  PluginInstance* plugin_instance = host_globals->GetInstance(instance);
+  PluginInstanceImpl* plugin_instance = host_globals->GetInstance(instance);
   if (!plugin_instance)
     return;
 
   EnterResource<PPB_InputEvent_API> enter(input_event, false);
   if (enter.failed())
     return;
 
   const InputEventData& input_event_data = enter.object()->GetInputEventData();
   plugin_instance->SimulateInputEvent(input_event_data);
 }
 
 PP_Var GetDocumentURL(PP_Instance instance, PP_URLComponents_Dev* components) {
-  PluginInstance* plugin_instance = host_globals->GetInstance(instance);
+  PluginInstanceImpl* plugin_instance = host_globals->GetInstance(instance);
   if (!plugin_instance)
     return PP_MakeUndefined();
   return plugin_instance->GetDocumentURL(instance, components);
 }
 
 uint32_t GetLiveVars(PP_Var live_vars[], uint32_t array_size) {
   std::vector<PP_Var> vars =
       PpapiGlobals::Get()->GetVarTracker()->GetLiveVars();
   for (size_t i = 0u;
        i < std::min(static_cast<size_t>(array_size), vars.size());
@@ skipping 220 matching lines @@
   // plugin in the usual sense, so it isn't tracked by the browser.
   scoped_refptr<PluginModule> external_plugin_module(
       new PluginModule(name_,
                        path_,
                        NULL,  // no lifetime_delegate
                        permissions_));
   return external_plugin_module;
 }
 
 PP_ExternalPluginResult PluginModule::InitAsProxiedExternalPlugin(
-    PluginInstance* instance) {
+    PluginInstanceImpl* instance) {
   DCHECK(out_of_process_proxy_.get());
   // InitAsProxied (for the trusted/out-of-process case) initializes only the
   // module, and one or more instances are added later. In this case, the
   // PluginInstance was already created as in-process, so we missed the proxy
   // AddInstance step and must do it now.
   out_of_process_proxy_->AddInstance(instance->pp_instance());
   // For external plugins, we need to tell the instance to reset itself as
   // proxied. This will clear cached interface pointers and send DidCreate (etc)
   // to the plugin side of the proxy.
   return instance->ResetAsProxied(this);
@@ skipping 23 matching lines @@
 // static
 PluginModule::GetInterfaceFunc PluginModule::GetLocalGetInterfaceFunc() {
   return &GetInterface;
 }
 
 // static
 bool PluginModule::SupportsInterface(const char* name) {
   return !!InternalGetInterface(name);
 }
 
-PluginInstance* PluginModule::CreateInstance(
+PluginInstanceImpl* PluginModule::CreateInstance(
     PluginDelegate* delegate,
     content::RenderView* render_view,
     WebKit::WebPluginContainer* container,
     const GURL& plugin_url) {
-  PluginInstance* instance = PluginInstance::Create(delegate, render_view, this,
-                                                    container, plugin_url);
+  PluginInstanceImpl* instance = PluginInstanceImpl::Create(
+      delegate, render_view, this, container, plugin_url);
   if (!instance) {
     LOG(WARNING) << "Plugin doesn't support instance interface, failing.";
     return NULL;
   }
   if (out_of_process_proxy_)
     out_of_process_proxy_->AddInstance(instance->pp_instance());
   return instance;
 }
 
-PluginInstance* PluginModule::GetSomeInstance() const {
+PluginInstanceImpl* PluginModule::GetSomeInstance() const {
   // This will generally crash later if there is not actually any instance to
   // return, so we force a crash now to make bugs easier to track down.
   CHECK(!instances_.empty());
   return *instances_.begin();
 }
 
 const void* PluginModule::GetPluginInterface(const char* name) const {
   if (out_of_process_proxy_)
     return out_of_process_proxy_->GetProxiedInterface(name);
 
   // In-process plugins.
   if (!entry_points_.get_interface)
     return NULL;
   return entry_points_.get_interface(name);
 }
 
-void PluginModule::InstanceCreated(PluginInstance* instance) {
+void PluginModule::InstanceCreated(PluginInstanceImpl* instance) {
   instances_.insert(instance);
 }
 
-void PluginModule::InstanceDeleted(PluginInstance* instance) {
+void PluginModule::InstanceDeleted(PluginInstanceImpl* instance) {
   if (out_of_process_proxy_)
     out_of_process_proxy_->RemoveInstance(instance->pp_instance());
   instances_.erase(instance);
 }
 
 scoped_refptr< ::ppapi::CallbackTracker> PluginModule::GetCallbackTracker() {
   return callback_tracker_;
 }
 
 void PluginModule::PluginCrashed() {
@@ skipping 42 matching lines @@
   int retval = entry_points.initialize_module(pp_module(), &GetInterface);
   if (retval != 0) {
     LOG(WARNING) << "PPP_InitializeModule returned failure " << retval;
     return false;
   }
   return true;
 }
 
 }  // namespace ppapi
 }  // namespace webkit