chromium/out/Default/gen/third_party/blink/renderer/core/inspector/protocol/dom.cc

// 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 "third_party/blink/renderer/core/inspector/protocol/dom.h"

#include "third_party/blink/renderer/core/inspector/protocol/protocol.h"

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

namespace blink {
namespace protocol {
namespace DOM {

DeserializerState;
ProtocolTypeTraits;

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

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



CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);


namespace PseudoTypeEnum {
const char FirstLine[] = …;
const char FirstLetter[] = …;
const char Before[] = …;
const char After[] = …;
const char Marker[] = …;
const char Backdrop[] = …;
const char Selection[] = …;
const char SearchText[] = …;
const char TargetText[] = …;
const char SpellingError[] = …;
const char GrammarError[] = …;
const char Highlight[] = …;
const char FirstLineInherited[] = …;
const char ScrollMarker[] = …;
const char ScrollMarkerGroup[] = …;
const char ScrollNextButton[] = …;
const char ScrollPrevButton[] = …;
const char Scrollbar[] = …;
const char ScrollbarThumb[] = …;
const char ScrollbarButton[] = …;
const char ScrollbarTrack[] = …;
const char ScrollbarTrackPiece[] = …;
const char ScrollbarCorner[] = …;
const char Resizer[] = …;
const char InputListButton[] = …;
const char ViewTransition[] = …;
const char ViewTransitionGroup[] = …;
const char ViewTransitionImagePair[] = …;
const char ViewTransitionOld[] = …;
const char ViewTransitionNew[] = …;
} // namespace PseudoTypeEnum


namespace ShadowRootTypeEnum {
const char UserAgent[] = …;
const char Open[] = …;
const char Closed[] = …;
} // namespace ShadowRootTypeEnum


namespace CompatibilityModeEnum {
const char QuirksMode[] = …;
const char LimitedQuirksMode[] = …;
const char NoQuirksMode[] = …;
} // namespace CompatibilityModeEnum


namespace PhysicalAxesEnum {
const char Horizontal[] = …;
const char Vertical[] = …;
const char Both[] = …;
} // namespace PhysicalAxesEnum


namespace LogicalAxesEnum {
const char Inline[] = …;
const char Block[] = …;
const char Both[] = …;
} // namespace LogicalAxesEnum


namespace ScrollOrientationEnum {
const char Horizontal[] = …;
const char Vertical[] = …;
} // namespace ScrollOrientationEnum


CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);


CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);


CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);



CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);


CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);


CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);


CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);


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


namespace Enable {
namespace IncludeWhitespaceEnum {
const char* None = …;
const char* All = …;
} // namespace IncludeWhitespaceEnum
} // namespace Enable

namespace GetElementByRelation {
namespace RelationEnum {
const char* PopoverTarget = …;
} // namespace RelationEnum
} // namespace GetElementByRelation

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

void Frontend::attributeModified(int nodeId, const String& name, const String& value)
{ … }

void Frontend::attributeRemoved(int nodeId, const String& name)
{ … }

void Frontend::characterDataModified(int nodeId, const String& characterData)
{ … }

void Frontend::childNodeCountUpdated(int nodeId, int childNodeCount)
{ … }

void Frontend::childNodeInserted(int parentNodeId, int previousNodeId, std::unique_ptr<protocol::DOM::Node> node)
{ … }

void Frontend::childNodeRemoved(int parentNodeId, int nodeId)
{ … }

void Frontend::distributedNodesUpdated(int insertionPointId, std::unique_ptr<protocol::Array<protocol::DOM::BackendNode>> distributedNodes)
{ … }

void Frontend::documentUpdated()
{ … }

void Frontend::inlineStyleInvalidated(std::unique_ptr<protocol::Array<int>> nodeIds)
{ … }

void Frontend::pseudoElementAdded(int parentId, std::unique_ptr<protocol::DOM::Node> pseudoElement)
{ … }

void Frontend::topLayerElementsUpdated()
{ … }

void Frontend::pseudoElementRemoved(int parentId, int pseudoElementId)
{ … }

void Frontend::setChildNodes(int parentId, std::unique_ptr<protocol::Array<protocol::DOM::Node>> nodes)
{ … }

void Frontend::shadowRootPopped(int hostId, int rootId)
{ … }

void Frontend::shadowRootPushed(int hostId, std::unique_ptr<protocol::DOM::Node> root)
{ … }

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(crdtp::span<uint8_t> command_name) { … }
}  // namespace

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


