--- a/dom/base/nsDOMClassInfo.cpp
+++ b/dom/base/nsDOMClassInfo.cpp
@@ -10,17 +10,16 @@
#ifdef XP_WIN
#undef GetClassName
#endif
// JavaScript includes
#include "jsapi.h"
#include "jsfriendapi.h"
-#include "jsprvtd.h" // we are using private JS typedefs...
#include "jsdbgapi.h"
#include "WrapperFactory.h"
#include "AccessCheck.h"
#include "XrayWrapper.h"
#include "xpcpublic.h"
#include "xpcprivate.h"
#include "XPCWrapper.h"
--- a/js/src/builtin/RegExp.h
+++ b/js/src/builtin/RegExp.h
@@ -2,18 +2,16 @@
* 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/. */
#ifndef builtin_RegExp_h
#define builtin_RegExp_h
-#include "jsprvtd.h"
-
#include "vm/MatchPairs.h"
#include "vm/RegExpObject.h"
JSObject *
js_InitRegExpClass(JSContext *cx, js::HandleObject obj);
/*
* The following builtin natives are extern'd for pointer comparison in
--- a/js/src/frontend/BytecodeEmitter.h
+++ b/js/src/frontend/BytecodeEmitter.h
@@ -19,16 +19,19 @@
#include "frontend/ParseMaps.h"
#include "frontend/SharedContext.h"
#include "frontend/SourceNotes.h"
#include "vm/ScopeObject.h"
namespace js {
namespace frontend {
+template <typename ParseHandler>
+class Parser;
+
struct CGTryNoteList {
Vector<JSTryNote> list;
CGTryNoteList(ExclusiveContext *cx) : list(cx) {}
bool append(JSTryNoteKind kind, unsigned stackDepth, size_t start, size_t end);
size_t length() const { return list.length(); }
void finish(TryNoteArray *array);
};
--- a/js/src/frontend/FoldConstants.h
+++ b/js/src/frontend/FoldConstants.h
@@ -2,18 +2,16 @@
* 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/. */
#ifndef frontend_FoldConstants_h
#define frontend_FoldConstants_h
-#include "jsprvtd.h"
-
#include "frontend/SyntaxParseHandler.h"
namespace js {
namespace frontend {
// Perform constant folding on the given AST. For example, the program
// `print(2 + 2)` would become `print(4)`.
//
--- a/js/src/frontend/ParseMaps.h
+++ b/js/src/frontend/ParseMaps.h
@@ -13,16 +13,19 @@
#include "jsprvtd.h"
#include "ds/InlineMap.h"
#include "gc/Barrier.h"
#include "js/HashTable.h"
#include "js/Vector.h"
namespace js {
+
+class LifoAlloc;
+
namespace frontend {
class DefinitionSingle;
class DefinitionList;
typedef InlineMap<JSAtom *, jsatomid, 24> AtomIndexMap;
typedef InlineMap<JSAtom *, DefinitionSingle, 24> AtomDefnMap;
typedef InlineMap<JSAtom *, DefinitionList, 24> AtomDefnListMap;
--- a/js/src/frontend/ParseNode.h
+++ b/js/src/frontend/ParseNode.h
@@ -16,16 +16,18 @@
namespace js {
namespace frontend {
template <typename ParseHandler>
struct ParseContext;
class FullParseHandler;
+class FunctionBox;
+class ObjectBox;
/*
* Indicates a location in the stack that an upvar value can be retrieved from
* as a two tuple of (level, slot).
*
* Some existing client code uses the level value as a delta, or level "skip"
* quantity. We could probably document that through use of more types at some
* point in the future.
--- a/js/src/frontend/SyntaxParseHandler.h
+++ b/js/src/frontend/SyntaxParseHandler.h
@@ -8,16 +8,19 @@
#define frontend_SyntaxParseHandler_h
#include "frontend/ParseNode.h"
#include "frontend/TokenStream.h"
namespace js {
namespace frontend {
+template <typename ParseHandler>
+class Parser;
+
// Parse handler used when processing the syntax in a block of code, to generate
// the minimal information which is required to detect syntax errors and allow
// bytecode to be emitted for outer functions.
//
// When parsing, we start at the top level with a full parse, and when possible
// only check the syntax for inner functions, so that they can be lazily parsed
// into bytecode when/if they first run. Checking the syntax of a function is
// several times faster than doing a full parse/emit, and lazy parsing improves
--- a/js/src/jsanalyze.h
+++ b/js/src/jsanalyze.h
@@ -17,16 +17,21 @@
#include "vm/Runtime.h"
class JSScript;
namespace js {
namespace analyze {
+class LoopAnalysis;
+class SlotValue;
+class SSAValue;
+class SSAUseChain;
+
/*
* There are three analyses we can perform on a JSScript, outlined below.
* The results of all three are stored in ScriptAnalysis, but the analyses
* themselves can be performed separately. Along with type inference results,
* per-script analysis results are tied to the per-compartment analysis pool
* and are freed on every garbage collection.
*
* - Basic bytecode analysis. For each bytecode, determine the stack depth at
--- a/js/src/jsatom.h
+++ b/js/src/jsatom.h
@@ -213,15 +213,18 @@ AtomizeChars(ExclusiveContext *cx, const
template <AllowGC allowGC>
extern JSAtom *
AtomizeString(ExclusiveContext *cx, JSString *str, js::InternBehavior ib = js::DoNotInternAtom);
template <AllowGC allowGC>
extern JSAtom *
ToAtom(ExclusiveContext *cx, typename MaybeRooted<Value, allowGC>::HandleType v);
+template <XDRMode mode>
+class XDRState;
+
template<XDRMode mode>
bool
XDRAtom(XDRState<mode> *xdr, js::MutableHandleAtom atomp);
} /* namespace js */
#endif /* jsatom_h */
--- a/js/src/jsclass.h
+++ b/js/src/jsclass.h
@@ -13,19 +13,21 @@
* object behavior and, e.g., allows custom slow layout.
*/
#include "jsapi.h"
#include "jsprvtd.h"
namespace js {
+class Class;
+class FreeOp;
+class PropertyId;
class PropertyName;
class SpecialId;
-class PropertyId;
// This is equal to JSFunction::class_. Use it in places where you don't want
// to #include jsfun.h.
extern JS_FRIEND_DATA(js::Class* const) FunctionClassPtr;
static JS_ALWAYS_INLINE jsid
SPECIALID_TO_JSID(const SpecialId &sid);
--- a/js/src/jscntxt.h
+++ b/js/src/jscntxt.h
@@ -102,20 +102,21 @@ class AutoCycleDetector
bool foundCycle() { return cyclic; }
};
/* Updates references in the cycle detection set if the GC moves them. */
extern void
TraceCycleDetectionSet(JSTracer *trc, ObjectSet &set);
struct AutoResolving;
-
+class DtoaCache;
class ForkJoinSlice;
class RegExpCompartment;
-class DtoaCache;
+class RegExpStatics;
+class ForkJoinSlice;
/*
* Execution Context Overview:
*
* Several different structures may be used to provide a context for operations
* on the VM. Each context is thread local, but varies in what data it can
* access and what other threads may be running.
*
--- a/js/src/jsdbgapi.cpp
+++ b/js/src/jsdbgapi.cpp
@@ -13,17 +13,16 @@
#include <string.h>
#include "jsapi.h"
#include "jscntxt.h"
#include "jsfun.h"
#include "jsgc.h"
#include "jsobj.h"
#include "jsopcode.h"
-#include "jsprvtd.h"
#include "jsscript.h"
#include "jsstr.h"
#include "jstypes.h"
#include "jswatchpoint.h"
#include "frontend/SourceNotes.h"
#include "jit/AsmJSModule.h"
#include "vm/Debugger.h"
--- a/js/src/jsdbgapi.h
+++ b/js/src/jsdbgapi.h
@@ -7,16 +7,18 @@
#ifndef jsdbgapi_h
#define jsdbgapi_h
/*
* JS debugger API.
*/
#include "jsprvtd.h"
+namespace js { class StackFrame; }
+
namespace JS {
struct FrameDescription
{
JSScript *script;
unsigned lineno;
JSFunction *fun;
};
--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -25,16 +25,18 @@
((uintptr_t)(sp) < (limit)+(tolerance))
#else
# define JS_CHECK_STACK_SIZE_WITH_TOLERANCE(limit, sp, tolerance) \
((uintptr_t)(sp) > (limit)-(tolerance))
#endif
#define JS_CHECK_STACK_SIZE(limit, lval) JS_CHECK_STACK_SIZE_WITH_TOLERANCE(limit, lval, 0)
+class JSLinearString;
+
namespace JS {
template <class T>
class Heap;
} /* namespace JS */
extern JS_FRIEND_API(void)
JS_SetGrayGCRootsTracer(JSRuntime *rt, JSTraceDataOp traceOp, void *data);
--- a/js/src/jsinfer.h
+++ b/js/src/jsinfer.h
@@ -100,18 +100,26 @@ class RootedBase<TaggedProto> : public T
};
class CallObject;
namespace ion {
struct IonScript;
}
+namespace analyze {
+ class ScriptAnalysis;
+}
+
namespace types {
+class TypeCallsite;
+class TypeCompartment;
+class TypeSet;
+
/* Type set entry for either a JSObject with singleton type or a non-singleton TypeObject. */
struct TypeObjectKey {
static intptr_t keyBits(TypeObjectKey *obj) { return (intptr_t) obj; }
static TypeObjectKey *getKey(TypeObjectKey *obj) { return obj; }
};
/*
* Information about a single concrete type. We pack this into a single word,
--- a/js/src/jsobj.h
+++ b/js/src/jsobj.h
@@ -31,17 +31,16 @@
namespace JS {
struct ObjectsExtraSizes;
}
namespace js {
class AutoPropDescArrayRooter;
-class BaseProxyHandler;
struct GCMarker;
struct NativeIterator;
class Nursery;
struct StackShape;
inline JSObject *
CastAsObject(PropertyOp op)
{
--- a/js/src/jsproxy.h
+++ b/js/src/jsproxy.h
@@ -7,16 +7,17 @@
#ifndef jsproxy_h
#define jsproxy_h
#include "jsapi.h"
#include "jsfriendapi.h"
namespace js {
+class RegExpGuard;
class JS_FRIEND_API(Wrapper);
/*
* A proxy is a JSObject that implements generic behavior by providing custom
* implementations for each object trap. The implementation for each trap is
* provided by a C++ object stored on the proxy, known as its handler.
*
* A major use case for proxies is to forward each trap to another object,
--- a/js/src/jsprvtd.h
+++ b/js/src/jsprvtd.h
@@ -1,186 +1,64 @@
/* -*- 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/. */
#ifndef jsprvtd_h
#define jsprvtd_h
+
/*
* JS private typename definitions.
- *
- * This header is included only in other .h files, for convenience and for
- * simplicity of type naming. The alternative for structures is to use tags,
- * which are named the same as their typedef names (legal in C/C++, and less
- * noisy than suffixing the typedef name with "Struct" or "Str"). Instead,
- * all .h files that include this file may use the same typedef name, whether
- * declaring a pointer to struct type, or defining a member of struct type.
- *
- * A few fundamental scalar types are defined here too. Neither the scalar
- * nor the struct typedefs should change much, therefore the nearly-global
- * make dependency induced by this file should not prove painful.
*/
#include "jsapi.h"
-#include "jsutil.h"
-
-#include "js/HashTable.h"
-#include "js/Vector.h"
-
-/*
- * Convenience constants.
- */
-#define JS_BITS_PER_UINT32_LOG2 5
-#define JS_BITS_PER_UINT32 32
-
-/* The alignment required of objects stored in GC arenas. */
-static const unsigned JS_GCTHING_ALIGN = 8;
-static const unsigned JS_GCTHING_ZEROBITS = 3;
/* Scalar typedefs. */
typedef uint8_t jsbytecode;
typedef uint8_t jssrcnote;
typedef uintptr_t jsatomid;
-/* Struct typedefs. */
-typedef struct JSGCThing JSGCThing;
-typedef struct JSGenerator JSGenerator;
-typedef struct JSNativeEnumerator JSNativeEnumerator;
-typedef struct JSTryNote JSTryNote;
-
-/* Friend "Advanced API" typedefs. */
-typedef struct JSAtomState JSAtomState;
-typedef struct JSCodeSpec JSCodeSpec;
-typedef struct JSPrinter JSPrinter;
-typedef struct JSStackHeader JSStackHeader;
-typedef struct JSSubString JSSubString;
-typedef struct JSSpecializedNative JSSpecializedNative;
-
/* String typedefs. */
-class JSDependentString;
-class JSExtensibleString;
-class JSExternalString;
-class JSLinearString;
-class JSRope;
class JSAtom;
-class JSWrapper;
namespace js {
-struct ArgumentsData;
-struct Class;
-
-class AutoNameVector;
-class RegExpGuard;
-class RegExpObject;
-class RegExpObjectBuilder;
-class RegExpShared;
-class RegExpStatics;
-class MatchPairs;
class PropertyName;
-class LazyScript;
enum RegExpFlag
{
IgnoreCaseFlag = 0x01,
GlobalFlag = 0x02,
MultilineFlag = 0x04,
StickyFlag = 0x08,
NoFlags = 0x00,
AllFlags = 0x0f
};
-class StringBuffer;
-
-class FrameRegs;
-class StackFrame;
-class ScriptFrameIter;
-
-class Proxy;
-class JS_FRIEND_API(AutoEnterPolicy);
-class JS_FRIEND_API(BaseProxyHandler);
-class JS_FRIEND_API(Wrapper);
-class JS_FRIEND_API(CrossCompartmentWrapper);
-
-class TempAllocPolicy;
-class RuntimeAllocPolicy;
-
-class GlobalObject;
-
-template <typename K,
- typename V,
- size_t InlineElems>
-class InlineMap;
-
-class LifoAlloc;
-
class Shape;
-class Breakpoint;
-class BreakpointSite;
-class Debugger;
-class WatchpointMap;
-
/*
* Env is the type of what ES5 calls "lexical environments" (runtime
* activations of lexical scopes). This is currently just JSObject, and is
* implemented by Call, Block, With, and DeclEnv objects, among others--but
* environments and objects are really two different concepts.
*/
typedef JSObject Env;
typedef JSNative Native;
typedef JSParallelNative ParallelNative;
typedef JSThreadSafeNative ThreadSafeNative;
typedef JSPropertyOp PropertyOp;
typedef JSStrictPropertyOp StrictPropertyOp;
typedef JSPropertyDescriptor PropertyDescriptor;
-struct SourceCompressionToken;
-
-namespace frontend {
-
-struct BytecodeEmitter;
-struct Definition;
-class FullParseHandler;
-class FunctionBox;
-class ObjectBox;
-struct Token;
-struct TokenPos;
-class TokenStream;
-class ParseMapPool;
-class ParseNode;
-
-template <typename ParseHandler>
-class Parser;
-
-} /* namespace frontend */
-
-namespace analyze {
-
-struct LifetimeVariable;
-class LoopAnalysis;
-class ScriptAnalysis;
-class SlotValue;
-class SSAValue;
-class SSAUseChain;
-
-} /* namespace analyze */
-
-namespace types {
-
-class TypeSet;
-struct TypeCallsite;
-struct TypeObject;
-struct TypeCompartment;
-
-} /* namespace types */
+namespace types { struct TypeObject; }
typedef JS::Handle<Shape*> HandleShape;
typedef JS::Handle<types::TypeObject*> HandleTypeObject;
typedef JS::Handle<JSAtom*> HandleAtom;
typedef JS::Handle<PropertyName*> HandlePropertyName;
typedef JS::MutableHandle<Shape*> MutableHandleShape;
typedef JS::MutableHandle<JSAtom*> MutableHandleAtom;
@@ -190,46 +68,29 @@ typedef JS::Rooted<types::TypeObject*> R
typedef JS::Rooted<JSAtom*> RootedAtom;
typedef JS::Rooted<PropertyName*> RootedPropertyName;
enum XDRMode {
XDR_ENCODE,
XDR_DECODE
};
-template <XDRMode mode>
-class XDRState;
-
-class FreeOp;
-
struct IdValuePair
{
jsid id;
Value value;
IdValuePair() {}
IdValuePair(jsid idArg)
: id(idArg), value(UndefinedValue())
{}
};
} /* namespace js */
-namespace JSC {
-
-class ExecutableAllocator;
-
-} /* namespace JSC */
-
-namespace WTF {
-
-class BumpPointerAllocator;
-
-} /* namespace WTF */
-
/* "Friend" types used by jscntxt.h and jsdbgapi.h. */
typedef enum JSTrapStatus {
JSTRAP_ERROR,
JSTRAP_CONTINUE,
JSTRAP_RETURN,
JSTRAP_THROW,
JSTRAP_LIMIT
} JSTrapStatus;
--- a/js/src/jsscript.h
+++ b/js/src/jsscript.h
@@ -29,24 +29,31 @@ namespace ion {
struct IonScriptCounts;
}
# define ION_DISABLED_SCRIPT ((js::ion::IonScript *)0x1)
# define ION_COMPILING_SCRIPT ((js::ion::IonScript *)0x2)
# define BASELINE_DISABLED_SCRIPT ((js::ion::BaselineScript *)0x1)
+class BreakpointSite;
+class BindingIter;
+class RegExpObject;
+struct SourceCompressionToken;
class Shape;
-
-class BindingIter;
+class WatchpointMap;
namespace analyze {
class ScriptAnalysis;
}
+namespace frontend {
+ class BytecodeEmitter;
+}
+
}
/*
* Type of try note associated with each catch or finally block, and also with
* for-in and other kinds of loops. Non-for-in loops do not need these notes
* for exception unwinding, but storing their boundaries here is helpful for
* heuristics that need to know whether a given op is inside a loop.
*/
--- a/js/src/jsstr.h
+++ b/js/src/jsstr.h
@@ -15,21 +15,21 @@
#include "jsatom.h"
#include "jslock.h"
#include "jsutil.h"
#include "js/HashTable.h"
#include "vm/Unicode.h"
class JSFlatString;
+class JSLinearString;
class JSStableString;
namespace js {
-/* Implemented in jsstrinlines.h */
class StringBuffer;
/*
* When an algorithm does not need a string represented as a single linear
* array of characters, this range utility may be used to traverse the string a
* sequence of linear arrays of characters. This avoids flattening ropes.
*
* Implemented in jsstrinlines.h.
--- a/js/src/vm/ArgumentsObject.h
+++ b/js/src/vm/ArgumentsObject.h
@@ -9,16 +9,17 @@
#include "mozilla/MemoryReporting.h"
#include "jsfun.h"
namespace js {
class AbstractFramePtr;
+class ScriptFrameIter;
namespace ion {
class IonJSFrameLayout;
}
/*
* ArgumentsData stores the initial indexed arguments provided to the
* corresponding and that function itself. It is used to store arguments[i]
--- a/js/src/vm/Debugger.h
+++ b/js/src/vm/Debugger.h
@@ -16,16 +16,18 @@
#include "jsweakmap.h"
#include "gc/Barrier.h"
#include "js/HashTable.h"
#include "vm/GlobalObject.h"
namespace js {
+class Breakpoint;
+
/*
* A weakmap that supports the keys being in different compartments to the
* values, although all values must be in the same compartment.
*
* The Key and Value classes must support the compartment() method.
*
* The purpose of this is to allow the garbage collector to easily find edges
* from debugee object compartments to debugger compartments when calculating
--- a/js/src/vm/MatchPairs.h
+++ b/js/src/vm/MatchPairs.h
@@ -2,17 +2,20 @@
* 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/. */
#ifndef vm_MatchPairs_h
#define vm_MatchPairs_h
+#include "jsalloc.h"
+
#include "ds/LifoAlloc.h"
+#include "js/Vector.h"
/*
* RegExp match results are succinctly represented by pairs of integer
* indices delimiting (start, limit] segments of the input string.
*
* The pair count for a given RegExp match is the capturing parentheses
* count plus one for the "0 capturing paren" whole text match.
*/
--- a/js/src/vm/RegExpObject.h
+++ b/js/src/vm/RegExpObject.h
@@ -42,16 +42,19 @@
* needed for execution. When a RegExpShared needs to be created, it is looked
* up in a per-compartment table to allow reuse between objects. Lastly, on
* GC, every RegExpShared (that is not active on the callstack) is discarded.
* Because of the last point, any code using a RegExpShared (viz., by executing
* a regexp) must indicate the RegExpShared is active via RegExpGuard.
*/
namespace js {
+class RegExpShared;
+namespace frontend { class TokenStream; }
+
enum RegExpRunStatus
{
RegExpRunStatus_Error,
RegExpRunStatus_Success,
RegExpRunStatus_Success_NotFound
};
class RegExpObjectBuilder
--- a/js/src/vm/Runtime.h
+++ b/js/src/vm/Runtime.h
@@ -18,16 +18,17 @@
#include <string.h>
#include "jsapi.h"
#include "jsatom.h"
#include "jsclist.h"
#include "jsfriendapi.h"
#include "jsgc.h"
#include "jsprvtd.h"
+#include "jsproxy.h"
#include "ds/FixedSizeHash.h"
#include "ds/LifoAlloc.h"
#include "frontend/ParseMaps.h"
#include "gc/Nursery.h"
#include "gc/Statistics.h"
#include "gc/StoreBuffer.h"
#include "jit/AsmJSSignalHandlers.h"
@@ -58,31 +59,34 @@ extern void
js_ReportOutOfMemory(js::ThreadSafeContext *cx);
extern void
js_ReportAllocationOverflow(js::ThreadSafeContext *cx);
extern void
js_ReportOverRecursed(js::ThreadSafeContext *cx);
+namespace JSC { class ExecutableAllocator; }
+
+namespace WTF { class BumpPointerAllocator; }
+
namespace js {
typedef Rooted<JSLinearString*> RootedLinearString;
+class AsmJSActivation;
+class InterpreterFrames;
class MathCache;
+class WorkerThreadState;
namespace ion {
class IonRuntime;
struct PcScriptCache;
}
-class AsmJSActivation;
-class InterpreterFrames;
-class WorkerThreadState;
-
/*
* GetSrcNote cache to avoid O(n^2) growth in finding a source note for a
* given pc in a script. We use the script->code pointer to tag the cache,
* instead of the script address itself, so that source notes are always found
* by offset from the bytecode with which they were generated.
*/
struct GSNCache {
typedef HashMap<jsbytecode *,
--- a/js/src/vm/ScopeObject.h
+++ b/js/src/vm/ScopeObject.h
@@ -11,16 +11,18 @@
#include "jsobj.h"
#include "jsweakmap.h"
#include "gc/Barrier.h"
#include "vm/ProxyObject.h"
namespace js {
+namespace frontend { struct Definition; }
+
/*****************************************************************************/
/*
* All function scripts have an "enclosing static scope" that refers to the
* innermost enclosing let or function in the program text. This allows full
* reconstruction of the lexical scope for debugging or compiling efficient
* access to variables in enclosing scopes. The static scope is represented at
* runtime by a tree of compiler-created objects representing each scope:
--- a/js/src/vm/Stack.h
+++ b/js/src/vm/Stack.h
@@ -12,16 +12,17 @@
#include "jsautooplen.h"
#include "jsfun.h"
#include "jsscript.h"
#include "jit/IonFrameIterator.h"
struct JSContext;
struct JSCompartment;
+struct JSGenerator;
namespace js {
class StackFrame;
class FrameRegs;
class InvokeFrameGuard;
class FrameGuard;
--- a/js/xpconnect/src/XPCInlines.h
+++ b/js/xpconnect/src/XPCInlines.h
@@ -6,16 +6,17 @@
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* private inline methods (#include'd by xpcprivate.h). */
#ifndef xpcinlines_h___
#define xpcinlines_h___
#include "jsfriendapi.h"
+#include "jsutil.h"
/***************************************************************************/
inline void
XPCJSRuntime::AddVariantRoot(XPCTraceableVariant* variant)
{
variant->AddToRootSet(GetMapLock(), &mVariantRoots);
}
--- a/xpcom/base/CycleCollectedJSRuntime.cpp
+++ b/xpcom/base/CycleCollectedJSRuntime.cpp
@@ -54,17 +54,16 @@
// To improve debugging, if WantAllTraces() is true all JS objects are
// traversed.
#include "mozilla/CycleCollectedJSRuntime.h"
#include <algorithm>
#include "mozilla/MemoryReporting.h"
#include "mozilla/dom/BindingUtils.h"
#include "mozilla/dom/DOMJSClass.h"
-#include "jsfriendapi.h"
#include "jsprf.h"
#include "nsCycleCollectionNoteRootCallback.h"
#include "nsCycleCollectionParticipant.h"
#include "nsCycleCollector.h"
#include "nsDOMJSUtils.h"
#include "xpcpublic.h"
using namespace mozilla;
--- a/xpcom/base/CycleCollectedJSRuntime.h
+++ b/xpcom/base/CycleCollectedJSRuntime.h
@@ -3,18 +3,18 @@
/* 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/. */
#ifndef mozilla_CycleCollectedJSRuntime_h__
#define mozilla_CycleCollectedJSRuntime_h__
#include "mozilla/MemoryReporting.h"
-#include "jsprvtd.h"
#include "jsapi.h"
+#include "jsfriendapi.h"
#include "nsCycleCollector.h"
#include "nsCycleCollectionParticipant.h"
#include "nsDataHashtable.h"
#include "nsHashKeys.h"
#include "nsTArray.h"
class nsCycleCollectionNoteRootCallback;