[DevTools] Add awaitPromise flag to Runtime.runScript

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 46 matching lines @@
     if (hasError)
         *errorString = "Internal error";
     return hasError;
 }
 
 namespace {
 
 template<typename Callback>
 class ProtocolPromiseHandler {
 public:
-    static void add(V8InspectorImpl* inspector, v8::Local<v8::Context> context, v8::Local<v8::Promise> promise, int contextGroupId, int executionContextId, const String16& objectGroup, bool returnByValue, bool generatePreview, std::unique_ptr<Callback> callback)
+    static void add(V8InspectorImpl* inspector, v8::Local<v8::Context> context, v8::MaybeLocal<v8::Value> value, const String16& notPromiseError, int contextGroupId, int executionContextId, const String16& objectGroup, bool returnByValue, bool generatePreview, std::unique_ptr<Callback> callback)
     {
+        if (value.IsEmpty()) {
+            callback->sendFailure("Internal error");
+            return;
+        }
+        if (!value.ToLocalChecked()->IsPromise()) {
+            callback->sendFailure(notPromiseError);
+            return;
+        }
+        v8::Local<v8::Promise> promise = v8::Local<v8::Promise>::Cast(value.ToLocalChecked());
         Callback* rawCallback = callback.get();
         ProtocolPromiseHandler<Callback>* handler = new ProtocolPromiseHandler(inspector, contextGroupId, executionContextId, objectGroup, returnByValue, generatePreview, std::move(callback));
         v8::Local<v8::Value> wrapper = handler->m_wrapper.Get(inspector->isolate());
 
         v8::Local<v8::Function> thenCallbackFunction = v8::Function::New(context, thenCallback, wrapper, 0, v8::ConstructorBehavior::kThrow).ToLocalChecked();
         if (promise->Then(context, thenCallbackFunction).IsEmpty()) {
             rawCallback->sendFailure("Internal error");
             return;
         }
         v8::Local<v8::Function> catchCallbackFunction = v8::Function::New(context, catchCallback, wrapper, 0, v8::ConstructorBehavior::kThrow).ToLocalChecked();
@@ skipping 99 matching lines @@
         &wasThrown,
         &exceptionDetails);
     if (errorString.isEmpty()) {
         callback->sendSuccess(std::move(result), wasThrown, exceptionDetails);
         return true;
     }
     callback->sendFailure(errorString);
     return false;
 }
 
+int ensureContext(ErrorString* errorString, V8InspectorImpl* inspector, int contextGroupId, const Maybe<int>& executionContextId)
+{
+    int contextId;
+    if (executionContextId.isJust()) {
+        contextId = executionContextId.fromJust();
+    } else {
+        v8::HandleScope handles(inspector->isolate());
+        v8::Local<v8::Context> defaultContext = inspector->client()->ensureDefaultContextInGroup(contextGroupId);
+        if (defaultContext.IsEmpty()) {
+            *errorString = "Cannot find default execution context";
+            return 0;
+        }
+        contextId = V8Debugger::contextId(defaultContext);
+    }
+    return contextId;
+}
+
 } // namespace
 
 V8RuntimeAgentImpl::V8RuntimeAgentImpl(V8InspectorSessionImpl* session, protocol::FrontendChannel* FrontendChannel, protocol::DictionaryValue* state)
     : m_session(session)
     , m_state(state)
     , m_frontend(FrontendChannel)
     , m_inspector(session->inspector())
     , m_enabled(false)
 {
 }
 
 V8RuntimeAgentImpl::~V8RuntimeAgentImpl()
 {
 }
 
 void V8RuntimeAgentImpl::evaluate(
     const String16& expression,
     const Maybe<String16>& objectGroup,
     const Maybe<bool>& includeCommandLineAPI,
     const Maybe<bool>& doNotPauseOnExceptionsAndMuteConsole,
     const Maybe<int>& executionContextId,
     const Maybe<bool>& returnByValue,
     const Maybe<bool>& generatePreview,
     const Maybe<bool>& userGesture,
     const Maybe<bool>& awaitPromise,
     std::unique_ptr<EvaluateCallback> callback)
 {
-    int contextId;
-    if (executionContextId.isJust()) {
-        contextId = executionContextId.fromJust();
-    } else {
-        v8::HandleScope handles(m_inspector->isolate());
-        v8::Local<v8::Context> defaultContext = m_inspector->client()->ensureDefaultContextInGroup(m_session->contextGroupId());
-        if (defaultContext.IsEmpty()) {
-            callback->sendFailure("Cannot find default execution context");
-            return;
-        }
-        contextId = V8Debugger::contextId(defaultContext);
+    ErrorString errorString;
+    int contextId = ensureContext(&errorString, m_inspector, m_session->contextGroupId(), executionContextId);
+    if (!errorString.isEmpty()) {
+        callback->sendFailure(errorString);
+        return;
     }
 
-    ErrorString errorString;
     InjectedScript::ContextScope scope(&errorString, m_inspector, m_session->contextGroupId(), contextId);
     if (!scope.initialize()) {
         callback->sendFailure(errorString);
         return;
     }
 
     if (doNotPauseOnExceptionsAndMuteConsole.fromMaybe(false))
         scope.ignoreExceptionsAndMuteConsole();
     if (userGesture.fromMaybe(false))
         scope.pretendUserGesture();
@@ skipping 19 matching lines @@
     // Re-initialize after running client's code, as it could have destroyed context or session.
     if (!scope.initialize()) {
         callback->sendFailure(errorString);
         return;
     }
 
     if (!awaitPromise.fromMaybe(false) || scope.tryCatch().HasCaught()) {
         wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue, scope.tryCatch(), objectGroup.fromMaybe(""), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false), callback.get());
         return;
     }
