devtools_agent.mojom-blink.cc | Explore in Territory

// third_party/blink/public/mojom/devtools/devtools_agent.mojom-blink.cc is auto generated by mojom_bindings_generator.py, do not edit

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

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "third_party/blink/public/mojom/devtools/devtools_agent.mojom-blink.h"

#include <math.h>
#include <stdint.h>
#include <utility>

#include "base/debug/alias.h"
#include "base/hash/md5_constexpr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/features.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization_util.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "third_party/blink/public/mojom/devtools/devtools_agent.mojom-params-data.h"
#include "third_party/blink/public/mojom/devtools/devtools_agent.mojom-shared-message-ids.h"

#include "third_party/blink/public/mojom/devtools/devtools_agent.mojom-blink-import-headers.h"
#include "third_party/blink/public/mojom/devtools/devtools_agent.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"


namespace blink::mojom::blink {
DevToolsMessage::DevToolsMessage()
    : … { … }

DevToolsMessage::DevToolsMessage(
    ::mojo_base::BigBuffer data_in)
    : … { … }

DevToolsMessage::~DevToolsMessage() = default;

void DevToolsMessage::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool DevToolsMessage::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
DevToolsSessionState::DevToolsSessionState()
    : … { … }

DevToolsSessionState::DevToolsSessionState(
    const WTF::HashMap<WTF::String, std::optional<WTF::Vector<uint8_t>>>& entries_in)
    : … { … }

DevToolsSessionState::~DevToolsSessionState() = default;

void DevToolsSessionState::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool DevToolsSessionState::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char DevToolsAgent::Name_[] = …;

DevToolsAgent::IPCStableHashFunction DevToolsAgent::MessageToMethodInfo_(mojo::Message& message) { … }


const char* DevToolsAgent::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DevToolsAgent::AttachDevToolsSession_Sym::IPCStableHash() { … }
uint32_t DevToolsAgent::InspectElement_Sym::IPCStableHash() { … }
uint32_t DevToolsAgent::ReportChildTargets_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class DevToolsAgent_ReportChildTargets_ForwardToCallback
    : public mojo::MessageReceiver { … };

DevToolsAgentProxy::DevToolsAgentProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void DevToolsAgentProxy::AttachDevToolsSession(
    ::mojo::PendingAssociatedRemote<DevToolsSessionHost> in_host, ::mojo::PendingAssociatedReceiver<DevToolsSession> in_session, ::mojo::PendingReceiver<DevToolsSession> in_io_session, DevToolsSessionStatePtr in_reattach_session_state, bool in_client_expects_binary_responses, bool in_client_is_trusted, const WTF::String& in_session_id, bool in_session_waits_for_debugger) { … }

void DevToolsAgentProxy::InspectElement(
    const ::gfx::Point& in_point) { … }

void DevToolsAgentProxy::ReportChildTargets(
    bool in_report, bool in_wait_for_debugger, ReportChildTargetsCallback callback) { … }
class DevToolsAgent_ReportChildTargets_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool DevToolsAgent_ReportChildTargets_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void DevToolsAgent_ReportChildTargets_ProxyToResponder::Run(
    ) { … }

// static
bool DevToolsAgentStubDispatch::Accept(
    DevToolsAgent* impl,
    mojo::Message* message) { … }

// static
bool DevToolsAgentStubDispatch::AcceptWithResponder(
    DevToolsAgent* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kDevToolsAgentValidationInfo[] = …;

bool DevToolsAgentRequestValidator::Accept(mojo::Message* message) { … }

bool DevToolsAgentResponseValidator::Accept(mojo::Message* message) { … }
const char DevToolsAgentHost::Name_[] = …;

DevToolsAgentHost::IPCStableHashFunction DevToolsAgentHost::MessageToMethodInfo_(mojo::Message& message) { … }


const char* DevToolsAgentHost::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DevToolsAgentHost::ChildTargetCreated_Sym::IPCStableHash() { … }
uint32_t DevToolsAgentHost::MainThreadDebuggerPaused_Sym::IPCStableHash() { … }
uint32_t DevToolsAgentHost::MainThreadDebuggerResumed_Sym::IPCStableHash() { … }
uint32_t DevToolsAgentHost::BringToForeground_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

DevToolsAgentHostProxy::DevToolsAgentHostProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void DevToolsAgentHostProxy::ChildTargetCreated(
    ::mojo::PendingRemote<DevToolsAgent> in_worker_devtools_agent, ::mojo::PendingReceiver<DevToolsAgentHost> in_worker_devtools_agent_host, const ::blink::KURL& in_url, const WTF::String& in_name, const ::base::UnguessableToken& in_devtools_worker_token, bool in_waiting_for_debugger, DevToolsExecutionContextType in_context_type) { … }

void DevToolsAgentHostProxy::MainThreadDebuggerPaused(
    ) { … }

void DevToolsAgentHostProxy::MainThreadDebuggerResumed(
    ) { … }

void DevToolsAgentHostProxy::BringToForeground(
    ) { … }

// static
bool DevToolsAgentHostStubDispatch::Accept(
    DevToolsAgentHost* impl,
    mojo::Message* message) { … }

// static
bool DevToolsAgentHostStubDispatch::AcceptWithResponder(
    DevToolsAgentHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kDevToolsAgentHostValidationInfo[] = …;

bool DevToolsAgentHostRequestValidator::Accept(mojo::Message* message) { … }

const char DevToolsSession::Name_[] = …;

DevToolsSession::IPCStableHashFunction DevToolsSession::MessageToMethodInfo_(mojo::Message& message) { … }


const char* DevToolsSession::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DevToolsSession::DispatchProtocolCommand_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

DevToolsSessionProxy::DevToolsSessionProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void DevToolsSessionProxy::DispatchProtocolCommand(
    int32_t in_call_id, const WTF::String& in_method, ::base::span<const ::uint8_t> in_message) { … }

// static
bool DevToolsSessionStubDispatch::Accept(
    DevToolsSession* impl,
    mojo::Message* message) { … }

// static
bool DevToolsSessionStubDispatch::AcceptWithResponder(
    DevToolsSession* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kDevToolsSessionValidationInfo[] = …;

bool DevToolsSessionRequestValidator::Accept(mojo::Message* message) { … }

const char DevToolsSessionHost::Name_[] = …;

DevToolsSessionHost::IPCStableHashFunction DevToolsSessionHost::MessageToMethodInfo_(mojo::Message& message) { … }


const char* DevToolsSessionHost::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DevToolsSessionHost::DispatchProtocolResponse_Sym::IPCStableHash() { … }
uint32_t DevToolsSessionHost::DispatchProtocolNotification_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

DevToolsSessionHostProxy::DevToolsSessionHostProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void DevToolsSessionHostProxy::DispatchProtocolResponse(
    DevToolsMessagePtr in_message, int32_t in_call_id, DevToolsSessionStatePtr in_updates) { … }

void DevToolsSessionHostProxy::DispatchProtocolNotification(
    DevToolsMessagePtr in_message, DevToolsSessionStatePtr in_updates) { … }

// static
bool DevToolsSessionHostStubDispatch::Accept(
    DevToolsSessionHost* impl,
    mojo::Message* message) { … }

// static
bool DevToolsSessionHostStubDispatch::AcceptWithResponder(
    DevToolsSessionHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kDevToolsSessionHostValidationInfo[] = …;

bool DevToolsSessionHostRequestValidator::Accept(mojo::Message* message) { … }



}  // blink::mojom::blink


namespace mojo {


// static
bool StructTraits<::blink::mojom::blink::DevToolsMessage::DataView, ::blink::mojom::blink::DevToolsMessagePtr>::Read(
    ::blink::mojom::blink::DevToolsMessage::DataView input,
    ::blink::mojom::blink::DevToolsMessagePtr* output) { … }


// static
bool StructTraits<::blink::mojom::blink::DevToolsSessionState::DataView, ::blink::mojom::blink::DevToolsSessionStatePtr>::Read(
    ::blink::mojom::blink::DevToolsSessionState::DataView input,
    ::blink::mojom::blink::DevToolsSessionStatePtr* output) { … }

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace blink::mojom::blink {


void DevToolsAgentInterceptorForTesting::AttachDevToolsSession(::mojo::PendingAssociatedRemote<DevToolsSessionHost> host, ::mojo::PendingAssociatedReceiver<DevToolsSession> session, ::mojo::PendingReceiver<DevToolsSession> io_session, DevToolsSessionStatePtr reattach_session_state, bool client_expects_binary_responses, bool client_is_trusted, const WTF::String& session_id, bool session_waits_for_debugger) { … }
void DevToolsAgentInterceptorForTesting::InspectElement(const ::gfx::Point& point) { … }
void DevToolsAgentInterceptorForTesting::ReportChildTargets(bool report, bool wait_for_debugger, ReportChildTargetsCallback callback) { … }
DevToolsAgentAsyncWaiter::DevToolsAgentAsyncWaiter(
    DevToolsAgent* proxy) : … { … }

DevToolsAgentAsyncWaiter::~DevToolsAgentAsyncWaiter() = default;

void DevToolsAgentAsyncWaiter::ReportChildTargets(
    bool report, bool wait_for_debugger) { … }






void DevToolsAgentHostInterceptorForTesting::ChildTargetCreated(::mojo::PendingRemote<DevToolsAgent> worker_devtools_agent, ::mojo::PendingReceiver<DevToolsAgentHost> worker_devtools_agent_host, const ::blink::KURL& url, const WTF::String& name, const ::base::UnguessableToken& devtools_worker_token, bool waiting_for_debugger, DevToolsExecutionContextType context_type) { … }
void DevToolsAgentHostInterceptorForTesting::MainThreadDebuggerPaused() { … }
void DevToolsAgentHostInterceptorForTesting::MainThreadDebuggerResumed() { … }
void DevToolsAgentHostInterceptorForTesting::BringToForeground() { … }
DevToolsAgentHostAsyncWaiter::DevToolsAgentHostAsyncWaiter(
    DevToolsAgentHost* proxy) : … { … }

DevToolsAgentHostAsyncWaiter::~DevToolsAgentHostAsyncWaiter() = default;




void DevToolsSessionInterceptorForTesting::DispatchProtocolCommand(int32_t call_id, const WTF::String& method, ::base::span<const ::uint8_t> message) { … }
DevToolsSessionAsyncWaiter::DevToolsSessionAsyncWaiter(
    DevToolsSession* proxy) : … { … }

DevToolsSessionAsyncWaiter::~DevToolsSessionAsyncWaiter() = default;




void DevToolsSessionHostInterceptorForTesting::DispatchProtocolResponse(DevToolsMessagePtr message, int32_t call_id, DevToolsSessionStatePtr updates) { … }
void DevToolsSessionHostInterceptorForTesting::DispatchProtocolNotification(DevToolsMessagePtr message, DevToolsSessionStatePtr updates) { … }
DevToolsSessionHostAsyncWaiter::DevToolsSessionHostAsyncWaiter(
    DevToolsSessionHost* proxy) : … { … }

DevToolsSessionHostAsyncWaiter::~DevToolsSessionHostAsyncWaiter() = default;






}  // blink::mojom::blink


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/third_party/blink/public/mojom/devtools/devtools_agent.mojom-blink.cc
