--- a/js/ipc/JavaScriptParent.h
+++ b/js/ipc/JavaScriptParent.h
@@ -5,17 +5,17 @@
  * 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_jsipc_JavaScriptParent__
 #define mozilla_jsipc_JavaScriptParent__
 
 #include "JavaScriptShared.h"
 #include "mozilla/jsipc/PJavaScriptParent.h"
-#include "jsclass.h"
+#include "js/Class.h"
 
 #ifdef XP_WIN
 #undef GetClassName
 #undef GetClassInfo
 #endif
 
 namespace mozilla {
 namespace jsipc {

rename from js/src/jsclass.h
rename to js/public/Class.h
--- a/js/src/jsclass.h
+++ b/js/public/Class.h
@@ -1,25 +1,45 @@
 /* -*- 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 jsclass_h
-#define jsclass_h
+/* JSClass definition and its component types, plus related interfaces. */
+
+#ifndef js_Class_h
+#define js_Class_h
+
+#include "jspubtd.h"
+#include "jstypes.h"
+
+#include "js/CallArgs.h"
+#include "js/Id.h"
 
 /*
  * A JSClass acts as a vtable for JS objects that allows JSAPI clients to
  * control various aspects of the behavior of an object like property lookup.
  * js::Class is an engine-private extension that allows more control over
  * object behavior and, e.g., allows custom slow layout.
  */
 
-#include "jsapi.h"
+class JSFreeOp;
+
+namespace JS {
+template <typename T> class Handle;
+template <typename T> class MutableHandle;
+class Value;
+
+typedef JS::Handle<JSObject*> HandleObject;
+typedef JS::Handle<jsid> HandleId;
+typedef JS::Handle<JS::Value> HandleValue;
+typedef JS::MutableHandle<JSObject*> MutableHandleObject;
+typedef JS::MutableHandle<JS::Value> MutableHandleValue;
+}
 
 namespace js {
 
 class Class;
 class FreeOp;
 class PropertyId;
 class PropertyName;
 class Shape;
@@ -129,78 +149,261 @@ JSID_TO_SPECIALID(jsid id)
     if (JSID_IS_EMPTY(id))
         return SpecialId::empty();
     JS_ASSERT(JSID_IS_VOID(id));
     return SpecialId::voidId();
 }
 
 typedef JS::Handle<SpecialId> HandleSpecialId;
 
+} // namespace js
+
+// JSClass operation signatures.
+
+// Add or get a property named by id in obj.  Note the jsid id type -- id may
+// be a string (Unicode property identifier) or an int (element index).  The
+// *vp out parameter, on success, is the new property value after the action.
+typedef bool
+(* JSPropertyOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+                 JS::MutableHandle<JS::Value> vp);
+
+// Set a property named by id in obj, treating the assignment as strict
+// mode code if strict is true. Note the jsid id type -- id may be a string
+// (Unicode property identifier) or an int (element index). The *vp out
+// parameter, on success, is the new property value after the
+// set.
+typedef bool
+(* JSStrictPropertyOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+                       bool strict, JS::MutableHandle<JS::Value> vp);
+
+// Delete a property named by id in obj.
+//
+// If an error occurred, return false as per normal JSAPI error practice.
+//
+// If no error occurred, but the deletion attempt wasn't allowed (perhaps
+// because the property was non-configurable), set *succeeded to false and
+// return true.  This will cause |delete obj[id]| to evaluate to false in
+// non-strict mode code, and to throw a TypeError in strict mode code.
+//
+// If no error occurred and the deletion wasn't disallowed (this is *not* the
+// same as saying that a deletion actually occurred -- deleting a non-existent
+// property, or an inherited property, is allowed -- it's just pointless),
+// set *succeeded to true and return true.
+typedef bool
+(* JSDeletePropertyOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+                       bool *succeeded);
+
+// This function type is used for callbacks that enumerate the properties of
+// a JSObject.  The behavior depends on the value of enum_op:
+//
+//  JSENUMERATE_INIT
+//    A new, opaque iterator state should be allocated and stored in *statep.
+//    (You can use PRIVATE_TO_JSVAL() to tag the pointer to be stored).
+//
+//    The number of properties that will be enumerated should be returned as
+//    an integer jsval in *idp, if idp is non-null, and provided the number of
+//    enumerable properties is known.  If idp is non-null and the number of
+//    enumerable properties can't be computed in advance, *idp should be set
+//    to JSVAL_ZERO.
+//
+//  JSENUMERATE_INIT_ALL
+//    Used identically to JSENUMERATE_INIT, but exposes all properties of the
+//    object regardless of enumerability.
+//
+//  JSENUMERATE_NEXT
+//    A previously allocated opaque iterator state is passed in via statep.
+//    Return the next jsid in the iteration using *idp.  The opaque iterator
+//    state pointed at by statep is destroyed and *statep is set to JSVAL_NULL
+//    if there are no properties left to enumerate.
+//
+//  JSENUMERATE_DESTROY
+//    Destroy the opaque iterator state previously allocated in *statep by a
+//    call to this function when enum_op was JSENUMERATE_INIT or
+//    JSENUMERATE_INIT_ALL.
+//
+// The return value is used to indicate success, with a value of false
+// indicating failure.
+typedef bool
+(* JSNewEnumerateOp)(JSContext *cx, JS::Handle<JSObject*> obj, JSIterateOp enum_op,
+                     JS::MutableHandle<JS::Value> statep, JS::MutableHandle<jsid> idp);
+
+// The old-style JSClass.enumerate op should define all lazy properties not
+// yet reflected in obj.
+typedef bool
+(* JSEnumerateOp)(JSContext *cx, JS::Handle<JSObject*> obj);
+
+// Resolve a lazy property named by id in obj by defining it directly in obj.
+// Lazy properties are those reflected from some peer native property space
+// (e.g., the DOM attributes for a given node reflected as obj) on demand.
+//
+// JS looks for a property in an object, and if not found, tries to resolve
+// the given id.  If resolve succeeds, the engine looks again in case resolve
+// defined obj[id].  If no such property exists directly in obj, the process
+// is repeated with obj's prototype, etc.
+//
+// NB: JSNewResolveOp provides a cheaper way to resolve lazy properties.
+typedef bool
+(* JSResolveOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id);
+
+// Like JSResolveOp, but flags provide contextual information as follows:
+//
+//  JSRESOLVE_ASSIGNING   obj[id] is on the left-hand side of an assignment
+//
+// The *objp out parameter, on success, should be null to indicate that id
+// was not resolved; and non-null, referring to obj or one of its prototypes,
+// if id was resolved.  The hook may assume *objp is null on entry.
+//
+// This hook instead of JSResolveOp is called via the JSClass.resolve member
+// if JSCLASS_NEW_RESOLVE is set in JSClass.flags.
+typedef bool
+(* JSNewResolveOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id, unsigned flags,
+                   JS::MutableHandle<JSObject*> objp);
+
+// Convert obj to the given type, returning true with the resulting value in
+// *vp on success, and returning false on error or exception.
+typedef bool
+(* JSConvertOp)(JSContext *cx, JS::Handle<JSObject*> obj, JSType type,
+                JS::MutableHandle<JS::Value> vp);
+
+// Finalize obj, which the garbage collector has determined to be unreachable
+// from other live objects or from GC roots.  Obviously, finalizers must never
+// store a reference to obj.
+typedef void
+(* JSFinalizeOp)(JSFreeOp *fop, JSObject *obj);
+
+// Finalizes external strings created by JS_NewExternalString.
+struct JSStringFinalizer {
+    void (*finalize)(const JSStringFinalizer *fin, jschar *chars);
+};
+
+// JSClass.checkAccess type: check whether obj[id] may be accessed per mode,
+// returning false on error/exception, true on success with obj[id]'s last-got
+// value in *vp, and its attributes in *attrsp.  As for JSPropertyOp above, id
+// is either a string or an int jsval.
+typedef bool
+(* JSCheckAccessOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
+                    JSAccessMode mode, JS::MutableHandle<JS::Value> vp);
+
+// Check whether v is an instance of obj.  Return false on error or exception,
+// true on success with true in *bp if v is an instance of obj, false in
+// *bp otherwise.
+typedef bool
+(* JSHasInstanceOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::MutableHandle<JS::Value> vp,
+                    bool *bp);
+
+// Function type for trace operation of the class called to enumerate all
+// traceable things reachable from obj's private data structure. For each such
+// thing, a trace implementation must call one of the JS_Call*Tracer variants
+// on the thing.
+//
+// JSTraceOp implementation can assume that no other threads mutates object
+// state. It must not change state of the object or corresponding native
+// structures. The only exception for this rule is the case when the embedding
+// needs a tight integration with GC. In that case the embedding can check if
+// the traversal is a part of the marking phase through calling
+// JS_IsGCMarkingTracer and apply a special code like emptying caches or
+// marking its native structures.
+typedef void
+(* JSTraceOp)(JSTracer *trc, JSObject *obj);
+
+// Callback that JSTraceOp implementation can provide to return a string
+// describing the reference traced with JS_CallTracer.
+typedef void
+(* JSTraceNamePrinter)(JSTracer *trc, char *buf, size_t bufsize);
+
+// A generic type for functions mapping an object to another object, or null
+// if an error or exception was thrown on cx.
+typedef JSObject *
+(* JSObjectOp)(JSContext *cx, JS::Handle<JSObject*> obj);
+
+// Hook that creates an iterator object for a given object. Returns the
+// iterator object or null if an error or exception was thrown on cx.
+typedef JSObject *
+(* JSIteratorOp)(JSContext *cx, JS::HandleObject obj, bool keysonly);
+
+typedef JSObject *
+(* JSWeakmapKeyDelegateOp)(JSObject *obj);
+
 /* js::Class operation signatures. */
 
+namespace js {
+
 typedef bool
-(* LookupGenericOp)(JSContext *cx, HandleObject obj, HandleId id,
-                    MutableHandleObject objp, JS::MutableHandle<Shape*> propp);
+(* LookupGenericOp)(JSContext *cx, JS::HandleObject obj, JS::HandleId id,
+                    JS::MutableHandleObject objp, JS::MutableHandle<Shape*> propp);
 typedef bool
-(* LookupPropOp)(JSContext *cx, HandleObject obj, JS::Handle<PropertyName*> name,
-                 MutableHandleObject objp, JS::MutableHandle<Shape*> propp);
-typedef bool
-(* LookupElementOp)(JSContext *cx, HandleObject obj, uint32_t index,
-                    MutableHandleObject objp, JS::MutableHandle<Shape*> propp);
+(* LookupPropOp)(JSContext *cx, JS::HandleObject obj, JS::Handle<PropertyName*> name,
+                 JS::MutableHandleObject objp, JS::MutableHandle<Shape*> propp);
 typedef bool
-(* LookupSpecialOp)(JSContext *cx, HandleObject obj, HandleSpecialId sid,
-                    MutableHandleObject objp, JS::MutableHandle<Shape*> propp);
-typedef bool
-(* DefineGenericOp)(JSContext *cx, HandleObject obj, HandleId id, HandleValue value,
-                    JSPropertyOp getter, JSStrictPropertyOp setter, unsigned attrs);
+(* LookupElementOp)(JSContext *cx, JS::HandleObject obj, uint32_t index,
+                    JS::MutableHandleObject objp, JS::MutableHandle<Shape*> propp);
 typedef bool
-(* DefinePropOp)(JSContext *cx, HandleObject obj, JS::Handle<PropertyName*> name, HandleValue value,
-                 JSPropertyOp getter, JSStrictPropertyOp setter, unsigned attrs);
+(* LookupSpecialOp)(JSContext *cx, JS::HandleObject obj, HandleSpecialId sid,
+                    JS::MutableHandleObject objp, JS::MutableHandle<Shape*> propp);
 typedef bool
-(* DefineElementOp)(JSContext *cx, HandleObject obj, uint32_t index, HandleValue value,
-                    JSPropertyOp getter, JSStrictPropertyOp setter, unsigned attrs);
-typedef bool
-(* DefineSpecialOp)(JSContext *cx, HandleObject obj, HandleSpecialId sid, HandleValue value,
+(* DefineGenericOp)(JSContext *cx, JS::HandleObject obj, JS::HandleId id, JS::HandleValue value,
                     JSPropertyOp getter, JSStrictPropertyOp setter, unsigned attrs);
 typedef bool
-(* GenericIdOp)(JSContext *cx, HandleObject obj, HandleObject receiver, HandleId id, MutableHandleValue vp);
-typedef bool
-(* PropertyIdOp)(JSContext *cx, HandleObject obj, HandleObject receiver, JS::Handle<PropertyName*> name, MutableHandleValue vp);
+(* DefinePropOp)(JSContext *cx, JS::HandleObject obj, JS::Handle<PropertyName*> name,
+                 JS::HandleValue value, JSPropertyOp getter, JSStrictPropertyOp setter,
+                 unsigned attrs);
 typedef bool
-(* ElementIdOp)(JSContext *cx, HandleObject obj, HandleObject receiver, uint32_t index, MutableHandleValue vp);
+(* DefineElementOp)(JSContext *cx, JS::HandleObject obj, uint32_t index, JS::HandleValue value,
+                    JSPropertyOp getter, JSStrictPropertyOp setter, unsigned attrs);
 typedef bool
-(* ElementIfPresentOp)(JSContext *cx, HandleObject obj, HandleObject receiver, uint32_t index, MutableHandleValue vp, bool* present);
+(* DefineSpecialOp)(JSContext *cx, JS::HandleObject obj, HandleSpecialId sid,
+                    JS::HandleValue value, JSPropertyOp getter, JSStrictPropertyOp setter,
+                    unsigned attrs);
 typedef bool
-(* SpecialIdOp)(JSContext *cx, HandleObject obj, HandleObject receiver, HandleSpecialId sid, MutableHandleValue vp);
+(* GenericIdOp)(JSContext *cx, JS::HandleObject obj, JS::HandleObject receiver, JS::HandleId id,
+                JS::MutableHandleValue vp);
 typedef bool
-(* StrictGenericIdOp)(JSContext *cx, HandleObject obj, HandleId id, MutableHandleValue vp, bool strict);
+(* PropertyIdOp)(JSContext *cx, JS::HandleObject obj, JS::HandleObject receiver,
+                 JS::Handle<PropertyName*> name, JS::MutableHandleValue vp);
 typedef bool
-(* StrictPropertyIdOp)(JSContext *cx, HandleObject obj, JS::Handle<PropertyName*> name, MutableHandleValue vp, bool strict);
+(* ElementIdOp)(JSContext *cx, JS::HandleObject obj, JS::HandleObject receiver, uint32_t index,
+                JS::MutableHandleValue vp);
 typedef bool
-(* StrictElementIdOp)(JSContext *cx, HandleObject obj, uint32_t index, MutableHandleValue vp, bool strict);
+(* ElementIfPresentOp)(JSContext *cx, JS::HandleObject obj, JS::HandleObject receiver,
+                       uint32_t index, JS::MutableHandleValue vp, bool* present);
+typedef bool
+(* SpecialIdOp)(JSContext *cx, JS::HandleObject obj, JS::HandleObject receiver,
+                HandleSpecialId sid, JS::MutableHandleValue vp);
 typedef bool
-(* StrictSpecialIdOp)(JSContext *cx, HandleObject obj, HandleSpecialId sid, MutableHandleValue vp, bool strict);
+(* StrictGenericIdOp)(JSContext *cx, JS::HandleObject obj, JS::HandleId id,
+                      JS::MutableHandleValue vp, bool strict);
 typedef bool
-(* GenericAttributesOp)(JSContext *cx, HandleObject obj, HandleId id, unsigned *attrsp);
+(* StrictPropertyIdOp)(JSContext *cx, JS::HandleObject obj, JS::Handle<PropertyName*> name,
+                       JS::MutableHandleValue vp, bool strict);
 typedef bool
-(* PropertyAttributesOp)(JSContext *cx, HandleObject obj, JS::Handle<PropertyName*> name, unsigned *attrsp);
+(* StrictElementIdOp)(JSContext *cx, JS::HandleObject obj, uint32_t index,
+                      JS::MutableHandleValue vp, bool strict);
 typedef bool
-(* ElementAttributesOp)(JSContext *cx, HandleObject obj, uint32_t index, unsigned *attrsp);
+(* StrictSpecialIdOp)(JSContext *cx, JS::HandleObject obj, HandleSpecialId sid,
+                      JS::MutableHandleValue vp, bool strict);
+typedef bool
+(* GenericAttributesOp)(JSContext *cx, JS::HandleObject obj, JS::HandleId id, unsigned *attrsp);
 typedef bool
-(* SpecialAttributesOp)(JSContext *cx, HandleObject obj, HandleSpecialId sid, unsigned *attrsp);
+(* PropertyAttributesOp)(JSContext *cx, JS::HandleObject obj, JS::Handle<PropertyName*> name,
+                         unsigned *attrsp);
 typedef bool
-(* DeletePropertyOp)(JSContext *cx, HandleObject obj, JS::Handle<PropertyName*> name, bool *succeeded);
+(* ElementAttributesOp)(JSContext *cx, JS::HandleObject obj, uint32_t index, unsigned *attrsp);
+typedef bool
+(* SpecialAttributesOp)(JSContext *cx, JS::HandleObject obj, HandleSpecialId sid, unsigned *attrsp);
 typedef bool
-(* DeleteElementOp)(JSContext *cx, HandleObject obj, uint32_t index, bool *succeeded);
+(* DeletePropertyOp)(JSContext *cx, JS::HandleObject obj, JS::Handle<PropertyName*> name,
+                     bool *succeeded);
 typedef bool
-(* DeleteSpecialOp)(JSContext *cx, HandleObject obj, HandleSpecialId sid, bool *succeeded);
+(* DeleteElementOp)(JSContext *cx, JS::HandleObject obj, uint32_t index, bool *succeeded);
+typedef bool
+(* DeleteSpecialOp)(JSContext *cx, JS::HandleObject obj, HandleSpecialId sid, bool *succeeded);
 
 
 typedef JSObject *
-(* ObjectOp)(JSContext *cx, HandleObject obj);
+(* ObjectOp)(JSContext *cx, JS::HandleObject obj);
 typedef void
 (* FinalizeOp)(FreeOp *fop, JSObject *obj);
 
 #define JS_CLASS_MEMBERS                                                      \
     const char          *name;                                                \
     uint32_t            flags;                                                \
                                                                               \
     /* Mandatory function pointer members. */                                 \
@@ -292,16 +495,126 @@ struct ObjectOps
     ObjectOp            thisObject;
 };
 
 #define JS_NULL_OBJECT_OPS                                                    \
     {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,   \
      NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,        \
      NULL,NULL,NULL}
 
+} // namespace js
+
+// Classes, objects, and properties.
+
+typedef void (*JSClassInternal)();
+
+struct JSClass {
+    const char          *name;
+    uint32_t            flags;
+
+    // Mandatory function pointer members.
+    JSPropertyOp        addProperty;
+    JSDeletePropertyOp  delProperty;
+    JSPropertyOp        getProperty;
+    JSStrictPropertyOp  setProperty;
+    JSEnumerateOp       enumerate;
+    JSResolveOp         resolve;
+    JSConvertOp         convert;
+
+    // Optional members (may be null).
+    JSFinalizeOp        finalize;
+    JSCheckAccessOp     checkAccess;
+    JSNative            call;
+    JSHasInstanceOp     hasInstance;
+    JSNative            construct;
+    JSTraceOp           trace;
+
+    void                *reserved[40];
+};
+
+#define JSCLASS_HAS_PRIVATE             (1<<0)  // objects have private slot
+#define JSCLASS_NEW_ENUMERATE           (1<<1)  // has JSNewEnumerateOp hook
+#define JSCLASS_NEW_RESOLVE             (1<<2)  // has JSNewResolveOp hook
+#define JSCLASS_PRIVATE_IS_NSISUPPORTS  (1<<3)  // private is (nsISupports *)
+#define JSCLASS_IS_DOMJSCLASS           (1<<4)  // objects are DOM
+#define JSCLASS_IMPLEMENTS_BARRIERS     (1<<5)  // Correctly implements GC read
+                                                // and write barriers
+#define JSCLASS_EMULATES_UNDEFINED      (1<<6)  // objects of this class act
+                                                // like the value undefined,
+                                                // in some contexts
+#define JSCLASS_USERBIT1                (1<<7)  // Reserved for embeddings.
+
+// To reserve slots fetched and stored via JS_Get/SetReservedSlot, bitwise-or
+// JSCLASS_HAS_RESERVED_SLOTS(n) into the initializer for JSClass.flags, where
+// n is a constant in [1, 255].  Reserved slots are indexed from 0 to n-1.
+#define JSCLASS_RESERVED_SLOTS_SHIFT    8       // room for 8 flags below */
+#define JSCLASS_RESERVED_SLOTS_WIDTH    8       // and 16 above this field */
+#define JSCLASS_RESERVED_SLOTS_MASK     JS_BITMASK(JSCLASS_RESERVED_SLOTS_WIDTH)
+#define JSCLASS_HAS_RESERVED_SLOTS(n)   (((n) & JSCLASS_RESERVED_SLOTS_MASK)  \
+                                         << JSCLASS_RESERVED_SLOTS_SHIFT)
+#define JSCLASS_RESERVED_SLOTS(clasp)   (((clasp)->flags                      \
+                                          >> JSCLASS_RESERVED_SLOTS_SHIFT)    \
+                                         & JSCLASS_RESERVED_SLOTS_MASK)
+
+#define JSCLASS_HIGH_FLAGS_SHIFT        (JSCLASS_RESERVED_SLOTS_SHIFT +       \
+                                         JSCLASS_RESERVED_SLOTS_WIDTH)
+
+#define JSCLASS_IS_ANONYMOUS            (1<<(JSCLASS_HIGH_FLAGS_SHIFT+0))
+#define JSCLASS_IS_GLOBAL               (1<<(JSCLASS_HIGH_FLAGS_SHIFT+1))
+#define JSCLASS_INTERNAL_FLAG2          (1<<(JSCLASS_HIGH_FLAGS_SHIFT+2))
+#define JSCLASS_INTERNAL_FLAG3          (1<<(JSCLASS_HIGH_FLAGS_SHIFT+3))
+
+// Indicate whether the proto or ctor should be frozen.
+#define JSCLASS_FREEZE_PROTO            (1<<(JSCLASS_HIGH_FLAGS_SHIFT+4))
+#define JSCLASS_FREEZE_CTOR             (1<<(JSCLASS_HIGH_FLAGS_SHIFT+5))
+
+// Reserved for embeddings.
+#define JSCLASS_USERBIT2                (1<<(JSCLASS_HIGH_FLAGS_SHIFT+6))
+#define JSCLASS_USERBIT3                (1<<(JSCLASS_HIGH_FLAGS_SHIFT+7))
+
+#define JSCLASS_BACKGROUND_FINALIZE     (1<<(JSCLASS_HIGH_FLAGS_SHIFT+8))
+
+// Bits 26 through 31 are reserved for the CACHED_PROTO_KEY mechanism, see
+// below.
+
+// ECMA-262 requires that most constructors used internally create objects
+// with "the original Foo.prototype value" as their [[Prototype]] (__proto__)
+// member initial value.  The "original ... value" verbiage is there because
+// in ECMA-262, global properties naming class objects are read/write and
+// deleteable, for the most part.
+//
+// Implementing this efficiently requires that global objects have classes
+// with the following flags. Failure to use JSCLASS_GLOBAL_FLAGS was
+// prevously allowed, but is now an ES5 violation and thus unsupported.
+//
+#define JSCLASS_GLOBAL_SLOT_COUNT      (JSProto_LIMIT * 3 + 26)
+#define JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(n)                                    \
+    (JSCLASS_IS_GLOBAL | JSCLASS_HAS_RESERVED_SLOTS(JSCLASS_GLOBAL_SLOT_COUNT + (n)))
+#define JSCLASS_GLOBAL_FLAGS                                                  \
+    JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(0)
+#define JSCLASS_HAS_GLOBAL_FLAG_AND_SLOTS(clasp)                              \
+  (((clasp)->flags & JSCLASS_IS_GLOBAL)                                       \
+   && JSCLASS_RESERVED_SLOTS(clasp) >= JSCLASS_GLOBAL_SLOT_COUNT)
+
+// Fast access to the original value of each standard class's prototype.
+#define JSCLASS_CACHED_PROTO_SHIFT      (JSCLASS_HIGH_FLAGS_SHIFT + 10)
+#define JSCLASS_CACHED_PROTO_WIDTH      6
+#define JSCLASS_CACHED_PROTO_MASK       JS_BITMASK(JSCLASS_CACHED_PROTO_WIDTH)
+#define JSCLASS_HAS_CACHED_PROTO(key)   (uint32_t(key) << JSCLASS_CACHED_PROTO_SHIFT)
+#define JSCLASS_CACHED_PROTO_KEY(clasp) ((JSProtoKey)                         \
+                                         (((clasp)->flags                     \
+                                           >> JSCLASS_CACHED_PROTO_SHIFT)     \
+                                          & JSCLASS_CACHED_PROTO_MASK))
+
+// Initializer for unused members of statically initialized JSClass structs.
+#define JSCLASS_NO_INTERNAL_MEMBERS     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
+#define JSCLASS_NO_OPTIONAL_MEMBERS     0,0,0,0,0,JSCLASS_NO_INTERNAL_MEMBERS
+
+namespace js {
+
 struct Class
 {
     JS_CLASS_MEMBERS;
     ClassExtension      ext;
     ObjectOps           ops;
     uint8_t             pad[sizeof(JSClass) - sizeof(ClassSizeMeasurement) -
                             sizeof(ClassExtension) - sizeof(ObjectOps)];
 
@@ -381,28 +694,28 @@ enum ESClassValue {
  * so the caller must not assume anything about obj's representation (e.g., obj
  * may be a proxy).
  */
 inline bool
 ObjectClassIs(JSObject &obj, ESClassValue classValue, JSContext *cx);
 
 /* Just a helper that checks v.isObject before calling ObjectClassIs. */
 inline bool
-IsObjectWithClass(const Value &v, ESClassValue classValue, JSContext *cx);
+IsObjectWithClass(const JS::Value &v, ESClassValue classValue, JSContext *cx);
 
 inline bool
 IsPoisonedSpecialId(js::SpecialId iden)
 {
     if (iden.isObject())
-        return IsPoisonedPtr(iden.toObject());
+        return JS::IsPoisonedPtr(iden.toObject());
     return false;
 }
 
 template <> struct GCMethods<SpecialId>
 {
     static SpecialId initial() { return SpecialId(); }
     static ThingRootKind kind() { return THING_ROOT_ID; }
     static bool poisoned(SpecialId id) { return IsPoisonedSpecialId(id); }
 };
 
 }  /* namespace js */
 
-#endif  /* jsclass_h */
+#endif  /* js_Class_h */

--- a/js/src/jsapi-tests/testCustomIterator.cpp
+++ b/js/src/jsapi-tests/testCustomIterator.cpp
@@ -1,14 +1,13 @@
 /* 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/. */
 
-#include "jsclass.h"
-
+#include "js/Class.h"
 #include "jsapi-tests/tests.h"
 
 int count = 0;
 
 static bool
 IterNext(JSContext *cx, unsigned argc, jsval *vp)
 {
     if (count++ == 100)

--- a/js/src/jsapi-tests/testIntTypesABI.cpp
+++ b/js/src/jsapi-tests/testIntTypesABI.cpp
@@ -5,24 +5,24 @@
 /*
  * This test exercises the full, deliberately-exposed JSAPI interface to ensure
  * that no internal integer typedefs leak out.  Include every intentionally
  * public header file (and those headers included by them, for completeness),
  * even the ones tests.h itself included, to verify this.
  */
 
 #include "jsapi.h"
-#include "jsclass.h"
 #include "jscpucfg.h"
 #include "jspubtd.h"
 #include "jstypes.h"
 
 #include "js/Anchor.h"
 #include "js/CallArgs.h"
 #include "js/CharacterEncoding.h"
+#include "js/Class.h"
 #include "js/Date.h"
 #include "js/GCAPI.h"
 #include "js/HashTable.h"
 #include "js/HeapAPI.h"
 #include "js/MemoryMetrics.h"
 #include "js/PropertyKey.h"
 #include "js/Utility.h"
 #include "js/Value.h"

--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -17,16 +17,17 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 
 #include "jsalloc.h"
 #include "jspubtd.h"
 
 #include "js/CallArgs.h"
+#include "js/Class.h"
 #include "js/HashTable.h"
 #include "js/Id.h"
 #include "js/RootingAPI.h"
 #include "js/Utility.h"
 #include "js/Value.h"
 #include "js/Vector.h"
 
 /************************************************************************/
@@ -744,234 +745,34 @@ CallNonGenericMethod(JSContext *cx, IsAc
 
     return detail::CallMethodIfWrapped(cx, Test, Impl, args);
 }
 
 }  /* namespace JS */
 
 /************************************************************************/
 
-/* JSClass operation signatures. */
-
-/*
- * Add or get a property named by id in obj.  Note the jsid id type -- id may
- * be a string (Unicode property identifier) or an int (element index).  The
- * *vp out parameter, on success, is the new property value after the action.
- */
-typedef bool
-(* JSPropertyOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
-                 JS::MutableHandle<JS::Value> vp);
-
-/*
- * Set a property named by id in obj, treating the assignment as strict
- * mode code if strict is true. Note the jsid id type -- id may be a string
- * (Unicode property identifier) or an int (element index). The *vp out
- * parameter, on success, is the new property value after the
- * set.
- */
-typedef bool
-(* JSStrictPropertyOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
-                       bool strict, JS::MutableHandle<JS::Value> vp);
-
-/*
- * Delete a property named by id in obj.
- *
- * If an error occurred, return false as per normal JSAPI error practice.
- *
- * If no error occurred, but the deletion attempt wasn't allowed (perhaps
- * because the property was non-configurable), set *succeeded to false and
- * return true.  This will cause |delete obj[id]| to evaluate to false in
- * non-strict mode code, and to throw a TypeError in strict mode code.
- *
- * If no error occurred and the deletion wasn't disallowed (this is *not* the
- * same as saying that a deletion actually occurred -- deleting a non-existent
- * property, or an inherited property, is allowed -- it's just pointless),
- * set *succeeded to true and return true.
- */
-typedef bool
-(* JSDeletePropertyOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
-                       bool *succeeded);
-
-/*
- * This function type is used for callbacks that enumerate the properties of
- * a JSObject.  The behavior depends on the value of enum_op:
- *
- *  JSENUMERATE_INIT
- *    A new, opaque iterator state should be allocated and stored in *statep.
- *    (You can use PRIVATE_TO_JSVAL() to tag the pointer to be stored).
- *
- *    The number of properties that will be enumerated should be returned as
- *    an integer jsval in *idp, if idp is non-null, and provided the number of
- *    enumerable properties is known.  If idp is non-null and the number of
- *    enumerable properties can't be computed in advance, *idp should be set
- *    to JSVAL_ZERO.
- *
- *  JSENUMERATE_INIT_ALL
- *    Used identically to JSENUMERATE_INIT, but exposes all properties of the
- *    object regardless of enumerability.
- *
- *  JSENUMERATE_NEXT
- *    A previously allocated opaque iterator state is passed in via statep.
- *    Return the next jsid in the iteration using *idp.  The opaque iterator
- *    state pointed at by statep is destroyed and *statep is set to JSVAL_NULL
- *    if there are no properties left to enumerate.
- *
- *  JSENUMERATE_DESTROY
- *    Destroy the opaque iterator state previously allocated in *statep by a
- *    call to this function when enum_op was JSENUMERATE_INIT or
- *    JSENUMERATE_INIT_ALL.
- *
- * The return value is used to indicate success, with a value of false
- * indicating failure.
- */
-typedef bool
-(* JSNewEnumerateOp)(JSContext *cx, JS::Handle<JSObject*> obj, JSIterateOp enum_op,
-                     JS::MutableHandle<JS::Value> statep, JS::MutableHandle<jsid> idp);
-
-/*
- * The old-style JSClass.enumerate op should define all lazy properties not
- * yet reflected in obj.
- */
-typedef bool
-(* JSEnumerateOp)(JSContext *cx, JS::Handle<JSObject*> obj);
-
-/*
- * Resolve a lazy property named by id in obj by defining it directly in obj.
- * Lazy properties are those reflected from some peer native property space
- * (e.g., the DOM attributes for a given node reflected as obj) on demand.
- *
- * JS looks for a property in an object, and if not found, tries to resolve
- * the given id.  If resolve succeeds, the engine looks again in case resolve
- * defined obj[id].  If no such property exists directly in obj, the process
- * is repeated with obj's prototype, etc.
- *
- * NB: JSNewResolveOp provides a cheaper way to resolve lazy properties.
- */
-typedef bool
-(* JSResolveOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id);
-
-/*
- * Like JSResolveOp, but flags provide contextual information as follows:
- *
- *  JSRESOLVE_ASSIGNING   obj[id] is on the left-hand side of an assignment
- *
- * The *objp out parameter, on success, should be null to indicate that id
- * was not resolved; and non-null, referring to obj or one of its prototypes,
- * if id was resolved.  The hook may assume *objp is null on entry.
- *
- * This hook instead of JSResolveOp is called via the JSClass.resolve member
- * if JSCLASS_NEW_RESOLVE is set in JSClass.flags.
- */
-typedef bool
-(* JSNewResolveOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id, unsigned flags,
-                   JS::MutableHandle<JSObject*> objp);
-
-/*
- * Convert obj to the given type, returning true with the resulting value in
- * *vp on success, and returning false on error or exception.
- */
-typedef bool
-(* JSConvertOp)(JSContext *cx, JS::Handle<JSObject*> obj, JSType type,
-                JS::MutableHandle<JS::Value> vp);
-
-typedef struct JSFreeOp JSFreeOp;
-
 struct JSFreeOp {
   private:
     JSRuntime   *runtime_;
 
   protected:
     JSFreeOp(JSRuntime *rt)
       : runtime_(rt) { }
 
   public:
     JSRuntime *runtime() const {
         return runtime_;
     }
 };
 
-/*
- * Finalize obj, which the garbage collector has determined to be unreachable
- * from other live objects or from GC roots.  Obviously, finalizers must never
- * store a reference to obj.
- */
-typedef void
-(* JSFinalizeOp)(JSFreeOp *fop, JSObject *obj);
-
-/*
- * Finalizes external strings created by JS_NewExternalString.
- */
-typedef struct JSStringFinalizer JSStringFinalizer;
-
-struct JSStringFinalizer {
-    void (*finalize)(const JSStringFinalizer *fin, jschar *chars);
-};
-
-/*
- * JSClass.checkAccess type: check whether obj[id] may be accessed per mode,
- * returning false on error/exception, true on success with obj[id]'s last-got
- * value in *vp, and its attributes in *attrsp.  As for JSPropertyOp above, id
- * is either a string or an int jsval.
- */
-typedef bool
-(* JSCheckAccessOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::Handle<jsid> id,
-                    JSAccessMode mode, JS::MutableHandle<JS::Value> vp);
-
-/*
- * Check whether v is an instance of obj.  Return false on error or exception,
- * true on success with true in *bp if v is an instance of obj, false in
- * *bp otherwise.
- */
-typedef bool
-(* JSHasInstanceOp)(JSContext *cx, JS::Handle<JSObject*> obj, JS::MutableHandle<JS::Value> vp,
-                    bool *bp);
-
-/*
- * Function type for trace operation of the class called to enumerate all
- * traceable things reachable from obj's private data structure. For each such
- * thing, a trace implementation must call one of the JS_Call*Tracer variants
- * on the thing.
- *
- * JSTraceOp implementation can assume that no other threads mutates object
- * state. It must not change state of the object or corresponding native
- * structures. The only exception for this rule is the case when the embedding
- * needs a tight integration with GC. In that case the embedding can check if
- * the traversal is a part of the marking phase through calling
- * JS_IsGCMarkingTracer and apply a special code like emptying caches or
- * marking its native structures.
- */
-typedef void
-(* JSTraceOp)(JSTracer *trc, JSObject *obj);
-
-/*
- * Callback that JSTraceOp implementation can provide to return a string
- * describing the reference traced with JS_CallTracer.
- */
-typedef void
-(* JSTraceNamePrinter)(JSTracer *trc, char *buf, size_t bufsize);
-
-/*
- * A generic type for functions mapping an object to another object, or null
- * if an error or exception was thrown on cx.
- */
-typedef JSObject *
-(* JSObjectOp)(JSContext *cx, JS::Handle<JSObject*> obj);
-
-/*
- * Hook that creates an iterator object for a given object. Returns the
- * iterator object or null if an error or exception was thrown on cx.
- */
-typedef JSObject *
-(* JSIteratorOp)(JSContext *cx, JS::HandleObject obj, bool keysonly);
-
-typedef JSObject *
-(* JSWeakmapKeyDelegateOp)(JSObject *obj);
-
 /* Callbacks and their arguments. */
 
+/************************************************************************/
+
 typedef enum JSContextOp {
     JSCONTEXT_NEW,
     JSCONTEXT_DESTROY
 } JSContextOp;
 
 /*
  * The possible values for contextOp when the runtime calls the callback are:
  *   JSCONTEXT_NEW      JS_NewContext successfully created a new JSContext
@@ -2668,131 +2469,16 @@ JS_GetExternalStringFinalizer(JSString *
  * Set the size of the native stack that should not be exceed. To disable
  * stack size checking pass 0.
  */
 extern JS_PUBLIC_API(void)
 JS_SetNativeStackQuota(JSRuntime *cx, size_t stackSize);
 
 /************************************************************************/
 
-/*
- * Classes, objects, and properties.
- */
-typedef void (*JSClassInternal)();
-
-struct JSClass {
-    const char          *name;
-    uint32_t            flags;
-
-    /* Mandatory function pointer members. */
-    JSPropertyOp        addProperty;
-    JSDeletePropertyOp  delProperty;
-    JSPropertyOp        getProperty;
-    JSStrictPropertyOp  setProperty;
-    JSEnumerateOp       enumerate;
-    JSResolveOp         resolve;
-    JSConvertOp         convert;
-
-    /* Optional members (may be null). */
-    JSFinalizeOp        finalize;
-    JSCheckAccessOp     checkAccess;
-    JSNative            call;
-    JSHasInstanceOp     hasInstance;
-    JSNative            construct;
-    JSTraceOp           trace;
-
-    void                *reserved[40];
-};
-
-#define JSCLASS_HAS_PRIVATE             (1<<0)  /* objects have private slot */
-#define JSCLASS_NEW_ENUMERATE           (1<<1)  /* has JSNewEnumerateOp hook */
-#define JSCLASS_NEW_RESOLVE             (1<<2)  /* has JSNewResolveOp hook */
-#define JSCLASS_PRIVATE_IS_NSISUPPORTS  (1<<3)  /* private is (nsISupports *) */
-#define JSCLASS_IS_DOMJSCLASS           (1<<4)  /* objects are DOM */
-#define JSCLASS_IMPLEMENTS_BARRIERS     (1<<5)  /* Correctly implements GC read
-                                                   and write barriers */
-#define JSCLASS_EMULATES_UNDEFINED      (1<<6)  /* objects of this class act
-                                                   like the value undefined,
-                                                   in some contexts */
-#define JSCLASS_USERBIT1                (1<<7)  /* Reserved for embeddings. */
-
-/*
- * To reserve slots fetched and stored via JS_Get/SetReservedSlot, bitwise-or
- * JSCLASS_HAS_RESERVED_SLOTS(n) into the initializer for JSClass.flags, where
- * n is a constant in [1, 255].  Reserved slots are indexed from 0 to n-1.
- */
-#define JSCLASS_RESERVED_SLOTS_SHIFT    8       /* room for 8 flags below */
-#define JSCLASS_RESERVED_SLOTS_WIDTH    8       /* and 16 above this field */
-#define JSCLASS_RESERVED_SLOTS_MASK     JS_BITMASK(JSCLASS_RESERVED_SLOTS_WIDTH)
-#define JSCLASS_HAS_RESERVED_SLOTS(n)   (((n) & JSCLASS_RESERVED_SLOTS_MASK)  \
-                                         << JSCLASS_RESERVED_SLOTS_SHIFT)
-#define JSCLASS_RESERVED_SLOTS(clasp)   (((clasp)->flags                      \
-                                          >> JSCLASS_RESERVED_SLOTS_SHIFT)    \
-                                         & JSCLASS_RESERVED_SLOTS_MASK)
-
-#define JSCLASS_HIGH_FLAGS_SHIFT        (JSCLASS_RESERVED_SLOTS_SHIFT +       \
-                                         JSCLASS_RESERVED_SLOTS_WIDTH)
-
-#define JSCLASS_IS_ANONYMOUS            (1<<(JSCLASS_HIGH_FLAGS_SHIFT+0))
-#define JSCLASS_IS_GLOBAL               (1<<(JSCLASS_HIGH_FLAGS_SHIFT+1))
-#define JSCLASS_INTERNAL_FLAG2          (1<<(JSCLASS_HIGH_FLAGS_SHIFT+2))
-#define JSCLASS_INTERNAL_FLAG3          (1<<(JSCLASS_HIGH_FLAGS_SHIFT+3))
-
-/* Indicate whether the proto or ctor should be frozen. */
-#define JSCLASS_FREEZE_PROTO            (1<<(JSCLASS_HIGH_FLAGS_SHIFT+4))
-#define JSCLASS_FREEZE_CTOR             (1<<(JSCLASS_HIGH_FLAGS_SHIFT+5))
-
-/* Reserved for embeddings. */
-#define JSCLASS_USERBIT2                (1<<(JSCLASS_HIGH_FLAGS_SHIFT+6))
-#define JSCLASS_USERBIT3                (1<<(JSCLASS_HIGH_FLAGS_SHIFT+7))
-
-#define JSCLASS_BACKGROUND_FINALIZE     (1<<(JSCLASS_HIGH_FLAGS_SHIFT+8))
-
-/*
- * Bits 26 through 31 are reserved for the CACHED_PROTO_KEY mechanism, see
- * below.
- */
-
-/* Global flags. */
-#define JSGLOBAL_FLAGS_CLEARED          0x1
-
-/*
- * ECMA-262 requires that most constructors used internally create objects
- * with "the original Foo.prototype value" as their [[Prototype]] (__proto__)
- * member initial value.  The "original ... value" verbiage is there because
- * in ECMA-262, global properties naming class objects are read/write and
- * deleteable, for the most part.
- *
- * Implementing this efficiently requires that global objects have classes
- * with the following flags. Failure to use JSCLASS_GLOBAL_FLAGS was
- * prevously allowed, but is now an ES5 violation and thus unsupported.
- */
-#define JSCLASS_GLOBAL_SLOT_COUNT      (JSProto_LIMIT * 3 + 26)
-#define JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(n)                                    \
-    (JSCLASS_IS_GLOBAL | JSCLASS_HAS_RESERVED_SLOTS(JSCLASS_GLOBAL_SLOT_COUNT + (n)))
-#define JSCLASS_GLOBAL_FLAGS                                                  \
-    JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(0)
-#define JSCLASS_HAS_GLOBAL_FLAG_AND_SLOTS(clasp)                              \
-  (((clasp)->flags & JSCLASS_IS_GLOBAL)                                       \
-   && JSCLASS_RESERVED_SLOTS(clasp) >= JSCLASS_GLOBAL_SLOT_COUNT)
-
-/* Fast access to the original value of each standard class's prototype. */
-#define JSCLASS_CACHED_PROTO_SHIFT      (JSCLASS_HIGH_FLAGS_SHIFT + 10)
-#define JSCLASS_CACHED_PROTO_WIDTH      6
-#define JSCLASS_CACHED_PROTO_MASK       JS_BITMASK(JSCLASS_CACHED_PROTO_WIDTH)
-#define JSCLASS_HAS_CACHED_PROTO(key)   (uint32_t(key) << JSCLASS_CACHED_PROTO_SHIFT)
-#define JSCLASS_CACHED_PROTO_KEY(clasp) ((JSProtoKey)                         \
-                                         (((clasp)->flags                     \
-                                           >> JSCLASS_CACHED_PROTO_SHIFT)     \
-                                          & JSCLASS_CACHED_PROTO_MASK))
-
-/* Initializer for unused members of statically initialized JSClass structs. */
-#define JSCLASS_NO_INTERNAL_MEMBERS     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
-#define JSCLASS_NO_OPTIONAL_MEMBERS     0,0,0,0,0,JSCLASS_NO_INTERNAL_MEMBERS
-
 extern JS_PUBLIC_API(int)
 JS_IdArrayLength(JSContext *cx, JSIdArray *ida);
 
 extern JS_PUBLIC_API(jsid)
 JS_IdArrayGet(JSContext *cx, JSIdArray *ida, int index);
 
 extern JS_PUBLIC_API(void)
 JS_DestroyIdArray(JSContext *cx, JSIdArray *ida);

