Remove support for NPObjects.

content/renderer/npapi/webplugin_delegate_proxy.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/npapi/webplugin_delegate_proxy.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process/process.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "build/build_config.h"
 #include "cc/resources/shared_bitmap.h"
 #include "content/child/child_process.h"
 #include "content/child/child_shared_bitmap_manager.h"
-#include "content/child/npapi/npobject_proxy.h"
-#include "content/child/npapi/npobject_stub.h"
-#include "content/child/npapi/npobject_util.h"
 #include "content/child/npapi/webplugin_resource_client.h"
 #include "content/child/plugin_messages.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/cursors/webcursor.h"
 #include "content/common/frame_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/npapi/plugin_channel_host.h"
 #include "content/renderer/npapi/webplugin_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/sad_plugin.h"
 #include "ipc/ipc_channel_handle.h"
 #include "net/base/mime_util.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebDragData.h"
 #include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/WebKit/public/web/WebBindings.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/gfx/blit.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/skia_util.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #include "content/public/common/sandbox_init.h"
 #endif
 
-using blink::WebBindings;
 using blink::WebCursorInfo;
 using blink::WebDragData;
 using blink::WebInputEvent;
 using blink::WebString;
 using blink::WebView;
 
 namespace content {
 
 namespace {
 
@@ skipping 104 matching lines @@
       plugin_(plugin),
       uses_shared_bitmaps_(false),
 #if defined(OS_MACOSX)
       uses_compositor_(false),
 #elif defined(OS_WIN)
       dummy_activation_window_(NULL),
 #endif
       window_(gfx::kNullPluginWindow),
       mime_type_(mime_type),
       instance_id_(MSG_ROUTING_NONE),
-      npobject_(NULL),
-      npp_(new NPP_t),
       sad_plugin_(NULL),
       invalidate_pending_(false),
       transparent_(false),
       front_buffer_index_(0),
       page_url_(render_view_->webview()->mainFrame()->document().url()) {
 }
 
 WebPluginDelegateProxy::~WebPluginDelegateProxy() {
-  if (npobject_)
-    WebBindings::releaseObject(npobject_);
 }
 
 WebPluginDelegateProxy::SharedBitmap::SharedBitmap() {}
 
 WebPluginDelegateProxy::SharedBitmap::~SharedBitmap() {}
 
 void WebPluginDelegateProxy::PluginDestroyed() {
 #if defined(OS_MACOSX) || defined(OS_WIN)
   // Ensure that the renderer doesn't think the plugin still has focus.
   if (render_view_)
@@ skipping 15 matching lines @@
     render_view_->UnregisterPluginDelegate(this);
 
   if (channel_host_.get()) {
     Send(new PluginMsg_DestroyInstance(instance_id_));
 
     // Must remove the route after sending the destroy message, rather than
     // before, since RemoveRoute can lead to all the outstanding NPObjects
     // being told the channel went away if this was the last instance.
     channel_host_->RemoveRoute(instance_id_);
 
-    // Remove the mapping between our instance-Id and NPP identifiers, used by
-    // the channel to track object ownership, before releasing it.
-    channel_host_->RemoveMappingForNPObjectOwner(instance_id_);
-
     // Release the channel host now. If we are is the last reference to the
     // channel, this avoids a race where this renderer asks a new connection to
     // the same plugin between now and the time 'this' is actually deleted.
     // Destroying the channel host is what releases the channel name -> FD
     // association on POSIX, and if we ask for a new connection before it is
     // released, the plugin will give us a new FD, and we'll assert when trying
     // to associate it with the channel name.
     channel_host_ = NULL;
   }
 
@@ skipping 72 matching lines @@
     }
   }
 
   // Failed too often, give up.
   if (!result)
     return false;
 
   channel_host_ = channel_host;
   instance_id_ = instance_id;
 
-  channel_host_->AddRoute(instance_id_, this, NULL);
-
-  // Inform the channel of the mapping between our instance-Id and dummy NPP
-  // identifier, for use in object ownership tracking.
-  channel_host_->AddMappingForNPObjectOwner(instance_id_, GetPluginNPP());
+  channel_host_->AddRoute(instance_id_, this);
 
   // Now tell the PluginInstance in the plugin process to initialize.
   PluginMsg_Init_Params params;
   params.url = url;
   params.page_url = page_url_;
   params.arg_names = arg_names;
   params.arg_values = arg_values;
   params.host_render_view_routing_id = render_view_->routing_id();
   params.load_manually = load_manually;
 
@@ skipping 19 matching lines @@
 }
 
 bool WebPluginDelegateProxy::OnMessageReceived(const IPC::Message& msg) {
   GetContentClient()->SetActiveURL(page_url_);
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebPluginDelegateProxy, msg)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindow, OnSetWindow)
     IPC_MESSAGE_HANDLER(PluginHostMsg_CancelResource, OnCancelResource)
     IPC_MESSAGE_HANDLER(PluginHostMsg_InvalidateRect, OnInvalidateRect)
