[DevTools] Added Runtime.awaitPromise protocol method

third_party/WebKit/Source/platform/v8_inspector/V8RuntimeAgentImpl.cpp

 /*
  * Copyright (C) 2011 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 19 matching lines @@
 
 #include "platform/v8_inspector/V8RuntimeAgentImpl.h"
 
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
 #include "platform/v8_inspector/RemoteObjectId.h"
 #include "platform/v8_inspector/V8ConsoleMessage.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
+#include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 
 namespace blink {
 
 namespace V8RuntimeAgentImplState {
 static const char customObjectFormatterEnabled[] = "customObjectFormatterEnabled";
 static const char runtimeEnabled[] = "runtimeEnabled";
 };
 
 using protocol::Runtime::ExceptionDetails;
 using protocol::Runtime::RemoteObject;
 
 static bool hasInternalError(ErrorString* errorString, bool hasError)
 {
     if (hasError)
         *errorString = "Internal error";
     return hasError;
 }
 
+namespace {
+
+class ProtocolPromiseHandler {
+public:
+    static void add(V8DebuggerImpl* debugger, int contextGroupId, const String16& promiseObjectId, std::unique_ptr<protocol::Runtime::Backend::AwaitPromiseCallback> callback, bool returnByValue, bool generatePreview)
+    {
+        ErrorString errorString;
+        InjectedScript::ObjectScope scope(&errorString, debugger, contextGroupId, promiseObjectId);
+        if (!scope.initialize()) {
+            callback->sendFailure(errorString);
+            return;
+        }
+        if (!scope.object()->IsPromise()) {
+            callback->sendFailure("Could not find promise with given id");
+            return;
+        }
+
+        protocol::Runtime::Backend::AwaitPromiseCallback* rawCallback = callback.get();
+        ProtocolPromiseHandler* handler = new ProtocolPromiseHandler(debugger, contextGroupId, promiseObjectId, std::move(callback), returnByValue, generatePreview);
+        v8::Local<v8::Value> wrapper = handler->m_wrapper.Get(debugger->isolate());
+        v8::Local<v8::Promise> promise = v8::Local<v8::Promise>::Cast(scope.object());
+
+        v8::Local<v8::Function> thenCallbackFunction = v8::Function::New(scope.context(), thenCallback, wrapper, 0, v8::ConstructorBehavior::kThrow).ToLocalChecked();
+        if (promise->Then(scope.context(), thenCallbackFunction).IsEmpty()) {
+            rawCallback->sendFailure("Internal error");
+            return;
+        }
+        v8::Local<v8::Function> catchCallbackFunction = v8::Function::New(scope.context(), catchCallback, wrapper, 0, v8::ConstructorBehavior::kThrow).ToLocalChecked();
+        if (promise->Catch(scope.context(), catchCallbackFunction).IsEmpty()) {
+            rawCallback->sendFailure("Internal error");
+            return;
+        }
+    }
+
+private:
+    static void thenCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+    {
+        ProtocolPromiseHandler* handler = static_cast<ProtocolPromiseHandler*>(info.Data().As<v8::External>()->Value());
+        DCHECK(handler);
+        v8::Local<v8::Value> value = info.Length() > 0 ? info[0] : v8::Local<v8::Value>::Cast(v8::Undefined(info.GetIsolate()));
+        handler->m_callback->sendSuccess(handler->wrapObject(value), Maybe<bool>(), Maybe<protocol::Runtime::ExceptionDetails>());
+    }
+
+    static void catchCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+    {
+        ProtocolPromiseHandler* handler = static_cast<ProtocolPromiseHandler*>(info.Data().As<v8::External>()->Value());
+        DCHECK(handler);
+        v8::Local<v8::Value> value = info.Length() > 0 ? info[0] : v8::Local<v8::Value>::Cast(v8::Undefined(info.GetIsolate()));
+
+        std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails;
+        std::unique_ptr<V8StackTraceImpl> stack = handler->m_debugger->captureStackTraceImpl(true);
+        if (stack) {
+            exceptionDetails = protocol::Runtime::ExceptionDetails::create()
+                .setText("Promise was rejected")
+                .setLineNumber(!stack->isEmpty() ? stack->topLineNumber() : 0)
+                .setColumnNumber(!stack->isEmpty() ? stack->topColumnNumber() : 0)
+                .setScriptId(!stack->isEmpty() ? stack->topScriptId() : String16())
+                .setStackTrace(stack->buildInspectorObjectImpl())
+                .build();
+        }
+        handler->m_callback->sendSuccess(handler->wrapObject(value), true, std::move(exceptionDetails));
+    }
+
+    ProtocolPromiseHandler(V8DebuggerImpl* debugger, int contextGroupId, const String16& promiseObjectId, std::unique_ptr<V8RuntimeAgentImpl::AwaitPromiseCallback> callback, bool returnByValue, bool generatePreview)
+        : m_debugger(debugger)
+        , m_contextGroupId(contextGroupId)
+        , m_promiseObjectId(promiseObjectId)
+        , m_callback(std::move(callback))
+        , m_returnByValue(returnByValue)
+        , m_generatePreview(generatePreview)
+        , m_wrapper(debugger->isolate(), v8::External::New(debugger->isolate(), this))
+    {
+        m_wrapper.SetWeak(this, cleanup, v8::WeakCallbackType::kParameter);
+    }
+
+    static void cleanup(const v8::WeakCallbackInfo<ProtocolPromiseHandler>& data)
+    {
+        if (!data.GetParameter()->m_wrapper.IsEmpty()) {
+            data.GetParameter()->m_wrapper.Reset();
+            data.SetSecondPassCallback(cleanup);
+        } else {
+            data.GetParameter()->m_callback->sendFailure("Promise was collected");
+            delete data.GetParameter();
+        }
+    }
+
+    std::unique_ptr<protocol::Runtime::RemoteObject> wrapObject(v8::Local<v8::Value> value)
+    {
+        ErrorString errorString;
+        InjectedScript::ObjectScope scope(&errorString, m_debugger, m_contextGroupId, m_promiseObjectId);
+        if (!scope.initialize()) {
+            m_callback->sendFailure(errorString);
+            return nullptr;
+        }
+        std::unique_ptr<protocol::Runtime::RemoteObject> wrappedValue = scope.injectedScript()->wrapObject(&errorString, value, scope.objectGroupName(), m_returnByValue, m_generatePreview);
+        if (!wrappedValue) {
+            m_callback->sendFailure(errorString);
+            return nullptr;
+        }
+        return wrappedValue;
+    }
+
+    V8DebuggerImpl* m_debugger;
+    int m_contextGroupId;
+    String16 m_promiseObjectId;
+    std::unique_ptr<V8RuntimeAgentImpl::AwaitPromiseCallback> m_callback;
+    bool m_returnByValue;
+    bool m_generatePreview;
+    v8::Global<v8::External> m_wrapper;
+};
+
+} // namespace
+
 V8RuntimeAgentImpl::V8RuntimeAgentImpl(V8InspectorSessionImpl* session, protocol::FrontendChannel* FrontendChannel, protocol::DictionaryValue* state)
     : m_session(session)
     , m_state(state)
     , m_frontend(FrontendChannel)
     , m_debugger(session->debugger())
     , m_enabled(false)
 {
 }
 
 V8RuntimeAgentImpl::~V8RuntimeAgentImpl()
@@ skipping 59 matching lines @@
         maybeResultValue,
         scope.tryCatch(),
         objectGroup.fromMaybe(""),
         returnByValue.fromMaybe(false),
         generatePreview.fromMaybe(false),
         result,
         wasThrown,
         exceptionDetails);
 }
 
+void V8RuntimeAgentImpl::awaitPromise(ErrorString* errorString,
+    const String16& promiseObjectId,
+    const Maybe<bool>& returnByValue,
+    const Maybe<bool>& generatePreview,
+    std::unique_ptr<AwaitPromiseCallback> callback)
+{
+    ProtocolPromiseHandler::add(m_debugger, m_session->contextGroupId(), promiseObjectId, std::move(callback), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false));
+}
+
 void V8RuntimeAgentImpl::callFunctionOn(ErrorString* errorString,
     const String16& objectId,
     const String16& expression,
     const Maybe<protocol::Array<protocol::Runtime::CallArgument>>& optionalArguments,
     const Maybe<bool>& doNotPauseOnExceptionsAndMuteConsole,
     const Maybe<bool>& returnByValue,
     const Maybe<bool>& generatePreview,
     const Maybe<bool>& userGesture,
     std::unique_ptr<RemoteObject>* result,
     Maybe<bool>* wasThrown)
@@ skipping 288 matching lines @@
         reportMessage(message, true);
 }
 
 void V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message, bool generatePreview)
 {
     message->reportToFrontend(&m_frontend, m_session, generatePreview);
     m_frontend.flush();
 }
 
 } // namespace blink