[inspector] don't use v8::Isolate::GetCurrent in V8StackTraceImpl

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 "src/inspector/string-util.h"
 #include "src/inspector/v8-debugger-agent-impl.h"
 #include "src/inspector/v8-debugger.h"
 #include "src/inspector/v8-inspector-impl.h"
@@ skipping 22 matching lines @@
 
   String16 functionName;
   v8::Local<v8::String> functionNameValue(frame->GetFunctionName());
   if (!functionNameValue.IsEmpty())
     functionName = toProtocolString(functionNameValue);
 
   int sourceLineNumber = frame->GetLineNumber() - 1;
   int sourceColumn = frame->GetColumn() - 1;
   // TODO(clemensh): Figure out a way to do this translation only right before
   // sending the stack trace over wire.
-  if (wasmTranslation)
-    wasmTranslation->TranslateWasmScriptLocationToProtocolLocation(
-        &scriptId, &sourceLineNumber, &sourceColumn);
+  wasmTranslation->TranslateWasmScriptLocationToProtocolLocation(
+      &scriptId, &sourceLineNumber, &sourceColumn);
   return V8StackTraceImpl::Frame(functionName, scriptId, sourceName,
                                  sourceLineNumber + 1, sourceColumn + 1);
 }
 
 void toFramesVector(v8::Local<v8::StackTrace> stackTrace,
                     std::vector<V8StackTraceImpl::Frame>& frames,
                     size_t maxStackSize, v8::Isolate* isolate,
                     V8Debugger* debugger, int contextGroupId) {
   DCHECK(isolate->InContext());
   int frameCount = stackTrace->GetFrameCount();
   if (frameCount > static_cast<int>(maxStackSize))
     frameCount = static_cast<int>(maxStackSize);
-  WasmTranslation* wasmTranslation =
-      debugger ? debugger->wasmTranslation() : nullptr;
+  WasmTranslation* wasmTranslation = debugger->wasmTranslation();
   for (int i = 0; i < frameCount; i++) {
     v8::Local<v8::StackFrame> stackFrame = stackTrace->GetFrame(i);
     frames.push_back(toFrame(stackFrame, wasmTranslation, contextGroupId));
   }
 }
 
 }  //  namespace
 
 V8StackTraceImpl::Frame::Frame()
     : m_functionName("undefined"),
@@ skipping 41 matching lines @@
     v8::Isolate* isolate, bool capture) {
   isolate->SetCaptureStackTraceForUncaughtExceptions(
       capture, V8StackTraceImpl::maxCallStackSizeToCapture, stackTraceOptions);
 }
 
 // static
 std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::create(
     V8Debugger* debugger, int contextGroupId,
     v8::Local<v8::StackTrace> stackTrace, size_t maxStackSize,
     const String16& description) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  DCHECK(debugger);
+  v8::Isolate* isolate = debugger->inspector()->isolate();
   v8::HandleScope scope(isolate);
   std::vector<V8StackTraceImpl::Frame> frames;
   if (!stackTrace.IsEmpty())
     toFramesVector(stackTrace, frames, maxStackSize, isolate, debugger,
                    contextGroupId);
 
   int maxAsyncCallChainDepth = 1;
   V8StackTraceImpl* asyncCallChain = nullptr;
-  if (debugger && maxStackSize > 1) {
+  if (maxStackSize > 1) {
     asyncCallChain = debugger->currentAsyncCallChain();
     maxAsyncCallChainDepth = debugger->maxAsyncCallChainDepth();
   }
   // 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 && asyncCallChain && asyncCallChain->m_contextGroupId &&
       asyncCallChain->m_contextGroupId != contextGroupId) {
     asyncCallChain = nullptr;
@@ skipping 22 matching lines @@
   }
   if (deepest) deepest->m_parent.reset();
 
   return result;
 }
 
 // static
 std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::capture(
     V8Debugger* debugger, int contextGroupId, size_t maxStackSize,
     const String16& description) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  DCHECK(debugger);
+  v8::Isolate* isolate = debugger->inspector()->isolate();
   v8::HandleScope handleScope(isolate);
   v8::Local<v8::StackTrace> stackTrace;
   if (isolate->InContext()) {
     stackTrace = v8::StackTrace::CurrentStackTrace(
         isolate, static_cast<int>(maxStackSize), stackTraceOptions);
   }
   return V8StackTraceImpl::create(debugger, contextGroupId, stackTrace,
                                   maxStackSize, description);
 }
 
@@ skipping 79 matching lines @@
   if (m_parent) stackTrace->setParent(m_parent->buildInspectorObjectImpl());
   if (m_creation && m_creation->m_frames.size()) {
     stackTrace->setPromiseCreationFrame(
         m_creation->m_frames[0].buildInspectorObject());
   }
   return stackTrace;
 }
 
 std::unique_ptr<protocol::Runtime::StackTrace>
 V8StackTraceImpl::buildInspectorObjectForTail(V8Debugger* debugger) const {
-  v8::HandleScope handleScope(v8::Isolate::GetCurrent());
+  DCHECK(debugger);
+  v8::HandleScope handleScope(debugger->inspector()->isolate());
   // Next call collapses possible empty stack and ensures
   // maxAsyncCallChainDepth.
   std::unique_ptr<V8StackTraceImpl> fullChain = V8StackTraceImpl::create(
       debugger, m_contextGroupId, v8::Local<v8::StackTrace>(),
       V8StackTraceImpl::maxCallStackSizeToCapture);
   if (!fullChain || !fullChain->m_parent) return nullptr;
   return fullChain->m_parent->buildInspectorObjectImpl();
 }
 
 std::unique_ptr<protocol::Runtime::API::StackTrace>
@@ skipping 14 matching lines @@
     stackTrace.append(String16::fromInteger(frame.lineNumber()));
     stackTrace.append(':');
     stackTrace.append(String16::fromInteger(frame.columnNumber()));
     stackTrace.append(')');
   }
   String16 string = stackTrace.toString();
   return StringBufferImpl::adopt(string);
 }
 
 }  // namespace v8_inspector