-    IPC_MESSAGE_HANDLER(PluginHostMsg_GetWindowScriptNPObject,
-                        OnGetWindowScriptNPObject)
-    IPC_MESSAGE_HANDLER(PluginHostMsg_GetPluginElement, OnGetPluginElement)
     IPC_MESSAGE_HANDLER(PluginHostMsg_ResolveProxy, OnResolveProxy)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetCookie, OnSetCookie)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetCookies, OnGetCookies)
     IPC_MESSAGE_HANDLER(PluginHostMsg_CancelDocumentLoad, OnCancelDocumentLoad)
     IPC_MESSAGE_HANDLER(PluginHostMsg_DidStartLoading, OnDidStartLoading)
     IPC_MESSAGE_HANDLER(PluginHostMsg_DidStopLoading, OnDidStopLoading)
     IPC_MESSAGE_HANDLER(PluginHostMsg_DeferResourceLoading,
                         OnDeferResourceLoading)
     IPC_MESSAGE_HANDLER(PluginHostMsg_URLRedirectResponse,
                         OnURLRedirectResponse)
@@ skipping 253 matching lines @@
 
   if (invalidate_pending_) {
     // Only send the PaintAck message if this paint is in response to an
     // invalidate from the plugin, since this message acts as an access token
     // to ensure only one process is using the shared bitmap at a time.
     invalidate_pending_ = false;
     Send(new PluginMsg_DidPaint(instance_id_));
   }
 }
 
-NPObject* WebPluginDelegateProxy::GetPluginScriptableObject() {
-  if (npobject_)
-    return WebBindings::retainObject(npobject_);
-
-  if (!channel_host_.get())
-    return NULL;
-
-  int route_id = MSG_ROUTING_NONE;
-  Send(new PluginMsg_GetPluginScriptableObject(instance_id_, &route_id));
-  if (route_id == MSG_ROUTING_NONE)
-    return NULL;
-
-  if (!channel_host_.get())
-    return nullptr;
-
-  npobject_ = NPObjectProxy::Create(
-      channel_host_.get(), route_id, 0, page_url_, GetPluginNPP());
-
-  return WebBindings::retainObject(npobject_);
-}
-
-NPP WebPluginDelegateProxy::GetPluginNPP() {
-  // Return a dummy NPP for WebKit to use to identify this plugin.
-  return npp_.get();
-}
-
 bool WebPluginDelegateProxy::GetFormValue(base::string16* value) {
   bool success = false;
   Send(new PluginMsg_GetFormValue(instance_id_, value, &success));
   return success;
 }
 
 void WebPluginDelegateProxy::SetFocus(bool focused) {
   Send(new PluginMsg_SetFocus(instance_id_, focused));
 #if defined(OS_WIN)
   if (render_view_)
@@ skipping 187 matching lines @@
       gfx::IntersectRects(rect, gfx::Rect(plugin_rect_.size()));
 
   invalidate_pending_ = true;
   // The plugin is blocked on the renderer because the invalidate message it has
   // sent us is synchronous, so we can use buffer flipping here if the caller
   // allows it.
   UpdateFrontBuffer(clipped_rect, true);
   plugin_->InvalidateRect(clipped_rect);
 }
 
-void WebPluginDelegateProxy::OnGetWindowScriptNPObject(
-    int route_id, bool* success) {
-  *success = false;
-  NPObject* npobject = NULL;
-  if (plugin_)
-    npobject = plugin_->GetWindowScriptNPObject();
-
-  if (!npobject)
-    return;
-
-  // The stub will delete itself when the proxy tells it that it's released, or
-  // otherwise when the channel is closed.
-  new NPObjectStub(npobject, channel_host_.get(), route_id, 0, page_url_);
-  *success = true;
-}
-
 void WebPluginDelegateProxy::OnResolveProxy(const GURL& url,
                                             bool* result,
                                             std::string* proxy_list) {
   *result = RenderThreadImpl::current()->ResolveProxy(url, proxy_list);
 }
 
-void WebPluginDelegateProxy::OnGetPluginElement(int route_id, bool* success) {
-  *success = false;
-  NPObject* npobject = NULL;
-  if (plugin_)
-    npobject = plugin_->GetPluginElement();
-  if (!npobject)
-    return;
-
-  // The stub will delete itself when the proxy tells it that it's released, or
-  // otherwise when the channel is closed.
-  new NPObjectStub(
-      npobject, channel_host_.get(), route_id, 0, page_url_);
-  *success = true;
-}
-
 void WebPluginDelegateProxy::OnSetCookie(const GURL& url,
                                          const GURL& first_party_for_cookies,
                                          const std::string& cookie) {
   if (plugin_)
     plugin_->SetCookie(url, first_party_for_cookies, cookie);
 }
 
 void WebPluginDelegateProxy::OnGetCookies(const GURL& url,
                                           const GURL& first_party_for_cookies,
                                           std::string* cookies) {
@@ skipping 152 matching lines @@
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }
 
 void WebPluginDelegateProxy::OnCheckIfRunInsecureContent(const GURL& url,
                                                          bool* result) {
   *result = plugin_->CheckIfRunInsecureContent(url);
 }
 
 }  // namespace content