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

content/renderer/pepper/pepper_plugin_delegate_impl.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 "content/renderer/pepper/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <cstddef>
 #include <map>
 #include <queue>
@@ skipping 78 matching lines @@
 #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/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/WebKit/public/web/WebScreenInfo.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/gfx/size.h"
 #include "url/gurl.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"
 #include "webkit/plugins/ppapi/ppapi_webplugin_impl.h"
 #include "webkit/plugins/ppapi/ppb_tcp_server_socket_private_impl.h"
 #include "webkit/plugins/ppapi/ppb_tcp_socket_private_impl.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
 using WebKit::WebView;
 using WebKit::WebFrame;
 
 namespace content {
 
@@ skipping 65 matching lines @@
     if (host) {
       RenderView* render_view = host->GetRenderViewForInstance(instance);
       webkit::ppapi::PluginInstance* plugin_instance =
           host->GetPluginInstance(instance);
       render_view->Send(new ViewHostMsg_DidCreateOutOfProcessPepperInstance(
           plugin_child_id_,
           instance,
           PepperRendererInstanceData(
               0,  // The render process id will be supplied in the browser.
               render_view->GetRoutingID(),
-              plugin_instance->container()->element().document().url(),
-              plugin_instance->plugin_url()),
+              plugin_instance->GetContainer()->element().document().url(),
+              plugin_instance->GetPluginURL()),
           is_external_));
     }
   }
   virtual void RemoveInstance(PP_Instance instance) OVERRIDE {
     ppapi::proxy::HostDispatcher::RemoveForInstance(instance);
 
     RendererPpapiHostImpl* host =
         RendererPpapiHostImpl::GetForPPInstance(instance);
     // TODO(brettw) remove null check as described in AddInstance.
     if (host) {
@@ skipping 43 matching lines @@
   }
   virtual void DidFail(quota::QuotaStatusCode error) OVERRIDE {
     callback_.Run(0);
   }
  private:
   PluginCallback callback_;
 };
 
 class PluginInstanceLockTarget : public MouseLockDispatcher::LockTarget {
  public:
-  PluginInstanceLockTarget(webkit::ppapi::PluginInstance* plugin)
+  PluginInstanceLockTarget(webkit::ppapi::PluginInstanceImpl* plugin)
       : plugin_(plugin) {}
 
   virtual void OnLockMouseACK(bool succeeded) OVERRIDE {
     plugin_->OnLockMouseACK(succeeded);
   }
 
   virtual void OnMouseLockLost() OVERRIDE {
     plugin_->OnMouseLockLost();
   }
 
   virtual bool HandleMouseLockedInputEvent(
       const WebKit::WebMouseEvent &event) OVERRIDE {
     plugin_->HandleMouseLockedInputEvent(event);
     return true;
   }
 
  private:
-  webkit::ppapi::PluginInstance* plugin_;
+  webkit::ppapi::PluginInstanceImpl* plugin_;
 };
 
 void DoNotifyCloseFile(int file_open_id, base::PlatformFileError /* unused */) {
   ChildThread::current()->file_system_dispatcher()->NotifyCloseFile(
       file_open_id);
 }
 
 void DidOpenFileSystemURL(
     const webkit::ppapi::PluginDelegate::AsyncOpenFileSystemURLCallback&
         callback,
@@ skipping 244 matching lines @@
     }
   }
 
   return false;
 }
 
 void PepperPluginDelegateImpl::ViewWillInitiatePaint() {
   // Notify all of our instances that we started painting. This is used for
   // internal bookkeeping only, so we know that the set can not change under
   // us.
-  for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
+  for (std::set<webkit::ppapi::PluginInstanceImpl*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->ViewWillInitiatePaint();
 }
 
 void PepperPluginDelegateImpl::ViewInitiatedPaint() {
   // Notify all instances that we painted.  The same caveats apply as for
   // ViewFlushedPaint regarding instances closing themselves, so we take
   // similar precautions.
-  std::set<webkit::ppapi::PluginInstance*> plugins = active_instances_;
-  for (std::set<webkit::ppapi::PluginInstance*>::iterator i = plugins.begin();
+  std::set<webkit::ppapi::PluginInstanceImpl*> plugins = active_instances_;
+  for (std::set<webkit::ppapi::PluginInstanceImpl*>::iterator i =
+          plugins.begin();
        i != plugins.end(); ++i) {
     if (active_instances_.find(*i) != active_instances_.end())
       (*i)->ViewInitiatedPaint();
   }
 }
 
 void PepperPluginDelegateImpl::ViewFlushedPaint() {
   // Notify all instances that we flushed. This will call into the plugin, and
   // we it may ask to close itself as a result. This will, in turn, modify our
   // set, possibly invalidating the iterator. So we iterate on a copy that
   // won't change out from under us.
-  std::set<webkit::ppapi::PluginInstance*> plugins = active_instances_;
-  for (std::set<webkit::ppapi::PluginInstance*>::iterator i = plugins.begin();
+  std::set<webkit::ppapi::PluginInstanceImpl*> plugins = active_instances_;
+  for (std::set<webkit::ppapi::PluginInstanceImpl*>::iterator i =
+           plugins.begin();
        i != plugins.end(); ++i) {
     // The copy above makes sure our iterator is never invalid if some plugins
     // are destroyed. But some plugin may decide to close all of its views in
     // response to a paint in one of them, so we need to make sure each one is
     // still "current" before using it.
     //
     // It's possible that a plugin was destroyed, but another one was created
     // with the same address. In this case, we'll call ViewFlushedPaint on that
     // new plugin. But that's OK for this particular case since we're just
     // notifying all of our instances that the view flushed, and the new one is
     // one of our instances.
     //
     // What about the case where a new one is created in a callback at a new
     // address and we don't issue the callback? We're still OK since this
     // callback is used for flush callbacks and we could not have possibly
     // started a new paint (ViewWillInitiatePaint) for the new plugin while
     // processing a previous paint for an existing one.
     if (active_instances_.find(*i) != active_instances_.end())
       (*i)->ViewFlushedPaint();
   }
 }
 
-webkit::ppapi::PluginInstance*
+webkit::ppapi::PluginInstanceImpl*
 PepperPluginDelegateImpl::GetBitmapForOptimizedPluginPaint(
     const gfx::Rect& paint_bounds,
     TransportDIB** dib,
     gfx::Rect* location,
     gfx::Rect* clip,
     float* scale_factor) {
-  for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
+  for (std::set<webkit::ppapi::PluginInstanceImpl*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i) {
-    webkit::ppapi::PluginInstance* instance = *i;
+    webkit::ppapi::PluginInstanceImpl* instance = *i;
     // In Flash fullscreen , the plugin contents should be painted onto the
     // fullscreen widget instead of the web page.
     if (!instance->FlashIsFullscreenOrPending() &&
         instance->GetBitmapForOptimizedPluginPaint(paint_bounds, dib, location,
                                                    clip, scale_factor))
       return *i;
   }
   return NULL;
 }
 
 void PepperPluginDelegateImpl::PluginFocusChanged(
-    webkit::ppapi::PluginInstance* instance,
+    webkit::ppapi::PluginInstanceImpl* instance,
     bool focused) {
   if (focused)
     focused_plugin_ = instance;
   else if (focused_plugin_ == instance)
     focused_plugin_ = NULL;
   if (render_view_)
     render_view_->PpapiPluginFocusChanged();
 }
 
 void PepperPluginDelegateImpl::PluginTextInputTypeChanged(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   if (focused_plugin_ == instance && render_view_)
     render_view_->PpapiPluginTextInputTypeChanged();
 }
 
 void PepperPluginDelegateImpl::PluginCaretPositionChanged(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   if (focused_plugin_ == instance && render_view_)
     render_view_->PpapiPluginCaretPositionChanged();
 }
 
 void PepperPluginDelegateImpl::PluginRequestedCancelComposition(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   if (focused_plugin_ == instance && render_view_)
     render_view_->PpapiPluginCancelComposition();
 }
 
 void PepperPluginDelegateImpl::PluginSelectionChanged(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   if (focused_plugin_ == instance && render_view_)
     render_view_->PpapiPluginSelectionChanged();
 }
 
 void PepperPluginDelegateImpl::SimulateImeSetComposition(
     const string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   if (render_view_) {
@@ skipping 90 matching lines @@
   if (!focused_plugin_)
     return false;
   return focused_plugin_->IsPluginAcceptingCompositionEvents();
 }
 
 bool PepperPluginDelegateImpl::CanComposeInline() const {
   return IsPluginAcceptingCompositionEvents();
 }
 
 void PepperPluginDelegateImpl::PluginCrashed(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   render_view_->PluginCrashed(instance->module()->path(),
                               instance->module()->GetPeerProcessId());
   UnSetAndDeleteLockTargetAdapter(instance);
 }
 
 void PepperPluginDelegateImpl::InstanceCreated(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   active_instances_.insert(instance);
 
   // Set the initial focus.
   instance->SetContentAreaFocus(render_view_->has_focus());
 }
 
 void PepperPluginDelegateImpl::InstanceDeleted(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   active_instances_.erase(instance);
   UnSetAndDeleteLockTargetAdapter(instance);
 
   if (last_mouse_event_target_ == instance)
     last_mouse_event_target_ = NULL;
   if (focused_plugin_ == instance)
     PluginFocusChanged(instance, false);
 }
 
 scoped_ptr< ::ppapi::thunk::ResourceCreationAPI>
 PepperPluginDelegateImpl::CreateResourceCreationAPI(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   RendererPpapiHostImpl* host_impl = static_cast<RendererPpapiHostImpl*>(
       instance->module()->GetEmbedderState());
   return host_impl->CreateInProcessResourceCreationAPI(instance);
 }
 
 SkBitmap* PepperPluginDelegateImpl::GetSadPluginBitmap() {
   return GetContentClient()->renderer()->GetSadPluginBitmap();
 }
 
 WebKit::WebPlugin* PepperPluginDelegateImpl::CreatePluginReplacement(
     const base::FilePath& file_path) {
   return GetContentClient()->renderer()->CreatePluginReplacement(
       render_view_, file_path);
 }
 
 webkit::ppapi::PluginDelegate::PlatformImage2D*
 PepperPluginDelegateImpl::CreateImage2D(int width, int height) {
   return PepperPlatformImage2DImpl::Create(width, height);
 }
 
 webkit::ppapi::PluginDelegate::PlatformGraphics2D*
 PepperPluginDelegateImpl::GetGraphics2D(
-    webkit::ppapi::PluginInstance* instance,
+    webkit::ppapi::PluginInstanceImpl* instance,
     PP_Resource resource) {
   ppapi::host::ResourceHost* host =
       GetRendererResourceHost(instance->pp_instance(), resource);
   if (!host)
     return NULL;
   PepperGraphics2DHost* result = host->AsPepperGraphics2DHost();
   DLOG_IF(ERROR, !result) << "Resource is not PepperGraphics2DHost.";
   return result;
 }
 
@@ skipping 148 matching lines @@
   callback->Run(error_code, base::PassPlatformFile(&file));
   // Make sure we won't leak file handle if the requester has died.
   if (file != base::kInvalidPlatformFileValue)
     base::FileUtilProxy::Close(GetFileThreadMessageLoopProxy().get(),
                                file,
                                base::FileUtilProxy::StatusCallback());
   delete callback;
 }
 
 void PepperPluginDelegateImpl::OnSetFocus(bool has_focus) {
-  for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
+  for (std::set<webkit::ppapi::PluginInstanceImpl*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->SetContentAreaFocus(has_focus);
 }
 
 void PepperPluginDelegateImpl::PageVisibilityChanged(bool is_visible) {
-  for (std::set<webkit::ppapi::PluginInstance*>::iterator i =
+  for (std::set<webkit::ppapi::PluginInstanceImpl*>::iterator i =
            active_instances_.begin();
        i != active_instances_.end(); ++i)
     (*i)->PageVisibilityChanged(is_visible);
 }
 
 bool PepperPluginDelegateImpl::IsPluginFocused() const {
   return focused_plugin_ != NULL;
 }
 
 void PepperPluginDelegateImpl::WillHandleMouseEvent() {
@@ skipping 280 matching lines @@
     const std::vector<char>& der,
     ppapi::PPB_X509Certificate_Fields* fields) {
   bool succeeded = false;
   render_view_->Send(
       new PpapiHostMsg_PPBX509Certificate_ParseDER(der, &succeeded, fields));
   return succeeded;
 }
 
 webkit::ppapi::FullscreenContainer*
 PepperPluginDelegateImpl::CreateFullscreenContainer(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   return render_view_->CreatePepperFullscreenContainer(instance);
 }
 
 gfx::Size PepperPluginDelegateImpl::GetScreenSize() {
   WebKit::WebScreenInfo info = render_view_->screenInfo();
   return gfx::Size(info.rect.width, info.rect.height);
 }
 
 std::string PepperPluginDelegateImpl::GetDefaultEncoding() {
   return render_view_->webkit_preferences().default_encoding;
 }
 
 void PepperPluginDelegateImpl::ZoomLimitsChanged(double minimum_factor,
                                                  double maximum_factor) {
   double minimum_level = WebView::zoomFactorToZoomLevel(minimum_factor);
   double maximum_level = WebView::zoomFactorToZoomLevel(maximum_factor);
   render_view_->webview()->zoomLimitsChanged(minimum_level, maximum_level);
 }
 
 void PepperPluginDelegateImpl::HandleDocumentLoad(
-    webkit::ppapi::PluginInstance* instance,
+    webkit::ppapi::PluginInstanceImpl* instance,
     const WebKit::WebURLResponse& response) {
   DCHECK(!instance->document_loader());
 
   PP_Instance pp_instance = instance->pp_instance();
   RendererPpapiHostImpl* host_impl = static_cast<RendererPpapiHostImpl*>(
       instance->module()->GetEmbedderState());
 
   // Create a loader resource host for this load. Note that we have to set
   // the document_loader before issuing the in-process
   // PPP_Instance.HandleDocumentLoad call below, since this may reentrantly
@@ skipping 64 matching lines @@
 base::SharedMemory* PepperPluginDelegateImpl::CreateAnonymousSharedMemory(
     size_t size) {
   return RenderThread::Get()->HostAllocateSharedMemoryBuffer(size).release();
 }
 
 ppapi::Preferences PepperPluginDelegateImpl::GetPreferences() {
   return ppapi::Preferences(render_view_->webkit_preferences());
 }
 
 bool PepperPluginDelegateImpl::LockMouse(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   return GetMouseLockDispatcher(instance)->LockMouse(
       GetOrCreateLockTargetAdapter(instance));
 }
 
 void PepperPluginDelegateImpl::UnlockMouse(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   GetMouseLockDispatcher(instance)->UnlockMouse(
       GetOrCreateLockTargetAdapter(instance));
 }
 
 bool PepperPluginDelegateImpl::IsMouseLocked(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   return GetMouseLockDispatcher(instance)->IsMouseLockedTo(
       GetOrCreateLockTargetAdapter(instance));
 }
 
 void PepperPluginDelegateImpl::DidChangeCursor(
-    webkit::ppapi::PluginInstance* instance,
+    webkit::ppapi::PluginInstanceImpl* instance,
     const WebKit::WebCursorInfo& cursor) {
   // Update the cursor appearance immediately if the requesting plugin is the
   // one which receives the last mouse event. Otherwise, the new cursor won't be
   // picked up until the plugin gets the next input event. That is bad if, e.g.,
   // the plugin would like to set an invisible cursor when there isn't any user
   // input for a while.
   if (instance == last_mouse_event_target_)
     render_view_->didChangeCursor(cursor);
 }
 
 void PepperPluginDelegateImpl::DidReceiveMouseEvent(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   last_mouse_event_target_ = instance;
 }
 
 bool PepperPluginDelegateImpl::IsInFullscreenMode() {
   return render_view_->is_fullscreen();
 }
 
 void PepperPluginDelegateImpl::SampleGamepads(WebKit::WebGamepads* data) {
   if (!gamepad_shared_memory_reader_)
     gamepad_shared_memory_reader_.reset(new GamepadSharedMemoryReader);
@@ skipping 225 matching lines @@
       NOTREACHED();
       return 0;
   }
 #else
   return 0;
 #endif
 }
 
 MouseLockDispatcher::LockTarget*
     PepperPluginDelegateImpl::GetOrCreateLockTargetAdapter(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   MouseLockDispatcher::LockTarget* target = mouse_lock_instances_[instance];
   if (target)
     return target;
 
   return mouse_lock_instances_[instance] =
       new PluginInstanceLockTarget(instance);
 }
 
 void PepperPluginDelegateImpl::UnSetAndDeleteLockTargetAdapter(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   LockTargetMap::iterator it = mouse_lock_instances_.find(instance);
   if (it != mouse_lock_instances_.end()) {
     MouseLockDispatcher::LockTarget* target = it->second;
     GetMouseLockDispatcher(instance)->OnLockTargetDestroyed(target);
     delete target;
     mouse_lock_instances_.erase(it);
   }
 }
 
 MouseLockDispatcher* PepperPluginDelegateImpl::GetMouseLockDispatcher(
-    webkit::ppapi::PluginInstance* instance) {
+    webkit::ppapi::PluginInstanceImpl* instance) {
   if (instance->flash_fullscreen()) {
     RenderWidgetFullscreenPepper* container =
         static_cast<RenderWidgetFullscreenPepper*>(
             instance->fullscreen_container());
     return container->mouse_lock_dispatcher();
   } else {
     return render_view_->mouse_lock_dispatcher();
   }
 }
 
 IPC::PlatformFileForTransit PepperPluginDelegateImpl::ShareHandleWithRemote(
     base::PlatformFile handle,
     base::ProcessId target_process_id,
     bool should_close_source) const {
   return BrokerGetFileHandleForProcess(
       handle,
       target_process_id,
       should_close_source);
 }
 
 bool PepperPluginDelegateImpl::IsRunningInProcess(PP_Instance instance) const {
   RendererPpapiHostImpl* host =
       RendererPpapiHostImpl::GetForPPInstance(instance);
   return host && host->IsRunningInProcess();
 }
 
 }  // namespace content