Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-05 16:46:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
003b6f4a78
gecko-dev/lib/libmocha/lm.h

873 lines
29 KiB
C
Raw Blame History

/* -*- 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.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
#ifndef lm_h___
#define lm_h___
/*
* JS in the Navigator library-private interface.
*/
#include "xp.h" /* for uint and PA_Block */
#include "prlong.h" /* for int64 time type used below */
#include "libevent.h" /* until its a stand-alone */
#include "libmocha.h"
/*
* Shared string constants for common property names.
*/
extern char lm_argc_err_str[]; /* "incorrect number of arguments" */
extern char lm_unknown_origin_str[]; /* "[unknown origin]" */
extern char lm_onLoad_str[]; /* "onLoad" */
extern char lm_onUnload_str[]; /* "onUnload" */
extern char lm_onAbort_str[]; /* "onAbort" */
extern char lm_onError_str[]; /* "onError" */
extern char lm_onScroll_str[]; /* "onScroll" */
extern char lm_onFocus_str[]; /* "onFocus" */
extern char lm_onBlur_str[]; /* "onBlur" */
extern char lm_onSelect_str[]; /* "onSelect" */
extern char lm_onChange_str[]; /* "onChange" */
extern char lm_onReset_str[]; /* "onReset" */
extern char lm_onSubmit_str[]; /* "onSubmit" */
extern char lm_onClick_str[]; /* "onClick" */
extern char lm_onMouseDown_str[]; /* "onMouseDown" */
extern char lm_onMouseOver_str[]; /* "onMouseOver" */
extern char lm_onMouseOut_str[]; /* "onMouseOut" */
extern char lm_onMouseUp_str[]; /* "onMouseUp" */
extern char lm_onLocate_str[]; /* "onLocate" */
extern char lm_onHelp_str[]; /* "onHelp" [EA] */
extern char lm_focus_str[]; /* "focus" */
extern char lm_blur_str[]; /* "blur" */
extern char lm_select_str[]; /* "select" */
extern char lm_click_str[]; /* "click" */
extern char lm_scroll_str[]; /* "scroll" */
extern char lm_enable_str[]; /* "enable" */
extern char lm_disable_str[]; /* "disable" */
extern char lm_toString_str[]; /* "toString" */
extern char lm_length_str[]; /* "length" */
extern char lm_document_str[]; /* "document" */
extern char lm_forms_str[]; /* "forms" */
extern char lm_links_str[]; /* "links" */
extern char lm_anchors_str[]; /* "anchors" */
extern char lm_applets_str[]; /* "applets" */
extern char lm_embeds_str[]; /* "embeds" */
extern char lm_plugins_str[]; /* "plugins" */
extern char lm_images_str[]; /* "images" */
extern char lm_layers_str[]; /* "layers" */
#ifdef DOM
extern char lm_spans_str[]; /* "spans" */
extern char lm_transclusions_str[]; /* "transclusions" */
#endif
extern char lm_builtins_str[];
extern char lm_location_str[]; /* "location" */
extern char lm_navigator_str[]; /* "navigator" */
extern char lm_netcaster_str[]; /* "netcaster" */
extern char lm_components_str[]; /* "components" */
extern char lm_parentLayer_str[]; /* "parentLayer" */
extern char lm_opener_str[]; /* "opener" */
extern char lm_closed_str[]; /* "closed" */
extern char lm_assign_str[]; /* "assign" */
extern char lm_reload_str[]; /* "reload" */
extern char lm_replace_str[]; /* "replace" */
extern char lm_event_str[]; /* "event" */
extern char lm_methodPrefix_str[]; /* "#method" */
extern char lm_methodArgc_str[]; /* "#method" */
extern char lm_methodArgv_str[]; /* "#method" */
extern char lm_getPrefix_str[]; /* "#get_" */
extern char lm_setPrefix_str[]; /* "#set_" */
extern char lm_typePrefix_str[]; /* "#type_" */
extern const char *lm_event_argv[]; /* {lm_event_str} */
extern PRThread *lm_InterpretThread;
extern PRThread *mozilla_thread;
extern PRThread *lm_js_lock_previous_owner;
extern JSContext *lm_writing_context;
/*
* Timeout structure threaded on MochaDecoder.timeouts for cleanup.
*/
struct JSTimeout {
int32 ref_count; /* reference count to shared usage */
char *expr; /* the JS expression to evaluate */
JSObject *funobj; /* or function to call, if !expr */
jsval *argv; /* function actual arguments */
void *toid; /* Identifier, used internally only */
uint32 public_id; /* Returned as value of setTimeout() */
uint16 argc; /* and argument count */
uint16 spare; /* alignment padding */
int32 doc_id; /* document this is for */
int32 interval; /* Non-zero if repetitive timeout */
int64 when; /* nominal time to run this timeout */
JSVersion version; /* Version of JavaScript to execute */
JSPrincipals *principals; /* principals with which to execute */
char *filename; /* filename of setTimeout call */
uint32 lineno; /* line number of setTimeout call */
JSTimeout *next; /* next timeout in list */
};
extern void lm_ClearWindowTimeouts(MochaDecoder *decoder);
struct JSNestingUrl {
JSNestingUrl *next;
char *str;
};
/*
* Event queue stack madness to handle doc.write("<script>doc.write...").
*/
typedef struct QueueStackElement {
PREventQueue * queue;
MWContext * context;
int32 doc_id;
struct QueueStackElement * up;
struct QueueStackElement * down;
PRPackedBool done;
PRPackedBool discarding;
PRPackedBool inherit_parent;
void * retval;
} QueueStackElement;
extern void
et_SubEventLoop(QueueStackElement * qse);
/*
* Stack size per window context, plus one for the navigator.
*/
#define LM_STACK_SIZE 8192
extern JSRuntime *lm_runtime;
extern JSClass lm_window_class;
extern JSClass lm_layer_class;
extern JSClass lm_document_class;
extern JSClass lm_event_class;
extern JSBool lm_SaveParamString(JSContext *cx, PA_Block *bp,
const char *str);
extern MochaDecoder *lm_NewWindow(MWContext *context);
extern void lm_DestroyWindow(MochaDecoder *decoder);
/*
* Hold and drop the reference count for tree back-edges that go from object
* private data to the containing decoder. These refs do not keep the object
* tree under decoder alive from the GC, but they do keep decoder from being
* destroyed and some out of order finalizer tripping over its freed memory.
*/
#ifdef DEBUG
extern MochaDecoder *lm_HoldBackCount(MochaDecoder *decoder);
extern void lm_DropBackCount(MochaDecoder *decoder);
#define HOLD_BACK_COUNT(decoder) lm_HoldBackCount(decoder)
#define DROP_BACK_COUNT(decoder) lm_DropBackCount(decoder)
#else
#define HOLD_BACK_COUNT(decoder) \
(((decoder) ? (decoder)->back_count++ : 0), (decoder))
#define DROP_BACK_COUNT(decoder) \
(((decoder) && --(decoder)->back_count <= 0 && !(decoder)->forw_count) \
? lm_DestroyWindow(decoder) \
: (void)0)
#endif
extern JSBool lm_InitWindowContent(MochaDecoder *decoder);
extern JSBool lm_DefineWindowProps(JSContext *cx,
MochaDecoder *decoder);
extern JSBool lm_ResolveWindowProps(JSContext *cx,
MochaDecoder *decoder,
JSObject *obj,
jsval id);
extern void lm_FreeWindowContent(MochaDecoder *decoder,
JSBool fromDiscard);
extern JSBool lm_SetInputStream(JSContext *cx,
MochaDecoder *decoder,
NET_StreamClass *stream,
URL_Struct *url_struct,
JSBool free_stream_on_close);
extern JSObject *lm_DefineDocument(MochaDecoder *decoder,
int32 layer_id);
extern JSObject *lm_DefineHistory(MochaDecoder *decoder);
extern JSObject *lm_DefineLocation(MochaDecoder *decoder);
extern JSObject *lm_DefineNavigator(MochaDecoder *decoder);
extern JSObject *lm_DefineComponents(MochaDecoder *decoder);
extern JSObject *lm_DefineCrypto(MochaDecoder *decoder);
extern JSObject *lm_DefineScreen(MochaDecoder *decoder,
JSObject *parent);
#ifdef NAV_HARDWARE
extern JSObject *lm_DefineHardware(MochaDecoder *decoder,
JSObject *parent);
#endif
extern JSBool lm_DefinePluginClasses(MochaDecoder *decoder);
extern JSBool lm_DefineBarClasses(MochaDecoder *decoder);
extern JSBool lm_ResolveBar(JSContext *cx, MochaDecoder *decoder,
const char *name);
extern JSBool lm_DefineTriggers(void);
extern JSObject *lm_NewPluginList(JSContext *cx, JSObject *parent_obj);
extern JSObject *lm_NewMIMETypeList(JSContext *cx);
extern JSObject *lm_GetDocumentFromLayerId(MochaDecoder *decoder,
int32 layer_id);
extern JSObject *lm_DefinePkcs11(MochaDecoder *decoder);
/*
* Get (create if needed) document's form, link, and named anchor arrays.
*/
extern JSObject *lm_GetFormArray(MochaDecoder *decoder,
JSObject *document);
extern JSObject *lm_GetLinkArray(MochaDecoder *decoder,
JSObject *document);
extern JSObject *lm_GetNameArray(MochaDecoder *decoder,
JSObject *document);
#ifdef DOM
extern JSObject *lm_GetSpanArray(MochaDecoder *decoder,
JSObject *document);
extern JSObject *lm_GetTransclusionArray(MochaDecoder *decoder,
JSObject *document);
extern JSObject *lm_DOMGetDocumentElement(MochaDecoder *decoder,
JSObject *document);
#endif
extern JSObject *lm_GetAppletArray(MochaDecoder *decoder,
JSObject *document);
extern JSObject *lm_GetEmbedArray(MochaDecoder *decoder,
JSObject *document);
extern JSObject *lm_GetImageArray(MochaDecoder *decoder,
JSObject *document);
extern JSObject *lm_GetDocumentLayerArray(MochaDecoder *decoder,
JSObject *document);
extern JSBool lm_InitBuiltinClass(MochaDecoder *decoder);
extern JSObject *lm_GetBuiltinsArray(MochaDecoder *decoder, JSObject *document);
/*
* dummy object for applets and embeds that can't be reflected
*/
extern JSObject *lm_DummyObject;
extern void lm_InitDummyObject(JSContext *cx);
/* bit vector for handlers */
typedef enum {
HANDLER_ONCLICK = 1 << 0,
HANDLER_ONFOCUS = 1 << 1,
HANDLER_ONBLUR = 1 << 2,
HANDLER_ONCHANGE = 1 << 3,
HANDLER_ONSELECT = 1 << 4,
HANDLER_ONSCROLL = 1 << 5,
HANDLER_ONMOUSEDOWN = 1 << 6,
HANDLER_ONMOUSEUP = 1 << 7,
HANDLER_ONKEYDOWN = 1 << 8,
HANDLER_ONKEYUP = 1 << 9,
HANDLER_ONKEYPRESS = 1 << 10,
HANDLER_ONDBLCLICK = 1 << 11
} JSHandlersBitVector;
/*
* Base class of all JS input private object data structures.
*/
typedef struct JSInputBase {
MochaDecoder *decoder; /* this window's JS decoder */
int32 type; /* layout form element type */
JSHandlersBitVector handlers; /* bit vector for handlers */
} JSInputBase;
/*
* Base class of event-handling elements like layers and documents.
*/
typedef struct JSInputHandler {
JSInputBase base; /* decoder and type */
JSObject *object; /* this input handler's JS object */
uint32 event_mask; /* mask of events in progress */
} JSInputHandler;
/*
* Base class of input event-capturing elements like layers and documents.
*/
typedef struct JSEventReceiver {
JSObject *object; /* this event receiver's JS object */
uint32 event_mask; /* mask of events in progress */
} JSEventReceiver;
/*
* Base class of input event-handling elements like anchors and form inputs.
*/
typedef struct JSEventCapturer {
JSEventReceiver base; /* this event capturer's receiver base */
uint32 event_bit; /* mask of events being captured */
} JSEventCapturer;
#define base_decoder base.decoder
#define base_type base.type
#define base_handlers base.handlers
/*
* JS URL object.
*
* Location is a special URL: when you set one of its properties, your client
* window goes to the newly formed address.
*/
typedef struct JSURL {
JSInputHandler handler;
int32 layer_id;
uint32 index;
JSString *href;
JSString *target;
JSString *text;
} JSURL;
/* JS Document Object
* Documents exist per-window and per-layer
*/
typedef struct JSDocument {
JSEventCapturer capturer;
MochaDecoder *decoder;
JSObject *object;
int32 layer_id; /* The containing layer's id */
JSObject *forms;
JSObject *links;
JSObject *anchors;
JSObject *applets;
JSObject *embeds;
JSObject *images;
JSObject *layers;
#ifdef DOM
JSObject *spans;
JSObject *transclusions;
JSObject *dom_documentElement;
#endif
JSObject *builtins;
} JSDocument;
#define URL_NOT_INDEXED ((uint32)-1)
#define url_decoder handler.base_decoder
#define url_type handler.base_type
#define url_object handler.object
#define url_event_mask handler.event_mask
extern JSURL *
lm_NewURL(JSContext *cx, MochaDecoder *decoder,
LO_AnchorData *anchor_data, JSObject *document);
extern void
lm_ReplaceURL(MWContext *context, URL_Struct *url_struct);
extern JSBool
lm_GetURL(JSContext *cx, MochaDecoder *decoder, URL_Struct *url_struct);
extern const char *
lm_CheckURL(JSContext *cx, const char *url_string, JSBool checkFile);
extern JSBool
lm_CheckWindowName(JSContext *cx, const char *window_name);
extern PRHashTable *
lm_GetIdToObjectMap(MochaDecoder *decoder);
extern JSBool PR_CALLBACK
lm_BranchCallback(JSContext *cx, JSScript *script);
extern void PR_CALLBACK
lm_ErrorReporter(JSContext *cx, const char *message,
JSErrorReport *report);
extern JSObject *
lm_GetFormObjectByID(MWContext *context, int32 layer_id, uint form_id);
extern LO_FormElementStruct *
lm_GetFormElementByIndex(JSContext * cx, JSObject *form_obj, int32 index);
extern JSObject *
lm_GetFormElementFromMapping(JSContext *cx, JSObject *form_obj, uint32 index);
extern JSBool
lm_AddFormElement(JSContext *cx, JSObject *form, JSObject *obj,
char *name, uint index);
extern JSBool
lm_ReflectRadioButtonArray(MWContext *context, int32 layer_id, intn form_id,
const char *name, PA_Tag * tag);
extern JSBool
lm_SendEvent(MWContext *context, JSObject *obj, JSEvent *event,
jsval *result);
extern JSBool
lm_HandleEvent(JSContext *cx, JSObject *obj, JSObject *eventObj,
jsval funval, jsval *result);
extern JSBool
lm_FindEventHandler(MWContext *context, JSObject *obj, JSObject *eventObj,
jsval funval, jsval *result);
extern JSObject *
lm_NewEventObject(MochaDecoder * decoder, JSEvent * pEvent);
typedef struct JSEventNames {
const char *lowerName;
const char *mixedName;
} JSEventNames;
extern const char *
lm_EventName(uint32 event_bit);
extern JSEventNames *
lm_GetEventNames(uint32 event_bit);
/*
* Compile the given attribute and attach it to the JSObject
*/
extern JSBool
lm_CompileEventHandler(MochaDecoder * decoder, PA_Block id, PA_Block data,
int newline_count, JSObject *object, const char *name,
PA_Block block);
extern uint32
lm_FindEventInMWContext(MWContext *context);
/*
* Remember the current form object that we are processing
*/
extern void
lm_SetActiveForm(MWContext * context, int32 id);
/*
* Called when we want to get rid of the old contents of a layer
* and create a new document.
*/
extern void
lm_NewLayerDocument(MochaDecoder *decoder, int32 layer_id);
/*
* Called to set the source URL as a result of a document.open() on the
* layer's document.
*/
JSBool
lm_SetLayerSourceURL(MochaDecoder *decoder, int32 layer_id, char *url);
/*
* Get a layer obj from a parent id and a layer name. Used for lazy reflection.
*/
extern JSObject *
lm_GetNamedLayer(MochaDecoder *decoder, int32 parent_layer_id,
const char *name);
extern const char *
lm_GetLayerOriginURL(JSContext *cx, JSObject *obj);
/* Clears out object references from the doc private data */
extern void
lm_CleanUpDocumentRoots(MochaDecoder *decoder, JSObject *obj);
/* Calls CleanUpDocumentRoots for a layer's document */
extern void
lm_DestroyLayer(MWContext *context, JSObject *obj);
/*
* Called when the content associated with a document is destroyed,
* but the document itself may not be. Cleans out object references
* from doc private data (so that the objects can be collected). Also
* deals with correctly relinquishing event capture.
*/
extern void
lm_CleanUpDocument(MochaDecoder *decoder, JSObject *document);
extern NET_StreamClass *
lm_ClearDecoderStream(MochaDecoder *decoder, JSBool fromDiscard);
extern void
lm_ProcessImageEvent(MWContext *context, JSObject *obj,
LM_ImageEvent event);
extern JSObject *
lm_NewImage(JSContext *cx, LO_ImageStruct *image_data);
extern JSObject *
lm_NewSoftupObject(JSContext *cx, MochaDecoder *decoder, const char *jarargs);
extern void
lm_RegisterComponent(const char *targetName, ETBoolPtrFunc active_callback,
ETVoidPtrFunc startup_callback);
extern void
lm_RegisterComponentProp(const char *comp, const char *targetName,
uint8 retType, ETCompPropSetterFunc setter,
ETCompPropGetterFunc getter);
extern void
lm_RegisterComponentMethod(const char *comp, const char *targetName,
uint8 retType, ETCompMethodFunc method, int32 nargs);
/*
* Class initializers (the wave of the future).
*/
extern JSBool
lm_InitSecurity(MochaDecoder *decoder);
extern JSBool
lm_InitDocumentClass(MochaDecoder *decoder);
extern JSBool
lm_InitImageClass(MochaDecoder *decoder);
extern JSBool
lm_InitAnchorClass(MochaDecoder *decoder);
#ifdef DOM
extern JSBool
lm_InitSpanClass(MochaDecoder *decoder);
extern JSBool
lm_InitTransclusionClass(MochaDecoder *decoder);
#endif
extern JSBool
lm_InitLayerClass(MochaDecoder *decoder);
extern JSBool
lm_InitInputClasses(MochaDecoder *decoder);
extern JSBool
lm_InitEventClasses(MochaDecoder *decoder);
extern JSBool
lm_InitRectClass(MochaDecoder *decoder);
/* Create an image context for anonymous images. */
extern JSBool
lm_NewImageContext(MWContext *context, MochaDecoder *decoder);
/*
* Called to save and restore timeouts across a resize_reload.
*/
void
lm_SaveWindowTimeouts(MochaDecoder *decoder);
void
lm_RestoreWindowTimeouts(MochaDecoder *decoder);
/*
* Call this function from LO_ResetForm() to let the form's onReset attribute
* event handler run and do specialized form element data reinitialization.
* Returns JS_TRUE if the form reset should continue, JS_FALSE if it
* should be aborted.
*/
extern JSBool
lm_SendOnReset(MWContext *context, JSEvent *event, LO_Element *element);
/*
* See if our outer object is the current form or the document
*/
extern JSObject *
lm_GetOuterObject(MochaDecoder * decoder);
/*
* Entry point for the netlib to notify JS of load and unload events.
*/
extern void
lm_SendLoadEvent(MWContext *context, int32 event, JSBool resize_reload);
/*
* Load or unload event for a layer
*/
extern void
lm_SendLayerLoadEvent(MWContext *context, int32 event, int32 layer_id, JSBool resize_reload);
/*
* This one should be called when a form is submitted. If there is an
* INPUT tag of type "submit", the JS author could write an "onClick"
* handler property of the submit button, but for forms that auto-submit
* we want an "onSubmit" form property handler.
*
* Returns JS_TRUE if the submit should continue, JS_FALSE if it
* should be aborted.
*/
extern JSBool
lm_SendOnSubmit(MWContext *context, JSEvent *event, LO_Element *element);
extern JSBool
lm_InputEvent(MWContext *context, LO_Element *element, JSEvent *pEvent,
jsval *rval);
extern JSBool
lm_KeyInputEvent(MWContext *context, LO_Element *element, JSEvent *pEvent,
jsval *rval);
extern JSBool
lm_MouseInputEvent(MWContext *context, LO_Element *element, JSEvent *pEvent,
jsval *rval);
extern NET_StreamClass *
lm_DocCacheConverter(MWContext * context, URL_Struct * url,
const char * wysiwyg_url);
extern char *
lm_MakeWysiwygUrl(JSContext *cx, MochaDecoder *decoder, int32 layer_id,
JSPrincipals *principals);
typedef struct JSObjectArray {
MochaDecoder *decoder;
jsint length;
int32 layer_id;
} JSObjectArray;
extern JSBool
lm_AddObjectToArray(JSContext * cx, JSObject * array_obj,
const char * name, jsint index, JSObject * obj);
/* Version Information; sits on top of JS_SetVersion and JS_GetVersion */
extern void
lm_SetVersion(MochaDecoder *decoder, JSVersion version);
#define lm_GetVersion(decoder) JS_GetVersion((decoder)->js_context)
/*
* Security -----------------------------------
*/
typedef enum JSTarget {
JSTARGET_UNIVERSAL_BROWSER_READ,
JSTARGET_UNIVERSAL_BROWSER_WRITE,
JSTARGET_UNIVERSAL_SEND_MAIL,
JSTARGET_UNIVERSAL_FILE_READ,
JSTARGET_UNIVERSAL_FILE_WRITE,
JSTARGET_UNIVERSAL_PREFERENCES_READ,
JSTARGET_UNIVERSAL_PREFERENCES_WRITE,
JSTARGET_MAX
} JSTarget;
extern const char *
lm_GetSubjectOriginURL(JSContext *cx);
extern const char *
lm_GetObjectOriginURL(JSContext *cx, JSObject *object);
extern const char *
lm_SetObjectOriginURL(JSContext *cx, JSObject *object, const char *origin);
extern JSPrincipals *
lm_GetPrincipalsFromStackFrame(JSContext *cx);
extern JSPrincipals *
lm_GetCompilationPrincipals(MochaDecoder *decoder,
JSPrincipals *layoutPrincipals);
extern JSBool
lm_CanAccessTarget(JSContext *cx, JSTarget target);
extern JSBool
lm_CheckPermissions(JSContext *cx, JSObject *obj, JSTarget target);
extern JSBool
lm_GetCrossOriginEnabled(void);
extern JSBool
lm_GetUnsignedExecutionEnabled(void);
extern JSBool
lm_CheckContainerAccess(JSContext *cx, JSObject *obj, MochaDecoder *decoder,
JSTarget target);
/*
* Get the innermost (in the sense of the parent scope chain of "obj")
* nonnull principals. Will create principals at the window level if
* none exist. Will always return nonnull principals except in the case
* of memory failure.
* Argument "container" specifies the start of the search, the
* container where the principals were found will be stored into
* "foundIn" if "foundIn" is nonnull.
*/
extern JSPrincipals *
lm_GetInnermostPrincipals(JSContext *cx, JSObject *container,
JSObject **foundIn);
extern JSPrincipals *
lm_GetContainerPrincipals(JSContext *cx, JSObject *container);
extern void
lm_SetContainerPrincipals(JSContext *cx, JSObject *container,
JSPrincipals *principals);
extern JSBool
lm_CanCaptureEvent(JSContext *cx, JSFunction *fun, JSEvent *event);
extern void
lm_SetExternalCapture(JSContext *cx, JSPrincipals *principals,
JSBool b);
extern JSBool
lm_CheckSetParentSlot(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
extern JSBool
lm_SetDocumentDomain(JSContext *cx, JSPrincipals *principals,
const char *newDomain);
extern void
lm_InvalidateCertPrincipals(MochaDecoder *decoder, JSPrincipals *principals);
extern void
lm_DestroyPrincipalsList(JSContext *cx, JSPrincipalsList *list);
/*
* --------------------------------------------
*/
/* For when mozilla needs to call LM_PutMochaDecoder in the mocha thread. */
extern void
et_PutMochaDecoder(MWContext *context, MochaDecoder *decoder);
/* This function is private to libmocha, so don't stuff it in libevent.h, chouck ! */
extern int32
ET_PostCreateLayer(MWContext *context, int32 wrap_width, int32 parent_layer_id);
extern void
lm_RestoreLayerState(MWContext *context, int32 layer_id,
LO_BlockInitializeStruct *param);
extern PRHashNumber
lm_KeyHash(const void *key);
extern JSBool
lm_jsval_to_rgb(JSContext *cx, jsval *vp, LO_Color **rgbp);
extern JSBool
layer_setBgColorProperty(JSContext *cx, JSObject *obj, jsval *vp);
extern JSObject *
lm_GetActiveContainer(MochaDecoder *decoder);
extern JSBool
lm_GetPrincipalsCompromise(JSContext *cx, JSObject *obj);
extern char *
lm_FixNewlines(JSContext *cx, const char *value, JSBool formElement);
extern JSBool PR_CALLBACK
win_open(JSContext *cx, JSObject *obj, uint argc, jsval *argv, jsval *rval);
/* defined in libmocha.h */
#ifdef JSDEBUGGER
extern void
lm_InitJSDebug(JSRuntime *jsruntime);
extern void
lm_ExitJSDebug(JSRuntime *jsruntime);
#endif
#define IS_MESSAGE_WINDOW(context) \
(((context)->type == MWContextMail) || \
((context)->type == MWContextNews) || \
((context)->type == MWContextMailMsg) || \
((context)->type == MWContextNewsMsg))
/* INTL support */
extern char *
lm_StrToLocalEncoding(MWContext * context, JSString * str);
extern JSString *
lm_LocalEncodingToStr(MWContext * context, char * bytes);
extern char *
lm_StrToEncoding(JSContext *cx, uint16 charset, JSString * str);
extern JSString *
lm_EncodingToStr(JSContext *cx, uint16 charset, char * bytes);
/* end INTL support */
/* MLM */
typedef struct lm_lock_waiter {
JSLockReleaseFunc fn;
void * data;
struct lm_lock_waiter * next;
} lm_lock_waiter;
typedef struct ContextListStr ContextList;
struct WindowGroup {
LMWindowGroup *next;
LMWindowGroup *prev;
/* XXXMLM - this entry is currently unused; it should eventually hold
* a shared JSContext for the thread group.
*/
JSContext *js_context;
PRBool interruptCurrentOp;
PRMonitor *owner_monitor;
PRThread *thread;
PRThread *owner;
lm_lock_waiter *waiting_list;
int32 current_count;
PRBool mozWantsLock;
PRBool mozGotLock;
PRBool hasLock;
JSContext *lock_context;
JSTimeout **js_timeout_insertion_point;
JSTimeout *js_timeout_running;
uint inputRecurring;
PREventQueue *interpret_queue;
QueueStackElement *queue_stack;
uint queue_depth;
uint queue_count;
PRMonitor *queue_monitor;
ContextList *mw_contexts;
MWContext *current_context;
PRBool done;
};
extern void lm_InitWindowGroups(void);
extern LMWindowGroup *lm_NewWindowGroup(void);
extern void lm_StartWindowGroup(LMWindowGroup *grp);
extern void lm_DestroyWindowGroup(LMWindowGroup *grp);
extern LMWindowGroup *LM_GetDefaultWindowGroup(MWContext *mwc);
extern LMWindowGroup *lm_MWContextToGroup(MWContext *mwc);
extern LMWindowGroup *lm_QueueStackToGroup(QueueStackElement *qse);
extern PREventQueue *LM_MWContextToQueue(MWContext *mwc);
extern PREventQueue *LM_WindowGroupToQueue(LMWindowGroup *lmg);
extern ContextList *lm_GetEntryForContext(LMWindowGroup *grp, MWContext *cx);
extern void LM_AddContextToGroup(LMWindowGroup *grp, MWContext *cx);
extern void LM_RemoveContextFromGroup(MWContext *cx);
extern PRBool LM_IsLocked(LMWindowGroup *grp);
extern void LM_BeginRequest(LMWindowGroup *grp, JSContext *jsc);
extern void LM_EndRequest(LMWindowGroup *grp, JSContext *jsc);
extern JSBool LM_LockJSByGroup(LMWindowGroup *grp, char **errp);
extern void LM_UnlockJSByGroup(LMWindowGroup *grp);
extern JSBool lm_inited(void);
/* See also LM_GetCrippledContext() in libmocha.h */
extern MochaDecoder *LM_GetCrippledDecoder(void);
extern void LM_SetCrippledDecoder(MochaDecoder *md);
extern JSBool LM_ShouldRunGC(JSContext *cx, JSGCStatus status);
/* MLM */
#endif /* lm_h___ */
Reference in New Issue View Git Blame Copy Permalink