[DevTools] Removed wasThrown from evaluate-like 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 80 matching lines @@
             rawCallback->sendFailure("Internal error");
             return;
         }
     }
 private:
     static void thenCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
     {
         ProtocolPromiseHandler<Callback>* handler = static_cast<ProtocolPromiseHandler<Callback>*>(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>());
+        handler->m_callback->sendSuccess(handler->wrapObject(value), Maybe<protocol::Runtime::ExceptionDetails>());
     }
 
     static void catchCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
     {
         ProtocolPromiseHandler<Callback>* handler = static_cast<ProtocolPromiseHandler<Callback>*>(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_inspector->debugger()->captureStackTrace(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));
+        handler->m_callback->sendSuccess(handler->wrapObject(value), std::move(exceptionDetails));
     }
 
     ProtocolPromiseHandler(V8InspectorImpl* inspector, int contextGroupId, int executionContextId, const String16& objectGroup, bool returnByValue, bool generatePreview, std::unique_ptr<Callback> callback)
         : m_inspector(inspector)
         , m_contextGroupId(contextGroupId)
         , m_executionContextId(executionContextId)
         , m_objectGroup(objectGroup)
         , m_returnByValue(returnByValue)
         , m_generatePreview(generatePreview)
         , m_callback(std::move(callback))
@@ skipping 36 matching lines @@
     bool m_returnByValue;
     bool m_generatePreview;
     std::unique_ptr<Callback> m_callback;
     v8::Global<v8::External> m_wrapper;
 };
 
 template<typename Callback>
 bool wrapEvaluateResultAsync(InjectedScript* injectedScript, v8::MaybeLocal<v8::Value> maybeResultValue, const v8::TryCatch& tryCatch, const String16& objectGroup, bool returnByValue, bool generatePreview, Callback* callback)
 {
     std::unique_ptr<RemoteObject> result;
-    Maybe<bool> wasThrown;
     Maybe<protocol::Runtime::ExceptionDetails> exceptionDetails;
 
     ErrorString errorString;
     injectedScript->wrapEvaluateResult(&errorString,
         maybeResultValue,
         tryCatch,
         objectGroup,
         returnByValue,
         generatePreview,
         &result,
-        &wasThrown,
         &exceptionDetails);
     if (errorString.isEmpty()) {
-        callback->sendSuccess(std::move(result), wasThrown, exceptionDetails);
+        callback->sendSuccess(std::move(result), 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()) {
@@ skipping 479 matching lines @@
         reportMessage(message, true);
 }
 
 void V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message, bool generatePreview)
 {
     message->reportToFrontend(&m_frontend, m_session, generatePreview);
     m_frontend.flush();
 }
 
 } // namespace blink