The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

 /* vim: set ts=8 sts=4 et sw=4 tw=99: */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /*

  * XPConnect allows JS code to manipulate C++ object and C++ code to manipulate

  * JS objects. JS manipulation of C++ objects tends to be significantly more

  * complex. This comment explains how it is orchestrated by XPConnect.

  *

  * For each C++ object to be manipulated in JS, there is a corresponding JS

  * object. This is called the "flattened JS object". By default, there is an

  * additional C++ object involved of type XPCWrappedNative. The XPCWrappedNative

  * holds pointers to the C++ object and the flat JS object.

  *

  * All XPCWrappedNative objects belong to an XPCWrappedNativeScope. These scopes

  * are essentially in 1:1 correspondence with JS global objects. The

  * XPCWrappedNativeScope has a pointer to the JS global object. The parent of a

  * flattened JS object is, by default, the global JS object corresponding to the

  * wrapper's XPCWrappedNativeScope (the exception to this rule is when a

  * PreCreate hook asks for a different parent; see nsIXPCScriptable below).

  *

  * Some C++ objects (notably DOM objects) have information associated with them

  * that lists the interfaces implemented by these objects. A C++ object exposes

  * this information by implementing nsIClassInfo. If a C++ object implements

  * nsIClassInfo, then JS code can call its methods without needing to use

  * QueryInterface first. Typically, all instances of a C++ class share the same

  * nsIClassInfo instance. (That is, obj->QueryInterface(nsIClassInfo) returns

  * the same result for every obj of a given class.)

  *

  * XPConnect tracks nsIClassInfo information in an XPCWrappedNativeProto object.

  * A given XPCWrappedNativeScope will have one XPCWrappedNativeProto for each

  * nsIClassInfo instance being used. The XPCWrappedNativeProto has an associated

  * JS object, which is used as the prototype of all flattened JS objects created

  * for C++ objects with the given nsIClassInfo.

  *

  * Each XPCWrappedNativeProto has a pointer to its XPCWrappedNativeScope. If an

  * XPCWrappedNative wraps a C++ object with class info, then it points to its

  * XPCWrappedNativeProto. Otherwise it points to its XPCWrappedNativeScope. (The

  * pointers are smooshed together in a tagged union.) Either way it can reach

  * its scope.

  *

  * An XPCWrappedNativeProto keeps track of the set of interfaces implemented by

  * the C++ object in an XPCNativeSet. (The list of interfaces is obtained by

  * calling a method on the nsIClassInfo.) An XPCNativeSet is a collection of

  * XPCNativeInterfaces. Each interface stores the list of members, which can be

  * methods, constants, getters, or setters.

  *

  * An XPCWrappedNative also points to an XPCNativeSet. Initially this starts out

  * the same as the XPCWrappedNativeProto's set. If there is no proto, it starts

  * out as a singleton set containing nsISupports. If JS code QI's new interfaces

  * outside of the existing set, the set will grow. All QueryInterface results

  * are cached in XPCWrappedNativeTearOff objects, which are linked off of the

  * XPCWrappedNative.

  *

  * Besides having class info, a C++ object may be "scriptable" (i.e., implement

  * nsIXPCScriptable). This allows it to implement a more DOM-like interface,

  * besides just exposing XPCOM methods and constants. An nsIXPCScriptable

  * instance has hooks that correspond to all the normal JSClass hooks. Each

  * nsIXPCScriptable instance is mirrored by an XPCNativeScriptableInfo in

  * XPConnect. These can have pointers from XPCWrappedNativeProto and

  * XPCWrappedNative (since C++ objects can have scriptable info without having

  * class info).

  *

  * Most data in an XPCNativeScriptableInfo is shared between instances. The

  * shared data is stored in an XPCNativeScriptableShared object. This type is

  * important because it holds the JSClass of the flattened JS objects with the

  * given scriptable info.

  */

 /* All the XPConnect private declarations - only include locally. */

 #ifndef xpcprivate_h___

 #define xpcprivate_h___

 #include "mozilla/Alignment.h"

 #include "mozilla/Assertions.h"

 #include "mozilla/Attributes.h"

 #include "mozilla/CycleCollectedJSRuntime.h"

 #include "mozilla/GuardObjects.h"

 #include "mozilla/Maybe.h"

 #include "mozilla/MemoryReporting.h"

 #include "mozilla/TimeStamp.h"

 #include <math.h>

 #include <stdint.h>

 #include <stdlib.h>

 #include <string.h>

 #include "xpcpublic.h"

 #include "js/TracingAPI.h"

 #include "js/WeakMapPtr.h"

 #include "pldhash.h"

 #include "nscore.h"

 #include "nsXPCOM.h"

 #include "nsAutoPtr.h"

 #include "nsCycleCollectionParticipant.h"

 #include "nsDebug.h"

 #include "nsISupports.h"

 #include "nsIServiceManager.h"

 #include "nsIClassInfoImpl.h"

 #include "nsIComponentManager.h"

 #include "nsIComponentRegistrar.h"

 #include "nsISupportsPrimitives.h"

 #include "nsMemory.h"

 #include "nsIXPConnect.h"

 #include "nsIInterfaceInfo.h"

 #include "nsIXPCScriptable.h"

 #include "nsIXPCSecurityManager.h"

 #include "nsIJSRuntimeService.h"

 #include "nsWeakReference.h"

 #include "nsCOMPtr.h"

 #include "nsXPTCUtils.h"

 #include "xptinfo.h"

 #include "XPCForwards.h"

 #include "XPCLog.h"

 #include "xpccomponents.h"

 #include "xpcexception.h"

 #include "xpcjsid.h"

 #include "prenv.h"

 #include "prclist.h"

 #include "prcvar.h"

 #include "nsString.h"

 #include "nsReadableUtils.h"

 #include "nsXPIDLString.h"

 #include "nsAutoJSValHolder.h"

 #include "MainThreadUtils.h"

 #include "nsIConsoleService.h"

 #include "nsIScriptError.h"

 #include "nsIException.h"

 #include "nsVariant.h"

 #include "nsIPropertyBag.h"

 #include "nsIProperty.h"

 #include "nsCOMArray.h"

 #include "nsTArray.h"

 #include "nsBaseHashtable.h"

 #include "nsHashKeys.h"

 #include "nsWrapperCache.h"

 #include "nsStringBuffer.h"

 #include "nsDataHashtable.h"

 #include "nsDeque.h"

 #include "nsIScriptSecurityManager.h"

 #include "nsNetUtil.h"

 #include "nsIPrincipal.h"

 #include "nsJSPrincipals.h"

 #include "nsIScriptObjectPrincipal.h"

 #include "xpcObjectHelper.h"

 #include "nsIThreadInternal.h"

 #include "SandboxPrivate.h"

 #include "BackstagePass.h"

 #include "nsCxPusher.h"

 #include "nsAXPCNativeCallContext.h"

 #ifdef XP_WIN

 // Nasty MS defines

 #ifdef GetClassInfo

 #undef GetClassInfo

 #endif

 #ifdef GetClassName

 #undef GetClassName

 #endif

 #endif /* XP_WIN */

 #include "nsINode.h"

 /***************************************************************************/

 // default initial sizes for maps (hashtables)

 #define XPC_CONTEXT_MAP_SIZE                16

 #define XPC_JS_MAP_SIZE                     64

 #define XPC_JS_CLASS_MAP_SIZE               64

 #define XPC_NATIVE_MAP_SIZE                 64

 #define XPC_NATIVE_PROTO_MAP_SIZE           16

 #define XPC_DYING_NATIVE_PROTO_MAP_SIZE     16

 #define XPC_DETACHED_NATIVE_PROTO_MAP_SIZE  32

 #define XPC_NATIVE_INTERFACE_MAP_SIZE       64

 #define XPC_NATIVE_SET_MAP_SIZE             64

 #define XPC_NATIVE_JSCLASS_MAP_SIZE         32

 #define XPC_THIS_TRANSLATOR_MAP_SIZE         8

 #define XPC_NATIVE_WRAPPER_MAP_SIZE         16

 #define XPC_WRAPPER_MAP_SIZE                16

 /***************************************************************************/

 // data declarations...

 extern const char XPC_CONTEXT_STACK_CONTRACTID[];

 extern const char XPC_RUNTIME_CONTRACTID[];

 extern const char XPC_EXCEPTION_CONTRACTID[];

 extern const char XPC_CONSOLE_CONTRACTID[];

 extern const char XPC_SCRIPT_ERROR_CONTRACTID[];

 extern const char XPC_ID_CONTRACTID[];

 extern const char XPC_XPCONNECT_CONTRACTID[];

 /***************************************************************************/

 // Useful macros...

 #define XPC_STRING_GETTER_BODY(dest, src)                                     \

     NS_ENSURE_ARG_POINTER(dest);                                              \

     char* result;                                                             \

     if (src)                                                                  \

         result = (char*) nsMemory::Clone(src,                                 \

                                          sizeof(char)*(strlen(src)+1));       \

     else                                                                      \

         result = nullptr;                                                      \

     *dest = result;                                                           \

     return (result || !src) ? NS_OK : NS_ERROR_OUT_OF_MEMORY

 #define WRAPPER_SLOTS (JSCLASS_HAS_PRIVATE | JSCLASS_IMPLEMENTS_BARRIERS )

 #define INVALID_OBJECT ((JSObject *)1)

 // If IS_WN_CLASS for the JSClass of an object is true, the object is a

 // wrappednative wrapper, holding the XPCWrappedNative in its private slot.

 static inline bool IS_WN_CLASS(const js::Class* clazz)

 {

     return clazz->ext.isWrappedNative;

 }

 static inline bool IS_WN_REFLECTOR(JSObject *obj)

 {

     return IS_WN_CLASS(js::GetObjectClass(obj));

 }

 /***************************************************************************

 ****************************************************************************

 *

 * Core runtime and context classes...

 *

 ****************************************************************************

 ***************************************************************************/

 // We have a general rule internally that getters that return addref'd interface

 // pointer generally do so using an 'out' parm. When interface pointers are

 // returned as function call result values they are not addref'd. Exceptions

 // to this rule are noted explicitly.

 inline bool

 AddToCCKind(JSGCTraceKind kind)

 {

     return kind == JSTRACE_OBJECT || kind == JSTRACE_SCRIPT;

 }

 class nsXPConnect : public nsIXPConnect,

                     public nsIThreadObserver,

                     public nsSupportsWeakReference,

                     public nsIJSRuntimeService

 {

 public:

     // all the interface method declarations...

     NS_DECL_ISUPPORTS

     NS_DECL_NSIXPCONNECT

     NS_DECL_NSITHREADOBSERVER

     NS_DECL_NSIJSRUNTIMESERVICE

     // non-interface implementation

 public:

     // These get non-addref'd pointers

     static nsXPConnect*  XPConnect()

     {

         // Do a release-mode assert that we're not doing anything significant in

         // XPConnect off the main thread. If you're an extension developer hitting

         // this, you need to change your code. See bug 716167.

         if (!MOZ_LIKELY(NS_IsMainThread()))

             MOZ_CRASH();

         return gSelf;

     }

     static XPCJSRuntime* GetRuntimeInstance();

     XPCJSRuntime* GetRuntime() {return mRuntime;}

     static bool IsISupportsDescendant(nsIInterfaceInfo* info);

     nsIXPCSecurityManager* GetDefaultSecurityManager() const

     {

         // mDefaultSecurityManager is main-thread only.

         if (!NS_IsMainThread()) {

             return nullptr;

         }

         return mDefaultSecurityManager;

     }

     // This returns an AddRef'd pointer. It does not do this with an 'out' param

     // only because this form is required by the generic module macro:

     // NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR

     static nsXPConnect* GetSingleton();

     // Called by module code in dll startup

     static void InitStatics();

     // Called by module code on dll shutdown.

     static void ReleaseXPConnectSingleton();

     virtual ~nsXPConnect();

     bool IsShuttingDown() const {return mShuttingDown;}

     nsresult GetInfoForIID(const nsIID * aIID, nsIInterfaceInfo** info);

     nsresult GetInfoForName(const char * name, nsIInterfaceInfo** info);

     virtual nsIPrincipal* GetPrincipal(JSObject* obj,

                                        bool allowShortCircuit) const;

     void RecordTraversal(void *p, nsISupports *s);

     virtual char* DebugPrintJSStack(bool showArgs,

                                     bool showLocals,

                                     bool showThisProps);

     static bool ReportAllJSExceptions()

     {

       return gReportAllJSExceptions > 0;

     }

     static void CheckForDebugMode(JSRuntime *rt);

 protected:

     nsXPConnect();

 private:

     // Singleton instance

     static nsXPConnect*             gSelf;

     static bool                     gOnceAliveNowDead;

     XPCJSRuntime*                   mRuntime;

     nsRefPtr<nsIXPCSecurityManager> mDefaultSecurityManager;

     bool                            mShuttingDown;

     // nsIThreadInternal doesn't remember which observers it called

     // OnProcessNextEvent on when it gets around to calling AfterProcessNextEvent.

     // So if XPConnect gets initialized mid-event (which can happen), we'll get

     // an 'after' notification without getting an 'on' notification. If we don't

     // watch out for this, we'll do an unmatched |pop| on the context stack.

     uint16_t                 mEventDepth;

     static uint32_t gReportAllJSExceptions;

 public:

     static nsIScriptSecurityManager *gScriptSecurityManager;

 };

 /***************************************************************************/

 class XPCRootSetElem

 {

 public:

     XPCRootSetElem()

     {

 #ifdef DEBUG

         mNext = nullptr;

         mSelfp = nullptr;

 #endif

     }

     ~XPCRootSetElem()

     {

         MOZ_ASSERT(!mNext, "Must be unlinked");

         MOZ_ASSERT(!mSelfp, "Must be unlinked");

     }

     inline XPCRootSetElem* GetNextRoot() { return mNext; }

     void AddToRootSet(XPCRootSetElem **listHead);

     void RemoveFromRootSet();

 private:

     XPCRootSetElem *mNext;

     XPCRootSetElem **mSelfp;

 };

 /***************************************************************************/

 // In the current xpconnect system there can only be one XPCJSRuntime.

 // So, xpconnect can only be used on one JSRuntime within the process.

 class XPCJSContextStack;

 class WatchdogManager;

 enum WatchdogTimestampCategory

 {

     TimestampRuntimeStateChange = 0,

     TimestampWatchdogWakeup,

     TimestampWatchdogHibernateStart,

     TimestampWatchdogHibernateStop,

     TimestampCount

 };

 class AsyncFreeSnowWhite;

 class XPCJSRuntime : public mozilla::CycleCollectedJSRuntime

 {

 public:

     static XPCJSRuntime* newXPCJSRuntime(nsXPConnect* aXPConnect);

     static XPCJSRuntime* Get() { return nsXPConnect::XPConnect()->GetRuntime(); }

     XPCJSContextStack* GetJSContextStack() {return mJSContextStack;}

     void DestroyJSContextStack();

     XPCCallContext*  GetCallContext() const {return mCallContext;}

     XPCCallContext*  SetCallContext(XPCCallContext* ccx)

         {XPCCallContext* old = mCallContext; mCallContext = ccx; return old;}

     jsid GetResolveName() const {return mResolveName;}

     jsid SetResolveName(jsid name)

         {jsid old = mResolveName; mResolveName = name; return old;}

     XPCWrappedNative* GetResolvingWrapper() const {return mResolvingWrapper;}

     XPCWrappedNative* SetResolvingWrapper(XPCWrappedNative* w)

         {XPCWrappedNative* old = mResolvingWrapper;

          mResolvingWrapper = w; return old;}

     JSObject2WrappedJSMap*     GetWrappedJSMap()        const

         {return mWrappedJSMap;}

     IID2WrappedJSClassMap*     GetWrappedJSClassMap()   const

         {return mWrappedJSClassMap;}

     IID2NativeInterfaceMap* GetIID2NativeInterfaceMap() const

         {return mIID2NativeInterfaceMap;}

     ClassInfo2NativeSetMap* GetClassInfo2NativeSetMap() const

         {return mClassInfo2NativeSetMap;}

     NativeSetMap* GetNativeSetMap() const

         {return mNativeSetMap;}

     IID2ThisTranslatorMap* GetThisTranslatorMap() const

         {return mThisTranslatorMap;}

     XPCNativeScriptableSharedMap* GetNativeScriptableSharedMap() const

         {return mNativeScriptableSharedMap;}

     XPCWrappedNativeProtoMap* GetDyingWrappedNativeProtoMap() const

         {return mDyingWrappedNativeProtoMap;}

     XPCWrappedNativeProtoMap* GetDetachedWrappedNativeProtoMap() const

         {return mDetachedWrappedNativeProtoMap;}

     bool OnJSContextNew(JSContext* cx);

     virtual bool

     DescribeCustomObjects(JSObject* aObject, const js::Class* aClasp,

                           char (&aName)[72]) const MOZ_OVERRIDE;

     virtual bool

     NoteCustomGCThingXPCOMChildren(const js::Class* aClasp, JSObject* aObj,

                                    nsCycleCollectionTraversalCallback& aCb) const MOZ_OVERRIDE;

     /**

      * Infrastructure for classes that need to defer part of the finalization

      * until after the GC has run, for example for objects that we don't want to

      * destroy during the GC.

      */

 public:

     bool GetDoingFinalization() const {return mDoingFinalization;}

     // Mapping of often used strings to jsid atoms that live 'forever'.

     //

     // To add a new string: add to this list and to XPCJSRuntime::mStrings

     // at the top of xpcjsruntime.cpp

     enum {

         IDX_CONSTRUCTOR             = 0 ,

         IDX_TO_STRING               ,

         IDX_TO_SOURCE               ,

         IDX_LAST_RESULT             ,

         IDX_RETURN_CODE             ,

         IDX_VALUE                   ,

         IDX_QUERY_INTERFACE         ,

         IDX_COMPONENTS              ,

         IDX_WRAPPED_JSOBJECT        ,

         IDX_OBJECT                  ,

         IDX_FUNCTION                ,

         IDX_PROTOTYPE               ,

         IDX_CREATE_INSTANCE         ,

         IDX_ITEM                    ,

         IDX_PROTO                   ,

         IDX_ITERATOR                ,

         IDX_EXPOSEDPROPS            ,

         IDX_EVAL                    ,

         IDX_CONTROLLERS             ,

         IDX_TOTAL_COUNT // just a count of the above

     };

     JS::HandleId GetStringID(unsigned index) const

     {

         MOZ_ASSERT(index < IDX_TOTAL_COUNT, "index out of range");

         // fromMarkedLocation() is safe because the string is interned.

         return JS::HandleId::fromMarkedLocation(&mStrIDs[index]);

     }

     JS::HandleValue GetStringJSVal(unsigned index) const

     {

         MOZ_ASSERT(index < IDX_TOTAL_COUNT, "index out of range");

         // fromMarkedLocation() is safe because the string is interned.

         return JS::HandleValue::fromMarkedLocation(&mStrJSVals[index]);

     }

     const char* GetStringName(unsigned index) const

     {

         MOZ_ASSERT(index < IDX_TOTAL_COUNT, "index out of range");

         return mStrings[index];

     }

     void TraceNativeBlackRoots(JSTracer* trc) MOZ_OVERRIDE;

     void TraceAdditionalNativeGrayRoots(JSTracer* aTracer) MOZ_OVERRIDE;

     void TraverseAdditionalNativeRoots(nsCycleCollectionNoteRootCallback& cb) MOZ_OVERRIDE;

     void UnmarkSkippableJSHolders();

     void PrepareForForgetSkippable() MOZ_OVERRIDE;

     void BeginCycleCollectionCallback() MOZ_OVERRIDE;

     void EndCycleCollectionCallback(mozilla::CycleCollectorResults &aResults) MOZ_OVERRIDE;

     void DispatchDeferredDeletion(bool continuation) MOZ_OVERRIDE;

     void CustomGCCallback(JSGCStatus status) MOZ_OVERRIDE;

     bool CustomContextCallback(JSContext *cx, unsigned operation) MOZ_OVERRIDE;

     static void GCSliceCallback(JSRuntime *rt,

                                 JS::GCProgress progress,

                                 const JS::GCDescription &desc);

     static void FinalizeCallback(JSFreeOp *fop, JSFinalizeStatus status, bool isCompartmentGC);

     inline void AddVariantRoot(XPCTraceableVariant* variant);

     inline void AddWrappedJSRoot(nsXPCWrappedJS* wrappedJS);

     inline void AddObjectHolderRoot(XPCJSObjectHolder* holder);

     static void SuspectWrappedNative(XPCWrappedNative *wrapper,

                                      nsCycleCollectionNoteRootCallback &cb);

     void DebugDump(int16_t depth);

     void SystemIsBeingShutDown();

     bool GCIsRunning() const {return mGCIsRunning;}

     ~XPCJSRuntime();

     nsString* NewShortLivedString();

     void DeleteShortLivedString(nsString *string);

     void AddGCCallback(xpcGCCallback cb);

     void RemoveGCCallback(xpcGCCallback cb);

     void AddContextCallback(xpcContextCallback cb);

     void RemoveContextCallback(xpcContextCallback cb);

     static JSContext* DefaultJSContextCallback(JSRuntime *rt);

     static void ActivityCallback(void *arg, bool active);

     static void CTypesActivityCallback(JSContext *cx,

                                        js::CTypesActivityType type);

     static bool InterruptCallback(JSContext *cx);

     static void OutOfMemoryCallback(JSContext *cx);

     size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);

     AutoMarkingPtr**  GetAutoRootsAdr() {return &mAutoRoots;}

     JSObject* GetJunkScope();

     JSObject* GetCompilationScope();

     void DeleteSingletonScopes();

     PRTime GetWatchdogTimestamp(WatchdogTimestampCategory aCategory);

     void OnAfterProcessNextEvent() { mSlowScriptCheckpoint = mozilla::TimeStamp(); }

 private:

     XPCJSRuntime(); // no implementation

     XPCJSRuntime(nsXPConnect* aXPConnect);

     void ReleaseIncrementally(nsTArray<nsISupports *> &array);

     static const char* const mStrings[IDX_TOTAL_COUNT];

     jsid mStrIDs[IDX_TOTAL_COUNT];

     jsval mStrJSVals[IDX_TOTAL_COUNT];

     XPCJSContextStack*       mJSContextStack;

     XPCCallContext*          mCallContext;

     AutoMarkingPtr*          mAutoRoots;

     jsid                     mResolveName;

     XPCWrappedNative*        mResolvingWrapper;

     JSObject2WrappedJSMap*   mWrappedJSMap;

     IID2WrappedJSClassMap*   mWrappedJSClassMap;

     IID2NativeInterfaceMap*  mIID2NativeInterfaceMap;

     ClassInfo2NativeSetMap*  mClassInfo2NativeSetMap;

     NativeSetMap*            mNativeSetMap;

     IID2ThisTranslatorMap*   mThisTranslatorMap;

     XPCNativeScriptableSharedMap* mNativeScriptableSharedMap;

     XPCWrappedNativeProtoMap* mDyingWrappedNativeProtoMap;

     XPCWrappedNativeProtoMap* mDetachedWrappedNativeProtoMap;

     bool mGCIsRunning;

     nsTArray<nsXPCWrappedJS*> mWrappedJSToReleaseArray;

     nsTArray<nsISupports*> mNativesToReleaseArray;

     bool mDoingFinalization;

     XPCRootSetElem *mVariantRoots;

     XPCRootSetElem *mWrappedJSRoots;

     XPCRootSetElem *mObjectHolderRoots;

     nsTArray<xpcGCCallback> extraGCCallbacks;

     nsTArray<xpcContextCallback> extraContextCallbacks;

     nsRefPtr<WatchdogManager> mWatchdogManager;

     JS::GCSliceCallback mPrevGCSliceCallback;

     JS::PersistentRootedObject mJunkScope;

     JS::PersistentRootedObject mCompilationScope;

     nsRefPtr<AsyncFreeSnowWhite> mAsyncSnowWhiteFreer;

     mozilla::TimeStamp mSlowScriptCheckpoint;

 #define XPCCCX_STRING_CACHE_SIZE 2

     mozilla::Maybe<nsString> mScratchStrings[XPCCCX_STRING_CACHE_SIZE];

     friend class Watchdog;

     friend class AutoLockWatchdog;

     friend class XPCIncrementalReleaseRunnable;

 };

 /***************************************************************************/

 /***************************************************************************/

 // XPCContext is mostly a dumb class to hold JSContext specific data and

 // maps that let us find wrappers created for the given JSContext.

 // no virtuals

 class XPCContext

 {

     friend class XPCJSRuntime;

 public:

     static XPCContext* GetXPCContext(JSContext* aJSContext)

         {

             MOZ_ASSERT(JS_GetSecondContextPrivate(aJSContext), "should already have XPCContext");

             return static_cast<XPCContext *>(JS_GetSecondContextPrivate(aJSContext));

         }

     XPCJSRuntime* GetRuntime() const {return mRuntime;}

     JSContext* GetJSContext() const {return mJSContext;}

     enum LangType {LANG_UNKNOWN, LANG_JS, LANG_NATIVE};

     LangType GetCallingLangType() const

         {

             return mCallingLangType;

         }

     LangType SetCallingLangType(LangType lt)

         {

             LangType tmp = mCallingLangType;

             mCallingLangType = lt;

             return tmp;

         }

     bool CallerTypeIsJavaScript() const

         {

             return LANG_JS == mCallingLangType;

         }

     bool CallerTypeIsNative() const

         {

             return LANG_NATIVE == mCallingLangType;

         }

     bool CallerTypeIsKnown() const

         {

             return LANG_UNKNOWN != mCallingLangType;

         }

     nsresult GetException(nsIException** e)

         {

             nsCOMPtr<nsIException> rval = mException;

             rval.forget(e);

             return NS_OK;

         }

     void SetException(nsIException* e)

         {

             mException = e;

         }

     nsresult GetLastResult() {return mLastResult;}

     void SetLastResult(nsresult rc) {mLastResult = rc;}

     nsresult GetPendingResult() {return mPendingResult;}

     void SetPendingResult(nsresult rc) {mPendingResult = rc;}

     void DebugDump(int16_t depth);

     void AddScope(PRCList *scope) { PR_INSERT_AFTER(scope, &mScopes); }

     void RemoveScope(PRCList *scope) { PR_REMOVE_LINK(scope); }

     void MarkErrorUnreported() { mErrorUnreported = true; }

     void ClearUnreportedError() { mErrorUnreported = false; }

     bool WasErrorReported() { return !mErrorUnreported; }

     ~XPCContext();

 private:

     XPCContext();    // no implementation

     XPCContext(XPCJSRuntime* aRuntime, JSContext* aJSContext);

     static XPCContext* newXPCContext(XPCJSRuntime* aRuntime,

                                      JSContext* aJSContext);

 private:

     XPCJSRuntime* mRuntime;

     JSContext*  mJSContext;

     nsresult mLastResult;

     nsresult mPendingResult;

     nsCOMPtr<nsIException> mException;

     LangType mCallingLangType;

     bool mErrorUnreported;

     // A linked list of scopes to notify when we are destroyed.

     PRCList mScopes;

 };

 /***************************************************************************/

 #define NATIVE_CALLER  XPCContext::LANG_NATIVE

 #define JS_CALLER      XPCContext::LANG_JS

 // No virtuals

 // XPCCallContext is ALWAYS declared as a local variable in some function;

 // i.e. instance lifetime is always controled by some C++ function returning.

 //

 // These things are created frequently in many places. We *intentionally* do

 // not inialialize all members in order to save on construction overhead.

 // Some constructor pass more valid params than others. We init what must be

 // init'd and leave other members undefined. In debug builds the accessors

 // use a CHECK_STATE macro to track whether or not the object is in a valid

 // state to answer the question a caller might be asking. As long as this

 // class is maintained correctly it can do its job without a bunch of added

 // overhead from useless initializations and non-DEBUG error checking.

 //

 // Note that most accessors are inlined.

 class MOZ_STACK_CLASS XPCCallContext : public nsAXPCNativeCallContext

 {

 public:

     NS_IMETHOD GetCallee(nsISupports **aResult);

     NS_IMETHOD GetCalleeMethodIndex(uint16_t *aResult);

     NS_IMETHOD GetCalleeWrapper(nsIXPConnectWrappedNative **aResult);

     NS_IMETHOD GetJSContext(JSContext **aResult);

     NS_IMETHOD GetArgc(uint32_t *aResult);

     NS_IMETHOD GetArgvPtr(jsval **aResult);

     NS_IMETHOD GetCalleeInterface(nsIInterfaceInfo **aResult);

     NS_IMETHOD GetCalleeClassInfo(nsIClassInfo **aResult);

     NS_IMETHOD GetPreviousCallContext(nsAXPCNativeCallContext **aResult);

     NS_IMETHOD GetLanguage(uint16_t *aResult);

     enum {NO_ARGS = (unsigned) -1};

     static JSContext* GetDefaultJSContext();

     XPCCallContext(XPCContext::LangType callerLanguage,

                    JSContext* cx,

                    JS::HandleObject obj    = JS::NullPtr(),

                    JS::HandleObject funobj = JS::NullPtr(),

                    JS::HandleId id         = JSID_VOIDHANDLE,

                    unsigned argc           = NO_ARGS,

                    jsval *argv             = nullptr,

                    jsval *rval             = nullptr);

     virtual ~XPCCallContext();

     inline bool                         IsValid() const ;

     inline XPCJSRuntime*                GetRuntime() const ;

     inline XPCContext*                  GetXPCContext() const ;

     inline JSContext*                   GetJSContext() const ;

     inline bool                         GetContextPopRequired() const ;

     inline XPCContext::LangType         GetCallerLanguage() const ;

     inline XPCContext::LangType         GetPrevCallerLanguage() const ;

     inline XPCCallContext*              GetPrevCallContext() const ;

     inline JSObject*                    GetFlattenedJSObject() const ;

     inline nsISupports*                 GetIdentityObject() const ;

     inline XPCWrappedNative*            GetWrapper() const ;

     inline XPCWrappedNativeProto*       GetProto() const ;

     inline bool                         CanGetTearOff() const ;

     inline XPCWrappedNativeTearOff*     GetTearOff() const ;

     inline XPCNativeScriptableInfo*     GetScriptableInfo() const ;

     inline bool                         CanGetSet() const ;

     inline XPCNativeSet*                GetSet() const ;

     inline bool                         CanGetInterface() const ;

     inline XPCNativeInterface*          GetInterface() const ;

     inline XPCNativeMember*             GetMember() const ;

     inline bool                         HasInterfaceAndMember() const ;

     inline jsid                         GetName() const ;

     inline bool                         GetStaticMemberIsLocal() const ;

     inline unsigned                     GetArgc() const ;

     inline jsval*                       GetArgv() const ;

     inline jsval*                       GetRetVal() const ;

     inline uint16_t                     GetMethodIndex() const ;

     inline void                         SetMethodIndex(uint16_t index) ;

     inline jsid GetResolveName() const;

     inline jsid SetResolveName(JS::HandleId name);

     inline XPCWrappedNative* GetResolvingWrapper() const;

     inline XPCWrappedNative* SetResolvingWrapper(XPCWrappedNative* w);

     inline void SetRetVal(jsval val);

     void SetName(jsid name);

     void SetArgsAndResultPtr(unsigned argc, jsval *argv, jsval *rval);

     void SetCallInfo(XPCNativeInterface* iface, XPCNativeMember* member,

                      bool isSetter);

     nsresult  CanCallNow();

     void SystemIsBeingShutDown();

     operator JSContext*() const {return GetJSContext();}

 private:

     // no copy ctor or assignment allowed

     XPCCallContext(const XPCCallContext& r); // not implemented

     XPCCallContext& operator= (const XPCCallContext& r); // not implemented

     XPCWrappedNative* UnwrapThisIfAllowed(JS::HandleObject obj, JS::HandleObject fun,

                                           unsigned argc);

 private:

     // posible values for mState

     enum State {

         INIT_FAILED,

         SYSTEM_SHUTDOWN,

         HAVE_CONTEXT,

         HAVE_OBJECT,

         HAVE_NAME,

         HAVE_ARGS,

         READY_TO_CALL,

         CALL_DONE

     };

 #ifdef DEBUG

 inline void CHECK_STATE(int s) const {MOZ_ASSERT(mState >= s, "bad state");}

 #else

 #define CHECK_STATE(s) ((void)0)

 #endif

 private:

     JSAutoRequest                   mAr;

     State                           mState;

     nsRefPtr<nsXPConnect>           mXPC;

     XPCContext*                     mXPCContext;

     JSContext*                      mJSContext;

     XPCContext::LangType            mCallerLanguage;

     // ctor does not necessarily init the following. BEWARE!

     XPCContext::LangType            mPrevCallerLanguage;

     XPCCallContext*                 mPrevCallContext;

     JS::RootedObject                mFlattenedJSObject;

     XPCWrappedNative*               mWrapper;

     XPCWrappedNativeTearOff*        mTearOff;

     XPCNativeScriptableInfo*        mScriptableInfo;

     XPCNativeSet*                   mSet;

     XPCNativeInterface*             mInterface;

     XPCNativeMember*                mMember;

     JS::RootedId                    mName;

     bool                            mStaticMemberIsLocal;

     unsigned                        mArgc;

     jsval*                          mArgv;

     jsval*                          mRetVal;

     uint16_t                        mMethodIndex;

 };

 /***************************************************************************

 ****************************************************************************

 *

 * Core classes for wrapped native objects for use from JavaScript...

 *

 ****************************************************************************

 ***************************************************************************/

 // These are the various JSClasses and callbacks whose use that required

 // visibility from more than one .cpp file.

 struct XPCWrappedNativeJSClass;

 extern const XPCWrappedNativeJSClass XPC_WN_NoHelper_JSClass;

 extern const js::Class XPC_WN_NoMods_WithCall_Proto_JSClass;

 extern const js::Class XPC_WN_NoMods_NoCall_Proto_JSClass;

 extern const js::Class XPC_WN_ModsAllowed_WithCall_Proto_JSClass;

 extern const js::Class XPC_WN_ModsAllowed_NoCall_Proto_JSClass;

 extern const js::Class XPC_WN_Tearoff_JSClass;

 extern const js::Class XPC_WN_NoHelper_Proto_JSClass;

 extern bool

 XPC_WN_CallMethod(JSContext *cx, unsigned argc, jsval *vp);

 extern bool

 XPC_WN_GetterSetter(JSContext *cx, unsigned argc, jsval *vp);

 extern bool

 XPC_WN_JSOp_Enumerate(JSContext *cx, JS::HandleObject obj, JSIterateOp enum_op,

                       JS::MutableHandleValue statep, JS::MutableHandleId idp);

 extern JSObject*

 XPC_WN_JSOp_ThisObject(JSContext *cx, JS::HandleObject obj);

 // Macros to initialize Object or Function like XPC_WN classes

 #define XPC_WN_WithCall_ObjectOps                                             \

     {                                                                         \

         nullptr, /* lookupGeneric */                                          \

         nullptr, /* lookupProperty */                                         \

         nullptr, /* lookupElement */                                          \

         nullptr, /* defineGeneric */                                          \

         nullptr, /* defineProperty */                                         \

         nullptr, /* defineElement */                                          \

         nullptr, /* getGeneric    */                                          \

         nullptr, /* getProperty    */                                         \

         nullptr, /* getElement    */                                          \

         nullptr, /* setGeneric    */                                          \

         nullptr, /* setProperty    */                                         \

         nullptr, /* setElement    */                                          \

         nullptr, /* getGenericAttributes  */                                  \

         nullptr, /* setGenericAttributes  */                                  \

         nullptr, /* deleteProperty */                                         \

         nullptr, /* deleteElement */                                          \

         nullptr, nullptr, /* watch/unwatch */                                 \

         nullptr, /* slice */                                                  \

         XPC_WN_JSOp_Enumerate,                                                \

         XPC_WN_JSOp_ThisObject,                                               \

     }

 #define XPC_WN_NoCall_ObjectOps                                               \

     {                                                                         \

         nullptr, /* lookupGeneric */                                          \

         nullptr, /* lookupProperty */                                         \

         nullptr, /* lookupElement */                                          \

         nullptr, /* defineGeneric */                                          \

         nullptr, /* defineProperty */                                         \

         nullptr, /* defineElement */                                          \

         nullptr, /* getGeneric    */                                          \

         nullptr, /* getProperty    */                                         \

         nullptr, /* getElement    */                                          \

         nullptr, /* setGeneric    */                                          \

         nullptr, /* setProperty    */                                         \

         nullptr, /* setElement    */                                          \

         nullptr, /* getGenericAttributes  */                                  \

         nullptr, /* setGenericAttributes  */                                  \

         nullptr, /* deleteProperty */                                         \

         nullptr, /* deleteElement */                                          \

         nullptr, nullptr, /* watch/unwatch */                                 \

         nullptr, /* slice */                                                  \

         XPC_WN_JSOp_Enumerate,                                                \

         XPC_WN_JSOp_ThisObject,                                               \

     }

 // Maybe this macro should check for class->enumerate ==

 // XPC_WN_Shared_Proto_Enumerate or something rather than checking for

 // 4 classes?

 static inline bool IS_PROTO_CLASS(const js::Class *clazz)

 {

     return clazz == &XPC_WN_NoMods_WithCall_Proto_JSClass ||

            clazz == &XPC_WN_NoMods_NoCall_Proto_JSClass ||

            clazz == &XPC_WN_ModsAllowed_WithCall_Proto_JSClass ||

            clazz == &XPC_WN_ModsAllowed_NoCall_Proto_JSClass;

 }

 /***************************************************************************/

 // XPCWrappedNativeScope is one-to-one with a JS global object.

 class nsXPCComponentsBase;

 class XPCWrappedNativeScope : public PRCList

 {

 public:

     static XPCWrappedNativeScope*

     GetNewOrUsed(JSContext *cx, JS::HandleObject aGlobal);

     XPCJSRuntime*

     GetRuntime() const {return XPCJSRuntime::Get();}

     Native2WrappedNativeMap*

     GetWrappedNativeMap() const {return mWrappedNativeMap;}

     ClassInfo2WrappedNativeProtoMap*

     GetWrappedNativeProtoMap() const {return mWrappedNativeProtoMap;}

     nsXPCComponentsBase*

     GetComponents() const {return mComponents;}

     // Forces the creation of a privileged |Components| object, even in

     // content scopes. This will crash if used outside of automation.

     void

     ForcePrivilegedComponents();

     bool AttachComponentsObject(JSContext *aCx);

     // Returns the JS object reflection of the Components object.

     bool

     GetComponentsJSObject(JS::MutableHandleObject obj);

     JSObject*

     GetGlobalJSObject() const {

         JS::ExposeObjectToActiveJS(mGlobalJSObject);

         return mGlobalJSObject;

     }

     JSObject*

     GetGlobalJSObjectPreserveColor() const {return mGlobalJSObject;}

     nsIPrincipal*

     GetPrincipal() const {

         JSCompartment *c = js::GetObjectCompartment(mGlobalJSObject);

         return nsJSPrincipals::get(JS_GetCompartmentPrincipals(c));

     }

     JSObject*

     GetExpandoChain(JS::HandleObject target);

     bool

     SetExpandoChain(JSContext *cx, JS::HandleObject target, JS::HandleObject chain);

     void RemoveWrappedNativeProtos();

     static void

     SystemIsBeingShutDown();

     static void

     TraceWrappedNativesInAllScopes(JSTracer* trc, XPCJSRuntime* rt);

     void TraceInside(JSTracer *trc) {

         MOZ_ASSERT(mGlobalJSObject);

         mGlobalJSObject.trace(trc, "XPCWrappedNativeScope::mGlobalJSObject");

         if (mXBLScope)

             mXBLScope.trace(trc, "XPCWrappedNativeScope::mXBLScope");

         if (mXrayExpandos.initialized())

             mXrayExpandos.trace(trc);

     }

     static void

     SuspectAllWrappers(XPCJSRuntime* rt, nsCycleCollectionNoteRootCallback &cb);

     static void

     StartFinalizationPhaseOfGC(JSFreeOp *fop, XPCJSRuntime* rt);

     static void

     FinishedFinalizationPhaseOfGC();

     static void

     MarkAllWrappedNativesAndProtos();

 #ifdef DEBUG

     static void

     ASSERT_NoInterfaceSetsAreMarked();

 #endif

     static void

     SweepAllWrappedNativeTearOffs();

     static void

     DebugDumpAllScopes(int16_t depth);

     void

     DebugDump(int16_t depth);

     struct ScopeSizeInfo {

         ScopeSizeInfo(mozilla::MallocSizeOf mallocSizeOf)

             : mMallocSizeOf(mallocSizeOf),

               mScopeAndMapSize(0),

               mProtoAndIfaceCacheSize(0)

         {}

         mozilla::MallocSizeOf mMallocSizeOf;

         size_t mScopeAndMapSize;

         size_t mProtoAndIfaceCacheSize;

     };

     static void

     AddSizeOfAllScopesIncludingThis(ScopeSizeInfo* scopeSizeInfo);

     void

     AddSizeOfIncludingThis(ScopeSizeInfo* scopeSizeInfo);

     bool

     IsValid() const {return mRuntime != nullptr;}

     static bool

     IsDyingScope(XPCWrappedNativeScope *scope);

     static void InitStatics() { gScopes = nullptr; gDyingScopes = nullptr; }

     XPCContext *GetContext() { return mContext; }

     void ClearContext() { mContext = nullptr; }

     typedef js::HashSet<JSObject *,

                         js::PointerHasher<JSObject *, 3>,

                         js::SystemAllocPolicy> DOMExpandoSet;

     bool RegisterDOMExpandoObject(JSObject *expando) {

         // Expandos are proxy objects, and proxies are always tenured.

         JS::AssertGCThingMustBeTenured(expando);

         if (!mDOMExpandoSet) {

             mDOMExpandoSet = new DOMExpandoSet();

             mDOMExpandoSet->init(8);

         }

         return mDOMExpandoSet->put(expando);

     }

     void RemoveDOMExpandoObject(JSObject *expando) {

         if (mDOMExpandoSet)

             mDOMExpandoSet->remove(expando);

     }

     // Gets the appropriate scope object for XBL in this scope. The context

     // must be same-compartment with the global upon entering, and the scope

     // object is wrapped into the compartment of the global.

     JSObject *EnsureXBLScope(JSContext *cx);

     XPCWrappedNativeScope(JSContext *cx, JS::HandleObject aGlobal);

     nsAutoPtr<JSObject2JSObjectMap> mWaiverWrapperMap;

     bool IsXBLScope() { return mIsXBLScope; }

     bool AllowXBLScope();

     bool UseXBLScope() { return mUseXBLScope; }

 protected:

     virtual ~XPCWrappedNativeScope();

     static void KillDyingScopes();

     XPCWrappedNativeScope(); // not implemented

 private:

     static XPCWrappedNativeScope* gScopes;

     static XPCWrappedNativeScope* gDyingScopes;

     XPCJSRuntime*                    mRuntime;

     Native2WrappedNativeMap*         mWrappedNativeMap;

     ClassInfo2WrappedNativeProtoMap* mWrappedNativeProtoMap;

     nsRefPtr<nsXPCComponentsBase>    mComponents;

     XPCWrappedNativeScope*           mNext;

     // The JS global object for this scope.  If non-null, this will be the

     // default parent for the XPCWrappedNatives that have us as the scope,

     // unless a PreCreate hook overrides it.  Note that this _may_ be null (see

     // constructor).

     JS::ObjectPtr                    mGlobalJSObject;

     // XBL Scope. This is is a lazily-created sandbox for non-system scopes.

     // EnsureXBLScope() decides whether it needs to be created or not.

     // This reference is wrapped into the compartment of mGlobalJSObject.

     JS::ObjectPtr                    mXBLScope;

     XPCContext*                      mContext;

     nsAutoPtr<DOMExpandoSet> mDOMExpandoSet;

     JS::WeakMapPtr<JSObject*, JSObject*> mXrayExpandos;

     bool mIsXBLScope;

     // For remote XUL domains, we run all XBL in the content scope for compat

     // reasons (though we sometimes pref this off for automation). We separately

     // track the result of this decision (mAllowXBLScope), from the decision

     // of whether to actually _use_ an XBL scope (mUseXBLScope), which depends

     // on the type of global and whether the compartment is system principal

     // or not.

     //

     // This distinction is useful primarily because, if true, we know that we

     // have no way of distinguishing XBL script from content script for the

     // given scope. In these (unsupported) situations, we just always claim to

     // be XBL.

     bool mAllowXBLScope;

     bool mUseXBLScope;

 };

 /***************************************************************************/

 // XPCNativeMember represents a single idl declared method, attribute or

 // constant.

 // Tight. No virtual methods. Can be bitwise copied (until any resolution done).

 class XPCNativeMember

 {

 public:

     static bool GetCallInfo(JSObject* funobj,

                             XPCNativeInterface** pInterface,

                             XPCNativeMember**    pMember);

     jsid   GetName() const {return mName;}

     uint16_t GetIndex() const {return mIndex;}

     bool GetConstantValue(XPCCallContext& ccx, XPCNativeInterface* iface,

                           jsval* pval)

         {MOZ_ASSERT(IsConstant(),

                     "Only call this if you're sure this is a constant!");

          return Resolve(ccx, iface, JS::NullPtr(), pval);}

     bool NewFunctionObject(XPCCallContext& ccx, XPCNativeInterface* iface,

                            JS::HandleObject parent, jsval* pval);

     bool IsMethod() const

         {return 0 != (mFlags & METHOD);}

     bool IsConstant() const

         {return 0 != (mFlags & CONSTANT);}

     bool IsAttribute() const

         {return 0 != (mFlags & GETTER);}

     bool IsWritableAttribute() const

         {return 0 != (mFlags & SETTER_TOO);}

     bool IsReadOnlyAttribute() const

         {return IsAttribute() && !IsWritableAttribute();}

     void SetName(jsid a) {mName = a;}

     void SetMethod(uint16_t index)

         {mFlags = METHOD; mIndex = index;}

     void SetConstant(uint16_t index)

         {mFlags = CONSTANT; mIndex = index;}

     void SetReadOnlyAttribute(uint16_t index)

         {mFlags = GETTER; mIndex = index;}

     void SetWritableAttribute()

         {MOZ_ASSERT(mFlags == GETTER,"bad"); mFlags = GETTER | SETTER_TOO;}

     /* default ctor - leave random contents */

     XPCNativeMember()  {MOZ_COUNT_CTOR(XPCNativeMember);}

     ~XPCNativeMember() {MOZ_COUNT_DTOR(XPCNativeMember);}

 private:

     bool Resolve(XPCCallContext& ccx, XPCNativeInterface* iface,

                  JS::HandleObject parent, jsval *vp);

     enum {

         METHOD      = 0x01,

         CONSTANT    = 0x02,

         GETTER      = 0x04,

         SETTER_TOO  = 0x08

     };

 private:

     // our only data...

     jsid     mName;

     uint16_t mIndex;

     uint16_t mFlags;

 };

 /***************************************************************************/

 // XPCNativeInterface represents a single idl declared interface. This is

 // primarily the set of XPCNativeMembers.

 // Tight. No virtual methods.

 class XPCNativeInterface

 {

   public:

     static XPCNativeInterface* GetNewOrUsed(const nsIID* iid);

     static XPCNativeInterface* GetNewOrUsed(nsIInterfaceInfo* info);

     static XPCNativeInterface* GetNewOrUsed(const char* name);

     static XPCNativeInterface* GetISupports();

     inline nsIInterfaceInfo* GetInterfaceInfo() const {return mInfo.get();}

     inline jsid              GetName()          const {return mName;}

     inline const nsIID* GetIID() const;

     inline const char*  GetNameString() const;

     inline XPCNativeMember* FindMember(jsid name) const;

     inline bool HasAncestor(const nsIID* iid) const;

     uint16_t GetMemberCount() const {

         return mMemberCount;

     }

     XPCNativeMember* GetMemberAt(uint16_t i) {

         MOZ_ASSERT(i < mMemberCount, "bad index");

         return &mMembers[i];

     }

     void DebugDump(int16_t depth);

 #define XPC_NATIVE_IFACE_MARK_FLAG ((uint16_t)JS_BIT(15)) // only high bit of 16 is set

     void Mark() {

         mMarked = 1;

     }

     void Unmark() {

         mMarked = 0;

     }

     bool IsMarked() const {

         return mMarked != 0;

     }

     // NOP. This is just here to make the AutoMarkingPtr code compile.

     inline void TraceJS(JSTracer* trc) {}

     inline void AutoTrace(JSTracer* trc) {}

     static void DestroyInstance(XPCNativeInterface* inst);

     size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);

   protected:

     static XPCNativeInterface* NewInstance(nsIInterfaceInfo* aInfo);

     XPCNativeInterface();   // not implemented

     XPCNativeInterface(nsIInterfaceInfo* aInfo, jsid aName)

       : mInfo(aInfo), mName(aName), mMemberCount(0), mMarked(0)

     {

         MOZ_COUNT_CTOR(XPCNativeInterface);

     }

     ~XPCNativeInterface() {

         MOZ_COUNT_DTOR(XPCNativeInterface);

     }

     void* operator new(size_t, void* p) CPP_THROW_NEW {return p;}

     XPCNativeInterface(const XPCNativeInterface& r); // not implemented

     XPCNativeInterface& operator= (const XPCNativeInterface& r); // not implemented

 private:

     nsCOMPtr<nsIInterfaceInfo> mInfo;

     jsid                       mName;

     uint16_t                   mMemberCount : 15;

     uint16_t                   mMarked : 1;

     XPCNativeMember            mMembers[1]; // always last - object sized for array

 };

 /***************************************************************************/

 // XPCNativeSetKey is used to key a XPCNativeSet in a NativeSetMap.

 class XPCNativeSetKey

 {

 public:

     XPCNativeSetKey(XPCNativeSet*       BaseSet  = nullptr,

                     XPCNativeInterface* Addition = nullptr,

                     uint16_t            Position = 0)

         : mIsAKey(IS_A_KEY), mPosition(Position), mBaseSet(BaseSet),

           mAddition(Addition) {}

     ~XPCNativeSetKey() {}

     XPCNativeSet*           GetBaseSet()  const {return mBaseSet;}

     XPCNativeInterface*     GetAddition() const {return mAddition;}

     uint16_t                GetPosition() const {return mPosition;}

     // This is a fun little hack...

     // We build these keys only on the stack. We use them for lookup in

     // NativeSetMap. Becasue we don't want to pay the cost of cloning a key and

     // sticking it into the hashtable, when the XPCNativeSet actually

     // gets added to the table the 'key' in the table is a pointer to the

     // set itself and not this key. Our key compare function expects to get

     // a key and a set. When we do external lookups in the map we pass in one

     // of these keys and our compare function gets passed a key and a set.

     // (see compare_NativeKeyToSet in xpcmaps.cpp). This is all well and good.

     // Except, when the table decides to resize itself. Then it tries to use

     // our compare function with the 'keys' that are in the hashtable (which are

     // really XPCNativeSet objects and not XPCNativeSetKey objects!

     //

     // So, the hack is to have the compare function assume it is getting a

     // XPCNativeSetKey pointer and call this IsAKey method. If that fails then

     // it realises that it really has a XPCNativeSet pointer and deals with that

     // fact. This is safe because we know that both of these classes have no

     // virtual methods and their first data member is a uint16_t. We are

     // confident that XPCNativeSet->mMemberCount will never be 0xffff.

     bool                    IsAKey() const {return mIsAKey == IS_A_KEY;}

     enum {IS_A_KEY = 0xffff};

     // Allow shallow copy

 private:

     uint16_t                mIsAKey;    // must be first data member

     uint16_t                mPosition;

     XPCNativeSet*           mBaseSet;

     XPCNativeInterface*     mAddition;

 };

 /***************************************************************************/

 // XPCNativeSet represents an ordered collection of XPCNativeInterface pointers.

 class XPCNativeSet

 {

   public:

     static XPCNativeSet* GetNewOrUsed(const nsIID* iid);

     static XPCNativeSet* GetNewOrUsed(nsIClassInfo* classInfo);

     static XPCNativeSet* GetNewOrUsed(XPCNativeSet* otherSet,

                                       XPCNativeInterface* newInterface,

                                       uint16_t position);

     // This generates a union set.

     //

     // If preserveFirstSetOrder is true, the elements from |firstSet| come first,

     // followed by any non-duplicate items from |secondSet|. If false, the same

     // algorithm is applied; but if we detect that |secondSet| is a superset of

     // |firstSet|, we return |secondSet| without worrying about whether the

     // ordering might differ from |firstSet|.

     static XPCNativeSet* GetNewOrUsed(XPCNativeSet* firstSet,

                                       XPCNativeSet* secondSet,

                                       bool preserveFirstSetOrder);

     static void ClearCacheEntryForClassInfo(nsIClassInfo* classInfo);

     inline bool FindMember(jsid name, XPCNativeMember** pMember,

                              uint16_t* pInterfaceIndex) const;

     inline bool FindMember(jsid name, XPCNativeMember** pMember,

                              XPCNativeInterface** pInterface) const;

     inline bool FindMember(jsid name,

                              XPCNativeMember** pMember,

                              XPCNativeInterface** pInterface,

                              XPCNativeSet* protoSet,

                              bool* pIsLocal) const;

     inline bool HasInterface(XPCNativeInterface* aInterface) const;

     inline bool HasInterfaceWithAncestor(XPCNativeInterface* aInterface) const;

     inline bool HasInterfaceWithAncestor(const nsIID* iid) const;

     inline XPCNativeInterface* FindInterfaceWithIID(const nsIID& iid) const;

     inline XPCNativeInterface* FindNamedInterface(jsid name) const;

     uint16_t GetMemberCount() const {

         return mMemberCount;

     }

     uint16_t GetInterfaceCount() const {

         return mInterfaceCount;

     }

     XPCNativeInterface **GetInterfaceArray() {

         return mInterfaces;

     }

     XPCNativeInterface* GetInterfaceAt(uint16_t i)

         {MOZ_ASSERT(i < mInterfaceCount, "bad index"); return mInterfaces[i];}

     inline bool MatchesSetUpToInterface(const XPCNativeSet* other,

                                           XPCNativeInterface* iface) const;

 #define XPC_NATIVE_SET_MARK_FLAG ((uint16_t)JS_BIT(15)) // only high bit of 16 is set

     inline void Mark();

     // NOP. This is just here to make the AutoMarkingPtr code compile.

     inline void TraceJS(JSTracer* trc) {}

     inline void AutoTrace(JSTracer* trc) {}

   private:

     void MarkSelfOnly() {

         mMarked = 1;

     }

   public:

     void Unmark() {

         mMarked = 0;

     }

     bool IsMarked() const {

         return !!mMarked;

     }

 #ifdef DEBUG

     inline void ASSERT_NotMarked();

 #endif

     void DebugDump(int16_t depth);

     static void DestroyInstance(XPCNativeSet* inst);

     size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);

   protected:

     static XPCNativeSet* NewInstance(XPCNativeInterface** array,

                                      uint16_t count);

     static XPCNativeSet* NewInstanceMutate(XPCNativeSet*       otherSet,

                                            XPCNativeInterface* newInterface,

                                            uint16_t            position);

     XPCNativeSet()

       : mMemberCount(0), mInterfaceCount(0), mMarked(0)

     {

         MOZ_COUNT_CTOR(XPCNativeSet);

     }

     ~XPCNativeSet() {

         MOZ_COUNT_DTOR(XPCNativeSet);

     }

     void* operator new(size_t, void* p) CPP_THROW_NEW {return p;}

   private:

     uint16_t                mMemberCount;

     uint16_t                mInterfaceCount : 15;

     uint16_t                mMarked : 1;

     XPCNativeInterface*     mInterfaces[1];  // always last - object sized for array

 };

 /***************************************************************************/

 // XPCNativeScriptableFlags is a wrapper class that holds the flags returned

 // from calls to nsIXPCScriptable::GetScriptableFlags(). It has convenience

 // methods to check for particular bitflags. Since we also use this class as

 // a member of the gc'd class XPCNativeScriptableShared, this class holds the

 // bit and exposes the inlined methods to support marking.

 #define XPC_WN_SJSFLAGS_MARK_FLAG JS_BIT(31) // only high bit of 32 is set

 class XPCNativeScriptableFlags

 {

 private:

     uint32_t mFlags;

 public:

     XPCNativeScriptableFlags(uint32_t flags = 0) : mFlags(flags) {}

     uint32_t GetFlags() const {return mFlags & ~XPC_WN_SJSFLAGS_MARK_FLAG;}

     void     SetFlags(uint32_t flags) {mFlags = flags;}

     operator uint32_t() const {return GetFlags();}

     XPCNativeScriptableFlags(const XPCNativeScriptableFlags& r)

         {mFlags = r.GetFlags();}

     XPCNativeScriptableFlags& operator= (const XPCNativeScriptableFlags& r)

         {mFlags = r.GetFlags(); return *this;}

     void Mark()       {mFlags |= XPC_WN_SJSFLAGS_MARK_FLAG;}

     void Unmark()     {mFlags &= ~XPC_WN_SJSFLAGS_MARK_FLAG;}

     bool IsMarked() const {return 0 != (mFlags & XPC_WN_SJSFLAGS_MARK_FLAG);}

 #ifdef GET_IT

 #undef GET_IT

 #endif

 #define GET_IT(f_) const {return 0 != (mFlags & nsIXPCScriptable:: f_ );}

     bool WantPreCreate()                GET_IT(WANT_PRECREATE)

     bool WantCreate()                   GET_IT(WANT_CREATE)

     bool WantPostCreate()               GET_IT(WANT_POSTCREATE)

     bool WantAddProperty()              GET_IT(WANT_ADDPROPERTY)

     bool WantDelProperty()              GET_IT(WANT_DELPROPERTY)

     bool WantGetProperty()              GET_IT(WANT_GETPROPERTY)

     bool WantSetProperty()              GET_IT(WANT_SETPROPERTY)

     bool WantEnumerate()                GET_IT(WANT_ENUMERATE)

     bool WantNewEnumerate()             GET_IT(WANT_NEWENUMERATE)

     bool WantNewResolve()               GET_IT(WANT_NEWRESOLVE)

     bool WantConvert()                  GET_IT(WANT_CONVERT)

     bool WantFinalize()                 GET_IT(WANT_FINALIZE)

     bool WantCall()                     GET_IT(WANT_CALL)

     bool WantConstruct()                GET_IT(WANT_CONSTRUCT)

     bool WantHasInstance()              GET_IT(WANT_HASINSTANCE)

     bool WantOuterObject()              GET_IT(WANT_OUTER_OBJECT)

     bool UseJSStubForAddProperty()      GET_IT(USE_JSSTUB_FOR_ADDPROPERTY)

     bool UseJSStubForDelProperty()      GET_IT(USE_JSSTUB_FOR_DELPROPERTY)

     bool UseJSStubForSetProperty()      GET_IT(USE_JSSTUB_FOR_SETPROPERTY)

     bool DontEnumStaticProps()          GET_IT(DONT_ENUM_STATIC_PROPS)

     bool DontEnumQueryInterface()       GET_IT(DONT_ENUM_QUERY_INTERFACE)

     bool DontAskInstanceForScriptable() GET_IT(DONT_ASK_INSTANCE_FOR_SCRIPTABLE)

     bool ClassInfoInterfacesOnly()      GET_IT(CLASSINFO_INTERFACES_ONLY)

     bool AllowPropModsDuringResolve()   GET_IT(ALLOW_PROP_MODS_DURING_RESOLVE)

     bool AllowPropModsToPrototype()     GET_IT(ALLOW_PROP_MODS_TO_PROTOTYPE)

     bool IsGlobalObject()               GET_IT(IS_GLOBAL_OBJECT)

     bool DontReflectInterfaceNames()    GET_IT(DONT_REFLECT_INTERFACE_NAMES)

 #undef GET_IT

 };

 /***************************************************************************/

 // XPCNativeScriptableShared is used to hold the JSClass and the

 // associated scriptable flags for XPCWrappedNatives. These are shared across

 // the runtime and are garbage collected by xpconnect. We *used* to just store

 // this inside the XPCNativeScriptableInfo (usually owned by instances of

 // XPCWrappedNativeProto. This had two problems... It was wasteful, and it

 // was a big problem when wrappers are reparented to different scopes (and

 // thus different protos (the DOM does this).

 // We maintain the invariant that every JSClass for which ext.isWrappedNative

 // is true is a contained in an instance of this struct, and can thus be cast

 // to it.

 struct XPCWrappedNativeJSClass

 {

     js::Class base;

     uint32_t interfacesBitmap;

 };

 class XPCNativeScriptableShared

 {

 public:

     const XPCNativeScriptableFlags& GetFlags() const {return mFlags;}

     uint32_t                        GetInterfacesBitmap() const

         {return mJSClass.interfacesBitmap;}

     const JSClass*                  GetJSClass()

         {return Jsvalify(&mJSClass.base);}

     XPCNativeScriptableShared(uint32_t aFlags, char* aName,

                               uint32_t interfacesBitmap)

         : mFlags(aFlags)

         {memset(&mJSClass, 0, sizeof(mJSClass));

          mJSClass.base.name = aName;  // take ownership

          mJSClass.interfacesBitmap = interfacesBitmap;

          MOZ_COUNT_CTOR(XPCNativeScriptableShared);}

     ~XPCNativeScriptableShared()

         {if (mJSClass.base.name)nsMemory::Free((void*)mJSClass.base.name);

          MOZ_COUNT_DTOR(XPCNativeScriptableShared);}

     char* TransferNameOwnership()

         {char* name=(char*)mJSClass.base.name; mJSClass.base.name = nullptr;

         return name;}

     void PopulateJSClass();

     void Mark()       {mFlags.Mark();}

     void Unmark()     {mFlags.Unmark();}

     bool IsMarked() const {return mFlags.IsMarked();}

 private:

     XPCNativeScriptableFlags mFlags;

     XPCWrappedNativeJSClass  mJSClass;

 };

 /***************************************************************************/

 // XPCNativeScriptableInfo is used to hold the nsIXPCScriptable state for a

 // given class or instance.

 class XPCNativeScriptableInfo

 {

 public:

     static XPCNativeScriptableInfo*

     Construct(const XPCNativeScriptableCreateInfo* sci);

     nsIXPCScriptable*

     GetCallback() const {return mCallback;}

     const XPCNativeScriptableFlags&

     GetFlags() const      {return mShared->GetFlags();}

     uint32_t

     GetInterfacesBitmap() const {return mShared->GetInterfacesBitmap();}

     const JSClass*

     GetJSClass()          {return mShared->GetJSClass();}

     XPCNativeScriptableShared*

     GetScriptableShared() {return mShared;}

     void

     SetCallback(nsIXPCScriptable* s) {mCallback = s;}

     void

     SetCallback(already_AddRefed<nsIXPCScriptable>&& s) {mCallback = s;}

     void

     SetScriptableShared(XPCNativeScriptableShared* shared) {mShared = shared;}

     void Mark() {

         if (mShared)

             mShared->Mark();

     }

     void TraceJS(JSTracer *trc) {}

     void AutoTrace(JSTracer *trc) {}

 protected:

     XPCNativeScriptableInfo(nsIXPCScriptable* scriptable = nullptr,

                             XPCNativeScriptableShared* shared = nullptr)

         : mCallback(scriptable), mShared(shared)

                                {MOZ_COUNT_CTOR(XPCNativeScriptableInfo);}

 public:

     ~XPCNativeScriptableInfo() {MOZ_COUNT_DTOR(XPCNativeScriptableInfo);}

 private:

     // disable copy ctor and assignment

     XPCNativeScriptableInfo(const XPCNativeScriptableInfo& r); // not implemented

     XPCNativeScriptableInfo& operator= (const XPCNativeScriptableInfo& r); // not implemented

 private:

     nsCOMPtr<nsIXPCScriptable>  mCallback;

     XPCNativeScriptableShared*  mShared;

 };

 /***************************************************************************/

 // XPCNativeScriptableCreateInfo is used in creating new wrapper and protos.

 // it abstracts out the scriptable interface pointer and the flags. After

 // creation these are factored differently using XPCNativeScriptableInfo.

 class MOZ_STACK_CLASS XPCNativeScriptableCreateInfo

 {

 public:

     XPCNativeScriptableCreateInfo(const XPCNativeScriptableInfo& si)

         : mCallback(si.GetCallback()), mFlags(si.GetFlags()),

           mInterfacesBitmap(si.GetInterfacesBitmap()) {}

     XPCNativeScriptableCreateInfo(already_AddRefed<nsIXPCScriptable>&& callback,

                                   XPCNativeScriptableFlags flags,

                                   uint32_t interfacesBitmap)

         : mCallback(callback), mFlags(flags),

           mInterfacesBitmap(interfacesBitmap) {}

     XPCNativeScriptableCreateInfo()

         : mFlags(0), mInterfacesBitmap(0) {}

     nsIXPCScriptable*

     GetCallback() const {return mCallback;}

     const XPCNativeScriptableFlags&

     GetFlags() const      {return mFlags;}

     uint32_t

     GetInterfacesBitmap() const     {return mInterfacesBitmap;}

     void

     SetCallback(already_AddRefed<nsIXPCScriptable>&& callback)

         {mCallback = callback;}

     void

     SetFlags(const XPCNativeScriptableFlags& flags)  {mFlags = flags;}

     void

     SetInterfacesBitmap(uint32_t interfacesBitmap)

         {mInterfacesBitmap = interfacesBitmap;}

 private:

     nsCOMPtr<nsIXPCScriptable>  mCallback;

     XPCNativeScriptableFlags    mFlags;

     uint32_t                    mInterfacesBitmap;

 };

 /***********************************************/

 // XPCWrappedNativeProto hold the additional shared wrapper data

 // for XPCWrappedNative whose native objects expose nsIClassInfo.

 class XPCWrappedNativeProto

 {

 public:

     static XPCWrappedNativeProto*

     GetNewOrUsed(XPCWrappedNativeScope* scope,

                  nsIClassInfo* classInfo,

                  const XPCNativeScriptableCreateInfo* scriptableCreateInfo,

                  bool callPostCreatePrototype = true);

     XPCWrappedNativeScope*

     GetScope()   const {return mScope;}

     XPCJSRuntime*

     GetRuntime() const {return mScope->GetRuntime();}

     JSObject*

     GetJSProtoObject() const {

         JS::ExposeObjectToActiveJS(mJSProtoObject);

         return mJSProtoObject;

     }

     nsIClassInfo*

     GetClassInfo()     const {return mClassInfo;}

     XPCNativeSet*

     GetSet()           const {return mSet;}

     XPCNativeScriptableInfo*

     GetScriptableInfo()   {return mScriptableInfo;}

     uint32_t

     GetClassInfoFlags() const {return mClassInfoFlags;}

 #ifdef GET_IT

 #undef GET_IT

 #endif

 #define GET_IT(f_) const {return !!(mClassInfoFlags & nsIClassInfo:: f_ );}

     bool ClassIsSingleton()           GET_IT(SINGLETON)

     bool ClassIsDOMObject()           GET_IT(DOM_OBJECT)

     bool ClassIsPluginObject()        GET_IT(PLUGIN_OBJECT)

 #undef GET_IT

     void SetScriptableInfo(XPCNativeScriptableInfo* si)

         {MOZ_ASSERT(!mScriptableInfo, "leak here!"); mScriptableInfo = si;}

     bool CallPostCreatePrototype();

     void JSProtoObjectFinalized(js::FreeOp *fop, JSObject *obj);

     void SystemIsBeingShutDown();

     void DebugDump(int16_t depth);

     void TraceSelf(JSTracer *trc) {

         if (mJSProtoObject)

             mJSProtoObject.trace(trc, "XPCWrappedNativeProto::mJSProtoObject");

     }

     void TraceInside(JSTracer *trc) {

         if (JS_IsGCMarkingTracer(trc)) {

             mSet->Mark();

             if (mScriptableInfo)

                 mScriptableInfo->Mark();

         }

         GetScope()->TraceInside(trc);

     }

     void TraceJS(JSTracer *trc) {

         TraceSelf(trc);

         TraceInside(trc);

     }

     void WriteBarrierPre(JSRuntime* rt)

     {

         if (JS::IsIncrementalBarrierNeeded(rt) && mJSProtoObject)

             mJSProtoObject.writeBarrierPre(rt);

     }

     // NOP. This is just here to make the AutoMarkingPtr code compile.

     inline void AutoTrace(JSTracer* trc) {}

     // Yes, we *do* need to mark the mScriptableInfo in both cases.

     void Mark() const

         {mSet->Mark();

          if (mScriptableInfo) mScriptableInfo->Mark();}

 #ifdef DEBUG

     void ASSERT_SetNotMarked() const {mSet->ASSERT_NotMarked();}

 #endif

     ~XPCWrappedNativeProto();

 protected:

     // disable copy ctor and assignment

     XPCWrappedNativeProto(const XPCWrappedNativeProto& r); // not implemented

     XPCWrappedNativeProto& operator= (const XPCWrappedNativeProto& r); // not implemented

     // hide ctor

     XPCWrappedNativeProto(XPCWrappedNativeScope* Scope,

                           nsIClassInfo* ClassInfo,

                           uint32_t ClassInfoFlags,

                           XPCNativeSet* Set);

     bool Init(const XPCNativeScriptableCreateInfo* scriptableCreateInfo,

               bool callPostCreatePrototype);

 private:

 #ifdef DEBUG

     static int32_t gDEBUG_LiveProtoCount;

 #endif

 private:

     XPCWrappedNativeScope*   mScope;

     JS::ObjectPtr            mJSProtoObject;

     nsCOMPtr<nsIClassInfo>   mClassInfo;

     uint32_t                 mClassInfoFlags;

     XPCNativeSet*            mSet;

     XPCNativeScriptableInfo* mScriptableInfo;

 };

 /***********************************************/

 // XPCWrappedNativeTearOff represents the info needed to make calls to one

 // interface on the underlying native object of a XPCWrappedNative.

 class XPCWrappedNativeTearOff

 {

 public:

     bool IsAvailable() const {return mInterface == nullptr;}

     bool IsReserved()  const {return mInterface == (XPCNativeInterface*)1;}

     bool IsValid()     const {return !IsAvailable() && !IsReserved();}

     void   SetReserved()       {mInterface = (XPCNativeInterface*)1;}

     XPCNativeInterface* GetInterface() const {return mInterface;}

     nsISupports*        GetNative()    const {return mNative;}

     JSObject*           GetJSObject();

     JSObject*           GetJSObjectPreserveColor() const;

     void SetInterface(XPCNativeInterface*  Interface) {mInterface = Interface;}

     void SetNative(nsISupports*  Native)              {mNative = Native;}

     void SetJSObject(JSObject*  JSObj);

     void JSObjectFinalized() {SetJSObject(nullptr);}

     XPCWrappedNativeTearOff()

         : mInterface(nullptr), mNative(nullptr), mJSObject(nullptr) {}

     ~XPCWrappedNativeTearOff();

     // NOP. This is just here to make the AutoMarkingPtr code compile.

     inline void TraceJS(JSTracer* trc) {}

     inline void AutoTrace(JSTracer* trc) {}

     void Mark()       {mJSObject = (JSObject*)(intptr_t(mJSObject) | 1);}

     void Unmark()     {mJSObject = (JSObject*)(intptr_t(mJSObject) & ~1);}

     bool IsMarked() const {return !!(intptr_t(mJSObject) & 1);}

 private:

     XPCWrappedNativeTearOff(const XPCWrappedNativeTearOff& r) MOZ_DELETE;

     XPCWrappedNativeTearOff& operator= (const XPCWrappedNativeTearOff& r) MOZ_DELETE;

 private:

     XPCNativeInterface* mInterface;

     nsISupports*        mNative;

     JSObject*           mJSObject;

 };

 /***********************************************/

 // XPCWrappedNativeTearOffChunk is a collections of XPCWrappedNativeTearOff

 // objects. It lets us allocate a set of XPCWrappedNativeTearOff objects and

 // link the sets - rather than only having the option of linking single

 // XPCWrappedNativeTearOff objects.

 //

 // The value of XPC_WRAPPED_NATIVE_TEAROFFS_PER_CHUNK can be tuned at buildtime

 // to balance between the code of allocations of additional chunks and the waste

 // of space for ununsed XPCWrappedNativeTearOff objects.

 #define XPC_WRAPPED_NATIVE_TEAROFFS_PER_CHUNK 1

 class XPCWrappedNativeTearOffChunk

 {

 friend class XPCWrappedNative;

 private:

     XPCWrappedNativeTearOffChunk() : mNextChunk(nullptr) {}

     ~XPCWrappedNativeTearOffChunk() {delete mNextChunk;}

 private:

     XPCWrappedNativeTearOff mTearOffs[XPC_WRAPPED_NATIVE_TEAROFFS_PER_CHUNK];

     XPCWrappedNativeTearOffChunk* mNextChunk;

 };

 void *xpc_GetJSPrivate(JSObject *obj);

 /***************************************************************************/

 // XPCWrappedNative the wrapper around one instance of a native xpcom object

 // to be used from JavaScript.

 class XPCWrappedNative : public nsIXPConnectWrappedNative

 {

 public:

     NS_DECL_CYCLE_COLLECTING_ISUPPORTS

     NS_DECL_NSIXPCONNECTJSOBJECTHOLDER

     NS_DECL_NSIXPCONNECTWRAPPEDNATIVE

     NS_DECL_CYCLE_COLLECTION_CLASS(XPCWrappedNative)

     nsIPrincipal* GetObjectPrincipal() const;

     bool

     IsValid() const { return mFlatJSObject.hasFlag(FLAT_JS_OBJECT_VALID); }

 #define XPC_SCOPE_WORD(s)   (intptr_t(s))

 #define XPC_SCOPE_MASK      (intptr_t(0x3))

 #define XPC_SCOPE_TAG       (intptr_t(0x1))

 #define XPC_WRAPPER_EXPIRED (intptr_t(0x2))

     static inline bool

     IsTaggedScope(XPCWrappedNativeScope* s)

         {return XPC_SCOPE_WORD(s) & XPC_SCOPE_TAG;}

     static inline XPCWrappedNativeScope*

     TagScope(XPCWrappedNativeScope* s)

         {MOZ_ASSERT(!IsTaggedScope(s), "bad pointer!");

          return (XPCWrappedNativeScope*)(XPC_SCOPE_WORD(s) | XPC_SCOPE_TAG);}

     static inline XPCWrappedNativeScope*

     UnTagScope(XPCWrappedNativeScope* s)

         {return (XPCWrappedNativeScope*)(XPC_SCOPE_WORD(s) & ~XPC_SCOPE_TAG);}

     inline bool

     IsWrapperExpired() const

         {return XPC_SCOPE_WORD(mMaybeScope) & XPC_WRAPPER_EXPIRED;}

     bool

     HasProto() const {return !IsTaggedScope(mMaybeScope);}

     XPCWrappedNativeProto*

     GetProto() const

         {return HasProto() ?

          (XPCWrappedNativeProto*)

          (XPC_SCOPE_WORD(mMaybeProto) & ~XPC_SCOPE_MASK) : nullptr;}

     void SetProto(XPCWrappedNativeProto* p);

     XPCWrappedNativeScope*

     GetScope() const

         {return GetProto() ? GetProto()->GetScope() :

          (XPCWrappedNativeScope*)

          (XPC_SCOPE_WORD(mMaybeScope) & ~XPC_SCOPE_MASK);}

     nsISupports*

     GetIdentityObject() const {return mIdentity;}

     /**

      * This getter clears the gray bit before handing out the JSObject which

      * means that the object is guaranteed to be kept alive past the next CC.

      */

     JSObject*

     GetFlatJSObject() const

     {

         JS::ExposeObjectToActiveJS(mFlatJSObject);

         return mFlatJSObject;

     }

     /**

      * This getter does not change the color of the JSObject meaning that the

      * object returned is not guaranteed to be kept alive past the next CC.

      *

      * This should only be called if you are certain that the return value won't

      * be passed into a JS API function and that it won't be stored without

      * being rooted (or otherwise signaling the stored value to the CC).

      */

     JSObject*

     GetFlatJSObjectPreserveColor() const {return mFlatJSObject;}

     XPCNativeSet*

     GetSet() const {return mSet;}

     void

     SetSet(XPCNativeSet* set) {mSet = set;}

     static XPCWrappedNative* Get(JSObject *obj) {

         MOZ_ASSERT(IS_WN_REFLECTOR(obj));

         return (XPCWrappedNative*)js::GetObjectPrivate(obj);

     }

 private:

     inline void

     ExpireWrapper()

         {mMaybeScope = (XPCWrappedNativeScope*)

                        (XPC_SCOPE_WORD(mMaybeScope) | XPC_WRAPPER_EXPIRED);}

 public:

     XPCNativeScriptableInfo*

     GetScriptableInfo() const {return mScriptableInfo;}

     nsIXPCScriptable*      // call this wrong and you deserve to crash

     GetScriptableCallback() const  {return mScriptableInfo->GetCallback();}

     nsIClassInfo*

     GetClassInfo() const {return IsValid() && HasProto() ?

                             GetProto()->GetClassInfo() : nullptr;}

     bool

     HasMutatedSet() const {return IsValid() &&

                                   (!HasProto() ||

                                    GetSet() != GetProto()->GetSet());}

     XPCJSRuntime*

     GetRuntime() const {XPCWrappedNativeScope* scope = GetScope();

                         return scope ? scope->GetRuntime() : nullptr;}

     static nsresult

     WrapNewGlobal(xpcObjectHelper &nativeHelper,

                   nsIPrincipal *principal, bool initStandardClasses,

                   JS::CompartmentOptions& aOptions,

                   XPCWrappedNative **wrappedGlobal);

     static nsresult

     GetNewOrUsed(xpcObjectHelper& helper,

                  XPCWrappedNativeScope* Scope,

                  XPCNativeInterface* Interface,

                  XPCWrappedNative** wrapper);

 public:

     static nsresult

     GetUsedOnly(nsISupports* Object,

                 XPCWrappedNativeScope* Scope,

                 XPCNativeInterface* Interface,

                 XPCWrappedNative** wrapper);

     static nsresult

     ReparentWrapperIfFound(XPCWrappedNativeScope* aOldScope,

                            XPCWrappedNativeScope* aNewScope,

                            JS::HandleObject aNewParent,

                            nsISupports* aCOMObj);

     nsresult RescueOrphans();

     void FlatJSObjectFinalized();

     void SystemIsBeingShutDown();

     enum CallMode {CALL_METHOD, CALL_GETTER, CALL_SETTER};

     static bool CallMethod(XPCCallContext& ccx,

                            CallMode mode = CALL_METHOD);

     static bool GetAttribute(XPCCallContext& ccx)

         {return CallMethod(ccx, CALL_GETTER);}

     static bool SetAttribute(XPCCallContext& ccx)

         {return CallMethod(ccx, CALL_SETTER);}

     inline bool HasInterfaceNoQI(const nsIID& iid);

     XPCWrappedNativeTearOff* LocateTearOff(XPCNativeInterface* aInterface);

     XPCWrappedNativeTearOff* FindTearOff(XPCNativeInterface* aInterface,

                                          bool needJSObject = false,

                                          nsresult* pError = nullptr);

     void Mark() const

     {

         mSet->Mark();

         if (mScriptableInfo) mScriptableInfo->Mark();

         if (HasProto()) GetProto()->Mark();

     }

     // Yes, we *do* need to mark the mScriptableInfo in both cases.

     inline void TraceInside(JSTracer *trc) {

         if (JS_IsGCMarkingTracer(trc)) {

             mSet->Mark();

             if (mScriptableInfo)

                 mScriptableInfo->Mark();

         }

         if (HasProto())

             GetProto()->TraceSelf(trc);

         else

             GetScope()->TraceInside(trc);

         if (mFlatJSObject && JS_IsGlobalObject(mFlatJSObject))

         {

             xpc::TraceXPCGlobal(trc, mFlatJSObject);

         }

     }

     void TraceJS(JSTracer *trc) {

         TraceInside(trc);

     }

     void TraceSelf(JSTracer *trc) {

         // If this got called, we're being kept alive by someone who really

         // needs us alive and whole.  Do not let our mFlatJSObject go away.

         // This is the only time we should be tracing our mFlatJSObject,

         // normally somebody else is doing that. Be careful not to trace the

         // bogus INVALID_OBJECT value we can have during init, though.

         if (mFlatJSObject) {

             JS_CallTenuredObjectTracer(trc, &mFlatJSObject,

                                        "XPCWrappedNative::mFlatJSObject");

         }

     }

     static void Trace(JSTracer *trc, JSObject *obj);

     void AutoTrace(JSTracer *trc) {

         TraceSelf(trc);

     }

 #ifdef DEBUG

     void ASSERT_SetsNotMarked() const

         {mSet->ASSERT_NotMarked();

          if (HasProto()){GetProto()->ASSERT_SetNotMarked();}}

 #endif

     inline void SweepTearOffs();

     // Returns a string that shuld be free'd using JS_smprintf_free (or null).

     char* ToString(XPCWrappedNativeTearOff* to = nullptr) const;

     static void GatherProtoScriptableCreateInfo(nsIClassInfo* classInfo,

                                                 XPCNativeScriptableCreateInfo& sciProto);

     bool HasExternalReference() const {return mRefCnt > 1;}

     void NoteTearoffs(nsCycleCollectionTraversalCallback& cb);

     // Make ctor and dtor protected (rather than private) to placate nsCOMPtr.

 protected:

     XPCWrappedNative(); // not implemented

     // This ctor is used if this object will have a proto.

     XPCWrappedNative(already_AddRefed<nsISupports>&& aIdentity,

                      XPCWrappedNativeProto* aProto);

     // This ctor is used if this object will NOT have a proto.

     XPCWrappedNative(already_AddRefed<nsISupports>&& aIdentity,

                      XPCWrappedNativeScope* aScope,

                      XPCNativeSet* aSet);

     virtual ~XPCWrappedNative();

     void Destroy();

     void UpdateScriptableInfo(XPCNativeScriptableInfo *si);

 private:

     enum {

         // Flags bits for mFlatJSObject:

         FLAT_JS_OBJECT_VALID = JS_BIT(0)

     };

 private:

     bool Init(JS::HandleObject parent, const XPCNativeScriptableCreateInfo* sci);

     bool FinishInit();

     bool ExtendSet(XPCNativeInterface* aInterface);

     nsresult InitTearOff(XPCWrappedNativeTearOff* aTearOff,

                          XPCNativeInterface* aInterface,

                          bool needJSObject);

     bool InitTearOffJSObject(XPCWrappedNativeTearOff* to);

 public:

     static const XPCNativeScriptableCreateInfo& GatherScriptableCreateInfo(nsISupports* obj,

                                                                            nsIClassInfo* classInfo,

                                                                            XPCNativeScriptableCreateInfo& sciProto,

                                                                            XPCNativeScriptableCreateInfo& sciWrapper);

 private:

     union

     {

         XPCWrappedNativeScope*   mMaybeScope;

         XPCWrappedNativeProto*   mMaybeProto;

     };

     XPCNativeSet*                mSet;

     JS::TenuredHeap<JSObject*>   mFlatJSObject;

     XPCNativeScriptableInfo*     mScriptableInfo;

     XPCWrappedNativeTearOffChunk mFirstChunk;

 };

 /***************************************************************************

 ****************************************************************************

 *

 * Core classes for wrapped JSObject for use from native code...

 *

 ****************************************************************************

 ***************************************************************************/

 // this interfaces exists so we can refcount nsXPCWrappedJSClass

 // {2453EBA0-A9B8-11d2-BA64-00805F8A5DD7}

 #define NS_IXPCONNECT_WRAPPED_JS_CLASS_IID                                    \

 { 0x2453eba0, 0xa9b8, 0x11d2,                                                 \

   { 0xba, 0x64, 0x0, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 } }

 class nsIXPCWrappedJSClass : public nsISupports

 {

 public:

     NS_DECLARE_STATIC_IID_ACCESSOR(NS_IXPCONNECT_WRAPPED_JS_CLASS_IID)

     NS_IMETHOD DebugDump(int16_t depth) = 0;

 };

 NS_DEFINE_STATIC_IID_ACCESSOR(nsIXPCWrappedJSClass,

                               NS_IXPCONNECT_WRAPPED_JS_CLASS_IID)

 /*************************/

 // nsXPCWrappedJSClass represents the sharable factored out common code and

 // data for nsXPCWrappedJS instances for the same interface type.

 class nsXPCWrappedJSClass : public nsIXPCWrappedJSClass

 {

     // all the interface method declarations...

     NS_DECL_ISUPPORTS

     NS_IMETHOD DebugDump(int16_t depth);

 public:

     static already_AddRefed<nsXPCWrappedJSClass>

     GetNewOrUsed(JSContext* cx,

                  REFNSIID aIID);

     REFNSIID GetIID() const {return mIID;}

     XPCJSRuntime* GetRuntime() const {return mRuntime;}

     nsIInterfaceInfo* GetInterfaceInfo() const {return mInfo;}

     const char* GetInterfaceName();

     static bool IsWrappedJS(nsISupports* aPtr);

     NS_IMETHOD DelegatedQueryInterface(nsXPCWrappedJS* self, REFNSIID aIID,

                                        void** aInstancePtr);

     JSObject* GetRootJSObject(JSContext* cx, JSObject* aJSObj);

     NS_IMETHOD CallMethod(nsXPCWrappedJS* wrapper, uint16_t methodIndex,

                           const XPTMethodDescriptor* info,

                           nsXPTCMiniVariant* params);

     JSObject*  CallQueryInterfaceOnJSObject(JSContext* cx,

                                             JSObject* jsobj, REFNSIID aIID);

     static nsresult BuildPropertyEnumerator(XPCCallContext& ccx,

                                             JSObject* aJSObj,

                                             nsISimpleEnumerator** aEnumerate);

     static nsresult GetNamedPropertyAsVariant(XPCCallContext& ccx,

                                               JSObject* aJSObj,

                                               const nsAString& aName,

                                               nsIVariant** aResult);

     virtual ~nsXPCWrappedJSClass();

     static nsresult CheckForException(XPCCallContext & ccx,

                                       const char * aPropertyName,

                                       const char * anInterfaceName,

                                       bool aForceReport);

 private:

     nsXPCWrappedJSClass();   // not implemented

     nsXPCWrappedJSClass(JSContext* cx, REFNSIID aIID,

                         nsIInterfaceInfo* aInfo);

     bool IsReflectable(uint16_t i) const

         {return (bool)(mDescriptors[i/32] & (1 << (i%32)));}

     void SetReflectable(uint16_t i, bool b)

         {if (b) mDescriptors[i/32] |= (1 << (i%32));

          else mDescriptors[i/32] &= ~(1 << (i%32));}

     bool GetArraySizeFromParam(JSContext* cx,

                                const XPTMethodDescriptor* method,

                                const nsXPTParamInfo& param,

                                uint16_t methodIndex,

                                uint8_t paramIndex,

                                nsXPTCMiniVariant* params,

                                uint32_t* result);

     bool GetInterfaceTypeFromParam(JSContext* cx,

                                    const XPTMethodDescriptor* method,

                                    const nsXPTParamInfo& param,

                                    uint16_t methodIndex,

                                    const nsXPTType& type,

                                    nsXPTCMiniVariant* params,

                                    nsID* result);

     void CleanupPointerArray(const nsXPTType& datum_type,

                              uint32_t array_count,

                              void** arrayp);

     void CleanupPointerTypeObject(const nsXPTType& type,

                                   void** pp);

 private:

     XPCJSRuntime* mRuntime;

     nsCOMPtr<nsIInterfaceInfo> mInfo;

     char* mName;

     nsIID mIID;

     uint32_t* mDescriptors;

 };

 /*************************/

 // nsXPCWrappedJS is a wrapper for a single JSObject for use from native code.

 // nsXPCWrappedJS objects are chained together to represent the various

 // interface on the single underlying (possibly aggregate) JSObject.

 class nsXPCWrappedJS : protected nsAutoXPTCStub,

                        public nsIXPConnectWrappedJS,

                        public nsSupportsWeakReference,

                        public nsIPropertyBag,

                        public XPCRootSetElem

 {

 public:

     NS_DECL_CYCLE_COLLECTING_ISUPPORTS

     NS_DECL_NSIXPCONNECTJSOBJECTHOLDER

     NS_DECL_NSIXPCONNECTWRAPPEDJS

     NS_DECL_NSISUPPORTSWEAKREFERENCE

     NS_DECL_NSIPROPERTYBAG

     NS_DECL_CYCLE_COLLECTION_SKIPPABLE_CLASS_AMBIGUOUS(nsXPCWrappedJS, nsIXPConnectWrappedJS)

     NS_IMETHOD CallMethod(uint16_t methodIndex,

                           const XPTMethodDescriptor *info,

                           nsXPTCMiniVariant* params);

     /*

     * This is rarely called directly. Instead one usually calls

     * XPCConvert::JSObject2NativeInterface which will handles cases where the

     * JS object is already a wrapped native or a DOM object.

     */

     static nsresult

     GetNewOrUsed(JS::HandleObject aJSObj,

                  REFNSIID aIID,

                  nsXPCWrappedJS** wrapper);

     nsISomeInterface* GetXPTCStub() { return mXPTCStub; }

     /**

      * This getter does not change the color of the JSObject meaning that the

      * object returned is not guaranteed to be kept alive past the next CC.

      *

      * This should only be called if you are certain that the return value won't

      * be passed into a JS API function and that it won't be stored without

      * being rooted (or otherwise signaling the stored value to the CC).

      */

     JSObject* GetJSObjectPreserveColor() const {return mJSObj;}

     nsXPCWrappedJSClass*  GetClass() const {return mClass;}

     REFNSIID GetIID() const {return GetClass()->GetIID();}

     nsXPCWrappedJS* GetRootWrapper() const {return mRoot;}

     nsXPCWrappedJS* GetNextWrapper() const {return mNext;}

     nsXPCWrappedJS* Find(REFNSIID aIID);

     nsXPCWrappedJS* FindInherited(REFNSIID aIID);

     nsXPCWrappedJS* FindOrFindInherited(REFNSIID aIID) {

         nsXPCWrappedJS* wrapper = Find(aIID);

         if (wrapper)

             return wrapper;

         return FindInherited(aIID);

     }

     bool IsRootWrapper() const {return mRoot == this;}

     bool IsValid() const {return mJSObj != nullptr;}

     void SystemIsBeingShutDown();

     // These two methods are used by JSObject2WrappedJSMap::FindDyingJSObjects

     // to find non-rooting wrappers for dying JS objects. See the top of

     // XPCWrappedJS.cpp for more details.

     bool IsSubjectToFinalization() const {return IsValid() && mRefCnt == 1;}

     bool IsObjectAboutToBeFinalized() {return JS_IsAboutToBeFinalized(&mJSObj);}

     bool IsAggregatedToNative() const {return mRoot->mOuter != nullptr;}

     nsISupports* GetAggregatedNativeObject() const {return mRoot->mOuter;}

     void SetAggregatedNativeObject(nsISupports *aNative) {

         MOZ_ASSERT(aNative);

         if (mRoot->mOuter) {

             MOZ_ASSERT(mRoot->mOuter == aNative,

                        "Only one aggregated native can be set");

             return;

         }

         mRoot->mOuter = aNative;

     }

     void TraceJS(JSTracer* trc);

     static void GetTraceName(JSTracer* trc, char *buf, size_t bufsize);

     virtual ~nsXPCWrappedJS();

 protected:

     nsXPCWrappedJS();   // not implemented

     nsXPCWrappedJS(JSContext* cx,

                    JSObject* aJSObj,

                    nsXPCWrappedJSClass* aClass,

                    nsXPCWrappedJS* root);

     bool CanSkip();

     void Destroy();

     void Unlink();

 private:

     JS::Heap<JSObject*> mJSObj;

     nsRefPtr<nsXPCWrappedJSClass> mClass;

     nsXPCWrappedJS* mRoot;    // If mRoot != this, it is an owning pointer.

     nsXPCWrappedJS* mNext;

     nsCOMPtr<nsISupports> mOuter;    // only set in root

 };

 /***************************************************************************/

 class XPCJSObjectHolder : public nsIXPConnectJSObjectHolder,

                           public XPCRootSetElem

 {

 public:

     // all the interface method declarations...

     NS_DECL_ISUPPORTS

     NS_DECL_NSIXPCONNECTJSOBJECTHOLDER

     // non-interface implementation

 public:

     static XPCJSObjectHolder* newHolder(JSObject* obj);

     virtual ~XPCJSObjectHolder();

     void TraceJS(JSTracer *trc);

     static void GetTraceName(JSTracer* trc, char *buf, size_t bufsize);

 private:

     XPCJSObjectHolder(JSObject* obj);

     XPCJSObjectHolder(); // not implemented

     JS::Heap<JSObject*> mJSObj;

 };

 /***************************************************************************

 ****************************************************************************

 *

 * All manner of utility classes follow...

 *

 ****************************************************************************

 ***************************************************************************/

 class xpcProperty : public nsIProperty

 {

 public:

   NS_DECL_ISUPPORTS

   NS_DECL_NSIPROPERTY

   xpcProperty(const char16_t* aName, uint32_t aNameLen, nsIVariant* aValue);

   virtual ~xpcProperty() {}

 private:

     nsString             mName;

     nsCOMPtr<nsIVariant> mValue;

 };

 /***************************************************************************/

 // class here just for static methods

 class XPCConvert

 {

 public:

     static bool IsMethodReflectable(const XPTMethodDescriptor& info);

     /**

      * Convert a native object into a jsval.

      *

      * @param d [out] the resulting jsval

      * @param s the native object we're working with

      * @param type the type of object that s is

      * @param iid the interface of s that we want

      * @param scope the default scope to put on the new JSObject's parent

      *        chain

      * @param pErr [out] relevant error code, if any.

      */

     static bool NativeData2JS(JS::MutableHandleValue d,

                               const void* s, const nsXPTType& type,

                               const nsID* iid, nsresult* pErr);

     static bool JSData2Native(void* d, JS::HandleValue s,

                               const nsXPTType& type,

                               bool useAllocator, const nsID* iid,

                               nsresult* pErr);

     /**

      * Convert a native nsISupports into a JSObject.

      *

      * @param dest [out] the resulting JSObject

      * @param src the native object we're working with

      * @param iid the interface of src that we want (may be null)

      * @param Interface the interface of src that we want

      * @param cache the wrapper cache for src (may be null, in which case src

      *              will be QI'ed to get the cache)

      * @param allowNativeWrapper if true, this method may wrap the resulting

      *        JSObject in an XPCNativeWrapper and return that, as needed.

      * @param pErr [out] relevant error code, if any.

      * @param src_is_identity optional performance hint. Set to true only

      *                        if src is the identity pointer.

      */

     static bool NativeInterface2JSObject(JS::MutableHandleValue d,

                                          nsIXPConnectJSObjectHolder** dest,

                                          xpcObjectHelper& aHelper,

                                          const nsID* iid,

                                          XPCNativeInterface** Interface,

                                          bool allowNativeWrapper,

                                          nsresult* pErr);

     static bool GetNativeInterfaceFromJSObject(void** dest, JSObject* src,

                                                const nsID* iid,

                                                nsresult* pErr);

     static bool JSObject2NativeInterface(void** dest, JS::HandleObject src,

                                          const nsID* iid,

                                          nsISupports* aOuter,

                                          nsresult* pErr);

     static bool GetISupportsFromJSObject(JSObject* obj, nsISupports** iface);

     /**

      * Convert a native array into a jsval.

      *

      * @param d [out] the resulting jsval

      * @param s the native array we're working with

      * @param type the type of objects in the array

      * @param iid the interface of each object in the array that we want

      * @param count the number of items in the array

      * @param scope the default scope to put on the new JSObjects' parent chain

      * @param pErr [out] relevant error code, if any.

      */

     static bool NativeArray2JS(JS::MutableHandleValue d, const void** s,

                                const nsXPTType& type, const nsID* iid,

                                uint32_t count, nsresult* pErr);

     static bool JSArray2Native(void** d, JS::HandleValue s,

                                uint32_t count, const nsXPTType& type,

                                const nsID* iid, nsresult* pErr);

     static bool JSTypedArray2Native(void** d,

                                     JSObject* jsarray,

                                     uint32_t count,

                                     const nsXPTType& type,

                                     nsresult* pErr);

     static bool NativeStringWithSize2JS(JS::MutableHandleValue d, const void* s,

                                         const nsXPTType& type,

                                         uint32_t count,

                                         nsresult* pErr);

     static bool JSStringWithSize2Native(void* d, JS::HandleValue s,

                                         uint32_t count, const nsXPTType& type,

                                         nsresult* pErr);

     static nsresult JSValToXPCException(JS::MutableHandleValue s,

                                         const char* ifaceName,

                                         const char* methodName,

                                         nsIException** exception);

     static nsresult JSErrorToXPCException(const char* message,

                                           const char* ifaceName,

                                           const char* methodName,

                                           const JSErrorReport* report,

                                           nsIException** exception);

     static nsresult ConstructException(nsresult rv, const char* message,

                                        const char* ifaceName,

                                        const char* methodName,

                                        nsISupports* data,

                                        nsIException** exception,

                                        JSContext* cx,

                                        jsval *jsExceptionPtr);

 private:

     XPCConvert(); // not implemented

 };

 /***************************************************************************/

 // code for throwing exceptions into JS

 class nsXPCException;

 class XPCThrower

 {

 public:

     static void Throw(nsresult rv, JSContext* cx);

     static void Throw(nsresult rv, XPCCallContext& ccx);

     static void ThrowBadResult(nsresult rv, nsresult result, XPCCallContext& ccx);

     static void ThrowBadParam(nsresult rv, unsigned paramNum, XPCCallContext& ccx);

     static bool SetVerbosity(bool state)

         {bool old = sVerbose; sVerbose = state; return old;}

     static bool CheckForPendingException(nsresult result, JSContext *cx);

 private:

     static void Verbosify(XPCCallContext& ccx,

                           char** psz, bool own);

 private:

     static bool sVerbose;

 };

 /***************************************************************************/

 class nsXPCException

 {

 public:

     static bool NameAndFormatForNSResult(nsresult rv,

                                          const char** name,

                                          const char** format);

     static const void* IterateNSResults(nsresult* rv,

                                         const char** name,

                                         const char** format,

                                         const void** iterp);

     static uint32_t GetNSResultCount();

 };

 /***************************************************************************/

 /*

 * nsJSID implements nsIJSID. It is also used by nsJSIID and nsJSCID as a

 * member (as a hidden implementaion detail) to which they delegate many calls.

 */