[DevTools] Dont pass errorString to async protocol methods

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 168 matching lines @@
     , m_inspector(session->inspector())
     , m_enabled(false)
 {
 }
 
 V8RuntimeAgentImpl::~V8RuntimeAgentImpl()
 {
 }
 
 void V8RuntimeAgentImpl::evaluate(
-    ErrorString* errorString,
     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 = V8InspectorImpl::contextId(defaultContext);
     }
 
-    InjectedScript::ContextScope scope(errorString, m_inspector, m_session->contextGroupId(), contextId);
+    ErrorString errorString;
+    InjectedScript::ContextScope scope(&errorString, m_inspector, m_session->contextGroupId(), contextId);
     if (!scope.initialize()) {
-        callback->sendFailure(*errorString);
+        callback->sendFailure(errorString);
         return;
     }
 
     if (doNotPauseOnExceptionsAndMuteConsole.fromMaybe(false))
         scope.ignoreExceptionsAndMuteConsole();
     if (userGesture.fromMaybe(false))
         scope.pretendUserGesture();
 
     if (includeCommandLineAPI.fromMaybe(false) && !scope.installCommandLineAPI()) {
-        callback->sendFailure(*errorString);
+        callback->sendFailure(errorString);
         return;
     }
 
     bool evalIsDisabled = !scope.context()->IsCodeGenerationFromStringsAllowed();
     // Temporarily enable allow evals for inspector.
     if (evalIsDisabled)
         scope.context()->AllowCodeGenerationFromStrings(true);
 
     v8::MaybeLocal<v8::Value> maybeResultValue;
     v8::Local<v8::Script> script = m_inspector->compileScript(scope.context(), toV8String(m_inspector->isolate(), expression), String16(), false);
     if (!script.IsEmpty())
         maybeResultValue = m_inspector->runCompiledScript(scope.context(), script);
 
     if (evalIsDisabled)
         scope.context()->AllowCodeGenerationFromStrings(false);
 
     // Re-initialize after running client's code, as it could have destroyed context or session.
     if (!scope.initialize()) {
-        callback->sendFailure(*errorString);
+        callback->sendFailure(errorString);
         return;
     }
 
     std::unique_ptr<RemoteObject> result;
     Maybe<bool> wasThrown;
     Maybe<protocol::Runtime::ExceptionDetails> exceptionDetails;
 
-    scope.injectedScript()->wrapEvaluateResult(errorString,
+    scope.injectedScript()->wrapEvaluateResult(&errorString,
         maybeResultValue,
         scope.tryCatch(),
         objectGroup.fromMaybe(""),
         returnByValue.fromMaybe(false) && !awaitPromise.fromMaybe(false),
         generatePreview.fromMaybe(false) && !awaitPromise.fromMaybe(false),
         &result,
         &wasThrown,
         &exceptionDetails);
-    if (!errorString->isEmpty()) {
-        callback->sendFailure(*errorString);
+    if (!errorString.isEmpty()) {
+        callback->sendFailure(errorString);
         return;
     }
 
     if (!awaitPromise.fromMaybe(false) || wasThrown.fromMaybe(false)) {
         callback->sendSuccess(std::move(result), wasThrown, exceptionDetails);
         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, m_session->contextGroupId(), result->getObjectId(String16()), std::move(callback), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false));
 }
 
-void V8RuntimeAgentImpl::awaitPromise(ErrorString* errorString,
+void V8RuntimeAgentImpl::awaitPromise(
     const String16& promiseObjectId,
     const Maybe<bool>& returnByValue,
     const Maybe<bool>& generatePreview,
     std::unique_ptr<AwaitPromiseCallback> callback)
 {
     ProtocolPromiseHandler<AwaitPromiseCallback>::add(m_inspector, m_session->contextGroupId(), promiseObjectId, std::move(callback), returnByValue.fromMaybe(false), generatePreview.fromMaybe(false));
 }
 
 void V8RuntimeAgentImpl::callFunctionOn(ErrorString* errorString,
     const String16& objectId,
@@ skipping 296 matching lines @@
         reportMessage(message, true);
 }
 
 void V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message, bool generatePreview)
 {
     message->reportToFrontend(&m_frontend, m_session, generatePreview);
     m_frontend.flush();
 }
 
 } // namespace blink