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 39 matching lines @@
 using WebCore::TypeBuilder::Debugger::Location;
 using WebCore::TypeBuilder::Debugger::Scope;
 using WebCore::TypeBuilder::Runtime::PropertyDescriptor;
 using WebCore::TypeBuilder::Runtime::InternalPropertyDescriptor;
 using WebCore::TypeBuilder::Debugger::FunctionDetails;
 using WebCore::TypeBuilder::Runtime::RemoteObject;
 using WebCore::TypeBuilder::Runtime::PropertyPreview;
 
 namespace WebCore {
 
+static const uint64_t kMaxSafeIntegerForDouble = 0x1fffffffffffffUL;
+
 Dart_Handle getLibraryUrl(Dart_Handle handle)
 {
     intptr_t libraryId = 0;
     Dart_Handle ALLOW_UNUSED result = Dart_LibraryId(handle, &libraryId);
     ASSERT(!Dart_IsError(result));
     Dart_Handle libraryUrl = Dart_GetLibraryURL(libraryId);
     ASSERT(Dart_IsString(libraryUrl));
     return libraryUrl;
 }
 
@@ skipping 667 matching lines @@
 
 void DartInjectedScript::restartFrame(ErrorString* errorString, const StackTrace& callFrames, const String& callFrameId, RefPtr<JSONObject>* result)
 {
     ASSERT(!callFrames.isJavaScript());
     *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.isJavaScript());
     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.isJavaScript());
     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.isJavaScript());
     *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 351 matching lines @@
         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.isJavaScript());
+            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())
         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();
+
     for (intptr_t i = 0; i < length; i++) {
         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);
+        result = Dart_ActivationFrameGetLocation(frame, &functionName, &function, &location);
+        ASSERT(!Dart_IsError(result));
+
         const String& url = DartUtilities::toString(location.script_url);
         intptr_t line = 0;
         intptr_t column = 0;
         Dart_ActivationFrameInfo(frame, 0, 0, &line, &column);
         RefPtr<Location> locationJson = Location::create()
             .setScriptId(debugServer.getScriptId(url, Dart_CurrentIsolate()))
             .setLineNumber(line - 1);
         locationJson->setColumnNumber(column);
         Dart_Handle localVariables = Dart_GetLocalVariables(frame);
         Dart_Handle thisHandle = findReceiver(localVariables);
@@ skipping 34 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();
+
+        uintptr_t framePointer = 0;
+        result = Dart_ActivationFrameGetFramePointer(frame, &framePointer);

[rmacnak, 2014/09/08 22:51:44]

Why not represent the frame pointer as a string or as high and low halves in
JavaScript?

[Jacob, 2014/09/10 17:58:56]

I've switched to high and low halves instead of trying to be clever.

+        // No frame pointers will actually be larger than 2^48 on a current x64
+        // machine but we truncate to 52 bits of precision to future proof the
+        // method. As we don't care about the exact frame pointer only the
+        // order of frame pointers, truncating to 52 bits will still generate the
+        // correct ordering with high probability.
+        framePointer = framePointer & kMaxSafeIntegerForDouble;
+        callFrame->setFramePointer(static_cast<double>(framePointer));
+        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