-
-    if (maybeResultValue.IsEmpty()) {
-        callback->sendFailure("Internal error");
-        return;
-    }
-
-    if (!maybeResultValue.ToLocalChecked()->IsPromise()) {
-        callback->sendFailure("Result of expression is not a promise.");
-        return;
-    }
-
     ProtocolPromiseHandler<EvaluateCallback>::add(
         m_inspector,
         scope.context(),
-        v8::Local<v8::Promise>::Cast(maybeResultValue.ToLocalChecked()),
+        maybeResultValue,
+        "Result of the evaluation is not a promise",
         m_session->contextGroupId(),
         scope.injectedScript()->context()->contextId(),
         objectGroup.fromMaybe(""),
         returnByValue.fromMaybe(false),
         generatePreview.fromMaybe(false),
         std::move(callback));
 }
 
 void V8RuntimeAgentImpl::awaitPromise(
     const String16& promiseObjectId,
     const Maybe<bool>& returnByValue,
     const Maybe<bool>& generatePreview,
     std::unique_ptr<AwaitPromiseCallback> callback)
 {
     ErrorString errorString;
     InjectedScript::ObjectScope scope(&errorString, m_inspector, m_session->contextGroupId(), promiseObjectId);
     if (!scope.initialize()) {
         callback->sendFailure(errorString);
         return;
     }
-    if (!scope.object()->IsPromise()) {
-        callback->sendFailure("Could not find promise with given id");
-        return;
-    }
     ProtocolPromiseHandler<AwaitPromiseCallback>::add(
         m_inspector,
         scope.context(),
-        v8::Local<v8::Promise>::Cast(scope.object()),
+        scope.object(),
+        "Could not find promise with given id",
         m_session->contextGroupId(),
         scope.injectedScript()->context()->contextId(),
         scope.objectGroupName(),
         returnByValue.fromMaybe(false),
         generatePreview.fromMaybe(false),
         std::move(callback));
 }
 
 void V8RuntimeAgentImpl::callFunctionOn(
     const String16& objectId,
@@ skipping 57 matching lines @@
     if (!scope.initialize()) {
         callback->sendFailure(errorString);
         return;
     }
 
     if (!awaitPromise.fromMaybe(false) || scope.tryCatch().HasCaught()) {
         wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue, scope.tryCatch(), scope.objectGroupName(), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false), callback.get());
         return;
     }
 
