Support merged Dart-JS callstacks

Source/bindings/dart/DartInjectedScript.cpp

 /*
  * Copyright (C) 2014 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 691 matching lines @@
     }
 fail:
     ASSERT(exception);
     packageResult(exception, DartDebuggerObject::Error, objectGroup, errorString, returnByValue, generatePreview, result, wasThrown);
 
 
 }
 
 void DartInjectedScript::evaluateOnCallFrame(ErrorString* errorString, const StackTrace& callFrames, const Vector<StackTrace>& asyncCallStacks, const String& callFrameId, const String& expression, const String& objectGroup, bool includeCommandLineAPI, bool returnByValue, bool generatePreview, RefPtr<RemoteObject>* result, TypeBuilder::OptOutput<bool>* wasThrown)
 {
-    ASSERT(!callFrames.isJavaScript());
+    ASSERT(callFrames.hasDart());

[vsm, 2014/08/13 14:26:45]

Should this be checking that the latest frame on the stack is Dart?

[Jacob, 2014/08/13 21:36:15]

No because we can evaluate on the call frame just fine even if the last frame
isn't dart. Note that the specific call frame being evaluated against is
specified by callFrameId.

     if (!m_scriptState) {
         *errorString = "Invalid DartInjectedScript";
         return;
     }
     DartIsolateScope scope(m_scriptState->isolate());
     DartApiScope apiScope;
     // FIXMEDART: add v8Scope calls elsewhere.
     V8Scope v8scope(DartDOMData::current());
 
     Dart_ActivationFrame frame = callFrameForId(callFrames, asyncCallStacks, callFrameId);
     ASSERT(frame);
     if (!frame) {
         *errorString = "Call frame not found";
         return;
     }
 
     Dart_Handle function = 0;
     Dart_ActivationFrameGetLocation(frame, 0, &function, 0);
     ASSERT(function);
     Dart_Handle localVariables = Dart_GetLocalVariables(frame);
     Dart_Handle thisHandle = findReceiver(localVariables);
     Dart_Handle context = thisHandle ? thisHandle : lookupEnclosingType(function);
     evaluateAndPackageResult(context, expression, localVariables, includeCommandLineAPI, objectGroup, errorString, returnByValue, generatePreview, result, wasThrown);
 }
 
 void DartInjectedScript::restartFrame(ErrorString* errorString, const StackTrace& callFrames, const String& callFrameId, RefPtr<JSONObject>* result)
 {
-    ASSERT(!callFrames.isJavaScript());
+    ASSERT(callFrames.hasDart());
     *errorString = "Dart does not yet support restarting call frames";
     return;
 }
 
 void DartInjectedScript::getStepInPositions(ErrorString* errorString, const StackTrace& callFrames, const String& callFrameId, RefPtr<Array<TypeBuilder::Debugger::Location> >& positions)
 {
-    ASSERT(!callFrames.isJavaScript());
+    ASSERT(callFrames.hasDart());
     if (!m_scriptState) {
         *errorString = "Invalid DartInjectedScript";
         return;
     }
     DartIsolateScope scope(m_scriptState->isolate());
     DartApiScope apiScope;
     *errorString = "FIXME: support dart.";
     return;
 }
 
 void DartInjectedScript::setVariableValue(ErrorString* errorString, const StackTrace& callFrames, const String* callFrameIdOpt, const String* functionObjectIdOpt, int scopeNumber, const String& variableName, const String& newValueStr)
 {
+    ASSERT(callFrames.hasDart());
     if (!m_scriptState) {
         *errorString = "Invalid DartInjectedScript";
         return;
     }
     DartIsolateScope scope(m_scriptState->isolate());
     DartApiScope apiScope;
-    ASSERT(!callFrames.isJavaScript());
     *errorString = "Not supported by Dart.";
     return;
 }
 
 void DartInjectedScript::getFunctionDetails(ErrorString* errorString, const String& functionId, RefPtr<FunctionDetails>* result)
 {
     if (!m_scriptState) {
         *errorString = "Invalid DartInjectedScript";
         return;
     }
@@ skipping 59 matching lines @@
 {
     ASSERT(Dart_IsList(completions));
     intptr_t length = 0;
     Dart_ListLength(completions, &length);
     for (intptr_t i = 0; i < length; ++i)
         (*result)->addItem(DartUtilities::toString(Dart_ListGetAt(completions, i)));
 }
 
 void DartInjectedScript::getCompletionsOnCallFrame(ErrorString* errorString, const StackTrace& callFrames, const Vector<StackTrace>& asyncCallStacks, const String& callFrameId, const String& expression, RefPtr<TypeBuilder::Array<String> >* result)
 {
-    ASSERT(!callFrames.isJavaScript());
+    ASSERT(callFrames.hasDart());
     *result = TypeBuilder::Array<String>::create();
     if (!m_scriptState) {
         *errorString = "Invalid DartInjectedScript";
         return;
     }
     DartIsolateScope scope(m_scriptState->isolate());
     DartApiScope apiScope;
     V8Scope v8scope(DartDOMData::current());
 
     Dart_ActivationFrame frame = callFrameForId(callFrames, asyncCallStacks, callFrameId);
@@ skipping 330 matching lines @@
 
 String DartInjectedScript::getCallFrameId(int ordinal, int asyncOrdinal)
 {
     // FIXME: what if the stack trace contains frames from multiple
     // injectedScripts?
     return String::format("{\"ordinal\":%d,\"injectedScriptId\":%d,\"asyncOrdinal\":%d}", ordinal, m_injectedScriptId, asyncOrdinal);
 }
 
 Dart_ActivationFrame DartInjectedScript::callFrameForId(const StackTrace& callFrames, const Vector<StackTrace>& asyncCallStacks, const String& callFrameId)
 {
-    ASSERT(!callFrames.isJavaScript());
-    if (callFrames.isJavaScript())
+    ASSERT(callFrames.hasDart());
+    if (!callFrames.hasDart())
         return 0;
     Dart_StackTrace trace = callFrames.asDart();
     Dart_ActivationFrame frame = 0;
     int ordinal = 0;
     int asyncOrdinal = 0;
     RefPtr<JSONValue> json = parseJSON(callFrameId);
     if (json && json->type() == JSONValue::TypeObject) {
         bool ALLOW_UNUSED success = json->asObject()->getNumber("ordinal", &ordinal);
         ASSERT(success);
         success = json->asObject()->getNumber("asyncOrdinal", &asyncOrdinal);
         ASSERT(success);
     } else {
         ASSERT(json && json->type() == JSONValue::TypeObject);
         return 0;
     }
     Dart_Handle ALLOW_UNUSED result;
     if (asyncOrdinal > 0) { // 1-based index
         ASSERT(asyncOrdinal <= (int)asyncCallStacks.size());
         if (asyncOrdinal <= (int)asyncCallStacks.size()) {
-            ASSERT(!asyncCallStacks[asyncOrdinal-1].isJavaScript());
-            result = Dart_GetActivationFrame(asyncCallStacks[asyncOrdinal-1].asDart(), ordinal, &frame);
+            StackTrace asyncCallStack = asyncCallStacks[asyncOrdinal-1];
+            ASSERT(asyncCallStack.hasDart());
+            result = Dart_GetActivationFrame(asyncCallStack.asDart(), ordinal, &frame);
         } else {
             return 0;
         }
     } else {
         result = Dart_GetActivationFrame(trace, ordinal, &frame);
     }
     ASSERT(result);
     return frame;
 }
 
 PassRefPtr<Array<CallFrame> > DartInjectedScript::wrapCallFrames(const StackTrace& callFrames, int asyncOrdinal)
 {
-    ASSERT(!callFrames.isJavaScript());
-    if (callFrames.isJavaScript())
+    ASSERT(callFrames.hasDart());
+    if (!callFrames.hasDart())
         return nullptr;
+    DartIsolateScope scope(m_scriptState->isolate());
+    DartApiScope apiScope;
     Dart_StackTrace trace = callFrames.asDart();
     intptr_t length = 0;
     Dart_Handle ALLOW_UNUSED result;
     RefPtr<Array<CallFrame> > ret = Array<CallFrame>::create();
     result = Dart_StackTraceLength(trace, &length);
     ASSERT(!Dart_IsError(result));
     DartScriptDebugServer& debugServer = DartScriptDebugServer::shared();
     Dart_Handle libraries = Dart_GetLibraryIds();
+
+    DartDOMData* domData = DartDOMData::current();
+    StackTraceTimestampTracker* timestampTracker = domData->stackTraceTimestampTracker();
     for (intptr_t i = 0; i < length; i++) {
+        int64_t timestamp = timestampTracker->getTimestamp(length - i - 1);
         Dart_ActivationFrame frame = 0;
         result = Dart_GetActivationFrame(trace, i, &frame);
         ASSERT(!Dart_IsError(result));
         Dart_Handle functionName = 0;
         Dart_Handle function = 0;
         Dart_CodeLocation location;
         Dart_ActivationFrameGetLocation(frame, &functionName, &function, &location);
         const String& url = DartUtilities::toString(location.script_url);
         intptr_t line = 0;
         intptr_t column = 0;
@@ skipping 41 matching lines @@
                 .setType(Scope::Type::Library)
                 .setObject(wrapDartHandle(library, DartDebuggerObject::CurrentLibrary, "backtrace", false))
                 .release());
         }
 
         scopeChain->addItem(Scope::create()
             .setType(Scope::Type::Isolate)
             .setObject(wrapDartHandle(libraries, DartDebuggerObject::Isolate, "backtrace", false))
             .release());
 
-        ret->addItem(CallFrame::create()
+        RefPtr<CallFrame> callFrame = CallFrame::create()
             .setCallFrameId(getCallFrameId(i, asyncOrdinal))
             .setFunctionName(DartUtilities::toString(functionName))
             .setLocation(locationJson)
             .setScopeChain(scopeChain)
             .setThis(thisObject)
-            .release());
+            .release();
+        callFrame->setTimestamp(timestamp);
+        ret->addItem(callFrame);
     }
     return ret;
 }
 
 DartDebuggerObject::Kind DartInjectedScript::inferKind(Dart_Handle handle)
 {
     DartDOMData* domData = DartDOMData::current();
     ASSERT(domData);
     if (Dart_IsType(handle))
         return DartDebuggerObject::Class;
@@ skipping 90 matching lines @@
 }
 
 DartDebuggerObject* DartInjectedScript::lookupObject(const String& objectId)
 {
     ASSERT(validateObjectId(objectId));
     DebuggerObjectMap::iterator it = m_objects.find(objectId);
     return it != m_objects.end() ? it->value : 0;
 }
 
 } // namespace WebCore