Hide knowledge of webkit::ppapi::Plugin from chrome. This is part of moving ppapi implementation fr…

webkit/plugins/ppapi/ppapi_plugin_instance.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/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 13 matching lines @@
 #include "ppapi/c/dev/ppp_zoom_dev.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/c/ppb_core.h"
 #include "ppapi/c/ppb_gamepad.h"
 #include "ppapi/c/ppp_input_event.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/c/ppp_mouse_lock.h"
 #include "ppapi/c/private/ppp_instance_private.h"
+#include "ppapi/shared_impl/ppapi_permissions.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/ppb_gamepad_shared.h"
 #include "ppapi/shared_impl/ppb_input_event_shared.h"
 #include "ppapi/shared_impl/ppb_url_util_shared.h"
 #include "ppapi/shared_impl/ppb_view_shared.h"
 #include "ppapi/shared_impl/ppp_instance_combined.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/shared_impl/time_conversion.h"
 #include "ppapi/shared_impl/url_request_info_data.h"
@@ skipping 2407 matching lines @@
                                                         components);
 }
 
 PP_Var PluginInstance::GetPluginInstanceURL(
     PP_Instance instance,
     PP_URLComponents_Dev* components) {
   return ::ppapi::PPB_URLUtil_Shared::GenerateURLReturn(plugin_url_,
                                                         components);
 }
 
-PP_NaClResult PluginInstance::ResetAsProxied(
+PP_ExternalPluginResult PluginInstance::ResetAsProxied(
     scoped_refptr<PluginModule> module) {
   // Save the original module and switch over to the new one now that this
   // plugin is using the IPC-based proxy.
   original_module_ = module_;
   module_ = module;
 
   // Don't send any messages to the plugin until DidCreate() has finished.
   message_channel_->QueueJavaScriptMessages();
 
   // For NaCl instances, remember the NaCl plugin instance interface, so we
   // can shut it down by calling its DidDestroy in our Delete() method.
   original_instance_interface_.reset(instance_interface_.release());
 
   base::Callback<const void*(const char*)> get_plugin_interface_func =
       base::Bind(&PluginModule::GetPluginInterface, module_.get());
   PPP_Instance_Combined* ppp_instance_combined =
       PPP_Instance_Combined::Create(get_plugin_interface_func);
   if (!ppp_instance_combined) {
     // The proxy must support at least one usable PPP_Instance interface.
     // While this could be a failure to implement the interface in the NaCl
     // module, it is more likely that the NaCl process has crashed. Either
     // way, report that module initialization failed.
-    return PP_NACL_ERROR_MODULE;
+    return PP_EXTERNAL_PLUGIN_ERROR_MODULE;
   }
 
   instance_interface_.reset(ppp_instance_combined);
   // Clear all PPP interfaces we may have cached.
   plugin_find_interface_ = NULL;
   plugin_input_event_interface_ = NULL;
   checked_for_plugin_input_event_interface_ = false;
   plugin_messaging_interface_ = NULL;
   checked_for_plugin_messaging_interface_ = false;
   plugin_mouse_lock_interface_ = NULL;
   plugin_pdf_interface_ = NULL;
   checked_for_plugin_pdf_interface_ = false;
   plugin_private_interface_ = NULL;
   plugin_selection_interface_ = NULL;
   plugin_textinput_interface_ = NULL;
   plugin_zoom_interface_ = NULL;
 
   // Re-send the DidCreate event via the proxy.
   scoped_ptr<const char*[]> argn_array(StringVectorToArgArray(argn_));
   scoped_ptr<const char*[]> argv_array(StringVectorToArgArray(argv_));
   if (!instance_interface_->DidCreate(pp_instance(), argn_.size(),
                                       argn_array.get(), argv_array.get()))
-    return PP_NACL_ERROR_INSTANCE;
+    return PP_EXTERNAL_PLUGIN_ERROR_INSTANCE;
   message_channel_->StopQueueingJavaScriptMessages();
 
   // Clear sent_initial_did_change_view_ and cancel any pending DidChangeView
   // event. This way, SendDidChangeView will send the "current" view
   // immediately (before other events like HandleDocumentLoad).
   sent_initial_did_change_view_ = false;
   view_change_weak_ptr_factory_.InvalidateWeakPtrs();
   SendDidChangeView();
 
   DCHECK(nacl_document_load_);
   nacl_document_load_ = false;
   if (!nacl_document_response_.isNull()) {
     document_loader_ = NULL;
     // Pass the response to the new proxy.
     HandleDocumentLoad(nacl_document_response_);
     nacl_document_response_ = WebKit::WebURLResponse();
     // Replay any document load events we've received to the real loader.
     nacl_document_loader_->ReplayReceivedData(document_loader_);
     nacl_document_loader_.reset(NULL);
   }
 
-  return PP_NACL_OK;
+  return PP_EXTERNAL_PLUGIN_OK;
 }
 
 bool PluginInstance::IsValidInstanceOf(PluginModule* module) {
   DCHECK(module);
   return module == module_.get() ||
          module == original_module_.get();
 }
 
 NPP PluginInstance::instanceNPP() {
   return npp_.get();
@@ skipping 37 matching lines @@
     return 0;
 
   skia::PlatformCanvas* canvas = image_data->GetPlatformCanvas();
   // Note: Do not SkBitmap::copyTo the canvas bitmap directly because it will
   // ignore the allocated pixels in shared memory and re-allocate a new buffer.
   canvas->writePixels(image_skia_rep.sk_bitmap(), 0, 0);
 
   return image_data->GetReference();
 }
 
+base::FilePath PluginInstance::GetModulePath() {
+  return module_->path();
+}
+
+PP_ExternalPluginResult PluginInstance::SwitchToOutOfProcessProxy(
+    const base::FilePath& file_path,
+    ::ppapi::PpapiPermissions permissions,
+    const IPC::ChannelHandle& channel_handle,
+    base::ProcessId plugin_pid,
+    int plugin_child_id) {
+  // Create a new module for each instance of the external plugin that is using
+  // the IPC based out-of-process proxy. We can't use the existing module,
+  // because it is configured for the in-process plugin, and we must keep it
+  // that way to allow the page to create other instances.
+  scoped_refptr<webkit::ppapi::PluginModule> external_plugin_module(
+      module_->CreateModuleForExternalPluginInstance());
+
+  content::RendererPpapiHost* renderer_ppapi_host =
+      delegate_->CreateExternalPluginModule(
+          external_plugin_module,
+          file_path,
+          permissions,
+          channel_handle,
+          plugin_pid,
+          plugin_child_id);
+  if (!renderer_ppapi_host) {
+    DLOG(ERROR) << "CreateExternalPluginModule() failed";
+    return PP_EXTERNAL_PLUGIN_ERROR_MODULE;
+  }
+
+  // Finally, switch the instance to the proxy.
+  return external_plugin_module->InitAsProxiedExternalPlugin(this);
+}
+
 void PluginInstance::DoSetCursor(WebCursorInfo* cursor) {
   cursor_.reset(cursor);
   if (fullscreen_container_) {
     fullscreen_container_->DidChangeCursor(*cursor);
   } else {
     delegate()->DidChangeCursor(this, *cursor);
   }
 }
 
 bool PluginInstance::CanAccessMainFrame() const {
@@ skipping 50 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit