[inspector] handle context destroyed after console.log

src/inspector/V8ConsoleMessage.cpp

 // 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/V8ConsoleMessage.h"
 
 #include "src/inspector/InspectedContext.h"
 #include "src/inspector/StringUtil.h"
 #include "src/inspector/V8ConsoleAgentImpl.h"
 #include "src/inspector/V8InspectorImpl.h"
@@ skipping 319 matching lines @@
 
 V8MessageOrigin V8ConsoleMessage::origin() const { return m_origin; }
 
 ConsoleAPIType V8ConsoleMessage::type() const { return m_type; }
 
 // static
 std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForConsoleAPI(
     double timestamp, ConsoleAPIType type,
     const std::vector<v8::Local<v8::Value>>& arguments,
     std::unique_ptr<V8StackTraceImpl> stackTrace, InspectedContext* context) {
+  v8::Isolate* isolate = context->isolate();
+  int contextId = context->contextId();
+  int contextGroupId = context->contextGroupId();
+  V8InspectorImpl* inspector = context->inspector();
+
   std::unique_ptr<V8ConsoleMessage> message = wrapUnique(
       new V8ConsoleMessage(V8MessageOrigin::kConsole, timestamp, String16()));
   if (stackTrace && !stackTrace->isEmpty()) {
     message->m_url = toString16(stackTrace->topSourceURL());
     message->m_lineNumber = stackTrace->topLineNumber();
     message->m_columnNumber = stackTrace->topColumnNumber();
   }
   message->m_stackTrace = std::move(stackTrace);
   message->m_type = type;
-  message->m_contextId = context->contextId();
+  message->m_contextId = contextId;
   for (size_t i = 0; i < arguments.size(); ++i)
-    message->m_arguments.push_back(wrapUnique(
-        new v8::Global<v8::Value>(context->isolate(), arguments.at(i))));
+    message->m_arguments.push_back(
+        wrapUnique(new v8::Global<v8::Value>(isolate, arguments.at(i))));
   if (arguments.size())
-    message->m_message =
-        V8ValueStringBuilder::toString(arguments[0], context->isolate());
+    message->m_message = V8ValueStringBuilder::toString(arguments[0], isolate);
 
   V8ConsoleAPIType clientType = V8ConsoleAPIType::kLog;
   if (type == ConsoleAPIType::kDebug || type == ConsoleAPIType::kCount ||
       type == ConsoleAPIType::kTimeEnd)
     clientType = V8ConsoleAPIType::kDebug;
   else if (type == ConsoleAPIType::kError || type == ConsoleAPIType::kAssert)
     clientType = V8ConsoleAPIType::kError;
   else if (type == ConsoleAPIType::kWarning)
     clientType = V8ConsoleAPIType::kWarning;
   else if (type == ConsoleAPIType::kInfo)
     clientType = V8ConsoleAPIType::kInfo;
   else if (type == ConsoleAPIType::kClear)
     clientType = V8ConsoleAPIType::kClear;
-  context->inspector()->client()->consoleAPIMessage(
-      context->contextGroupId(), clientType, toStringView(message->m_message),
+  inspector->client()->consoleAPIMessage(
+      contextGroupId, clientType, toStringView(message->m_message),
       toStringView(message->m_url), message->m_lineNumber,
       message->m_columnNumber, message->m_stackTrace.get());
 
   return message;
 }
 
 // static
 std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForException(
     double timestamp, const String16& detailedMessage, const String16& url,
     unsigned lineNumber, unsigned columnNumber,
@@ skipping 37 matching lines @@
 V8ConsoleMessageStorage::V8ConsoleMessageStorage(V8InspectorImpl* inspector,
                                                  int contextGroupId)
     : m_inspector(inspector),
       m_contextGroupId(contextGroupId),
       m_expiredCount(0) {}
 
 V8ConsoleMessageStorage::~V8ConsoleMessageStorage() { clear(); }
 
 void V8ConsoleMessageStorage::addMessage(
     std::unique_ptr<V8ConsoleMessage> message) {
+  int contextGroupId = m_contextGroupId;
+  V8InspectorImpl* inspector = m_inspector;
   if (message->type() == ConsoleAPIType::kClear) clear();
 
   V8InspectorSessionImpl* session =
-      m_inspector->sessionForContextGroup(m_contextGroupId);
+      inspector->sessionForContextGroup(contextGroupId);
   if (session) {
     if (message->origin() == V8MessageOrigin::kConsole)
       session->consoleAgent()->messageAdded(message.get());
     session->runtimeAgent()->messageAdded(message.get());
   }
+  if (!inspector->hasConsoleMessageStorage(contextGroupId)) return;
 
   DCHECK(m_messages.size() <= maxConsoleMessageCount);
   if (m_messages.size() == maxConsoleMessageCount) {
     ++m_expiredCount;
     m_messages.pop_front();
   }
   m_messages.push_back(std::move(message));
 }
 
 void V8ConsoleMessageStorage::clear() {
   m_messages.clear();
   m_expiredCount = 0;
   if (V8InspectorSessionImpl* session =
           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