Auto merge of #381 - Mrowqa:capturing-js-stacks, r=jdm

Safe, straightforward API for capturing JS stacks

PR for servo/servo#14987

Can someone take a look if it goes in the right direction and also look through my comments? Maybe, I have left some "stupid questions", but I wanted to post my changes and get feedback before weekend - I work from Europe, so here is middle of the night.

CC: @jdm

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/rust-mozjs/381)
<!-- Reviewable:end -->

Author: bors-servo

Cargo.toml

@@ -13,6 +13,8 @@ cmake = "0.1"
 [[test]]
 name = "callback"
 [[test]]
+name = "capture_stack"
+[[test]]
 name = "custom_auto_rooter"
 [[test]]
 name = "custom_auto_rooter_macro"

src/conversions.rs

@@ -475,6 +475,19 @@ pub unsafe fn latin1_to_string(cx: *mut JSContext, s: *mut JSString) -> String {
     s
 }
 
+/// Converts a `JSString` into a `String`, regardless of used encoding.
+pub unsafe fn jsstr_to_string(cx: *mut JSContext, jsstr: *mut JSString) -> String {
+    if JS_StringHasLatin1Chars(jsstr) {
+        return latin1_to_string(cx, jsstr);
+    }
+
+    let mut length = 0;
+    let chars = JS_GetTwoByteStringCharsAndLength(cx, ptr::null(), jsstr, &mut length);
+    assert!(!chars.is_null());
+    let char_vec = slice::from_raw_parts(chars, length as usize);
+    String::from_utf16_lossy(char_vec)
+}
+
 // https://heycam.github.io/webidl/#es-USVString
 impl ToJSValConvertible for str {
     #[inline]
@@ -508,15 +521,7 @@ impl FromJSValConvertible for String {
             debug!("ToString failed");
             return Err(());
         }
-        if JS_StringHasLatin1Chars(jsstr) {
-            return Ok(latin1_to_string(cx, jsstr)).map(ConversionResult::Success);
-        }
-
-        let mut length = 0;
-        let chars = JS_GetTwoByteStringCharsAndLength(cx, ptr::null(), jsstr, &mut length);
-        assert!(!chars.is_null());
-        let char_vec = slice::from_raw_parts(chars, length as usize);
-        Ok(String::from_utf16_lossy(char_vec)).map(ConversionResult::Success)
+        Ok(jsstr_to_string(cx, jsstr)).map(ConversionResult::Success)
     }
 }
 

src/rust.rs

@@ -18,6 +18,7 @@ use std::marker::PhantomData;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use consts::{JSCLASS_RESERVED_SLOTS_MASK, JSCLASS_GLOBAL_SLOT_COUNT};
 use consts::{JSCLASS_IS_DOMJSCLASS, JSCLASS_IS_GLOBAL};
+use conversions::jsstr_to_string;
 use jsapi;
 use jsapi::{AutoGCRooter, AutoIdVector, AutoObjectVector, CallArgs, CompartmentOptions, ContextFriendFields};
 use jsapi::{Evaluate2, Handle, HandleBase, HandleObject, HandleValue, HandleValueArray, Heap};
@@ -36,6 +37,7 @@ use jsapi::{RootedBase, RuntimeOptionsRef, SetWarningReporter, Symbol, ToBoolean
 use jsapi::{ToInt32Slow, ToInt64Slow, ToNumberSlow, ToStringSlow, ToUint16Slow};
 use jsapi::{ToUint32Slow, ToUint64Slow, ToWindowProxyIfWindow, UndefinedHandleValue};
 use jsapi::{Value, jsid, PerThreadDataFriendFields, PerThreadDataFriendFields_RuntimeDummy};
+use jsapi::{CaptureCurrentStack, BuildStackString, IsSavedFrame};
 use jsapi::{AutoGCRooter_jspubtd_h_unnamed_1 as AutoGCRooterTag, _vftable_CustomAutoRooter as CustomAutoRooterVFTable};
 use jsval::{ObjectValue, UndefinedValue};
 use glue::{AppendToAutoObjectVector, CallFunctionTracer, CallIdTracer, CallObjectTracer};
@@ -1449,3 +1451,56 @@ macro_rules! new_jsjitinfo_bitfield_1 {
             (($slotIndex as u32) << 22u32)
     }
 }
