[inspector] fix crash in wrapping result for async Runtime.evaluate

src/inspector/v8-runtime-agent-impl.cc

 /*
  * 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 98 matching lines @@
  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()));
+    std::unique_ptr<protocol::Runtime::RemoteObject> wrappedValue(
+        handler->wrapObject(value));
+    if (!wrappedValue) return;
     handler->m_callback->sendSuccess(
-        handler->wrapObject(value),
-        Maybe<protocol::Runtime::ExceptionDetails>());
+        std::move(wrappedValue), 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::RemoteObject> wrappedValue(
+        handler->wrapObject(value));
+    if (!wrappedValue) return;
+
     std::unique_ptr<V8StackTraceImpl> stack =
         handler->m_inspector->debugger()->captureStackTrace(true);
     std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails =
         protocol::Runtime::ExceptionDetails::create()
             .setExceptionId(handler->m_inspector->nextExceptionId())
             .setText("Uncaught (in promise)")
             .setLineNumber(stack && !stack->isEmpty() ? stack->topLineNumber()
                                                       : 0)
             .setColumnNumber(
                 stack && !stack->isEmpty() ? stack->topColumnNumber() : 0)
-            .setException(handler->wrapObject(value))
+            .setException(wrappedValue->clone())
             .build();
     if (stack)
       exceptionDetails->setStackTrace(stack->buildInspectorObjectImpl());
     if (stack && !stack->isEmpty())
       exceptionDetails->setScriptId(toString16(stack->topScriptId()));
-    handler->m_callback->sendSuccess(handler->wrapObject(value),
+    handler->m_callback->sendSuccess(std::move(wrappedValue),
                                      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),
@@ skipping 562 matching lines @@
 }
 
 bool V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message,
                                        bool generatePreview) {
   message->reportToFrontend(&m_frontend, m_session, generatePreview);
   m_frontend.flush();
   return m_inspector->hasConsoleMessageStorage(m_session->contextGroupId());
 }
 
 }  // namespace v8_inspector