[inspector] AsyncStackTrace should always have non-zero context group id

src/inspector/v8-stack-trace-impl.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-stack-trace-impl.h"
 
 #include <algorithm>
 
 #include "src/inspector/v8-debugger.h"
 #include "src/inspector/wasm-translation.h"
@@ skipping 30 matching lines @@
   *asyncParent = debugger->currentAsyncParent();
   *asyncCreation = debugger->currentAsyncCreation();
   if (maxAsyncDepth) *maxAsyncDepth = debugger->maxAsyncCallChainDepth();
 
   DCHECK(!*asyncParent || !*asyncCreation ||
          (*asyncParent)->contextGroupId() ==
              (*asyncCreation)->contextGroupId());
   // Do not accidentally append async call chain from another group. This should
   // not happen if we have proper instrumentation, but let's double-check to be
   // safe.
-  if (contextGroupId && *asyncParent && (*asyncParent)->contextGroupId() &&
+  if (contextGroupId && *asyncParent &&
       (*asyncParent)->contextGroupId() != contextGroupId) {
     asyncParent->reset();
     asyncCreation->reset();
     if (maxAsyncDepth) *maxAsyncDepth = 0;
     return;
   }
 
   // Only the top stack in the chain may be empty and doesn't contain creation
   // stack, so ensure that second stack is non-empty (it's the top of appended
   // chain).
@@ skipping 205 matching lines @@
 
   // When async call chain is empty but doesn't contain useful schedule stack
   // and parent async call chain contains creationg stack but doesn't
   // synchronous we can merge them together.
   // e.g. Promise ThenableJob.
   if (asyncParent && frames.empty() &&
       asyncParent->m_description == description && !asyncCreation) {
     return asyncParent;
   }
 
+  DCHECK(contextGroupId || asyncParent);
+  if (!contextGroupId && asyncParent) {
+    contextGroupId = asyncParent->m_contextGroupId;
+  }
   return std::shared_ptr<AsyncStackTrace>(new AsyncStackTrace(
       contextGroupId, description, frames, asyncParent, asyncCreation));
 }
 
 AsyncStackTrace::AsyncStackTrace(
     int contextGroupId, const String16& description,
     const std::vector<V8StackTraceImpl::Frame>& frames,
     std::shared_ptr<AsyncStackTrace> asyncParent,
     std::shared_ptr<AsyncStackTrace> asyncCreation)
     : m_contextGroupId(contextGroupId),
       m_description(description),
       m_frames(frames),
       m_asyncParent(asyncParent),
-      m_asyncCreation(asyncCreation) {}
+      m_asyncCreation(asyncCreation) {
+  DCHECK(m_contextGroupId);
+}
 
 std::unique_ptr<protocol::Runtime::StackTrace>
 AsyncStackTrace::buildInspectorObject(AsyncStackTrace* asyncCreation,
                                       int maxAsyncDepth) const {
   std::unique_ptr<protocol::Runtime::StackTrace> stackTrace =
       buildInspectorObjectCommon(m_frames, m_asyncParent.lock(),
                                  m_asyncCreation.lock(), maxAsyncDepth);
   if (!m_description.isEmpty()) stackTrace->setDescription(m_description);
   if (asyncCreation && !asyncCreation->isEmpty()) {
     stackTrace->setPromiseCreationFrame(
         asyncCreation->m_frames[0].buildInspectorObject());
   }
   return stackTrace;
 }
 
 int AsyncStackTrace::contextGroupId() const { return m_contextGroupId; }
 
 std::weak_ptr<AsyncStackTrace> AsyncStackTrace::parent() const {
   return m_asyncParent;
 }
 
 std::weak_ptr<AsyncStackTrace> AsyncStackTrace::creation() const {
   return m_asyncCreation;
 }
 
 bool AsyncStackTrace::isEmpty() const { return m_frames.empty(); }
 
 }  // namespace v8_inspector