+
+pub struct CapturedJSStack<'a> {
+    cx: *mut JSContext,
+    stack: RootedGuard<'a, *mut JSObject>,
+}
+
+impl<'a> CapturedJSStack<'a> {
+    pub unsafe fn new(cx: *mut JSContext,
+                      mut guard: RootedGuard<'a, *mut JSObject>,
+                      max_frame_count: Option<u32>) -> Option<Self> {
+        let obj_handle = guard.handle_mut();
+
+        if !CaptureCurrentStack(cx, obj_handle, max_frame_count.unwrap_or(0)) {
+            None
+        }
+        else {
+            Some(CapturedJSStack {
+                cx: cx,
+                stack: guard,
+            })
+        }
+    }
+
+    pub fn as_string(&self, indent: Option<usize>) -> Option<String> {
+        unsafe {
+            let stack_handle = self.stack.handle();
+            rooted!(in(self.cx) let mut js_string = ptr::null_mut());
+            let string_handle = js_string.handle_mut();
+
+            if !IsSavedFrame(stack_handle.get()) {
+                return None;
+            }
+
+            if !BuildStackString(self.cx, stack_handle, string_handle, indent.unwrap_or(0)) {
+                return None;
+            }
+
+            Some(jsstr_to_string(self.cx, string_handle.get()))
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! capture_stack {
+    (in($cx:expr) let $name:ident = with max depth($max_frame_count:expr)) => {
+        rooted!(in($cx) let mut __obj = ::std::ptr::null_mut());
+        let $name = $crate::rust::CapturedJSStack::new($cx, __obj, Some($max_frame_count));
+    };
+    (in($cx:expr) let $name:ident ) => {
+        rooted!(in($cx) let mut __obj = ::std::ptr::null_mut());
+        let $name = $crate::rust::CapturedJSStack::new($cx, __obj, None);
+    }
+}

tests/capture_stack.rs

@@ -0,0 +1,62 @@
+/* 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/. */
+
+#[macro_use]
+extern crate mozjs;
+extern crate libc;
+
+use mozjs::jsapi::CallArgs;
+use mozjs::jsapi::CompartmentOptions;
+use mozjs::jsapi::JSAutoCompartment;
+use mozjs::jsapi::JSContext;
+use mozjs::jsapi::JS_DefineFunction;
+use mozjs::jsapi::JS_NewGlobalObject;
+use mozjs::jsapi::OnNewGlobalHookOption;
+use mozjs::jsapi::Value;
+use mozjs::jsval::UndefinedValue;
+use mozjs::rust::{Runtime, SIMPLE_GLOBAL_CLASS};
+
+use std::ptr;
+
+#[test]
+fn capture_stack() {
+    let runtime = Runtime::new().unwrap();
+    let context = runtime.cx();
+    let h_option = OnNewGlobalHookOption::FireOnNewGlobalHook;
+    let c_option = CompartmentOptions::default();
+
+    unsafe {
+        let global = JS_NewGlobalObject(context, &SIMPLE_GLOBAL_CLASS, ptr::null_mut(), h_option, &c_option);
+        rooted!(in(context) let global_root = global);
+        let global = global_root.handle();
+        let _ac = JSAutoCompartment::new(context, global.get());
+        let function = JS_DefineFunction(context, global, b"print_stack\0".as_ptr() as *const libc::c_char,
+                                         Some(print_stack), 0, 0);
+        assert!(!function.is_null());
+        let javascript = "
+            function foo(arg1) {
+                var bar = function() {
+                    print_stack();
+                };
+                bar();
+            }
+
+            foo(\"arg1-value\");
+        ";
+        rooted!(in(context) let mut rval = UndefinedValue());
+        let _ = runtime.evaluate_script(global, javascript, "test.js", 0, rval.handle_mut());
+    }
+}
+
+unsafe extern "C" fn print_stack(context: *mut JSContext, argc: u32, vp: *mut Value) -> bool {
+    let args = CallArgs::from_vp(vp, argc);
+
+    capture_stack!(in(context) let stack);
+    let str_stack = stack.unwrap().as_string(None).unwrap();
+    println!("{}", str_stack);
+    assert_eq!("foo/bar@test.js:3:21\nfoo@test.js:5:17\n@test.js:8:13\n".to_string(), str_stack);
+
+    args.rval().set(UndefinedValue());
+    return true;
+}