Remove support for NPObjects.

content/child/npapi/npobject_util.cc

Index: content/child/npapi/npobject_util.cc
diff --git a/content/child/npapi/npobject_util.cc b/content/child/npapi/npobject_util.cc
deleted file mode 100644
index aeb66ae3700b7603c33c31ac3d2781c422534cb0..0000000000000000000000000000000000000000
--- a/content/child/npapi/npobject_util.cc
+++ /dev/null
@@ -1,310 +0,0 @@
-// Copyright 2013 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/child/npapi/npobject_util.h"
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "base/strings/string_util.h"
-#include "content/child/npapi/np_channel_base.h"
-#include "content/child/npapi/npobject_proxy.h"
-#include "content/child/npapi/plugin_host.h"
-#include "content/child/plugin_messages.h"
-#include "third_party/WebKit/public/web/WebBindings.h"
-#include "third_party/npapi/bindings/nphostapi.h"
-
-using blink::WebBindings;
-
-namespace content {
-
-// true if the current process is a plugin process, false otherwise.
-static bool g_plugin_process;
-
-namespace {
-#if defined(ENABLE_PLUGINS)
-// The next 7 functions are called by the plugin code when it's using the
-// NPObject.  Plugins always ignore the functions in NPClass (except allocate
-// and deallocate), and instead just use the function pointers that were
-// passed in NPInitialize.
-// When the renderer interacts with an NPObject from the plugin, it of course
-// uses the function pointers in its NPClass structure.
-static bool NPN_HasMethodPatch(NPP npp,
-                               NPObject *npobj,
-                               NPIdentifier methodName) {
-  return NPObjectProxy::NPHasMethod(npobj, methodName);
-}
-
-static bool NPN_InvokePatch(NPP npp, NPObject *npobj,
-                            NPIdentifier methodName,
-                            const NPVariant *args,
-                            uint32_t argCount,
-                            NPVariant *result) {
-  return NPObjectProxy::NPInvokePrivate(npp, npobj, false, methodName, args,
-                                        argCount, result);
-}
-
-static bool NPN_InvokeDefaultPatch(NPP npp,
-                                   NPObject *npobj,
-                                   const NPVariant *args,
-                                   uint32_t argCount,
-                                   NPVariant *result) {
-  return NPObjectProxy::NPInvokePrivate(npp, npobj, true, 0, args, argCount,
-                                        result);
-}
-
-static bool NPN_HasPropertyPatch(NPP npp,
-                                 NPObject *npobj,
-                                 NPIdentifier propertyName) {
-  return NPObjectProxy::NPHasProperty(npobj, propertyName);
-}
-
-static bool NPN_GetPropertyPatch(NPP npp,
-                                 NPObject *npobj,
-                                 NPIdentifier propertyName,
-                                 NPVariant *result) {
-  return NPObjectProxy::NPGetProperty(npobj, propertyName, result);
-}
-
-static bool NPN_SetPropertyPatch(NPP npp,
-                                 NPObject *npobj,
-                                 NPIdentifier propertyName,
-                                 const NPVariant *value) {
-  return NPObjectProxy::NPSetProperty(npobj, propertyName, value);
-}
-
-static bool NPN_RemovePropertyPatch(NPP npp,
-                                    NPObject *npobj,
-                                    NPIdentifier propertyName) {
-  return NPObjectProxy::NPRemoveProperty(npobj, propertyName);
-}
-
-static bool NPN_EvaluatePatch(NPP npp,
-                              NPObject *npobj,
-                              NPString *script,
-                              NPVariant *result) {
-  return NPObjectProxy::NPNEvaluate(npp, npobj, script, result);
-}
-
-
-static void NPN_SetExceptionPatch(NPObject *obj, const NPUTF8 *message) {
-  std::string message_str(message);
-  if (IsPluginProcess()) {
-    NPChannelBase* renderer_channel = NPChannelBase::GetCurrentChannel();
-    if (renderer_channel)
-      renderer_channel->Send(new PluginHostMsg_SetException(message_str));
-  } else {
-    WebBindings::setException(obj, message_str.c_str());
-  }
-}
-
-static bool NPN_EnumeratePatch(NPP npp, NPObject *obj,
-                               NPIdentifier **identifier, uint32_t *count) {
-  return NPObjectProxy::NPNEnumerate(obj, identifier, count);
-}
-
-// The overrided table of functions provided to the plugin.
-NPNetscapeFuncs *GetHostFunctions() {
-  static bool init = false;
-  static NPNetscapeFuncs host_funcs;
-  if (init)
-    return &host_funcs;
-
-  memset(&host_funcs, 0, sizeof(host_funcs));
-  host_funcs.invoke = NPN_InvokePatch;
-  host_funcs.invokeDefault = NPN_InvokeDefaultPatch;
-  host_funcs.evaluate = NPN_EvaluatePatch;
-  host_funcs.getproperty = NPN_GetPropertyPatch;
-  host_funcs.setproperty = NPN_SetPropertyPatch;
-  host_funcs.removeproperty = NPN_RemovePropertyPatch;
-  host_funcs.hasproperty = NPN_HasPropertyPatch;
-  host_funcs.hasmethod = NPN_HasMethodPatch;
-  host_funcs.setexception = NPN_SetExceptionPatch;
-  host_funcs.enumerate = NPN_EnumeratePatch;
-
-  init = true;
-  return &host_funcs;
-}
-
-#endif  // defined(ENABLE_PLUGINS)
-}
-
-#if defined(ENABLE_PLUGINS)
-void PatchNPNFunctions() {
-  g_plugin_process = true;
-  NPNetscapeFuncs* funcs = GetHostFunctions();
-  PluginHost::Singleton()->PatchNPNetscapeFuncs(funcs);
-}
-#endif
-
-bool IsPluginProcess() {
-  return g_plugin_process;
-}
-
-void CreateNPIdentifierParam(NPIdentifier id, NPIdentifier_Param* param) {
-  param->identifier = id;
-}
-
-NPIdentifier CreateNPIdentifier(const NPIdentifier_Param& param) {
-  return param.identifier;
-}
-
-void CreateNPVariantParam(const NPVariant& variant,
-                          NPChannelBase* channel,
-                          NPVariant_Param* param,
-                          bool release,
-                          int render_view_id,
-                          const GURL& page_url) {
-  switch (variant.type) {
-    case NPVariantType_Void:
-      param->type = NPVARIANT_PARAM_VOID;
-      break;
-    case NPVariantType_Null:
-      param->type = NPVARIANT_PARAM_NULL;
-      break;
-    case NPVariantType_Bool:
-      param->type = NPVARIANT_PARAM_BOOL;
-      param->bool_value = variant.value.boolValue;
-      break;
-    case NPVariantType_Int32:
-      param->type = NPVARIANT_PARAM_INT;
-      param->int_value = variant.value.intValue;
-      break;
-    case NPVariantType_Double:
-      param->type = NPVARIANT_PARAM_DOUBLE;
-      param->double_value = variant.value.doubleValue;
-      break;
-    case NPVariantType_String:
-      param->type = NPVARIANT_PARAM_STRING;
-      if (variant.value.stringValue.UTF8Length) {
-        param->string_value.assign(variant.value.stringValue.UTF8Characters,
-                                   variant.value.stringValue.UTF8Length);
-      }
-      break;
-    case NPVariantType_Object: {
-      if (variant.value.objectValue->_class == NPObjectProxy::npclass()) {
-        param->type = NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID;
-        NPObjectProxy* proxy =
-            NPObjectProxy::GetProxy(variant.value.objectValue);
-        DCHECK(proxy);
-        param->npobject_routing_id = proxy->route_id();
-        // Don't release, because our original variant is the same as our proxy.
-        release = false;
-      } else {
-        // The channel could be NULL if there was a channel error. The caller's
-        // Send call will fail anyways.
-        if (channel) {
-          // NPObjectStub adds its own reference to the NPObject it owns, so if
-          // we were supposed to release the corresponding variant
-          // (release==true), we should still do that.
-          param->type = NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID;
-          int route_id = channel->GetExistingRouteForNPObjectStub(
-              variant.value.objectValue);
-          if (route_id != MSG_ROUTING_NONE) {
-            param->npobject_routing_id = route_id;
-          } else {
-            route_id = channel->GenerateRouteID();
-            new NPObjectStub(
-                variant.value.objectValue, channel, route_id, render_view_id,
-                page_url);
-            param->npobject_routing_id = route_id;
-          }
-
-          // Include the object's owner, should be the result of
-          // _NPN_GetObjectOwner, but we don't have that.
-          NPP owner = 0;
-          param->npobject_owner_id =
-              channel->GetExistingRouteForNPObjectOwner(owner);
-        } else {
-          param->type = NPVARIANT_PARAM_VOID;
-        }
-      }
-      break;
-    }
-    default:
-      NOTREACHED();
-  }
-
-  if (release)
-    WebBindings::releaseVariantValue(const_cast<NPVariant*>(&variant));
-}
-
-bool CreateNPVariant(const NPVariant_Param& param,
-                     NPChannelBase* channel,
-                     NPVariant* result,
-                     int render_view_id,
-                     const GURL& page_url) {
-  switch (param.type) {
-    case NPVARIANT_PARAM_VOID:
-      result->type = NPVariantType_Void;
-      break;
-    case NPVARIANT_PARAM_NULL:
-      result->type = NPVariantType_Null;
-      break;
-    case NPVARIANT_PARAM_BOOL:
-      result->type = NPVariantType_Bool;
-      result->value.boolValue = param.bool_value;
-      break;
-    case NPVARIANT_PARAM_INT:
-      result->type = NPVariantType_Int32;
-      result->value.intValue = param.int_value;
-      break;
-    case NPVARIANT_PARAM_DOUBLE:
-      result->type = NPVariantType_Double;
-      result->value.doubleValue = param.double_value;
-      break;
-    case NPVARIANT_PARAM_STRING: {
-      result->type = NPVariantType_String;
-      void* buffer = malloc(param.string_value.size());
-      size_t size = param.string_value.size();
-      result->value.stringValue.UTF8Characters = static_cast<NPUTF8*>(buffer);
-      memcpy(buffer, param.string_value.c_str(), size);
-      result->value.stringValue.UTF8Length = static_cast<int>(size);
-      break;
-    }
-    case NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID: {
-      result->type = NPVariantType_Object;
-      NPObject* object =
-          channel->GetExistingNPObjectProxy(param.npobject_routing_id);
-      if (object) {
-        WebBindings::retainObject(object);
-        result->value.objectValue = object;
-      } else {
-        NPP owner =
-            channel->GetExistingNPObjectOwner(param.npobject_owner_id);
-        // TODO(wez): Once NPObject tracking lands in Blink, check |owner| and
-        // return NPVariantType_Void if it is NULL.
-        result->value.objectValue =
-            NPObjectProxy::Create(channel,
-                                  param.npobject_routing_id,
-                                  render_view_id,
-                                  page_url,
-                                  owner);
-      }
-      break;
-    }
-    case NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID: {
-      NPObjectBase* npobject_base =
-          channel->GetNPObjectListenerForRoute(param.npobject_routing_id);
-      if (!npobject_base) {
-        DLOG(WARNING) << "Invalid routing id passed in"
-                      << param.npobject_routing_id;
-        return false;
-      }
-
-      DCHECK(npobject_base->GetUnderlyingNPObject() != NULL);
-
-      result->type = NPVariantType_Object;
-      result->value.objectValue = npobject_base->GetUnderlyingNPObject();
-      WebBindings::retainObject(result->value.objectValue);
-      break;
-    }
-    default:
-      NOTREACHED();
-  }
-  return true;
-}
-
-}  // namespace content