--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -6,18 +6,18 @@
 
 #ifndef jsfriendapi_h
 #define jsfriendapi_h
 
 #ifdef JS_HAS_CTYPES
 #include "mozilla/MemoryReporting.h"
 #endif
 
+#include "jsapi.h"
 #include "jsbytecode.h"
-#include "jsclass.h"
 #include "jspubtd.h"
 
 #include "js/CallArgs.h"
 
 /*
  * This macro checks if the stack pointer has exceeded a given limit. If
  * |tolerance| is non-zero, it returns true only if the stack pointer has
  * exceeded the limit by more than |tolerance| bytes.

--- a/js/src/jsproxy.h
+++ b/js/src/jsproxy.h
@@ -144,17 +144,17 @@ class JS_FRIEND_API(BaseProxyHandler)
     virtual JSString *fun_toString(JSContext *cx, HandleObject proxy, unsigned indent);
     virtual bool regexp_toShared(JSContext *cx, HandleObject proxy, RegExpGuard *g);
     virtual bool defaultValue(JSContext *cx, HandleObject obj, JSType hint, MutableHandleValue vp);
     virtual void finalize(JSFreeOp *fop, JSObject *proxy);
     virtual bool getElementIfPresent(JSContext *cx, HandleObject obj, HandleObject receiver,
                                      uint32_t index, MutableHandleValue vp, bool *present);
     virtual bool getPrototypeOf(JSContext *cx, HandleObject proxy, MutableHandleObject protop);
 
-    /* See comment for weakmapKeyDelegateOp in jsclass.h. */
+    /* See comment for weakmapKeyDelegateOp in js/Class.h. */
     virtual JSObject *weakmapKeyDelegate(JSObject *proxy);
 };
 
 /*
  * DirectProxyHandler includes a notion of a target object. All traps are
  * reimplemented such that they forward their behavior to the target. This
  * allows consumers of this class to forward to another object as transparently
  * and efficiently as possible.

--- a/js/src/moz.build
+++ b/js/src/moz.build
@@ -30,17 +30,16 @@ CONFIGURE_SUBST_FILES += ['devtools/root
 # browser builds.  Don't add new files here unless you know what you're
 # doing!
 EXPORTS += [
     'js-config.h',
     'js.msg',
     'jsalloc.h',
     'jsapi.h',
     'jsbytecode.h',
-    'jsclass.h',
     'jsclist.h',
     'jscpucfg.h',
     'jsdbgapi.h',
     'jsfriendapi.h',
     'jsprf.h',
     'jsprototypes.h',
     'jsproxy.h',
     'jspubtd.h',
@@ -57,16 +56,17 @@ if CONFIG['HAVE_DTRACE']:
 
 # If you add a header here, add it to js/src/jsapi-tests/testIntTypesABI.cpp so
 # that we ensure we don't over-expose our internal integer typedefs.  Note that
 # LegacyIntTypes.h below is deliberately exempted from this requirement.
 EXPORTS.js += [
     '../public/Anchor.h',
     '../public/CallArgs.h',
     '../public/CharacterEncoding.h',
+    '../public/Class.h',
     '../public/Date.h',
     '../public/GCAPI.h',
     '../public/HashTable.h',
     '../public/HeapAPI.h',
     '../public/Id.h',
     '../public/IdForward.h',
     '../public/LegacyIntTypes.h',
     '../public/MemoryMetrics.h',

--- a/js/src/vm/TypedArrayObject.h
+++ b/js/src/vm/TypedArrayObject.h
@@ -3,19 +3,20 @@
  * 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_TypedArrayObject_h
 #define vm_TypedArrayObject_h
 
 #include "jsapi.h"
-#include "jsclass.h"
 #include "jsobj.h"
 
+#include "js/Class.h"
+
 typedef struct JSProperty JSProperty;
 
 namespace js {
 
 typedef Vector<ArrayBufferObject *, 0, SystemAllocPolicy> ArrayBufferVector;
 
 // The inheritance hierarchy for the various classes relating to typed arrays
 // is as follows.

--- a/xpcom/base/CycleCollectedJSRuntime.h
+++ b/xpcom/base/CycleCollectedJSRuntime.h
@@ -4,17 +4,17 @@
  * 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 "jsapi.h"
-#include "jsclass.h"
+#include "js/Class.h"
 
 #include "nsCycleCollector.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsDataHashtable.h"
 #include "nsHashKeys.h"
 #include "nsTArray.h"
 
 class nsCycleCollectionNoteRootCallback;