Remove support for NPObjects.

content/renderer/npapi/webplugin_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/npapi/webplugin_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/location.h"
@@ skipping 80 matching lines @@
 
 bool WebPluginImpl::initialize(WebPluginContainer* container) {
   if (!render_view_.get()) {
     LOG(ERROR) << "No RenderView";
     return false;
   }
 
   WebPluginDelegateProxy* plugin_delegate = new WebPluginDelegateProxy(
       this, mime_type_, render_view_, render_frame_);
 
-  // Store the plugin's unique identifier, used by the container to track its
-  // script objects.
-  npp_ = plugin_delegate->GetPluginNPP();
-
   // Set the container before Initialize because the plugin may
   // synchronously call NPN_GetValue to get its container, or make calls
   // passing script objects that need to be tracked, during initialization.
   SetContainer(container);
 
   bool ok = plugin_delegate->Initialize(
       plugin_url_, arg_names_, arg_values_, load_manually_);
   if (!ok) {
     plugin_delegate->PluginDestroyed();
 
@@ skipping 20 matching lines @@
   delegate_ = plugin_delegate;
 
   return true;
 }
 
 void WebPluginImpl::destroy() {
   SetContainer(NULL);
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
-NPObject* WebPluginImpl::scriptableObject() {
-  if (!delegate_)
-    return NULL;
-
-  return delegate_->GetPluginScriptableObject();
-}
-
-NPP WebPluginImpl::pluginNPP() {
-  return npp_;
-}
-
 bool WebPluginImpl::getFormValue(blink::WebString& value) {
   if (!delegate_)
     return false;
   base::string16 form_value;
   if (!delegate_->GetFormValue(&form_value))
     return false;
   value = form_value;
   return true;
 }
 
@@ skipping 97 matching lines @@
     WebFrame* webframe,
     const WebPluginParams& params,
     const base::FilePath& file_path,
     const base::WeakPtr<RenderViewImpl>& render_view,
     RenderFrameImpl* render_frame)
     : render_frame_(render_frame),
       render_view_(render_view),
       webframe_(webframe),
       delegate_(NULL),
       container_(NULL),
-      npp_(NULL),
       plugin_url_(params.url),
       load_manually_(params.loadManually),
       first_geometry_update_(true),
       ignore_response_error_(false),
       file_path_(file_path),
       mime_type_(base::ToLowerASCII(base::UTF16ToASCII(
           base::StringPiece16(params.mimeType)))) {
   DCHECK_EQ(params.attributeNames.size(), params.attributeValues.size());
 
   for (size_t i = 0; i < params.attributeNames.size(); ++i) {
@@ skipping 140 matching lines @@
       // to recover at this point.  Break out.
       NOTREACHED();
       return ROUTED;
     }
   }
 
   container_->loadFrameRequest(request, target_str);
   return ROUTED;
 }
 
-NPObject* WebPluginImpl::GetWindowScriptNPObject() {
-  if (!webframe_) {
-    NOTREACHED();
-    return NULL;
-  }
-  return webframe_->windowObject();
-}
-
-NPObject* WebPluginImpl::GetPluginElement() {
-  return container_->scriptableObjectForElement();
-}
-
 bool WebPluginImpl::FindProxyForUrl(const GURL& url, std::string* proxy_list) {
   // Proxy resolving doesn't work in single-process mode.
   return false;
 }
 
 void WebPluginImpl::SetCookie(const GURL& url,
                               const GURL& first_party_for_cookies,
                               const std::string& cookie) {
   if (!render_view_.get())
     return;
@@ skipping 81 matching lines @@
 
 void WebPluginImpl::InvalidateRect(const gfx::Rect& rect) {
   if (container_)
     container_->invalidateRect(rect);
 }
 
 void WebPluginImpl::SetContainer(WebPluginContainer* container) {
   if (!container)
     TearDownPluginInstance(NULL);
   container_ = container;
-  if (container_)
-    container_->allowScriptObjects();
 }
 
 unsigned long WebPluginImpl::GetNextResourceId() {
   if (!webframe_)
     return 0;
   WebView* view = webframe_->view();
   if (!view)
     return 0;
   return view->createUniqueIdentifierForRequest();
 }
@@ skipping 37 matching lines @@
 
   // Destroy the current plugin instance.
   TearDownPluginInstance(loader);
 
   container_ = container_widget;
   webframe_ = webframe;
 
   WebPluginDelegateProxy* plugin_delegate = new WebPluginDelegateProxy(
       this, mime_type_, render_view_, render_frame_);
 
-  // Store the plugin's unique identifier, used by the container to track its
-  // script objects, and enable script objects (since Initialize may use them
-  // even if it fails).
-  npp_ = plugin_delegate->GetPluginNPP();
-  container_->allowScriptObjects();
-
   bool ok = plugin_delegate && plugin_delegate->Initialize(
       plugin_url_, arg_names_, arg_values_, load_manually_);
 
   if (!ok) {
-    container_->clearScriptObjects();
     container_ = NULL;
     // TODO(iyengar) Should we delete the current plugin instance here?
     return false;
   }
 
   delegate_ = plugin_delegate;
 
   // Force a geometry update to occur to ensure that the plugin becomes
   // visible.
   container_->reportGeometry();
 
   // The plugin move sequences accumulated via DidMove are sent to the browser
   // whenever the renderer paints. Force a paint here to ensure that changes
   // to the plugin window are propagated to the browser.
   container_->invalidate();
   return true;
 }
 
 void WebPluginImpl::TearDownPluginInstance(
     WebURLLoader* loader_to_ignore) {
   // JavaScript garbage collection may cause plugin script object references to
   // be retained long after the plugin is destroyed. Some plugins won't cope
   // with their objects being released after they've been destroyed, and once
   // we've actually unloaded the plugin the object's releaseobject() code may
   // no longer be in memory. The container tracks the plugin's objects and lets
   // us invalidate them, releasing the references to them held by the JavaScript
   // runtime.
   if (container_) {
-    container_->clearScriptObjects();
     container_->setWebLayer(NULL);
   }
 
   // Call PluginDestroyed() first to prevent the plugin from calling us back
   // in the middle of tearing down the render tree.
   if (delegate_) {
     // The plugin may call into the browser and pass script objects even during
     // teardown, so temporarily re-enable plugin script objects.
     DCHECK(container_);
-    container_->allowScriptObjects();
 
     delegate_->PluginDestroyed();
     delegate_ = NULL;
-
-    // Invalidate any script objects created during teardown here, before the
-    // plugin might actually be unloaded.
-    container_->clearScriptObjects();
   }
 
   // This needs to be called now and not in the destructor since the
   // webframe_ might not be valid anymore.
   webframe_ = NULL;
 }
 
 void WebPluginImpl::SetReferrer(blink::WebURLRequest* request,
                                 ReferrerValue referrer_flag) {
   switch (referrer_flag) {
     case DOCUMENT_URL:
       webframe_->setReferrerForRequest(*request, GURL());
       break;
 
     case PLUGIN_SRC:
       webframe_->setReferrerForRequest(*request, plugin_url_);
       break;
 
     default:
       break;
   }
 }
 
 }  // namespace content