Support merged Dart-JS callstacks

Source/bindings/common/StackTrace.h

 /*
  * 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 21 matching lines @@
 #define StackTrace_h
 
 #include "bindings/common/ScriptValue.h"
 #include <dart_debugger_api.h>
 
 namespace WebCore {
 
 class JSONValue;
 class ScriptState;
 class V8ScriptState;
+class DartScriptState;
 
 class StackTrace {

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

Can this be pushed to multivm?

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

This one is ugly to push to multi-vm because it references both DartScriptState*
and Dart_StackTrace.  I will need to refactor a bit further so that references
to Dart are hidden in subclasses.

 public:
-    explicit StackTrace()
+    explicit StackTrace();
+    explicit StackTrace(const StackTrace& javaScriptStackTrace, const StackTrace& dartStackTrace);
+    explicit StackTrace(const ScriptValue& stackTrace, V8ScriptState*);
+    explicit StackTrace(Dart_StackTrace, DartScriptState*);
+
+    bool hasJavaScript() const
     {
-        m_isJavaScript = true;
-        m_dartStackTrace = 0;
+        return m_hasJavaScript;
     }
 
-    explicit StackTrace(const ScriptValue& stackTrace)
+    bool hasDart() const
     {
-        m_isJavaScript = true;
-        m_scriptValue = stackTrace;
-        m_dartStackTrace = 0;
-    }
-
-    explicit StackTrace(Dart_StackTrace stackTrace)
-    {
-        m_isJavaScript = false;
-        m_dartStackTrace = stackTrace;
-    }
-
-    bool isJavaScript() const
-    {
-        return m_isJavaScript;
+        return m_hasDart;
     }
 
     ScriptValue asJavaScript() const
     {
-        ASSERT(m_isJavaScript);
+        ASSERT(m_hasJavaScript);
         return m_scriptValue;
     }
 
     Dart_StackTrace asDart() const
     {
-        ASSERT(!m_isJavaScript);
+        ASSERT(m_hasDart);
         return m_dartStackTrace;
     }
 
     bool isNull() const
     {
-        return m_isJavaScript ? m_scriptValue.isEmpty() : !m_dartStackTrace;
+        return !m_hasDart && !m_hasJavaScript;

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

If m_hasJavaScript, should you check m_scriptValue.isEmpty() as before?  Same
with Dart?

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

No need to now that we have hasJavaScript and hasDart flags instead of a single 
m_isJavaScript flag.
Note the constructor from a ScriptValue includes a safety check for isEmpty.
In other words, null stack traces are now not treated as being either dart or
js.

+    }
+
+    bool isMixedLanguageStackTrace() const
+    {
+        return m_hasJavaScript && m_hasDart;
+    }
+
+    DartScriptState* dartScriptState() const
+    {
+        return m_dartScriptState;
+    }
+
+    V8ScriptState* v8ScriptState() const
+    {
+        return m_v8ScriptState;
     }
 
 private:
-    bool m_isJavaScript;
+    bool m_hasJavaScript;
+    bool m_hasDart;
     ScriptValue m_scriptValue;
     Dart_StackTrace m_dartStackTrace;
+    V8ScriptState* m_v8ScriptState;
+    DartScriptState* m_dartScriptState;
 };
 
 class ActivationFrame {
 public:
     explicit ActivationFrame()
     {
         m_isJavaScript = true;
         m_dartActivationFrame = 0;
     }
 
     explicit ActivationFrame(const ScriptValue& activationFrame)
     {
         m_isJavaScript = true;
         m_scriptValue = activationFrame;
         m_dartActivationFrame = 0;
     }
 
     explicit ActivationFrame(Dart_ActivationFrame activationFrame)
     {
         m_isJavaScript = false;
         m_dartActivationFrame = activationFrame;
     }
 
     bool isJavaScript() const { return m_isJavaScript; }
+
     ScriptValue asJavaScript() const
     {
         ASSERT(m_isJavaScript);
         return m_scriptValue;
     }
 
     Dart_ActivationFrame asDart() const
     {
         ASSERT(!m_isJavaScript);
         return m_dartActivationFrame;
     }
 
 private:
     bool m_isJavaScript;
     ScriptValue m_scriptValue;
     Dart_ActivationFrame m_dartActivationFrame;
 };
 
+class StackTraceTimestamp {
+public:
+    StackTraceTimestamp(size_t stackDepth);
+
+    int64_t timestamp() const { return m_timestamp; }
+    size_t stackDepth() const { return m_stackDepth; }

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

What is stackDepth supposed to be?  The number of frames in a particular stack
trace?  The number of bytes?

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

number of frames.  perhaps size_t is confusing. I can change it to unsigned to
clarify if that improves things. No way we can handle more than 4B frames
anyway.

+private:
+    int64_t m_timestamp;
+    size_t m_stackDepth;
+};
+
+class StackTraceTimestampTracker {
+public:
+    void decrementRecursionLevel() { m_samples.removeLast(); }
+
+    void incrementRecursionLevel(size_t stackDepth)
+    {
+        m_samples.append(StackTraceTimestamp(stackDepth));
+    }
+
+    size_t recursionLevel() { return m_samples.size(); }
+    int64_t getTimestamp(size_t frame);
+private:
+    Vector<StackTraceTimestamp> m_samples;
+};
+
 } // namespace WebCore
 
 #endif // StackTrace_h