mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/lib/libmocha/lm_plgin.c

1268 строки
34 KiB
C
Исходник Ответственный История

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
*/
/*
* JS reflection of Navigator Plugins.
*
* This file contains implementations of several JS objects:
*
* + JSPluginList, a lazily-filled array of all installed
* plug-ins, based on the information exported from lib/plugin
* by the functions in np.h. The plug-in properties in the
* array are named by plug-in name, so you can do an array
* lookup by name, e.g. plugins["Shockwave"].
*
* + JSMIMETypeList, a lazily-filled array of all handled
* MIME types, based in the information exported from libnet
* by the functions in net.h. The type properties in the
* array are named by type, so you can do an array lookup by
* type, e.g. mimetypes["video/quicktime"].
*
* + JSPlugin, the reflection of an installed plug-in, with
* static properties for the plug-in's name, file name, etc.
* and dynamic properties for the MIME types supported by
* the plug-in.
*
* + JSMIMEType, the reflection of an individual MIME type,
* with properties for the type, file extensions, platform-
* specific file type, description of the type, and enabled
* plug-in. The enabled plug-in property is a weak object
* reference marked as JSPROP_BACKEDGE to break the cycle of
* references from plug-in to mime type to plug-in.
*
*/
#include "lm.h"
#include "prmem.h"
#include "np.h"
#include "net.h"
/*
* -----------------------------------------------------------------------
*
* Data types
*
* -----------------------------------------------------------------------
*/
typedef struct JSMIMEType
{
MochaDecoder *decoder;
JSObject *obj;
JSString *type; /* MIME type itself, e.g. "text/html" */
JSString *description; /* English description of MIME type */
JSString *suffixes; /* Comma-separated list of file suffixes */
JSObject *enabledPluginObj; /* Plug-in enabled for this MIME type */
void *fileType; /* Platform-specific file type */
} JSMIMEType;
typedef struct JSPlugin
{
MochaDecoder *decoder;
JSObject *obj;
JSString *name; /* Name of plug-in */
JSString *filename; /* Name of file on disk */
JSString *description; /* Descriptive HTML (version, etc.) */
NPReference plugref; /* Opaque reference to private plugin object */
uint32 length; /* Total number of mime types we have */
XP_Bool reentrant; /* Flag to halt recursion of getProperty */
} JSPlugin;
typedef struct JSPluginList
{
MochaDecoder *decoder;
JSObject *obj;
uint32 length; /* Total number of plug-ins */
XP_Bool reentrant; /* Flag to halt recursion of getProperty */
} JSPluginList;
typedef struct JSMIMETypeList
{
MochaDecoder *decoder;
JSObject *obj;
uint32 length; /* Total number of mime types */
PRPackedBool reentrant; /* Flag to halt recursion of getProperty */
} JSMIMETypeList;
/*
* -----------------------------------------------------------------------
*
* Function protos (all private to this file)
*
* -----------------------------------------------------------------------
*/
static JSMIMEType* mimetype_create_self(JSContext *cx, MochaDecoder* decoder, char* type,
char* description, char** suffixes, uint32 numExtents, void* fileType);
JSBool PR_CALLBACK mimetype_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
void PR_CALLBACK mimetype_finalize(JSContext *cx, JSObject *obj);
static JSPlugin* plugin_create_self(JSContext *cx, MochaDecoder* decoder, char* name,
char* filename, char* description, NPReference plugref);
static JSMIMEType* plugin_create_mimetype(JSContext* cx, JSPlugin* plugin,
XP_Bool byName, const char* targetName, jsint targetSlot);
JSBool PR_CALLBACK plugin_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
JSBool PR_CALLBACK plugin_resolve_name(JSContext *cx, JSObject *obj, jsval id);
void PR_CALLBACK plugin_finalize(JSContext *cx, JSObject *obj);
static JSPluginList* pluginlist_create_self(JSContext *cx, MochaDecoder* decoder, JSObject* parent_obj);
static JSPlugin* pluginlist_create_plugin(JSContext *cx, JSPluginList *pluginlist,
XP_Bool byName, const char* targetName, jsint targetSlot);
JSBool PR_CALLBACK pluginlist_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
JSBool PR_CALLBACK pluginlist_resolve_name(JSContext *cx, JSObject *obj, jsval id);
JSBool PR_CALLBACK pluginlist_enumerate(JSContext *cx, JSObject *obj);
void PR_CALLBACK pluginlist_finalize(JSContext *cx, JSObject *obj);
JSBool PR_CALLBACK pluginlist_refresh(JSContext *cx, JSObject *obj,
uint argc, jsval *argv, jsval *rval);
static JSMIMETypeList* mimetypelist_create_self(JSContext *cx, MochaDecoder* decoder);
static JSMIMEType* mimetypelist_create_mimetype(JSContext* cx, JSMIMETypeList* mimetypelist,
XP_Bool byName, const char* targetName, jsint targetSlot);
JSBool PR_CALLBACK mimetypelist_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
JSBool PR_CALLBACK mimetypelist_resolve_name(JSContext *cx, JSObject *obj, jsval id);
JSBool PR_CALLBACK mimetypelist_enumerate(JSContext *cx, JSObject *obj);
void PR_CALLBACK mimetypelist_finalize(JSContext *cx, JSObject *obj);
/*
* -----------------------------------------------------------------------
*
* Reflection of a MIME type.
*
* -----------------------------------------------------------------------
*/
enum mimetype_slot
{
MIMETYPE_TYPE = -1,
MIMETYPE_DESCRIPTION = -2,
MIMETYPE_SUFFIXES = -3,
MIMETYPE_ENABLEDPLUGIN = -4
};
static JSPropertySpec mimetype_props[] =
{
{"type", MIMETYPE_TYPE, JSPROP_ENUMERATE|JSPROP_READONLY},
{"description", MIMETYPE_DESCRIPTION, JSPROP_ENUMERATE|JSPROP_READONLY},
{"suffixes", MIMETYPE_SUFFIXES, JSPROP_ENUMERATE|JSPROP_READONLY},
{"enabledPlugin", MIMETYPE_ENABLEDPLUGIN, JSPROP_ENUMERATE|JSPROP_READONLY},
{0}
};
static JSClass mimetype_class =
{
"MimeType", JSCLASS_HAS_PRIVATE,
JS_PropertyStub, JS_PropertyStub,
mimetype_getProperty, mimetype_getProperty, JS_EnumerateStub,
JS_ResolveStub, JS_ConvertStub, mimetype_finalize
};
PR_STATIC_CALLBACK(JSBool)
MimeType(JSContext *cx, JSObject *obj, uint argc, jsval *argv, jsval *rval)
{
return JS_TRUE;
}
/* Constructor method for a JSMIMEType object */
static JSMIMEType*
mimetype_create_self(JSContext *cx, MochaDecoder* decoder,
char* type, char* description, char ** suffixes,
uint32 numExtents, void* fileType)
{
JSObject *obj;
JSMIMEType *mimetype;
mimetype = JS_malloc(cx, sizeof(JSMIMEType));
if (!mimetype)
return NULL;
XP_BZERO(mimetype, sizeof *mimetype);
obj = JS_NewObject(cx, &mimetype_class, NULL, NULL);
if (!obj || !JS_SetPrivate(cx, obj, mimetype)) {
JS_free(cx, mimetype);
return NULL;
}
if (!JS_DefineProperties(cx, obj, mimetype_props))
return NULL;
mimetype->decoder = HOLD_BACK_COUNT(decoder);
mimetype->obj = obj;
mimetype->fileType = fileType;
mimetype->type = JS_NewStringCopyZ(cx, type);
if (!mimetype->type || !JS_LockGCThing(cx, mimetype->type))
return NULL;
mimetype->description = JS_NewStringCopyZ(cx, description);
if (!mimetype->description || !JS_LockGCThing(cx, mimetype->description))
return NULL;
/*
* Assemble the list of file extensions into a string.
* The extensions are stored in an array of individual strings, so we
* first traverse the array to see how big the concatenated string will
* be, then allocate the memory and re-traverse the array to build the
* string. Each extension is seperated by trailing comma and space.
*/
{
uint32 index;
uint32 totalSize = 0;
char *extStr;
if (numExtents > 0)
{
for (index = 0; index < numExtents; index++)
totalSize += XP_STRLEN(suffixes[index]);
/* Add space for ', ' after each extension */
totalSize += (2 * (numExtents - 1));
}
/* Total size plus terminator */
extStr = XP_ALLOC(totalSize + 1);
if (! extStr)
return NULL;
extStr[0] = 0;
for (index = 0; index < numExtents; index++)
{
extStr = strcat(extStr, suffixes[index]);
if (index < numExtents - 1)
extStr = strcat(extStr, ", ");
}
mimetype->suffixes = JS_NewStringCopyZ(cx, extStr);
XP_FREE(extStr);
if (!mimetype->suffixes || !JS_LockGCThing(cx, mimetype->suffixes))
return NULL;
}
/*
* Conjure up the JS object for the plug-in enabled for this
* MIME type. First we get the name of the plug-in from libplugin;
* then we look up the plugin object by name in the global plug-in
* list (it's actually a "resolve", not a "lookup", so that the
* plug-in object will be created if it doesn't already exist).
*/
if (type) {
char* pluginName = NPL_FindPluginEnabledForType(type);
if (pluginName)
{
/* Look up the global plugin list object */
jsval val;
if (JS_LookupProperty(cx, decoder->navigator, "plugins", &val) &&
JSVAL_IS_OBJECT(val))
{
/* Look up the desired plugin by name in the list */
JSObject* pluginListObj = JSVAL_TO_OBJECT(val);
if (JS_GetProperty(cx, pluginListObj, pluginName, &val) &&
JSVAL_IS_OBJECT(val))
{
mimetype->enabledPluginObj = JSVAL_TO_OBJECT(val);
}
}
XP_FREE(pluginName);
}
}
return mimetype;
}
JSBool PR_CALLBACK
mimetype_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
JSMIMEType *mimetype;
JSString *str;
jsint slot;
if (!JSVAL_IS_INT(id))
return JS_TRUE;
slot = JSVAL_TO_INT(id);
mimetype = JS_GetInstancePrivate(cx, obj, &mimetype_class, NULL);
if (!mimetype)
return JS_TRUE;
switch (slot)
{
case MIMETYPE_TYPE:
str = mimetype->type;
break;
case MIMETYPE_DESCRIPTION:
str = mimetype->description;
break;
case MIMETYPE_SUFFIXES:
str = mimetype->suffixes;
break;
case MIMETYPE_ENABLEDPLUGIN:
*vp = OBJECT_TO_JSVAL(mimetype->enabledPluginObj);
return JS_TRUE;
default:
/* don't mess with user-defined props. */
return JS_TRUE;
}
if (str)
*vp = STRING_TO_JSVAL(str);
else
*vp = JS_GetEmptyStringValue(cx);
return JS_TRUE;
}
void PR_CALLBACK
mimetype_finalize(JSContext *cx, JSObject *obj)
{
JSMIMEType *mimetype;
mimetype = JS_GetPrivate(cx, obj);
if (!mimetype)
return;
DROP_BACK_COUNT(mimetype->decoder);
JS_UnlockGCThing(cx, mimetype->type);
JS_UnlockGCThing(cx, mimetype->description);
JS_UnlockGCThing(cx, mimetype->suffixes);
JS_free(cx, mimetype);
}
/*
* -----------------------------------------------------------------------
*
* Reflection of an installed plug-in.
*
* -----------------------------------------------------------------------
*/
enum plugin_slot
{
PLUGIN_NAME = -1,
PLUGIN_FILENAME = -2,
PLUGIN_DESCRIPTION = -3,
PLUGIN_ARRAY_LENGTH = -4
};
static JSPropertySpec plugin_props[] =
{
{"name", PLUGIN_NAME, JSPROP_ENUMERATE | JSPROP_READONLY},
{"filename", PLUGIN_FILENAME, JSPROP_ENUMERATE | JSPROP_READONLY},
{"description", PLUGIN_DESCRIPTION, JSPROP_ENUMERATE | JSPROP_READONLY},
{"length", PLUGIN_ARRAY_LENGTH, JSPROP_ENUMERATE | JSPROP_READONLY},
{0}
};
static JSClass plugin_class =
{
"Plugin", JSCLASS_HAS_PRIVATE,
JS_PropertyStub, JS_PropertyStub,
plugin_getProperty, plugin_getProperty, JS_EnumerateStub,
plugin_resolve_name, JS_ConvertStub, plugin_finalize
};
PR_STATIC_CALLBACK(JSBool)
Plugin(JSContext *cx, JSObject *obj, uint argc, jsval *argv, jsval *rval)
{
return JS_TRUE;
}
/* Constructor method for a JSPlugin object */
static JSPlugin*
plugin_create_self(JSContext *cx, MochaDecoder* decoder, char* name,
char* filename, char* description, NPReference plugref)
{
JSObject *obj;
JSPlugin *plugin;
plugin = JS_malloc(cx, sizeof(JSPlugin));
if (!plugin)
return NULL;
XP_BZERO(plugin, sizeof *plugin);
obj = JS_NewObject(cx, &plugin_class, NULL, NULL);
if (!obj || !JS_SetPrivate(cx, obj, plugin)) {
JS_free(cx, plugin);
return NULL;
}
if (!JS_DefineProperties(cx, obj, plugin_props))
return NULL;
/* Fill out static property fields */
plugin->decoder = HOLD_BACK_COUNT(decoder);
plugin->obj = obj;
plugin->plugref = plugref;
plugin->name = JS_NewStringCopyZ(cx, name);
if (!plugin->name || !JS_LockGCThing(cx, plugin->name))
return NULL;
plugin->filename = JS_NewStringCopyZ(cx, filename);
if (!plugin->filename || !JS_LockGCThing(cx, plugin->filename))
return NULL;
plugin->description = JS_NewStringCopyZ(cx, description);
if (!plugin->description || !JS_LockGCThing(cx, plugin->description))
return NULL;
/* Count how many MIME types we have */
{
NPReference typeref = NPRefFromStart;
while (NPL_IteratePluginTypes(&typeref, plugref, NULL, NULL, NULL, NULL))
plugin->length++;
}
return plugin;
}
/* Create a mimetype property for a plugin for a specified slot or name */
static JSMIMEType*
plugin_create_mimetype(JSContext* cx, JSPlugin* plugin, XP_Bool byName,
const char* targetName, jsint targetSlot)
{
NPMIMEType type = NULL;
char** suffixes = NULL;
char* description = NULL;
void* fileType = NULL;
NPReference typeref = NPRefFromStart;
jsint slot = 0;
XP_Bool found = FALSE;
/* Search for the type (by type name or slot number) */
while (NPL_IteratePluginTypes(&typeref, plugin->plugref, &type,
&suffixes, &description, &fileType))
{
if (byName)
found = (type && (XP_STRCMP(targetName, type) == 0));
else
found = (targetSlot == slot);
if (found)
break;
slot++;
}
/* Found the mime type, so create an object and property */
if (found) {
JSMIMEType* mimetype;
uint32 numExtents = 0;
while (suffixes[numExtents])
numExtents++;
mimetype = mimetype_create_self(cx, plugin->decoder, type, description,
suffixes, numExtents, fileType);
if (mimetype) {
char *name;
jsval val;
name = JS_GetStringBytes(mimetype->type);
val = OBJECT_TO_JSVAL(mimetype->obj);
JS_DefineProperty(cx, plugin->obj, name, val, NULL, NULL,
JSPROP_ENUMERATE | JSPROP_READONLY);
JS_AliasElement(cx, plugin->obj, name, slot);
}
return mimetype;
}
return NULL;
}
JSBool PR_CALLBACK
plugin_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
JSPlugin *plugin;
JSString *str;
jsint slot;
if (!JSVAL_IS_INT(id))
return JS_TRUE;
slot = JSVAL_TO_INT(id);
plugin = JS_GetInstancePrivate(cx, obj, &plugin_class, NULL);
if (!plugin)
return JS_TRUE;
/* Prevent infinite recursion through call to GetSlot below */
if (plugin->reentrant)
return JS_TRUE;
switch (slot)
{
case PLUGIN_NAME:
str = plugin->name;
break;
case PLUGIN_FILENAME:
str = plugin->filename;
break;
case PLUGIN_DESCRIPTION:
str = plugin->description;
break;
case PLUGIN_ARRAY_LENGTH:
*vp = INT_TO_JSVAL(plugin->length);
return JS_TRUE;
default:
/* Don't mess with a user-defined property. */
if (slot >= 0 && slot < (jsint) plugin->length) {
/* Search for an existing JSMIMEType for this slot */
JSObject* mimetypeObj = NULL;
jsval val;
plugin->reentrant = TRUE;
if (JS_GetElement(cx, obj, slot, &val) && JSVAL_IS_OBJECT(val))
mimetypeObj = JSVAL_TO_OBJECT(val);
else {
JSMIMEType* mimetype;
mimetype = plugin_create_mimetype(cx, plugin, FALSE, NULL, slot);
if (mimetype)
mimetypeObj = mimetype->obj;
}
plugin->reentrant = FALSE;
*vp = OBJECT_TO_JSVAL(mimetypeObj);
return JS_TRUE;
}
return JS_FALSE;
}
if (str)
*vp = STRING_TO_JSVAL(str);
else
*vp = JS_GetEmptyStringValue(cx);
return JS_TRUE;
}
JSBool PR_CALLBACK
plugin_resolve_name(JSContext *cx, JSObject *obj, jsval id)
{
JSPlugin* plugin;
jsval val;
const char * name;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
name = JS_GetStringBytes(JSVAL_TO_STRING(id));
plugin = JS_GetPrivate(cx, obj);
if (!plugin)
return JS_TRUE;
/* Prevent infinite recursion through call to LookupProperty below */
if (plugin->reentrant)
return JS_TRUE;
/* Look for a JSMIMEType object by this name already in our list */
plugin->reentrant = TRUE;
if (JS_LookupProperty(cx, obj, name, &val) && JSVAL_IS_OBJECT(val)) {
plugin->reentrant = FALSE;
return JS_TRUE;
}
plugin->reentrant = FALSE;
/* We don't already have the object, so make a new one */
if (plugin_create_mimetype(cx, plugin, TRUE, name, 0))
return JS_TRUE;
/* Still no match for the name? Must be some other property, or invalid. */
return JS_TRUE;
}
void PR_CALLBACK
plugin_finalize(JSContext *cx, JSObject *obj)
{
JSPlugin* plugin;
plugin = JS_GetPrivate(cx, obj);
if (!plugin)
return;
DROP_BACK_COUNT(plugin->decoder);
JS_UnlockGCThing(cx, plugin->name);
JS_UnlockGCThing(cx, plugin->filename);
JS_UnlockGCThing(cx, plugin->description);
JS_free(cx, plugin);
}
/*
* -----------------------------------------------------------------------
*
* Reflection of the list of installed plug-ins.
* The only static property is the array length;
* the array elements (JSPlugins) are added
* lazily when referenced.
*
* -----------------------------------------------------------------------
*/
enum pluginlist_slot
{
PLUGINLIST_ARRAY_LENGTH = -1
};
static JSPropertySpec pluginlist_props[] =
{
{"length", PLUGINLIST_ARRAY_LENGTH, JSPROP_READONLY},
{0}
};
static JSClass pluginlist_class =
{
"PluginArray", JSCLASS_HAS_PRIVATE,
JS_PropertyStub, JS_PropertyStub,
pluginlist_getProperty, pluginlist_getProperty, pluginlist_enumerate,
pluginlist_resolve_name, JS_ConvertStub, pluginlist_finalize
};
static JSFunctionSpec pluginlist_methods[] =
{
{"refresh", pluginlist_refresh, 0},
{0}
};
PR_STATIC_CALLBACK(JSBool)
PluginList(JSContext *cx, JSObject *obj,
uint argc, jsval *argv, jsval *rval)
{
return JS_TRUE;
}
/* Constructor method for a JSPluginList object */
static JSPluginList*
pluginlist_create_self(JSContext *cx, MochaDecoder* decoder, JSObject* parent_obj)
{
JSObject *obj;
JSPluginList *pluginlist;
pluginlist = JS_malloc(cx, sizeof(JSPluginList));
if (!pluginlist)
return NULL;
XP_BZERO(pluginlist, sizeof *pluginlist);
obj = JS_InitClass(cx, parent_obj, NULL, &pluginlist_class,
PluginList, 0, pluginlist_props,
pluginlist_methods, NULL, NULL);
if (!obj || !JS_SetPrivate(cx, obj, pluginlist)) {
JS_free(cx, pluginlist);
return NULL;
}
pluginlist->decoder = HOLD_BACK_COUNT(decoder);
pluginlist->obj = obj;
{
/* Compute total number of plug-ins (potential slots) */
NPReference ref = NPRefFromStart;
while (NPL_IteratePluginFiles(&ref, NULL, NULL, NULL))
pluginlist->length++;
}
return pluginlist;
}
/* Look up the plugin for the specified slot of the plug-in list */
static JSPlugin*
pluginlist_create_plugin(JSContext *cx, JSPluginList *pluginlist, XP_Bool byName,
const char* targetName, jsint targetSlot)
{
char* plugname = NULL;
char* filename = NULL;
char* description = NULL;
NPReference plugref = NPRefFromStart;
jsint slot = 0;
XP_Bool found = FALSE;
/* Search for the plug-in (by name or slot number) */
while (NPL_IteratePluginFiles(&plugref, &plugname, &filename, &description)) {
if (byName)
found = (plugname && (XP_STRCMP(targetName, plugname) == 0));
else
found = (targetSlot == slot);
if (found)
break;
slot++;
}
/* Found the plug-in, so create an object and property */
if (found) {
JSPlugin* plugin;
plugin = plugin_create_self(cx, pluginlist->decoder, plugname,
filename, description, plugref);
if (plugin) {
char *name;
jsval val;
name = JS_GetStringBytes(plugin->name);
val = OBJECT_TO_JSVAL(plugin->obj);
JS_DefineProperty(cx, pluginlist->obj, name, val, NULL, NULL,
JSPROP_ENUMERATE | JSPROP_READONLY);
JS_AliasElement(cx, pluginlist->obj, name, slot);
}
return plugin;
}
return NULL;
}
JSBool PR_CALLBACK
pluginlist_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
JSPluginList *pluginlist;
jsint slot;
if (!JSVAL_IS_INT(id))
return JS_TRUE;
slot = JSVAL_TO_INT(id);
pluginlist = JS_GetInstancePrivate(cx, obj, &pluginlist_class, NULL);
if (!pluginlist)
return JS_TRUE;
/* Prevent infinite recursion through call to GetSlot below */
if (pluginlist->reentrant)
return JS_TRUE;
switch (slot) {
case PLUGINLIST_ARRAY_LENGTH:
*vp = INT_TO_JSVAL(pluginlist->length);
break;
default:
/* Don't mess with a user-defined property. */
if (slot >= 0 && slot < (jsint) pluginlist->length) {
/* Search for an existing JSPlugin for this slot */
JSObject* pluginObj = NULL;
jsval val;
pluginlist->reentrant = TRUE;
if (JS_GetElement(cx, obj, slot, &val) && JSVAL_IS_OBJECT(val)) {
pluginObj = JSVAL_TO_OBJECT(val);
}
else {
JSPlugin* plugin;
plugin = pluginlist_create_plugin(cx, pluginlist, FALSE, NULL, slot);
if (plugin)
pluginObj = plugin->obj;
}
pluginlist->reentrant = FALSE;
*vp = OBJECT_TO_JSVAL(pluginObj);
return JS_TRUE;
}
}
return JS_TRUE;
}
JSBool PR_CALLBACK
pluginlist_resolve_name(JSContext *cx, JSObject *obj, jsval id)
{
JSPluginList* pluginlist;
jsval val;
const char * name;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
name = JS_GetStringBytes(JSVAL_TO_STRING(id));
pluginlist = JS_GetPrivate(cx, obj);
if (!pluginlist)
return JS_TRUE;
/* Prevent infinite recursion through call to LookupProperty below */
if (pluginlist->reentrant)
return JS_TRUE;
/* Look for a JSMIMEType object by this name already in our list */
pluginlist->reentrant = TRUE;
if (JS_LookupProperty(cx, obj, name, &val) && JSVAL_IS_OBJECT(val))
{
pluginlist->reentrant = FALSE;
return JS_TRUE;
}
pluginlist->reentrant = FALSE;
/* We don't already have the object, so make a new one */
if (pluginlist_create_plugin(cx, pluginlist, TRUE, name, 0))
return JS_TRUE;
/* Still no match for the name? Must be some other property, or invalid. */
return JS_TRUE;
}
JSBool PR_CALLBACK
pluginlist_enumerate(JSContext *cx, JSObject *obj)
{
return JS_TRUE;
}
void PR_CALLBACK
pluginlist_finalize(JSContext *cx, JSObject *obj)
{
JSPluginList* pluginlist;
pluginlist = JS_GetPrivate(cx, obj);
if (!pluginlist)
return;
DROP_BACK_COUNT(pluginlist->decoder);
JS_free(cx, pluginlist);
}
JSBool PR_CALLBACK
pluginlist_refresh(JSContext *cx, JSObject *obj,
uint argc, jsval *argv, jsval *rval)
{
JSBool value = JS_FALSE;
JSPluginList* pluginlist;
JSObject* navigator;
MochaDecoder* decoder;
MochaDecoder* crippled_decoder;
NPError error = NPERR_NO_ERROR;
if (!(pluginlist = JS_GetInstancePrivate(cx, obj, &pluginlist_class, argv)))
return JS_FALSE;
decoder = pluginlist->decoder;
/*
* Evaluate the parameter (if any). If the parameter
* is missing or can't be evaluated, default to FALSE.
*/
if (argc > 0)
(void) JS_ValueToBoolean(cx, argv[0], &value);
/* Synchronously execute this function on the Mozilla thread */
error = (NPError) ET_npl_RefreshPluginList(decoder->window_context, value);
if (error != NPERR_NO_ERROR)
{
/* XXX should JS_ReportError() here, but can't happen currently */
return JS_FALSE;
}
/*
* Remove references to the existing navigator object,
* and make a new one. If scripts have outstanding
* references to the old objects, they'll still be
* valid, but if they reference navigator.plugins
* anew they'll see any new plug-ins registered by
* NPL_RefreshPlugins.
*/
navigator = decoder->navigator;
decoder->navigator = NULL; /* Prevent lm_DefineNavigator from short-circuiting */
crippled_decoder = LM_GetCrippledDecoder();
crippled_decoder->navigator = NULL;
crippled_decoder->navigator = lm_DefineNavigator(decoder);
if (!decoder->navigator)
{
/*
* We failed to create a new navigator object, so
* restore the old one (saved in a local variable).
*/
decoder->navigator = navigator;
return JS_FALSE;
}
return JS_TRUE;
}
/*
* -----------------------------------------------------------------------
*
* Reflection of the list of handled MIME types.
*
* -----------------------------------------------------------------------
*/
enum mimetypelist_slot
{
MIMETYPELIST_ARRAY_LENGTH = -1
};
static JSPropertySpec mimetypelist_props[] =
{
{"length", MIMETYPELIST_ARRAY_LENGTH, JSPROP_READONLY},
{0}
};
static JSClass mimetypelist_class =
{
"MimeTypeArray", JSCLASS_HAS_PRIVATE,
JS_PropertyStub, JS_PropertyStub,
mimetypelist_getProperty, mimetypelist_getProperty, mimetypelist_enumerate,
mimetypelist_resolve_name, JS_ConvertStub, mimetypelist_finalize
};
/* Constructor method for a JSMIMETypeList object */
static JSMIMETypeList*
mimetypelist_create_self(JSContext *cx, MochaDecoder* decoder)
{
JSObject *obj;
JSMIMETypeList *mimetypelist;
mimetypelist = JS_malloc(cx, sizeof(JSMIMETypeList));
if (!mimetypelist)
return NULL;
XP_BZERO(mimetypelist, sizeof *mimetypelist);
obj = JS_NewObject(cx, &mimetypelist_class, NULL, NULL);
if (!obj || !JS_SetPrivate(cx, obj, mimetypelist)) {
JS_free(cx, mimetypelist);
return NULL;
}
if (!JS_DefineProperties(cx, obj, mimetypelist_props))
return NULL;
mimetypelist->decoder = HOLD_BACK_COUNT(decoder);
mimetypelist->obj = obj;
/*
* Count the number of types in the list.
* We can't just go by the number of items
* in the list, since it contains encodings, too.
*/
{
XP_List* cinfoList = cinfo_MasterListPointer();
NET_cdataStruct* cdata = NULL;
mimetypelist->length = 0;
while (cinfoList)
{
cdata = cinfoList->object;
if (cdata && cdata->ci.type)
mimetypelist->length++;
cinfoList = cinfoList->next;
}
}
return mimetypelist;
}
/*
* Common code to take a cdata and create a mimetype
*/
static JSMIMEType*
define_mimetype(JSContext* cx, JSMIMETypeList* mimetypelist,
NET_cdataStruct* cdata, jsint targetSlot)
{
JSMIMEType* mimetype;
mimetype = mimetype_create_self(cx, mimetypelist->decoder, cdata->ci.type,
cdata->ci.desc, cdata->exts, cdata->num_exts, NULL);
if (mimetype) {
char *name;
name = JS_GetStringBytes(mimetype->type);
JS_DefineProperty(cx, mimetypelist->obj, name,
OBJECT_TO_JSVAL(mimetype->obj), NULL, NULL,
JSPROP_ENUMERATE | JSPROP_READONLY);
JS_AliasElement(cx, mimetypelist->obj, name, targetSlot);
}
return mimetype;
}
/* Create a mimetype property for a specified slot or name */
static JSMIMEType*
mimetypelist_create_mimetype(JSContext* cx, JSMIMETypeList* mimetypelist,
XP_Bool byName, const char* targetName, jsint targetSlot)
{
XP_List* cinfoList = cinfo_MasterListPointer();
NET_cdataStruct* cdata = NULL;
XP_Bool found = FALSE;
if (byName) {
/* Look up by name */
targetSlot = 0;
while (cinfoList) {
cdata = cinfoList->object;
if (cdata) {
char* type = cdata->ci.type;
if (type && (XP_STRCMP(type, targetName) == 0)) {
found = TRUE;
break;
}
}
targetSlot++;
cinfoList = cinfoList->next;
}
}
else {
/*
* Look up by slot.
* The slot number does not directly correspond to list index,
* since not all items in the list correspond to properties
* (encodings are in list list as well as types).
*/
uint32 count = targetSlot + 1;
while (cinfoList) {
cdata = cinfoList->object;
if (cdata && cdata->ci.type)
count--;
if (count == 0) {
found = TRUE;
break;
}
cinfoList = cinfoList->next;
}
}
if (found)
return define_mimetype(cx, mimetypelist, cdata, targetSlot);
return NULL;
}
JSBool PR_CALLBACK
mimetypelist_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
JSMIMETypeList *mimetypelist;
jsint slot;
if (!JSVAL_IS_INT(id))
return JS_TRUE;
slot = JSVAL_TO_INT(id);
mimetypelist = JS_GetInstancePrivate(cx, obj, &mimetypelist_class, NULL);
if (!mimetypelist)
return JS_TRUE;
/* Prevent infinite recursion through call to GetSlot below */
if (mimetypelist->reentrant)
return JS_TRUE;
switch (slot)
{
case MIMETYPELIST_ARRAY_LENGTH:
*vp = INT_TO_JSVAL(mimetypelist->length);
break;
default:
/* Don't mess with a user-defined property. */
if (slot >= 0 && slot < (jsint) mimetypelist->length) {
/* Search for an existing JSMIMEType for this slot */
JSObject* mimetypeObj = NULL;
jsval val = JSVAL_VOID;
mimetypelist->reentrant = TRUE;
if (JS_GetElement(cx, obj, slot, &val) && JSVAL_IS_OBJECT(val)) {
mimetypeObj = JSVAL_TO_OBJECT(val);
}
else {
JSMIMEType* mimetype;
mimetype = mimetypelist_create_mimetype(cx, mimetypelist, FALSE, NULL, slot);
if (mimetype)
mimetypeObj = mimetype->obj;
}
mimetypelist->reentrant = FALSE;
*vp = OBJECT_TO_JSVAL(mimetypeObj);
return JS_TRUE;
}
break;
}
return JS_TRUE;
}
JSBool PR_CALLBACK
mimetypelist_resolve_name(JSContext *cx, JSObject *obj, jsval id)
{
JSMIMETypeList* mimetypelist;
jsval val;
const char * name;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
name = JS_GetStringBytes(JSVAL_TO_STRING(id));
mimetypelist = JS_GetPrivate(cx, obj);
if (!mimetypelist)
return JS_TRUE;
/* Prevent infinite recursion through call to LookupProperty below */
if (mimetypelist->reentrant)
return JS_TRUE;
/* Look for a JSMIMEType object by this name already in our list */
mimetypelist->reentrant = TRUE;
if (JS_LookupProperty(cx, obj, name, &val) && JSVAL_IS_OBJECT(val))
{
mimetypelist->reentrant = FALSE;
return JS_TRUE;
}
mimetypelist->reentrant = FALSE;
/* We don't already have the object, so make a new one */
if (mimetypelist_create_mimetype(cx, mimetypelist, TRUE, name, 0))
return JS_TRUE;
/* Still no match for the name? Must be some other property, or invalid. */
return JS_TRUE;
}
JSBool PR_CALLBACK
mimetypelist_enumerate(JSContext *cx, JSObject *obj)
{
JSMIMETypeList* mimetypelist;
XP_List* cinfoList = cinfo_MasterListPointer();
NET_cdataStruct* cdata = NULL;
jsint targetSlot = 0;
mimetypelist = JS_GetPrivate(cx, obj);
if (!mimetypelist)
return JS_TRUE;
while (cinfoList) {
cdata = cinfoList->object;
if (cdata)
define_mimetype(cx, mimetypelist, cdata, targetSlot++);
cinfoList = cinfoList->next;
}
return JS_TRUE;
}
void PR_CALLBACK
mimetypelist_finalize(JSContext *cx, JSObject *obj)
{
JSMIMETypeList *mimetypelist;
mimetypelist = JS_GetPrivate(cx, obj);
if (!mimetypelist)
return;
DROP_BACK_COUNT(mimetypelist->decoder);
JS_free(cx, mimetypelist);
}
/*
* Exported entry point, called from lm_nav.c.
* This function creates the JSPluginList object. The
* properties for the installed plug-ins are instantiated
* lazily in pluginlist_resolve_name.
*/
JSObject*
lm_NewPluginList(JSContext *cx, JSObject *parent_obj)
{
MochaDecoder* decoder;
JSPluginList* pluginlist;
decoder = JS_GetPrivate(cx, JS_GetGlobalObject(cx));
pluginlist = pluginlist_create_self(cx, decoder, parent_obj);
return (pluginlist ? pluginlist->obj : NULL);
}
/*
* Exported entry point to this file, called from lm_nav.c.
* This function creates the JSMIMETypeList object. The
* properties for the MIME types are instantiated
* lazily in mimetypelist_resolve_name.
*/
JSObject*
lm_NewMIMETypeList(JSContext *cx)
{
MochaDecoder* decoder;
JSMIMETypeList* mimetypelist;
decoder = JS_GetPrivate(cx, JS_GetGlobalObject(cx));
mimetypelist = mimetypelist_create_self(cx, decoder);
return (mimetypelist ? mimetypelist->obj : NULL);
}
JSBool
lm_DefinePluginClasses(MochaDecoder *decoder)
{
JSContext *cx = decoder->js_context;
if (!JS_InitClass(cx, decoder->window_object, NULL, &mimetype_class,
MimeType, 0, mimetype_props, NULL, NULL, NULL))
return JS_FALSE;
if (!JS_InitClass(cx, decoder->window_object, NULL, &plugin_class,
Plugin, 0, plugin_props, NULL, NULL, NULL))
return JS_FALSE;
return JS_TRUE;
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку