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

Source/core/inspector/PromiseTracker.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/inspector/PromiseTracker.h"
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "bindings/core/v8/ScriptState.h"
 #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; }
     ScopedPersistent<v8::Object>& promise() { return m_promise; }
 
 private:
     friend class PromiseTracker;
 
     int m_promiseHash;
 

[aandrey, 2014/09/01 13:39:27]

extra line

[Alexandra Mikhaylova, 2014/09/02 11:39:29]

Fixed.

+    int m_promiseId;
     ScopedPersistent<v8::Object> m_promise;
     ScriptCallFrame m_callFrame;
+    int m_parentPromiseId;
     ScopedPersistent<v8::Object> m_parentPromise;
     int m_status;
 
     WeakPtrFactory<PromiseData> m_weakPtrFactory;
 };
 
 static int indexOf(PromiseTracker::PromiseDataVector* vector, const ScopedPersistent<v8::Object>& promise)
 {
     for (size_t index = 0; index < vector->size(); ++index) {
         if (vector->at(index)->promise() == promise)
@@ skipping 30 matching lines @@
 
 private:
     WeakPtr<PromiseTracker::PromiseData> m_data;
     PromiseTracker::PromiseDataMap* m_promiseDataMap;
 };
 
 }
 
 PromiseTracker::PromiseTracker()
     : m_isEnabled(false)
+    , m_lastPromiseId(0)
 {
 }
 
 PromiseTracker::~PromiseTracker()
 {
 }
 
 void PromiseTracker::enable()
 {
     m_isEnabled = true;
 }
 
 void PromiseTracker::disable()
 {
     m_isEnabled = false;
     clear();
 }
 
 void PromiseTracker::clear()
 {
     m_promiseDataMap.clear();
+    m_lastPromiseId = 0;

[aandrey, 2014/09/01 13:39:27]

remove

[Alexandra Mikhaylova, 2014/09/02 11:39:29]

I think we shouldn't remove it as we're using integer and its "default" value is
not 0 in fact.

 }
 
-void PromiseTracker::didReceiveV8PromiseEvent(ScriptState* scriptState, v8::Handle<v8::Object> promise, v8::Handle<v8::Value> parentPromise, int status)
+PassRefPtr<PromiseTracker::PromiseData> PromiseTracker::findOrAddPromiseData(v8::Isolate* isolate, v8::Handle<v8::Object> promise)

[aandrey, 2014/09/01 13:39:27]

findOrAddPromiseData -> createPromiseDataIfNeeded

[Alexandra Mikhaylova, 2014/09/02 11:39:29]

Done.

 {
-    ASSERT(isEnabled());
-
     int promiseHash = promise->GetIdentityHash();
     PromiseDataVector* vector;
     PromiseDataMap::iterator it = m_promiseDataMap.find(promiseHash);
     if (it != m_promiseDataMap.end())
         vector = &it->value;
     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, ++m_lastPromiseId, promise));

[aandrey, 2014/09/01 13:39:27]

use this pattern:

int AsyncCallStackTracker::ExecutionContextData::circularSequentialID()
{
    ++m_circularSequentialID;
    if (m_circularSequentialID <= 0)
        m_circularSequentialID = 1;
    return m_circularSequentialID;
}

[Alexandra Mikhaylova, 2014/09/02 11:39:29]

Done, also renamed m_lastPromiseId to m_circularSequentialId to ease search.

         OwnPtr<PromiseDataWrapper> wrapper = adoptPtr(new PromiseDataWrapper(data->m_weakPtrFactory.createWeakPtr(), &m_promiseDataMap));
         data->m_promise.setWeak(wrapper.leakPtr(), &PromiseDataWrapper::didRemovePromise);
         vector->append(data);
     } else {
         data = vector->at(index);
     }
 
+    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 = findOrAddPromiseData(isolate, promise);
     if (!parentPromise.IsEmpty()) {
         ASSERT(parentPromise->IsObject());
-        data->m_parentPromise.set(isolate, parentPromise->ToObject());
+        v8::Handle<v8::Object> handle = parentPromise->ToObject();
+        RefPtr<PromiseData> parentData = findOrAddPromiseData(isolate, handle);
+        data->m_parentPromiseId = parentData->m_promiseId;
+        data->m_parentPromise.set(isolate, handle);
     } else {
         data->m_status = status;
         if (!status) {
             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);
         }
     }
 }
 
+PassRefPtr<Array<PromiseDetails> > PromiseTracker::getPromises()
+{
+    ASSERT(isEnabled());
+
+    RefPtr<Array<PromiseDetails> > result;
+    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);
+            RefPtr<CallFrame> callFrame = CallFrame::create()
+                .setFunctionName(data->m_callFrame.functionName())
+                .setScriptId(data->m_callFrame.scriptId())
+                .setUrl(data->m_callFrame.sourceURL())
+                .setLineNumber(data->m_callFrame.lineNumber())
+                .setColumnNumber(data->m_callFrame.columnNumber())
+                .release();

[aandrey, 2014/09/01 13:39:27]

use ScriptCallFrame::buildInspectorObject() instead

[Alexandra Mikhaylova, 2014/09/02 11:39:29]

Thanks! Done.

+            RefPtr<PromiseDetails> promiseDetails = PromiseDetails::create()
+                .setId(data->m_promiseId)
+                .setParentId(data->m_parentPromiseId)
+                .setStatus(data->m_status)
+                .setCallFrame(callFrame)

[aandrey, 2014/09/01 13:39:27]

this should be optional, added only if we captured the stack.
instead of ScriptCallFrame m_callFrame let's use RefPtr<ScriptCallStack>
m_callStack;

[Alexandra Mikhaylova, 2014/09/02 11:39:29]

Done.

+                .release();

[aandrey, 2014/09/01 13:39:27]

remove release() call

[Alexandra Mikhaylova, 2014/09/02 11:39:29]

Done.

+            result->addItem(promiseDetails);

[aandrey, 2014/09/01 13:39:27]

doesn't this crash? result is nullptr here

[Alexandra Mikhaylova, 2014/09/02 11:39:29]

Thanks, fixed it.

+        }
+    }
+
+    return result.release();
+}
+
 } // namespace blink