[WIP] Protocol for sending information about Promises to frontend.

Source/core/inspector/PromiseTracker.cpp

Index: Source/core/inspector/PromiseTracker.cpp
diff --git a/Source/core/inspector/PromiseTracker.cpp b/Source/core/inspector/PromiseTracker.cpp
index a9704ae61ab7e92729fd3488bb0bab63095cbe9e..d549b95260e38c2e754f893a5076c1c7729f5646 100644
--- a/Source/core/inspector/PromiseTracker.cpp
+++ b/Source/core/inspector/PromiseTracker.cpp
@@ -11,16 +11,22 @@
 #include "wtf/PassOwnPtr.h"
 #include "wtf/WeakPtr.h"
 
+using blink::TypeBuilder::Array;
+using blink::TypeBuilder::Console::CallFrame;
+using blink::TypeBuilder::Debugger::PromiseDetails;
+
 namespace blink {
 
 class PromiseTracker::PromiseData : public RefCounted<PromiseData> {
 public:
-    PromiseData(v8::Isolate* isolate, int promiseHash, v8::Handle<v8::Object> promise)
+    PromiseData(v8::Isolate* isolate, int promiseHash, int promiseId, v8::Handle<v8::Object> promise)
         : m_promiseHash(promiseHash)
+        , m_promiseId(promiseId)
         , m_promise(isolate, promise)
+        , m_parentPromiseId(0)
         , m_status(0)
         , m_weakPtrFactory(this)
-        {
+    {
     }
 
     int promiseHash() const { return m_promiseHash; }
@@ -30,13 +36,13 @@ private:
     friend class PromiseTracker;
 
     int m_promiseHash;
-
+    int m_promiseId;
     ScopedPersistent<v8::Object> m_promise;
-    ScriptCallFrame m_callFrame;
-    ScopedPersistent<v8::Object> m_parentPromise;
+    int m_parentPromiseId;
     int m_status;
-
     WeakPtrFactory<PromiseData> m_weakPtrFactory;
+    RefPtr<ScriptCallStack> m_callStack;
+    ScopedPersistent<v8::Object> m_parentPromise;
 };
 
 static int indexOf(PromiseTracker::PromiseDataVector* vector, const ScopedPersistent<v8::Object>& promise)
@@ -83,6 +89,7 @@ private:
 
 PromiseTracker::PromiseTracker()
     : m_isEnabled(false)
+    , m_circularSequentialId(0)
 {
 }
 
@@ -90,15 +97,11 @@ PromiseTracker::~PromiseTracker()
 {
 }
 
-void PromiseTracker::enable()
+void PromiseTracker::setEnabled(bool enabled)
 {
-    m_isEnabled = true;
-}
-
-void PromiseTracker::disable()
-{
-    m_isEnabled = false;
-    clear();
+    m_isEnabled = enabled;
+    if (!enabled)
+        clear();
 }
 
 void PromiseTracker::clear()
@@ -106,10 +109,16 @@ void PromiseTracker::clear()
     m_promiseDataMap.clear();
 }
 
-void PromiseTracker::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Handle<v8::Object> promise, v8::Handle<v8::Value> parentPromise, int status)
+int PromiseTracker::circularSequentialId()
 {
-    ASSERT(isEnabled());
+    ++m_circularSequentialId;
+    if (m_circularSequentialId <= 0)
+        m_circularSequentialId = 1;
+    return m_circularSequentialId;
+}
 
+PassRefPtr<PromiseTracker::PromiseData> PromiseTracker::createPromiseDataIfNeeded(v8::Isolate* isolate, v8::Handle<v8::Object> promise)
+{
     int promiseHash = promise->GetIdentityHash();
     PromiseDataVector* vector;
     PromiseDataMap::iterator it = m_promiseDataMap.find(promiseHash);
@@ -118,11 +127,10 @@ void PromiseTracker::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Hand
     else
         vector = &m_promiseDataMap.add(promiseHash, PromiseDataVector()).storedValue->value;
 
-    v8::Isolate* isolate = scriptState->isolate();
     RefPtr<PromiseData> data;
     int index = indexOf(vector, ScopedPersistent<v8::Object>(isolate, promise));
     if (index == -1) {
-        data = adoptRef(new PromiseData(isolate, promiseHash, promise));
+        data = adoptRef(new PromiseData(isolate, promiseHash, circularSequentialId(), promise));
         OwnPtr<PromiseDataWrapper> wrapper = adoptPtr(new PromiseDataWrapper(data->m_weakPtrFactory.createWeakPtr(), &m_promiseDataMap));
         data->m_promise.setWeak(wrapper.leakPtr(), &PromiseDataWrapper::didRemovePromise);
         vector->append(data);
@@ -130,18 +138,59 @@ void PromiseTracker::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Hand
         data = vector->at(index);
     }
 
-    if (!parentPromise.IsEmpty()) {
-        ASSERT(parentPromise->IsObject());
-        data->m_parentPromise.set(isolate, parentPromise->ToObject());
+    return data.release();
+}
+
+void PromiseTracker::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Handle<v8::Object> promise, v8::Handle<v8::Value> parentPromise, int status)
+{
+    ASSERT(isEnabled());
+
+    v8::Isolate* isolate = scriptState->isolate();
+    RefPtr<PromiseData> data = createPromiseDataIfNeeded(isolate, promise);
+    if (!parentPromise.IsEmpty() && parentPromise->IsObject()) {
+        v8::Handle<v8::Object> handle = parentPromise->ToObject();
+        RefPtr<PromiseData> parentData = createPromiseDataIfNeeded(isolate, handle);
+        data->m_parentPromiseId = parentData->m_promiseId;
+        data->m_parentPromise.set(isolate, handle);
     } else {
         data->m_status = status;
-        if (!status) {
+        if (!status && !data->m_callStack) {
             v8::Handle<v8::StackTrace> stackTrace(v8::StackTrace::CurrentStackTrace(isolate, 1));
             RefPtrWillBeRawPtr<ScriptCallStack> stack = createScriptCallStack(stackTrace, 1, isolate);
             if (stack->size())
-                data->m_callFrame = stack->at(0);
+                data->m_callStack = stack;
+        }
+    }
+}
+
+PassRefPtr<Array<PromiseDetails> > PromiseTracker::promises()
+{
+    ASSERT(isEnabled());
+
+    RefPtr<Array<PromiseDetails> > result = Array<PromiseDetails>::create();
+    for (PromiseDataMap::iterator it = m_promiseDataMap.begin(); it != m_promiseDataMap.end(); ++it) {
+        PromiseDataVector* vector = &it->value;
+        for (size_t index = 0; index < vector->size(); ++index) {
+            RefPtr<PromiseData> data = vector->at(index);
+            PromiseDetails::Status::Enum status;
+            if (!data->m_status)
+                status = PromiseDetails::Status::Pending;
+            else if (data->m_status == 1)
+                status = PromiseDetails::Status::Resolved;
+            else
+                status = PromiseDetails::Status::Rejected;
+            RefPtr<PromiseDetails> promiseDetails = PromiseDetails::create()
+                .setId(data->m_promiseId)
+                .setStatus(status);
+            if (data->m_parentPromiseId)
+                promiseDetails->setParentId(data->m_parentPromiseId);
+            if (data->m_callStack)
+                promiseDetails->setCallFrame(data->m_callStack->at(0).buildInspectorObject());
+            result->addItem(promiseDetails);
         }
     }
+
+    return result.release();
 }
 
 } // namespace blink