[inspector] fix UAF in another part of console code

src/inspector/v8-console-message.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/inspector/v8-console-message.h"
 
 #include "src/inspector/inspected-context.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/string-util.h"
 #include "src/inspector/v8-console-agent-impl.h"
@@ skipping 211 matching lines @@
           .build();
   result->setLine(static_cast<int>(m_lineNumber));
   result->setColumn(static_cast<int>(m_columnNumber));
   result->setUrl(m_url);
   frontend->messageAdded(std::move(result));
 }
 
 std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>>
 V8ConsoleMessage::wrapArguments(V8InspectorSessionImpl* session,
                                 bool generatePreview) const {
-  if (!m_arguments.size() || !m_contextId) return nullptr;
+  V8InspectorImpl* inspector = session->inspector();
+  int contextGroupId = session->contextGroupId();
+  int contextId = m_contextId;
+  if (!m_arguments.size() || !contextId) return nullptr;
   InspectedContext* inspectedContext =
-      session->inspector()->getContext(session->contextGroupId(), m_contextId);
+      inspector->getContext(contextGroupId, contextId);
   if (!inspectedContext) return nullptr;
 
   v8::Isolate* isolate = inspectedContext->isolate();
   v8::HandleScope handles(isolate);
   v8::Local<v8::Context> context = inspectedContext->context();
 
   std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>> args =
       protocol::Array<protocol::Runtime::RemoteObject>::create();
   if (m_type == ConsoleAPIType::kTable && generatePreview) {
     v8::Local<v8::Value> table = m_arguments[0]->Get(isolate);
     v8::Local<v8::Value> columns = m_arguments.size() > 1
                                        ? m_arguments[1]->Get(isolate)
                                        : v8::Local<v8::Value>();
     std::unique_ptr<protocol::Runtime::RemoteObject> wrapped =
         session->wrapTable(context, table, columns);
+    inspectedContext = inspector->getContext(contextGroupId, contextId);
+    if (!inspectedContext) return nullptr;
     if (wrapped)
       args->addItem(std::move(wrapped));
     else
       args = nullptr;
   } else {
     for (size_t i = 0; i < m_arguments.size(); ++i) {
       std::unique_ptr<protocol::Runtime::RemoteObject> wrapped =
           session->wrapObject(context, m_arguments[i]->Get(isolate), "console",
                               generatePreview);
+      inspectedContext = inspector->getContext(contextGroupId, contextId);
+      if (!inspectedContext) return nullptr;
       if (!wrapped) {
         args = nullptr;
         break;
       }
       args->addItem(std::move(wrapped));
     }
   }
   return args;
 }
 
 void V8ConsoleMessage::reportToFrontend(protocol::Runtime::Frontend* frontend,
                                         V8InspectorSessionImpl* session,
                                         bool generatePreview) const {
+  int contextGroupId = session->contextGroupId();
+  V8InspectorImpl* inspector = session->inspector();
+
   if (m_origin == V8MessageOrigin::kException) {
     std::unique_ptr<protocol::Runtime::RemoteObject> exception =
         wrapException(session, generatePreview);
+    if (!inspector->hasConsoleMessageStorage(contextGroupId)) return;
     std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails =
         protocol::Runtime::ExceptionDetails::create()
             .setExceptionId(m_exceptionId)
             .setText(exception ? m_message : m_detailedMessage)
             .setLineNumber(m_lineNumber ? m_lineNumber - 1 : 0)
             .setColumnNumber(m_columnNumber ? m_columnNumber - 1 : 0)
             .build();
     if (m_scriptId)
       exceptionDetails->setScriptId(String16::fromInteger(m_scriptId));
     if (!m_url.isEmpty()) exceptionDetails->setUrl(m_url);
     if (m_stackTrace)
       exceptionDetails->setStackTrace(m_stackTrace->buildInspectorObjectImpl());
     if (m_contextId) exceptionDetails->setExecutionContextId(m_contextId);
     if (exception) exceptionDetails->setException(std::move(exception));
     frontend->exceptionThrown(m_timestamp, std::move(exceptionDetails));
     return;
   }
   if (m_origin == V8MessageOrigin::kRevokedException) {
     frontend->exceptionRevoked(m_message, m_revokedExceptionId);
     return;
   }
   if (m_origin == V8MessageOrigin::kConsole) {
     std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>>
         arguments = wrapArguments(session, generatePreview);
+    if (!inspector->hasConsoleMessageStorage(contextGroupId)) return;
     if (!arguments) {
       arguments = protocol::Array<protocol::Runtime::RemoteObject>::create();
       if (!m_message.isEmpty()) {
         std::unique_ptr<protocol::Runtime::RemoteObject> messageArg =
             protocol::Runtime::RemoteObject::create()
                 .setType(protocol::Runtime::RemoteObject::TypeEnum::String)
                 .build();
         messageArg->setValue(protocol::StringValue::create(m_message));
         arguments->addItem(std::move(messageArg));
       }
@@ skipping 155 matching lines @@
           m_inspector->sessionForContextGroup(m_contextGroupId))
     session->releaseObjectGroup("console");
 }
 
 void V8ConsoleMessageStorage::contextDestroyed(int contextId) {
   for (size_t i = 0; i < m_messages.size(); ++i)
     m_messages[i]->contextDestroyed(contextId);
 }
 
 }  // namespace v8_inspector