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 {
 public:
-    explicit StackTrace()
+    explicit StackTrace();
+    explicit StackTrace(const StackTrace& javaScriptStackTrace, const StackTrace& dartStackTrace);

[vsm, 2014/08/29 08:42:08]

Can you add a comment here clarifying whether this is one contiguous JS/Dart
trace or all the (possibly discontinuous and/or interleaving) JS/Dart frames on
the stack?

[Jacob, 2014/09/05 23:35:56]

Rolled back the change to the StackTrace class and instead went with the cleaner
solution of a 
StackTraces class that lets you lookup a StackTrace for each ScriptState. This
will handle the multiple Dart DOM isolates case you mentioned as well as making
the code much less surprising. 

+    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;
     }
 
+    bool isMixedLanguageStackTrace() const
+    {
+        return m_hasJavaScript && m_hasDart;
+    }
+
+    DartScriptState* dartScriptState() const
+    {
+        return m_dartScriptState;
+    }
+
+    V8ScriptState* v8ScriptState() const
+    {
+        return m_v8ScriptState;
+    }
+
+    void merge(const StackTrace& other);
+
 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 {

[vsm, 2014/08/29 08:42:08]

Can you add a class or file level comment sketching out how these classes are
used?

[Jacob, 2014/09/05 23:35:55]

Removed this class as it is obsolete if both VMs provide methods to get stack
frame offsets.

+public:
+    StackTraceTimestamp(size_t stackDepth);
+
+    int64_t timestamp() const { return m_timestamp; }
+    size_t stackDepth() const { return m_stackDepth; }

[vsm, 2014/08/29 08:42:08]

Add comment: depth in frames or bytes?

[Jacob, 2014/09/05 23:35:55]

removed this class with switch to new faster approach.

+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