chromium/out/Default/gen/v8/src/inspector/protocol/Debugger.cpp

// This file is generated by TypeBuilder_cpp.template.

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/inspector/protocol/Debugger.h"

#include "src/inspector/protocol/Protocol.h"

#include "v8//third_party/inspector_protocol/crdtp/cbor.h"
#include "v8//third_party/inspector_protocol/crdtp/find_by_first.h"
#include "v8//third_party/inspector_protocol/crdtp/span.h"

namespace v8_inspector {
namespace protocol {
namespace Debugger {

DeserializerState;
ProtocolTypeTraits;

// ------------- Enum values from types.

const char Metainfo::domainName[] = …;
const char Metainfo::commandPrefix[] = …;
const char Metainfo::version[] = …;



V8_CRDTP_BEGIN_DESERIALIZER(…)

V8_CRDTP_BEGIN_SERIALIZER(…);


V8_CRDTP_BEGIN_DESERIALIZER(…)

V8_CRDTP_BEGIN_SERIALIZER(…);


V8_CRDTP_BEGIN_DESERIALIZER(…)

V8_CRDTP_BEGIN_SERIALIZER(…);


V8_CRDTP_BEGIN_DESERIALIZER(…)

V8_CRDTP_BEGIN_SERIALIZER(…);



const char* Scope::TypeEnum::Global = …;
const char* Scope::TypeEnum::Local = …;
const char* Scope::TypeEnum::With = …;
const char* Scope::TypeEnum::Closure = …;
const char* Scope::TypeEnum::Catch = …;
const char* Scope::TypeEnum::Block = …;
const char* Scope::TypeEnum::Script = …;
const char* Scope::TypeEnum::Eval = …;
const char* Scope::TypeEnum::Module = …;
const char* Scope::TypeEnum::WasmExpressionStack = …;
V8_CRDTP_BEGIN_DESERIALIZER(…)

V8_CRDTP_BEGIN_SERIALIZER(…);


V8_CRDTP_BEGIN_DESERIALIZER(…)

V8_CRDTP_BEGIN_SERIALIZER(…);

// static
std::unique_ptr<API::SearchMatch> API::SearchMatch::fromBinary(const uint8_t* data, size_t length)
{ … }


const char* BreakLocation::TypeEnum::DebuggerStatement = …;
const char* BreakLocation::TypeEnum::Call = …;
const char* BreakLocation::TypeEnum::Return = …;
V8_CRDTP_BEGIN_DESERIALIZER(…)

V8_CRDTP_BEGIN_SERIALIZER(…);


V8_CRDTP_BEGIN_DESERIALIZER(…)

V8_CRDTP_BEGIN_SERIALIZER(…);


namespace ScriptLanguageEnum {
const char JavaScript[] = …;
const char WebAssembly[] = …;
} // namespace ScriptLanguageEnum



const char* DebugSymbols::TypeEnum::None = …;
const char* DebugSymbols::TypeEnum::SourceMap = …;
const char* DebugSymbols::TypeEnum::EmbeddedDWARF = …;
const char* DebugSymbols::TypeEnum::ExternalDWARF = …;
V8_CRDTP_BEGIN_DESERIALIZER(…)

V8_CRDTP_BEGIN_SERIALIZER(…);


// ------------- Enum values from params.


namespace ContinueToLocation {
namespace TargetCallFramesEnum {
const char* Any = …;
const char* Current = …;
} // namespace TargetCallFramesEnum
} // namespace ContinueToLocation

namespace RestartFrame {
namespace ModeEnum {
const char* StepInto = …;
} // namespace ModeEnum
} // namespace RestartFrame

namespace SetInstrumentationBreakpoint {
namespace InstrumentationEnum {
const char* BeforeScriptExecution = …;
const char* BeforeScriptWithSourceMapExecution = …;
} // namespace InstrumentationEnum
} // namespace SetInstrumentationBreakpoint

namespace SetPauseOnExceptions {
namespace StateEnum {
const char* None = …;
const char* Caught = …;
const char* Uncaught = …;
const char* All = …;
} // namespace StateEnum
} // namespace SetPauseOnExceptions

namespace SetScriptSource {
namespace StatusEnum {
const char* Ok = …;
const char* CompileError = …;
const char* BlockedByActiveGenerator = …;
const char* BlockedByActiveFunction = …;
const char* BlockedByTopLevelEsModuleChange = …;
} // namespace StatusEnum
} // namespace SetScriptSource

namespace Paused {
namespace ReasonEnum {
const char* Ambiguous = …;
const char* Assert = …;
const char* CSPViolation = …;
const char* DebugCommand = …;
const char* DOM = …;
const char* EventListener = …;
const char* Exception = …;
const char* Instrumentation = …;
const char* OOM = …;
const char* Other = …;
const char* PromiseRejection = …;
const char* XHR = …;
const char* Step = …;
} // namespace ReasonEnum
} // namespace Paused

namespace API {
namespace Paused {
namespace ReasonEnum {
const char* Ambiguous = …;
const char* Assert = …;
const char* CSPViolation = …;
const char* DebugCommand = …;
const char* DOM = …;
const char* EventListener = …;
const char* Exception = …;
const char* Instrumentation = …;
const char* OOM = …;
const char* Other = …;
const char* PromiseRejection = …;
const char* XHR = …;
const char* Step = …;
} // namespace ReasonEnum
} // namespace Paused
} // namespace API

// ------------- Frontend notifications.

void Frontend::breakpointResolved(const String& breakpointId, std::unique_ptr<protocol::Debugger::Location> location)
{ … }

void Frontend::paused(std::unique_ptr<protocol::Array<protocol::Debugger::CallFrame>> callFrames, const String& reason, Maybe<protocol::DictionaryValue> data, Maybe<protocol::Array<String>> hitBreakpoints, Maybe<protocol::Runtime::StackTrace> asyncStackTrace, Maybe<protocol::Runtime::StackTraceId> asyncStackTraceId, Maybe<protocol::Runtime::StackTraceId> asyncCallStackTraceId)
{ … }

void Frontend::resumed()
{ … }

void Frontend::scriptFailedToParse(const String& scriptId, const String& url, int startLine, int startColumn, int endLine, int endColumn, int executionContextId, const String& hash, Maybe<protocol::DictionaryValue> executionContextAuxData, Maybe<String> sourceMapURL, Maybe<bool> hasSourceURL, Maybe<bool> isModule, Maybe<int> length, Maybe<protocol::Runtime::StackTrace> stackTrace, Maybe<int> codeOffset, Maybe<String> scriptLanguage, Maybe<String> embedderName)
{ … }

void Frontend::scriptParsed(const String& scriptId, const String& url, int startLine, int startColumn, int endLine, int endColumn, int executionContextId, const String& hash, Maybe<protocol::DictionaryValue> executionContextAuxData, Maybe<bool> isLiveEdit, Maybe<String> sourceMapURL, Maybe<bool> hasSourceURL, Maybe<bool> isModule, Maybe<int> length, Maybe<protocol::Runtime::StackTrace> stackTrace, Maybe<int> codeOffset, Maybe<String> scriptLanguage, Maybe<protocol::Debugger::DebugSymbols> debugSymbols, Maybe<String> embedderName)
{ … }

void Frontend::flush()
{ … }

void Frontend::sendRawNotification(std::unique_ptr<Serializable> notification)
{ … }

// --------------------- Dispatcher.

class DomainDispatcherImpl : public protocol::DomainDispatcher { … };

namespace {
// This helper method with a static map of command methods (instance methods
// of DomainDispatcherImpl declared just above) by their name is used immediately below,
// in the DomainDispatcherImpl::Dispatch method.
DomainDispatcherImpl::CallHandler CommandByName(v8_crdtp::span<uint8_t> command_name) { … }
}  // namespace

std::function<void(const v8_crdtp::Dispatchable&)> DomainDispatcherImpl::Dispatch(v8_crdtp::span<uint8_t> command_name) { … }


namespace {

struct continueToLocationParams : public v8_crdtp::DeserializableProtocolObject<continueToLocationParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::continueToLocation(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {


}  // namespace

void DomainDispatcherImpl::disable(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct enableParams : public v8_crdtp::DeserializableProtocolObject<enableParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::enable(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct evaluateOnCallFrameParams : public v8_crdtp::DeserializableProtocolObject<evaluateOnCallFrameParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::evaluateOnCallFrame(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getPossibleBreakpointsParams : public v8_crdtp::DeserializableProtocolObject<getPossibleBreakpointsParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getPossibleBreakpoints(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getScriptSourceParams : public v8_crdtp::DeserializableProtocolObject<getScriptSourceParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getScriptSource(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct disassembleWasmModuleParams : public v8_crdtp::DeserializableProtocolObject<disassembleWasmModuleParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::disassembleWasmModule(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct nextWasmDisassemblyChunkParams : public v8_crdtp::DeserializableProtocolObject<nextWasmDisassemblyChunkParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::nextWasmDisassemblyChunk(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getWasmBytecodeParams : public v8_crdtp::DeserializableProtocolObject<getWasmBytecodeParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getWasmBytecode(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getStackTraceParams : public v8_crdtp::DeserializableProtocolObject<getStackTraceParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getStackTrace(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {


}  // namespace

void DomainDispatcherImpl::pause(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct pauseOnAsyncCallParams : public v8_crdtp::DeserializableProtocolObject<pauseOnAsyncCallParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::pauseOnAsyncCall(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct removeBreakpointParams : public v8_crdtp::DeserializableProtocolObject<removeBreakpointParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::removeBreakpoint(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct restartFrameParams : public v8_crdtp::DeserializableProtocolObject<restartFrameParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::restartFrame(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct resumeParams : public v8_crdtp::DeserializableProtocolObject<resumeParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::resume(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct searchInContentParams : public v8_crdtp::DeserializableProtocolObject<searchInContentParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::searchInContent(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setAsyncCallStackDepthParams : public v8_crdtp::DeserializableProtocolObject<setAsyncCallStackDepthParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setAsyncCallStackDepth(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setBlackboxPatternsParams : public v8_crdtp::DeserializableProtocolObject<setBlackboxPatternsParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setBlackboxPatterns(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setBlackboxedRangesParams : public v8_crdtp::DeserializableProtocolObject<setBlackboxedRangesParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setBlackboxedRanges(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setBreakpointParams : public v8_crdtp::DeserializableProtocolObject<setBreakpointParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setBreakpoint(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setInstrumentationBreakpointParams : public v8_crdtp::DeserializableProtocolObject<setInstrumentationBreakpointParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setInstrumentationBreakpoint(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setBreakpointByUrlParams : public v8_crdtp::DeserializableProtocolObject<setBreakpointByUrlParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setBreakpointByUrl(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setBreakpointOnFunctionCallParams : public v8_crdtp::DeserializableProtocolObject<setBreakpointOnFunctionCallParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setBreakpointOnFunctionCall(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setBreakpointsActiveParams : public v8_crdtp::DeserializableProtocolObject<setBreakpointsActiveParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setBreakpointsActive(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setPauseOnExceptionsParams : public v8_crdtp::DeserializableProtocolObject<setPauseOnExceptionsParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setPauseOnExceptions(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setReturnValueParams : public v8_crdtp::DeserializableProtocolObject<setReturnValueParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setReturnValue(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setScriptSourceParams : public v8_crdtp::DeserializableProtocolObject<setScriptSourceParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setScriptSource(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setSkipAllPausesParams : public v8_crdtp::DeserializableProtocolObject<setSkipAllPausesParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setSkipAllPauses(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setVariableValueParams : public v8_crdtp::DeserializableProtocolObject<setVariableValueParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setVariableValue(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct stepIntoParams : public v8_crdtp::DeserializableProtocolObject<stepIntoParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::stepInto(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {


}  // namespace

void DomainDispatcherImpl::stepOut(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct stepOverParams : public v8_crdtp::DeserializableProtocolObject<stepOverParams> { … };

V8_CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::stepOver(const v8_crdtp::Dispatchable& dispatchable)
{ … }

namespace {
// This helper method (with a static map of redirects) is used from Dispatcher::wire
// immediately below.
const std::vector<std::pair<v8_crdtp::span<uint8_t>, v8_crdtp::span<uint8_t>>>& SortedRedirects() { … }
}  // namespace

// static
void Dispatcher::wire(UberDispatcher* uber, Backend* backend)
{ … }

} // Debugger
} // namespace v8_inspector
} // namespace protocol