namespace {

struct collectClassNamesFromSubtreeParams : public crdtp::DeserializableProtocolObject<collectClassNamesFromSubtreeParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::collectClassNamesFromSubtree(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct copyToParams : public crdtp::DeserializableProtocolObject<copyToParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::copyTo(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct describeNodeParams : public crdtp::DeserializableProtocolObject<describeNodeParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::describeNode(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct scrollIntoViewIfNeededParams : public crdtp::DeserializableProtocolObject<scrollIntoViewIfNeededParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::scrollIntoViewIfNeeded(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {


}  // namespace

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

namespace {

struct discardSearchResultsParams : public crdtp::DeserializableProtocolObject<discardSearchResultsParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::discardSearchResults(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

namespace {

struct focusParams : public crdtp::DeserializableProtocolObject<focusParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::focus(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getAttributesParams : public crdtp::DeserializableProtocolObject<getAttributesParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getAttributes(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getBoxModelParams : public crdtp::DeserializableProtocolObject<getBoxModelParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getBoxModel(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getContentQuadsParams : public crdtp::DeserializableProtocolObject<getContentQuadsParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getContentQuads(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getDocumentParams : public crdtp::DeserializableProtocolObject<getDocumentParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getDocument(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getFlattenedDocumentParams : public crdtp::DeserializableProtocolObject<getFlattenedDocumentParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getFlattenedDocument(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getNodesForSubtreeByStyleParams : public crdtp::DeserializableProtocolObject<getNodesForSubtreeByStyleParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getNodesForSubtreeByStyle(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getNodeForLocationParams : public crdtp::DeserializableProtocolObject<getNodeForLocationParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getNodeForLocation(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getOuterHTMLParams : public crdtp::DeserializableProtocolObject<getOuterHTMLParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getOuterHTML(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getRelayoutBoundaryParams : public crdtp::DeserializableProtocolObject<getRelayoutBoundaryParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getRelayoutBoundary(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getSearchResultsParams : public crdtp::DeserializableProtocolObject<getSearchResultsParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getSearchResults(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {


}  // namespace

void DomainDispatcherImpl::markUndoableState(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct moveToParams : public crdtp::DeserializableProtocolObject<moveToParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::moveTo(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct performSearchParams : public crdtp::DeserializableProtocolObject<performSearchParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::performSearch(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct pushNodeByPathToFrontendParams : public crdtp::DeserializableProtocolObject<pushNodeByPathToFrontendParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::pushNodeByPathToFrontend(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct pushNodesByBackendIdsToFrontendParams : public crdtp::DeserializableProtocolObject<pushNodesByBackendIdsToFrontendParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::pushNodesByBackendIdsToFrontend(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct querySelectorParams : public crdtp::DeserializableProtocolObject<querySelectorParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::querySelector(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct querySelectorAllParams : public crdtp::DeserializableProtocolObject<querySelectorAllParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::querySelectorAll(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {


}  // namespace

void DomainDispatcherImpl::getTopLayerElements(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getElementByRelationParams : public crdtp::DeserializableProtocolObject<getElementByRelationParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getElementByRelation(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {


}  // namespace

void DomainDispatcherImpl::redo(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct removeAttributeParams : public crdtp::DeserializableProtocolObject<removeAttributeParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::removeAttribute(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct removeNodeParams : public crdtp::DeserializableProtocolObject<removeNodeParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::removeNode(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct requestChildNodesParams : public crdtp::DeserializableProtocolObject<requestChildNodesParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::requestChildNodes(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct requestNodeParams : public crdtp::DeserializableProtocolObject<requestNodeParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::requestNode(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct resolveNodeParams : public crdtp::DeserializableProtocolObject<resolveNodeParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::resolveNode(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setAttributeValueParams : public crdtp::DeserializableProtocolObject<setAttributeValueParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setAttributeValue(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setAttributesAsTextParams : public crdtp::DeserializableProtocolObject<setAttributesAsTextParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setAttributesAsText(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setFileInputFilesParams : public crdtp::DeserializableProtocolObject<setFileInputFilesParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setFileInputFiles(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setNodeStackTracesEnabledParams : public crdtp::DeserializableProtocolObject<setNodeStackTracesEnabledParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setNodeStackTracesEnabled(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getNodeStackTracesParams : public crdtp::DeserializableProtocolObject<getNodeStackTracesParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getNodeStackTraces(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getFileInfoParams : public crdtp::DeserializableProtocolObject<getFileInfoParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getFileInfo(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {


}  // namespace

void DomainDispatcherImpl::getDetachedDomNodes(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setInspectedNodeParams : public crdtp::DeserializableProtocolObject<setInspectedNodeParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setInspectedNode(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setNodeNameParams : public crdtp::DeserializableProtocolObject<setNodeNameParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setNodeName(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setNodeValueParams : public crdtp::DeserializableProtocolObject<setNodeValueParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setNodeValue(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct setOuterHTMLParams : public crdtp::DeserializableProtocolObject<setOuterHTMLParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::setOuterHTML(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {


}  // namespace

void DomainDispatcherImpl::undo(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getFrameOwnerParams : public crdtp::DeserializableProtocolObject<getFrameOwnerParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getFrameOwner(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getContainerForNodeParams : public crdtp::DeserializableProtocolObject<getContainerForNodeParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getContainerForNode(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getQueryingDescendantsForContainerParams : public crdtp::DeserializableProtocolObject<getQueryingDescendantsForContainerParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getQueryingDescendantsForContainer(const crdtp::Dispatchable& dispatchable)
{ … }

namespace {

struct getAnchorElementParams : public crdtp::DeserializableProtocolObject<getAnchorElementParams> { … };

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::getAnchorElement(const 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<crdtp::span<uint8_t>, crdtp::span<uint8_t>>>& SortedRedirects() { … }
}  // namespace

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

} // DOM
} // namespace blink
} // namespace protocol