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_StackTrace 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_ActivationFrame frame = 0;
+        result = Dart_GetActivationFrame(stackTrace, frameIndex, &frame);
+        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)
+        }
+        ASSERT(frame);
+
+        Dart_Handle dartFunctionName;
+        Dart_Handle dartScriptUrl;
+        intptr_t lineNumber = 0;
+        intptr_t columnNumber = 0;
+        result = Dart_ActivationFrameInfo(frame, &dartFunctionName, &dartScriptUrl, &lineNumber, &columnNumber);
+        if (Dart_IsError(result)) {
             return 0;
-        int columnNumber = DartUtilities::toInteger(fields[3], exception);
-        if (exception)
-            return 0;
-        scriptCallStackFrames.append(ScriptCallFrame(functionName, "undefined", sourceName, lineNumber, columnNumber));
+        }
+
+        // This skips frames where source is unavailable. WebKit code for the
+        // console assumes that console.log et al. are implemented directly
+        // as natives, i.e. that the top-of-stack will be the caller of
+        // console.log. The Dart implementation involves intermediate Dart
+        // calls, which are skipped by this clause.
+        if (columnNumber == -1)
+            continue;
+
+        String functionName = DartUtilities::toString(dartFunctionName);
+        String scriptUrl = DartUtilities::toString(dartScriptUrl);
+
+        // FIXME: Cause of sources tab sometimes interpreting line/column information relative to the page instead of the script tag body?
+        const char* scriptName = "undefined";
+        scriptCallStackFrames.append(ScriptCallFrame(functionName, scriptName, scriptUrl, lineNumber, columnNumber));
     }
-    if (!frameCount)
+    if (scriptCallStackFrames.isEmpty())
         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_StackTrace trace = 0;
+    Dart_Handle result = Dart_GetStackTrace(&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_StackTrace stacktrace;
+        Dart_Handle traceResult = Dart_GetStackTraceFromError(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
 }
 }