[DevTools] Rename V8Debugger to V8Inspector.

third_party/WebKit/Source/platform/v8_inspector/V8StackTraceImpl.cpp

 // Copyright 2016 The Chromium 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 "platform/v8_inspector/V8StackTraceImpl.h"
 
 #include "platform/inspector_protocol/Platform.h"
 #include "platform/inspector_protocol/String16.h"
-#include "platform/v8_inspector/V8DebuggerImpl.h"
+#include "platform/v8_inspector/V8InspectorImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 
 #include <v8-debug.h>
 #include <v8-profiler.h>
 #include <v8-version.h>
 
 namespace blink {
 
 namespace {
 
@@ skipping 78 matching lines @@
     return Frame(m_functionName.isolatedCopy(), m_scriptId.isolatedCopy(), m_scriptName.isolatedCopy(), m_lineNumber, m_columnNumber);
 }
 
 // static
 void V8StackTraceImpl::setCaptureStackTraceForUncaughtExceptions(v8::Isolate* isolate, bool capture)
 {
     isolate->SetCaptureStackTraceForUncaughtExceptions(capture, V8StackTraceImpl::maxCallStackSizeToCapture, stackTraceOptions);
 }
 
 // static
-std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::create(V8DebuggerImpl* debugger, int contextGroupId, v8::Local<v8::StackTrace> stackTrace, size_t maxStackSize, const String16& description)
+std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::create(V8InspectorImpl* inspector, int contextGroupId, v8::Local<v8::StackTrace> stackTrace, size_t maxStackSize, const String16& description)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope scope(isolate);
     std::vector<V8StackTraceImpl::Frame> frames;
     if (!stackTrace.IsEmpty())
         toFramesVector(stackTrace, frames, maxStackSize, isolate);
 
     int maxAsyncCallChainDepth = 1;
     V8StackTraceImpl* asyncCallChain = nullptr;
-    if (debugger && maxStackSize > 1) {
-        asyncCallChain = debugger->currentAsyncCallChain();
-        maxAsyncCallChainDepth = debugger->maxAsyncCallChainDepth();
+    if (inspector && maxStackSize > 1) {
+        asyncCallChain = inspector->currentAsyncCallChain();
+        maxAsyncCallChainDepth = inspector->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;
         maxAsyncCallChainDepth = 1;
     }
 
     // Only the top stack in the chain may be empty, so ensure that second stack is non-empty (it's the top of appended chain).
     if (asyncCallChain && asyncCallChain->isEmpty())
         asyncCallChain = asyncCallChain->m_parent.get();
 
     if (stackTrace.IsEmpty() && !asyncCallChain)
         return nullptr;
 
     std::unique_ptr<V8StackTraceImpl> result(new V8StackTraceImpl(contextGroupId, description, frames, asyncCallChain ? asyncCallChain->cloneImpl() : nullptr));
 
     // Crop to not exceed maxAsyncCallChainDepth.
     V8StackTraceImpl* deepest = result.get();
     while (deepest && maxAsyncCallChainDepth) {
         deepest = deepest->m_parent.get();
         maxAsyncCallChainDepth--;
     }
     if (deepest)
         deepest->m_parent.reset();
 
     return result;
 }
 
-std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::capture(V8DebuggerImpl* debugger, int contextGroupId, size_t maxStackSize, const String16& description)
+std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::capture(V8InspectorImpl* inspector, int contextGroupId, size_t maxStackSize, const String16& description)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope handleScope(isolate);
     v8::Local<v8::StackTrace> stackTrace;
     if (isolate->InContext()) {
 #if V8_MAJOR_VERSION >= 5
         isolate->GetCpuProfiler()->CollectSample();
 #endif
         stackTrace = v8::StackTrace::CurrentStackTrace(isolate, maxStackSize, stackTraceOptions);
     }
-    return V8StackTraceImpl::create(debugger, contextGroupId, stackTrace, maxStackSize, description);
+    return V8StackTraceImpl::create(inspector, contextGroupId, stackTrace, maxStackSize, description);
 }
 
 std::unique_ptr<V8StackTrace> V8StackTraceImpl::clone()
 {
     return cloneImpl();
 }
 
 std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::cloneImpl()
 {
     std::vector<Frame> framesCopy(m_frames);
@@ skipping 63 matching lines @@
 
     std::unique_ptr<protocol::Runtime::StackTrace> stackTrace = protocol::Runtime::StackTrace::create()
         .setCallFrames(std::move(frames)).build();
     if (!m_description.isEmpty())
         stackTrace->setDescription(m_description);
     if (m_parent)
         stackTrace->setParent(m_parent->buildInspectorObjectImpl());
     return stackTrace;
 }
 
-std::unique_ptr<protocol::Runtime::StackTrace> V8StackTraceImpl::buildInspectorObjectForTail(V8DebuggerImpl* debugger) const
+std::unique_ptr<protocol::Runtime::StackTrace> V8StackTraceImpl::buildInspectorObjectForTail(V8InspectorImpl* inspector) const
 {
     v8::HandleScope handleScope(v8::Isolate::GetCurrent());
     // 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);
+    std::unique_ptr<V8StackTraceImpl> fullChain = V8StackTraceImpl::create(inspector, 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> V8StackTraceImpl::buildInspectorObject() const
 {
     return buildInspectorObjectImpl();
 }
 
 String16 V8StackTraceImpl::toString() const
 {
     String16Builder stackTrace;
     for (size_t i = 0; i < m_frames.size(); ++i) {
         const Frame& frame = m_frames[i];
         stackTrace.append("\n    at " + (frame.functionName().length() ? frame.functionName() : "(anonymous function)"));
         stackTrace.append(" (");
         stackTrace.append(frame.sourceURL());
         stackTrace.append(':');
         stackTrace.appendNumber(frame.lineNumber());
         stackTrace.append(':');
         stackTrace.appendNumber(frame.columnNumber());
         stackTrace.append(')');
     }
     return stackTrace.toString();
 }
 
 } // namespace blink