Dartium: do not call back into Dart code to parse or generate a stack trace.

Source/bindings/dart/DartUtilities.cpp

 // Copyright 2011, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //    * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //    * Redistributions in binary form must reproduce the above
@@ skipping 935 matching lines @@
 }
 
 PassRefPtr<ScriptArguments> DartUtilities::createScriptArguments(Dart_Handle argument, Dart_Handle& exception)
 {
     v8::Handle<v8::Value> v8Argument = DartHandleProxy::create(argument);
     Vector<ScriptValue> arguments;
     arguments.append(ScriptValue(v8Argument, v8::Isolate::GetCurrent()));
     return ScriptArguments::create(DartUtilities::currentScriptState(), arguments);
 }
 
-static PassRefPtr<ScriptCallStack> createScriptCallStackFromParsedStackTrace(Dart_Handle parsedStackTrace, Dart_Handle exception)
+static PassRefPtr<ScriptCallStack> createScriptCallStackFromStackTrace(Dart_ExceptionStackTrace stackTrace)
 {
-    Vector<Dart_Handle> callFrames;
-    DartUtilities::extractListElements(parsedStackTrace, exception, callFrames);
-    if (exception)
+    intptr_t frameCount = 0;
+    Dart_Handle result = Dart_StacktraceLength(stackTrace, &frameCount);
+    if (Dart_IsError(result))
         return 0;
 
-    size_t frameCount = callFrames.size();
     if (frameCount > ScriptCallStack::maxCallStackSizeToCapture)
         frameCount = ScriptCallStack::maxCallStackSizeToCapture;
 
     Vector<ScriptCallFrame> scriptCallStackFrames;
-    for (size_t i = 0; i < frameCount; i++) {
-        Dart_Handle callFrame = callFrames[i];
-        Vector<Dart_Handle> fields;
-        DartUtilities::extractListElements(callFrame, exception, fields);
-        if (exception)
+    for (intptr_t frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+        Dart_Handle dartFunctionName;
+        Dart_Handle dartScriptUrl;
+        intptr_t lineNumber = 0;
+        intptr_t columnNumber = 0;
+        result = Dart_StacktraceFrameInfo(stackTrace, frameIndex, &dartFunctionName, &dartScriptUrl, &lineNumber, &columnNumber);
+        if (Dart_IsError(result))
             return 0;
-        ASSERT(fields.size() == 4);
-        String functionName = DartUtilities::toString(fields[0]);
-        String sourceName = DartUtilities::toString(fields[1]);
-        int lineNumber = DartUtilities::toInteger(fields[2], exception);
-        if (exception)
+
+        const char* cstr = 0;
+        result = Dart_StringToCString(dartFunctionName, &cstr);
+        if (Dart_IsError(result))
             return 0;
-        int columnNumber = DartUtilities::toInteger(fields[3], exception);
-        if (exception)
+        String functionName(cstr);
+        result = Dart_StringToCString(dartScriptUrl, &cstr);
+        if (Dart_IsError(result))
             return 0;
-        scriptCallStackFrames.append(ScriptCallFrame(functionName, "undefined", sourceName, lineNumber, columnNumber));
+        String scriptUrl(cstr);
+
+        // FIXME

[rmacnak, 2013/11/07 21:30:41]

The console Sources tab sometimes tries to highlight the line information
relative to the HTML file rather than the script tag. Perhaps this is the cause?

+        const char* scriptName = "undefined";
+        // FIXME
+        if (columnNumber != -1)

[rmacnak, 2013/11/07 21:30:41]

When stack traces were parsed by a Dart regex, the regex effectively skipped
frames without a column number. For stacks involving calls to console.log or
print, this happens to make the top-of-stack be the caller of console.log/print,
which is expected by a few tests. Presumably they would break if Dartium were
run without a snapshot. The stack is requested by WebKit code, which embodies a
bad assumption that console.log will be implemented directly as a native and
that happens to hold for V8.

+            scriptCallStackFrames.append(ScriptCallFrame(functionName, scriptName, scriptUrl, lineNumber, columnNumber));
     }
     if (!frameCount)
         scriptCallStackFrames.append(ScriptCallFrame("undefined", "undefined", "undefined", 0, 0));
 
     return ScriptCallStack::create(scriptCallStackFrames);
 }
 
-static PassRefPtr<ScriptCallStack> createScriptCallStackFromStackTrace(Dart_Handle stackTrace, Dart_Handle& exception)
-{
-    Dart_Handle parsedStackTrace = DartUtilities::invokeUtilsMethod("parseStackTrace", 1, &stackTrace);
-    if (!DartUtilities::checkResult(parsedStackTrace, exception))
-        return 0;
-
-    return createScriptCallStackFromParsedStackTrace(parsedStackTrace, exception);
-}
-
 PassRefPtr<ScriptCallStack> DartUtilities::createScriptCallStack()
 {
-    Dart_ExceptionPauseInfo previousPauseInfo = Dart_GetExceptionPauseInfo();
-    if (previousPauseInfo != kNoPauseOnExceptions)
-        Dart_SetExceptionPauseInfo(kNoPauseOnExceptions);
-    Dart_Handle exception = 0;
-    Dart_Handle parsedStackTrace = DartUtilities::invokeUtilsMethod("captureParsedStackTrace", 0, 0);
-
-    if (previousPauseInfo != kNoPauseOnExceptions)
-        Dart_SetExceptionPauseInfo(previousPauseInfo);
-
-    if (!DartUtilities::checkResult(parsedStackTrace, exception))
-        return 0;
-
-    return createScriptCallStackFromParsedStackTrace(parsedStackTrace, exception);
+    Dart_ExceptionStackTrace trace = 0;
+    Dart_Handle result = Dart_CurrentStacktrace(&trace);
+    ASSERT(!Dart_IsError(result));
+    ASSERT(!Dart_IsNull(result));
+    ASSERT(trace);
+    return createScriptCallStackFromStackTrace(trace);
 }
 
 Dart_WeakPersistentHandle DartUtilities::createPrologueWeakPersistentHandle(Dart_Handle object, void* peer, Dart_WeakPersistentHandleFinalizer weakCallback)
 {
     DartWeakCallback* callback = new DartWeakCallback(peer, weakCallback);
     callback->m_object = Dart_NewPrologueWeakPersistentHandle(object, callback, &weakCallbackWrapper);
     DartDOMData::current()->weakCallbacks()->add(callback);
     return callback->m_object;
 }
 
@@ skipping 104 matching lines @@
         Dart_Handle exception = Dart_ErrorGetException(result);
         ASSERT(!Dart_IsError(exception));
 
         exception = Dart_ToString(exception);
         if (Dart_IsError(exception))
             errorMessage = String("Error converting exception to a string: ") + Dart_GetError(exception);
         else
             errorMessage = String("Exception: ") + DartUtilities::toString(exception);
 
         // Print the stack trace.
-        Dart_Handle stacktrace = Dart_ErrorGetStacktrace(result);
-        ASSERT(!Dart_IsError(stacktrace));
-        Dart_Handle stackTraceConversionException = 0;
-        callStack = createScriptCallStackFromStackTrace(stacktrace, stackTraceConversionException);
-        if (stackTraceConversionException)
-            errorMessage.append(String("\nError converting stack trace to a string: ") + DartUtilities::toString(stackTraceConversionException));
+        Dart_ExceptionStackTrace stacktrace;
+        Dart_Handle traceResult = Dart_ErrorGetStacktrace(result, &stacktrace);
+        ASSERT(!Dart_IsError(traceResult));
+        callStack = createScriptCallStackFromStackTrace(stacktrace);
     }
 
     if (context && context->isDocument()) {
         static_cast<Document*>(context)->reportException(ErrorEvent::create(errorMessage, sourceURL, lineNumber, 0, 0), callStack, NotSharableCrossOrigin);
     }
 }
 
 Dart_Handle DartUtilities::notImplementedException(const char* fileName, int lineNumber)
 {
     Dart_Handle args[2] = { Dart_NewStringFromCString(fileName), Dart_NewInteger(lineNumber) };
@@ skipping 25 matching lines @@
     if (!v) {
         return 0;
     }
     ASSERT(valueLen > 0 && static_cast<size_t>(valueLen) > strlen(v));
     strncpy(value, v, valueLen);
     value[valueLen - 1] = '\0';
     return strlen(value);
 #endif
 }
 }