-    if (maybeResultValue.IsEmpty()) {
-        callback->sendFailure("Internal error");
-        return;
-    }
-
-    if (!maybeResultValue.ToLocalChecked()->IsPromise()) {
-        callback->sendFailure("Result of the function call is not a promise.");
-        return;
-    }
-
     ProtocolPromiseHandler<CallFunctionOnCallback>::add(
         m_inspector,
         scope.context(),
-        v8::Local<v8::Promise>::Cast(maybeResultValue.ToLocalChecked()),
+        maybeResultValue,
+        "Result of the function call is not a promise",
         m_session->contextGroupId(),
         scope.injectedScript()->context()->contextId(),
         scope.objectGroupName(),
         returnByValue.fromMaybe(false),
         generatePreview.fromMaybe(false),
         std::move(callback));
 }
 
 void V8RuntimeAgentImpl::getProperties(
     ErrorString* errorString,
@@ skipping 71 matching lines @@
 void V8RuntimeAgentImpl::discardConsoleEntries(ErrorString*)
 {
     V8ConsoleMessageStorage* storage = m_inspector->ensureConsoleMessageStorage(m_session->contextGroupId());
     storage->clear();
 }
 
 void V8RuntimeAgentImpl::compileScript(ErrorString* errorString,
     const String16& expression,
     const String16& sourceURL,
     bool persistScript,
-    int executionContextId,
+    const Maybe<int>& executionContextId,
     Maybe<String16>* scriptId,
     Maybe<ExceptionDetails>* exceptionDetails)
 {
     if (!m_enabled) {
         *errorString = "Runtime agent is not enabled";
         return;
     }
-    InjectedScript::ContextScope scope(errorString, m_inspector, m_session->contextGroupId(), executionContextId);
+    int contextId = ensureContext(errorString, m_inspector, m_session->contextGroupId(), executionContextId);
+    if (!errorString->isEmpty())
+        return;
+    InjectedScript::ContextScope scope(errorString, m_inspector, m_session->contextGroupId(), contextId);
     if (!scope.initialize())
         return;
 
     v8::Local<v8::Script> script = m_inspector->compileScript(scope.context(), toV8String(m_inspector->isolate(), expression), sourceURL, false);
     if (script.IsEmpty()) {
         v8::Local<v8::Message> message = scope.tryCatch().Message();
         if (!message.IsEmpty())
             *exceptionDetails = scope.injectedScript()->createExceptionDetails(message);
         else
             *errorString = "Script compilation failed";
         return;
     }
 
     if (!persistScript)
         return;
 
     String16 scriptValueId = String16::fromInteger(script->GetUnboundScript()->GetId());
     std::unique_ptr<v8::Global<v8::Script>> global(new v8::Global<v8::Script>(m_inspector->isolate(), script));
     m_compiledScripts[scriptValueId] = std::move(global);
     *scriptId = scriptValueId;
 }
 
-void V8RuntimeAgentImpl::runScript(ErrorString* errorString,
+void V8RuntimeAgentImpl::runScript(
     const String16& scriptId,
-    int executionContextId,
+    const Maybe<int>& executionContextId,
     const Maybe<String16>& objectGroup,
     const Maybe<bool>& doNotPauseOnExceptionsAndMuteConsole,
     const Maybe<bool>& includeCommandLineAPI,
-    std::unique_ptr<RemoteObject>* result,
-    Maybe<ExceptionDetails>* exceptionDetails)
+    const Maybe<bool>& returnByValue,
+    const Maybe<bool>& generatePreview,
+    const Maybe<bool>& awaitPromise,
+    std::unique_ptr<RunScriptCallback> callback)
 {
     if (!m_enabled) {
-        *errorString = "Runtime agent is not enabled";
+        callback->sendFailure("Runtime agent is not enabled");
         return;
     }
 
     auto it = m_compiledScripts.find(scriptId);
     if (it == m_compiledScripts.end()) {
-        *errorString = "Script execution failed";
+        callback->sendFailure("No script with given id");
         return;
     }
 
-    InjectedScript::ContextScope scope(errorString, m_inspector, m_session->contextGroupId(), executionContextId);
-    if (!scope.initialize())
+    ErrorString errorString;
+    int contextId = ensureContext(&errorString, m_inspector, m_session->contextGroupId(), executionContextId);
+    if (!errorString.isEmpty()) {
+        callback->sendFailure(errorString);
         return;
+    }
+
+    InjectedScript::ContextScope scope(&errorString, m_inspector, m_session->contextGroupId(), contextId);
+    if (!scope.initialize()) {
+        callback->sendFailure(errorString);
+        return;
+    }
 
     if (doNotPauseOnExceptionsAndMuteConsole.fromMaybe(false))
         scope.ignoreExceptionsAndMuteConsole();
 
     std::unique_ptr<v8::Global<v8::Script>> scriptWrapper = std::move(it->second);
     m_compiledScripts.erase(it);
     v8::Local<v8::Script> script = scriptWrapper->Get(m_inspector->isolate());
     if (script.IsEmpty()) {
-        *errorString = "Script execution failed";
+        callback->sendFailure("Script execution failed");
         return;
     }
 
     if (includeCommandLineAPI.fromMaybe(false) && !scope.installCommandLineAPI())
         return;
 
     v8::MaybeLocal<v8::Value> maybeResultValue = m_inspector->runCompiledScript(scope.context(), script);
 
     // Re-initialize after running client's code, as it could have destroyed context or session.
     if (!scope.initialize())
         return;
-    scope.injectedScript()->wrapEvaluateResult(errorString, maybeResultValue, scope.tryCatch(), objectGroup.fromMaybe(""), false, false, result, nullptr, exceptionDetails);
+
+    if (!awaitPromise.fromMaybe(false) || scope.tryCatch().HasCaught()) {
+        wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue, scope.tryCatch(), objectGroup.fromMaybe(""), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false), callback.get());
+        return;
+    }
+    ProtocolPromiseHandler<RunScriptCallback>::add(
+        m_inspector,
+        scope.context(),
+        maybeResultValue.ToLocalChecked(),
+        "Result of the script execution is not a promise",
+        m_session->contextGroupId(),
+        scope.injectedScript()->context()->contextId(),
+        objectGroup.fromMaybe(""),
+        returnByValue.fromMaybe(false),
+        generatePreview.fromMaybe(false),
+        std::move(callback));
 }
 
 void V8RuntimeAgentImpl::restore()
 {
     if (!m_state->booleanProperty(V8RuntimeAgentImplState::runtimeEnabled, false))
         return;
     m_frontend.executionContextsCleared();
     ErrorString error;
     enable(&error);
     if (m_state->booleanProperty(V8RuntimeAgentImplState::customObjectFormatterEnabled, false))
@@ skipping 72 matching lines @@
         reportMessage(message, true);
 }
 
 void V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message, bool generatePreview)
 {
     message->reportToFrontend(&m_frontend, m_session, generatePreview);
     m_frontend.flush();
 }
 
 } // namespace blink