Upgrade SpiderMonkey

Makefile.in

@@ -137,6 +137,7 @@ endif
 # their name already, while others don't.
 DONE_$(1) = $$(B)src/$$(PATH_$(1))/lib*.dummy
 DEPS_SUBMODULES += $$(PATH_$(1))
+DEPS_SUBMODULES += $$(PATH_$(1))/dist/lib
 DEPS_SUBMODULES += $$(PATH_$(1))/.libs
 DEPS_SUBMODULES += $$(PATH_$(1))/src/.libs
 endef
@@ -156,7 +157,7 @@ include $(S)mk/sub.mk
 # Define how to compute approximate submodule dependencies.
 # TODO: this may be a bit brutish, but is there a better way?
 define DEF_SUBMODULE_DEPS
-ROUGH_DEPS_$(1)=$$(call rwildcard,$$(S)src/$$(PATH_$(1)),*h *c *cpp *rs *rc)
+ROUGH_DEPS_$(1)=$$(call rwildcard,$$(S)src/$$(PATH_$(1)),*.h *.c *.cpp *.rs *.rc)
 DONE_DEPS_$(1)=$$(foreach dep,$$(DEPS_$(1)),$$(DONE_$$(dep)))
 # the main target for a submodule
 endef
@@ -165,7 +166,7 @@ endef
 define DEF_SUBMODULE_RULES
 
 ENV_RLDFLAGS_$(1) = -L $$(CFG_BUILD_HOME)workspace/lib/$$(CFG_TARGET)
-ENV_RLDFLAGS_$(1) += $$(foreach dep,$$(DEPS_$(1)),-L $$(B)src/$$(PATH_$$(dep)) -L $$(B)src/$$(PATH_$$(dep))/.libs -L $$(B)src/$$(PATH_$$(dep))/src/.libs)
+ENV_RLDFLAGS_$(1) += $$(foreach dep,$$(DEPS_$(1)),-L $$(B)src/$$(PATH_$$(dep)) -L $$(B)src/$$(PATH_$$(dep))/.libs -L $$(B)src/$$(PATH_$$(dep))/src/.libs -L $$(B)src/$$(PATH_$$(dep))/dist/lib)
 
 # variables that depend on dependency definitions from sub.mk!
 ENV_CFLAGS_$(1) = CFLAGS="$$(CFLAGS_$(1))"
@@ -246,7 +247,7 @@ DONE_gfx = $(B)src/components/gfx/libgfx.dummy
 
 DEPS_gfx = $(CRATE_gfx) $(SRC_gfx) $(DONE_SUBMODULES) $(DONE_util) $(DONE_style) $(DONE_net) $(DONE_msg) $(DONE_macros)
 
-RFLAGS_script = $(strip $(CFG_RUSTC_FLAGS)) $(addprefix -L $(B)src/,$(DEPS_SUBMODULES)) -L $(B)src/components/util -L $(B)src/components/style -L $(B)src/components/net -L $(B)src/components/msg -L$(B)src/components/macros
+RFLAGS_script = $(strip $(CFG_RUSTC_FLAGS)) $(addprefix -L $(B)src/,$(DEPS_SUBMODULES)) -L $(B)src/supprt/spidermonkey/mozjs/dist/lib -L $(B)src/components/util -L $(B)src/components/style -L $(B)src/components/net -L $(B)src/components/msg -L$(B)src/components/macros
 
 BINDINGS_SRC = $(S)src/components/script/dom/bindings/codegen
 WEBIDLS_SRC = $(S)src/components/script/dom/webidls

configure

@@ -697,7 +697,7 @@ do
                 CONFIGURE_ARGS="${CONFIGURE_ARGS} --with-android-ndk=${CFG_ANDROID_NDK_PATH}"
                 CONFIGURE_ARGS="${CONFIGURE_ARGS} --with-android-toolchain=${CFG_ANDROID_CROSS_PATH}"
             fi
