chromium/out/Default/gen/content/browser/devtools/protocol/input.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 "content/browser/devtools/protocol/input.h"

#include "content/browser/devtools/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 content {
namespace protocol {
namespace Input {

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 GestureSourceTypeEnum {
const char Default[] = …;
const char Touch[] = …;
const char Mouse[] = …;
} // namespace GestureSourceTypeEnum


namespace MouseButtonEnum {
const char None[] = …;
const char Left[] = …;
const char Middle[] = …;
const char Right[] = …;
const char Back[] = …;
const char Forward[] = …;
} // namespace MouseButtonEnum



CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);


CRDTP_BEGIN_DESERIALIZER(…)

CRDTP_BEGIN_SERIALIZER(…);


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


namespace DispatchDragEvent {
namespace TypeEnum {
const char* DragEnter = …;
const char* DragOver = …;
const char* Drop = …;
const char* DragCancel = …;
} // namespace TypeEnum
} // namespace DispatchDragEvent

namespace DispatchKeyEvent {
namespace TypeEnum {
const char* KeyDown = …;
const char* KeyUp = …;
const char* RawKeyDown = …;
const char* Char = …;
} // namespace TypeEnum
} // namespace DispatchKeyEvent

namespace DispatchMouseEvent {
namespace TypeEnum {
const char* MousePressed = …;
const char* MouseReleased = …;
const char* MouseMoved = …;
const char* MouseWheel = …;
} // namespace TypeEnum
} // namespace DispatchMouseEvent

namespace DispatchMouseEvent {
namespace PointerTypeEnum {
const char* Mouse = …;
const char* Pen = …;
} // namespace PointerTypeEnum
} // namespace DispatchMouseEvent

namespace DispatchTouchEvent {
namespace TypeEnum {
const char* TouchStart = …;
const char* TouchEnd = …;
const char* TouchMove = …;
const char* TouchCancel = …;
} // namespace TypeEnum
} // namespace DispatchTouchEvent

namespace EmulateTouchFromMouseEvent {
namespace TypeEnum {
const char* MousePressed = …;
const char* MouseReleased = …;
const char* MouseMoved = …;
const char* MouseWheel = …;
} // namespace TypeEnum
} // namespace EmulateTouchFromMouseEvent

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

void Frontend::DragIntercepted(std::unique_ptr<protocol::Input::DragData> data)
{ … }

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) { … }


class DispatchDragEventCallbackImpl : public Backend::DispatchDragEventCallback, public DomainDispatcher::Callback { … };

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

class DispatchKeyEventCallbackImpl : public Backend::DispatchKeyEventCallback, public DomainDispatcher::Callback { … };

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

class InsertTextCallbackImpl : public Backend::InsertTextCallback, public DomainDispatcher::Callback { … };

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

class ImeSetCompositionCallbackImpl : public Backend::ImeSetCompositionCallback, public DomainDispatcher::Callback { … };

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

class DispatchMouseEventCallbackImpl : public Backend::DispatchMouseEventCallback, public DomainDispatcher::Callback { … };

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

class DispatchTouchEventCallbackImpl : public Backend::DispatchTouchEventCallback, public DomainDispatcher::Callback { … };

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

class CancelDraggingCallbackImpl : public Backend::CancelDraggingCallback, public DomainDispatcher::Callback { … };

namespace {


}  // namespace

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

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

class SynthesizePinchGestureCallbackImpl : public Backend::SynthesizePinchGestureCallback, public DomainDispatcher::Callback { … };

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

class SynthesizeScrollGestureCallbackImpl : public Backend::SynthesizeScrollGestureCallback, public DomainDispatcher::Callback { … };

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

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

class SynthesizeTapGestureCallbackImpl : public Backend::SynthesizeTapGestureCallback, public DomainDispatcher::Callback { … };

namespace {

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

CRDTP_BEGIN_DESERIALIZER(…)

}  // namespace

void DomainDispatcherImpl::synthesizeTapGesture(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)
{ … }

} // Input
} // namespace content
} // namespace protocol