-            CONFIGURE_ARGS="${CONFIGURE_ARGS} --enable-gczeal"
+            CONFIGURE_ARGS="${CONFIGURE_ARGS} --enable-gczeal --without-intl-api --enable-debug --disable-optimize"
             ;;
         support/skia/skia)
             # Right now the skia configure script actually ignores --enable-debug and the

src/components/gfx/render_task.rs

@@ -176,7 +176,7 @@ impl<C: RenderListener + Send> RenderTask<C> {
                   shutdown_chan: Sender<()>) {
         let mut builder = task::task().named("RenderTask");
         let ConstellationChan(c) = constellation_chan.clone();
-        send_on_failure(&mut builder, FailureMsg(failure_msg), c);
+        send_on_failure(&mut builder.opts, FailureMsg(failure_msg), c);
         builder.spawn(proc() {
 
             { // Ensures RenderTask and graphics context are destroyed before shutdown msg

src/components/main/layout/layout_task.rs

@@ -289,7 +289,7 @@ impl LayoutTask {
                   shutdown_chan: Sender<()>) {
         let mut builder = task::task().named("LayoutTask");
         let ConstellationChan(con_chan) = constellation_chan.clone();
-        send_on_failure(&mut builder, FailureMsg(failure_msg), con_chan);
+        send_on_failure(&mut builder.opts, FailureMsg(failure_msg), con_chan);
         builder.spawn(proc() {
             { // Ensures layout task is destroyed before we send shutdown message
                 let mut layout = LayoutTask::new(id,

src/components/main/servo.rs

@@ -25,6 +25,7 @@ extern crate layers;
 extern crate opengles;
 extern crate png;
 extern crate rustuv;
+#[link_args = "-ljs_static"]
 extern crate script;
 #[phase(syntax)]
 extern crate servo_macros = "macros";
@@ -164,6 +165,10 @@ fn run(opts: opts::Opts) {
     pool_config.event_loop_factory = rustuv::event_loop;
     let mut pool = green::SchedPool::new(pool_config);
 
+    unsafe {
+        js::jsapi::JS_Init();
+    }
+
     let (compositor_port, compositor_chan) = CompositorChan::new();
     let profiler_chan = Profiler::create(opts.profiler_period);
 
@@ -217,5 +222,10 @@ fn run(opts: opts::Opts) {
                            profiler_chan);
 
     pool.shutdown();
+
+    // Not strictly necessary, and hard to synchronize with native script tasks
+    /*unsafe {
+        js::jsapi::JS_ShutDown();
+    }*/
 }
 

src/components/script/dom/bindings/callback.rs

@@ -3,12 +3,11 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::utils::Reflectable;
-use js::jsapi::{JSContext, JSObject, JS_WrapObject, JS_ObjectIsCallable};
-use js::jsapi::{JS_GetProperty, JSTracer, JS_CallTracer};
+use js::jsapi::{JSContext, JSObject, JS_WrapObject, JS_ObjectIsCallable, JSHandleObject};
+use js::jsapi::{JS_GetProperty, JSTracer, JS_CallObjectTracer, JSMutableHandleObject};
+use js::jsapi::JSMutableHandleValue;
 use js::jsval::{JSVal, UndefinedValue};
-use js::JSTRACE_OBJECT;
 
-use libc;
 use std::cast;
 use std::ptr;
 
@@ -27,45 +26,56 @@ pub enum ExceptionHandling {
 
 #[deriving(Clone,Eq)]
 pub struct CallbackInterface {
-    pub callback: *JSObject
+    pub callback: *mut JSObject
 }
 
 impl<S: Encoder<E>, E> Encodable<S, E> for CallbackInterface {
     fn encode(&self, s: &mut S) -> Result<(), E> {
         unsafe {
             let tracer: *mut JSTracer = cast::transmute(s);
             "callback".to_c_str().with_ref(|name| {
-                (*tracer).debugPrinter = ptr::null();
-                (*tracer).debugPrintIndex = -1;
-                (*tracer).debugPrintArg = name as *libc::c_void;
-                JS_CallTracer(tracer as *JSTracer, self.callback, JSTRACE_OBJECT as u32);
+                // FIXME: JS_CallObjectTracer could theoretically do something that can
+                //        cause pointers to shuffle around. We need to pass a *mut *mut JSObject
+                //        to JS_CallObjectTracer, but the Encodable trait doesn't allow us
+                //        to obtain a mutable reference to self (and thereby self.cb);
+                //        All we can do right now is scream loudly if this actually causes
+                //        a problem in practice.
+                let mut cb = self.callback;
+                JS_CallObjectTracer(tracer, &mut cb, name);
+                assert!(cb == self.callback);
             });
         };
         Ok(())
     }
 }
 
 pub trait CallbackContainer {
-    fn callback(&self) -> *JSObject;
+    fn callback(&self) -> *mut JSObject;
 }
 
 impl CallbackContainer for CallbackInterface {
-    fn callback(&self) -> *JSObject {
+    fn callback(&self) -> *mut JSObject {
         self.callback
     }
 }
 
 impl CallbackInterface {
-    pub fn new(callback: *JSObject) -> CallbackInterface {
+    pub fn new(callback: *mut JSObject) -> CallbackInterface {
         CallbackInterface {
             callback: callback
         }
     }
 
-    pub fn GetCallableProperty(&self, cx: *JSContext, name: &str) -> Result<JSVal, ()> {
+    pub fn GetCallableProperty(&self, cx: *mut JSContext, name: &str) -> Result<JSVal, ()> {
         let mut callable = UndefinedValue();
         unsafe {
-            if name.to_c_str().with_ref(|name| JS_GetProperty(cx, self.callback, name, &mut callable as *mut JSVal as *JSVal)) == 0 {
+            let callback = JSHandleObject {
+                unnamed_field1: &self.callback,
+            };
+            let callablehandle = JSMutableHandleValue {
+                unnamed_field1: &mut callable,
+            };
+            if name.to_c_str().with_ref(|name| JS_GetProperty(cx, callback, name, callablehandle)) == 0 {
                 return Err(());
             }
 
@@ -79,39 +89,41 @@ impl CallbackInterface {
     }
 }
 
-pub fn GetJSObjectFromCallback<T: CallbackContainer>(callback: &T) -> *JSObject {
+pub fn GetJSObjectFromCallback<T: CallbackContainer>(callback: &T) -> *mut JSObject {
     callback.callback()
 }
 
-pub fn WrapCallThisObject<T: 'static + CallbackContainer + Reflectable>(cx: *JSContext,
-                                                                        _scope: *JSObject,
-                                                                        p: ~T) -> *JSObject {
-    let obj = GetJSObjectFromCallback(p);
+pub fn WrapCallThisObject<T: 'static + CallbackContainer + Reflectable>(cx: *mut JSContext,
+                                                                        _scope: *mut JSObject,
+                                                                        p: ~T) -> *mut JSObject {
+    let mut obj = GetJSObjectFromCallback(p);
     assert!(obj.is_not_null());
 
+    let obj = JSMutableHandleObject {
+        unnamed_field1: &mut obj,
+    };
     unsafe {
-        if JS_WrapObject(cx, &obj) == 0 {
-            return ptr::null();
+        if JS_WrapObject(cx, obj) == 0 {
+            return ptr::mut_null();
         }
+        return *obj.unnamed_field1;
     }
-
-    return obj;
 }
 
 pub struct CallSetup {
-    pub cx: *JSContext,
+    pub cx: *mut JSContext,
     pub handling: ExceptionHandling
 }
 
 impl CallSetup {
-    pub fn new(cx: *JSContext, handling: ExceptionHandling) -> CallSetup {
+    pub fn new(cx: *mut JSContext, handling: ExceptionHandling) -> CallSetup {
         CallSetup {
             cx: cx,
             handling: handling
         }
     }
 
-    pub fn GetContext(&self) -> *JSContext {
+    pub fn GetContext(&self) -> *mut JSContext {
         self.cx
     }
 }