core_probes_inl.h | Explore in Territory

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

// Generated from template:
//   /instrumenting_probes_inl.h.tmpl
// and input files:
//   core_probes.pidl


#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_CORE_PROBES_INL_H_
#define THIRD_PARTY_BLINK_RENDERER_CORE_CORE_PROBES_INL_H_

#include "third_party/blink/renderer/platform/heap/collection_support/heap_vector.h"
#include "third_party/blink/public/mojom/loader/same_document_navigation_type.mojom-shared.h"
#include "third_party/blink/public/web/web_media_inspector.h"
#include "third_party/blink/renderer/core/animation/animation.h"
#include "third_party/blink/renderer/core/core_probe_sink.h"
#include "third_party/blink/renderer/core/dom/character_data.h"
#include "third_party/blink/renderer/core/dom/pseudo_element.h"
#include "third_party/blink/renderer/core/frame/csp/content_security_policy.h"
#include "third_party/blink/renderer/core/html/html_slot_element.h"
#include "third_party/blink/renderer/core/loader/frame_loader_types.h"
#include "third_party/blink/renderer/core/page/chrome_client.h"
#include "third_party/blink/renderer/core/probe/core_probes.h"
#include "third_party/blink/renderer/core/speculation_rules/speculation_rule_set.h"


namespace blink {

class ClassicScript;
class ConsoleMessage;
class FontCustomPlatformData;
class FontFace;
class HTMLDocumentParser;
class HTMLInputElement;
class JSBasedEventListener;
class PerformanceEntry;
class Script;
class ScriptState;
class SpeculationCandidate;
class XMLHttpRequest;

namespace probe {


CORE_EXPORT void DidClearDocumentOfWindowObjectImpl(LocalFrame*);
inline void DidClearDocumentOfWindowObject(LocalFrame* param_local_frame) { … }

CORE_EXPORT void DidCreateMainWorldContextImpl(LocalFrame*);
inline void DidCreateMainWorldContext(LocalFrame* param_local_frame) { … }

CORE_EXPORT void WillInsertDOMNodeImpl(Node*);
inline void WillInsertDOMNode(Node* parent) { … }

CORE_EXPORT void DidInsertDOMNodeImpl(Node*);
inline void DidInsertDOMNode(Node* param_node) { … }

CORE_EXPORT void WillRemoveDOMNodeImpl(Node*);
inline void WillRemoveDOMNode(Node* param_node) { … }

CORE_EXPORT void WillModifyDOMAttrImpl(Element*, const AtomicString&, const AtomicString&);
inline void WillModifyDOMAttr(Element* param_element, const AtomicString& old_value, const AtomicString& new_value) { … }

CORE_EXPORT void DidModifyDOMAttrImpl(Element*, const QualifiedName&, const AtomicString&);
inline void DidModifyDOMAttr(Element* param_element, const QualifiedName& name, const AtomicString& value) { … }

CORE_EXPORT void DidRemoveDOMAttrImpl(Element*, const QualifiedName&);
inline void DidRemoveDOMAttr(Element* param_element, const QualifiedName& name) { … }

CORE_EXPORT void WillChangeStyleElementImpl(Element*);
inline void WillChangeStyleElement(Element* param_element) { … }

CORE_EXPORT void CharacterDataModifiedImpl(CharacterData*);
inline void CharacterDataModified(CharacterData* param_character_data) { … }

CORE_EXPORT void DidInvalidateStyleAttrImpl(Node*);
inline void DidInvalidateStyleAttr(Node* param_node) { … }

CORE_EXPORT void DidPerformSlotDistributionImpl(HTMLSlotElement*);
inline void DidPerformSlotDistribution(HTMLSlotElement* param_html_slot_element) { … }

CORE_EXPORT void DocumentDetachedImpl(Document*);
inline void DocumentDetached(Document* param_document) { … }

CORE_EXPORT void ActiveStyleSheetsUpdatedImpl(Document*);
inline void ActiveStyleSheetsUpdated(Document* param_document) { … }

CORE_EXPORT void FontsUpdatedImpl(ExecutionContext*, const FontFace*, const String&, const FontCustomPlatformData*);
inline void FontsUpdated(ExecutionContext* param_execution_context, const FontFace* face, const String& src, const FontCustomPlatformData* font_custom_platform_data) { … }

CORE_EXPORT void MediaQueryResultChangedImpl(Document*);
inline void MediaQueryResultChanged(Document* param_document) { … }

CORE_EXPORT void DidPushShadowRootImpl(Element*, ShadowRoot*);
inline void DidPushShadowRoot(Element* host, ShadowRoot* param_shadow_root) { … }

CORE_EXPORT void WillPopShadowRootImpl(Element*, ShadowRoot*);
inline void WillPopShadowRoot(Element* host, ShadowRoot* param_shadow_root) { … }

CORE_EXPORT void WillSendXMLHttpOrFetchNetworkRequestImpl(ExecutionContext*, const String&);
inline void WillSendXMLHttpOrFetchNetworkRequest(ExecutionContext* param_execution_context, const String& url) { … }

CORE_EXPORT void DidCreateCanvasContextImpl(Document*);
inline void DidCreateCanvasContext(Document* param_document) { … }

CORE_EXPORT void DidCreateOffscreenCanvasContextImpl(OffscreenCanvas*);
inline void DidCreateOffscreenCanvasContext(OffscreenCanvas* param_offscreen_canvas) { … }

CORE_EXPORT void DidFireWebGLErrorImpl(Element*, const String&);
inline void DidFireWebGLError(Element* param_element, const String& error_name) { … }

CORE_EXPORT void DidFireWebGLWarningImpl(Element*);
inline void DidFireWebGLWarning(Element* param_element) { … }

CORE_EXPORT void DidFireWebGLErrorOrWarningImpl(Element*, const String&);
inline void DidFireWebGLErrorOrWarning(Element* param_element, const String& message) { … }

CORE_EXPORT void DidResizeMainFrameImpl(LocalFrame*);
inline void DidResizeMainFrame(LocalFrame* param_local_frame) { … }

CORE_EXPORT void ApplyAcceptLanguageOverrideImpl(ExecutionContext*, String*);
inline void ApplyAcceptLanguageOverride(ExecutionContext* param_execution_context, String* accept_language) { … }

CORE_EXPORT void ApplyAcceptLanguageOverrideImpl(CoreProbeSink*, String*);
inline void ApplyAcceptLanguageOverride(CoreProbeSink* param_core_probe_sink, String* accept_language) { … }

CORE_EXPORT void ApplyHardwareConcurrencyOverrideImpl(CoreProbeSink*, unsigned int&);
inline void ApplyHardwareConcurrencyOverride(CoreProbeSink* param_core_probe_sink, unsigned int& hardware_concurrency) { … }

CORE_EXPORT void ApplyUserAgentOverrideImpl(CoreProbeSink*, String*);
inline void ApplyUserAgentOverride(CoreProbeSink* param_core_probe_sink, String* user_agent) { … }

CORE_EXPORT void ApplyUserAgentMetadataOverrideImpl(CoreProbeSink*, std::optional<blink::UserAgentMetadata>*);
inline void ApplyUserAgentMetadataOverride(CoreProbeSink* param_core_probe_sink, std::optional<blink::UserAgentMetadata>* ua_metadata_override) { … }

CORE_EXPORT void DidBlockRequestImpl(CoreProbeSink*, const ResourceRequest&, DocumentLoader*, const KURL&, const ResourceLoaderOptions&, ResourceRequestBlockedReason, ResourceType);
inline void DidBlockRequest(CoreProbeSink* param_core_probe_sink, const ResourceRequest& param_resource_request, DocumentLoader* param_document_loader, const KURL& fetch_context_url, const ResourceLoaderOptions& param_resource_loader_options, ResourceRequestBlockedReason param_resource_request_blocked_reason, ResourceType param_resource_type) { … }

CORE_EXPORT void DidChangeResourcePriorityImpl(LocalFrame*, DocumentLoader*, uint64_t, ResourceLoadPriority);
inline void DidChangeResourcePriority(LocalFrame* param_local_frame, DocumentLoader* param_document_loader, uint64_t identifier, ResourceLoadPriority load_priority) { … }

CORE_EXPORT void PrepareRequestImpl(CoreProbeSink*, DocumentLoader*, ResourceRequest&, ResourceLoaderOptions&, ResourceType);
inline void PrepareRequest(CoreProbeSink* param_core_probe_sink, DocumentLoader* param_document_loader, ResourceRequest& param_resource_request, ResourceLoaderOptions& param_resource_loader_options, ResourceType param_resource_type) { … }

CORE_EXPORT void WillSendRequestImpl(ExecutionContext*, DocumentLoader*, const KURL&, const ResourceRequest&, const ResourceResponse&, const ResourceLoaderOptions&, ResourceType, RenderBlockingBehavior, base::TimeTicks);
inline void WillSendRequest(ExecutionContext* param_execution_context, DocumentLoader* param_document_loader, const KURL& fetch_context_url, const ResourceRequest& param_resource_request, const ResourceResponse& redirect_response, const ResourceLoaderOptions& param_resource_loader_options, ResourceType param_resource_type, RenderBlockingBehavior param_render_blocking_behavior, base::TimeTicks timestamp) { … }

CORE_EXPORT void WillSendNavigationRequestImpl(CoreProbeSink*, uint64_t, DocumentLoader*, const KURL&, const AtomicString&, EncodedFormData*);
inline void WillSendNavigationRequest(CoreProbeSink* param_core_probe_sink, uint64_t identifier, DocumentLoader* param_document_loader, const KURL& param_kurl, const AtomicString& http_method, EncodedFormData* param_encoded_form_data) { … }

CORE_EXPORT void MarkResourceAsCachedImpl(LocalFrame*, DocumentLoader*, uint64_t);
inline void MarkResourceAsCached(LocalFrame* param_local_frame, DocumentLoader* param_document_loader, uint64_t identifier) { … }

CORE_EXPORT void DidReceiveResourceResponseImpl(CoreProbeSink*, uint64_t, DocumentLoader*, const ResourceResponse&, const Resource*);
inline void DidReceiveResourceResponse(CoreProbeSink* param_core_probe_sink, uint64_t identifier, DocumentLoader* param_document_loader, const ResourceResponse& param_resource_response, const Resource* param_resource) { … }

CORE_EXPORT void DidReceiveDataImpl(CoreProbeSink*, uint64_t, DocumentLoader*, const char*, uint64_t);
inline void DidReceiveData(CoreProbeSink* param_core_probe_sink, uint64_t identifier, DocumentLoader* param_document_loader, const char* data, uint64_t data_length) { … }

CORE_EXPORT void DidReceiveBlobImpl(CoreProbeSink*, uint64_t, DocumentLoader*, BlobDataHandle*);
inline void DidReceiveBlob(CoreProbeSink* param_core_probe_sink, uint64_t identifier, DocumentLoader* param_document_loader, BlobDataHandle* param_blob_data_handle) { … }

CORE_EXPORT void DidReceiveEncodedDataLengthImpl(CoreProbeSink*, DocumentLoader*, uint64_t, size_t);
inline void DidReceiveEncodedDataLength(CoreProbeSink* param_core_probe_sink, DocumentLoader* loader, uint64_t identifier, size_t encoded_data_length) { … }

CORE_EXPORT void DidFinishLoadingImpl(CoreProbeSink*, uint64_t, DocumentLoader*, base::TimeTicks, int64_t, int64_t);
inline void DidFinishLoading(CoreProbeSink* param_core_probe_sink, uint64_t identifier, DocumentLoader* param_document_loader, base::TimeTicks finish_time, int64_t encoded_data_length, int64_t decoded_body_length) { … }

CORE_EXPORT void DidReceiveCorsRedirectResponseImpl(ExecutionContext*, uint64_t, DocumentLoader*, const ResourceResponse&, Resource*);
inline void DidReceiveCorsRedirectResponse(ExecutionContext* param_execution_context, uint64_t identifier, DocumentLoader* param_document_loader, const ResourceResponse& param_resource_response, Resource* param_resource) { … }

CORE_EXPORT void DidFailLoadingImpl(CoreProbeSink*, uint64_t, DocumentLoader*, const ResourceError&, const base::UnguessableToken&);
inline void DidFailLoading(CoreProbeSink* param_core_probe_sink, uint64_t identifier, DocumentLoader* param_document_loader, const ResourceError& param_resource_error, const base::UnguessableToken& param_base) { … }

CORE_EXPORT void WillSendEventSourceRequestImpl(ExecutionContext*);
inline void WillSendEventSourceRequest(ExecutionContext* param_execution_context) { … }

CORE_EXPORT void WillDispatchEventSourceEventImpl(ExecutionContext*, uint64_t, const AtomicString&, const AtomicString&, const String&);
inline void WillDispatchEventSourceEvent(ExecutionContext* param_execution_context, uint64_t identifier, const AtomicString& event_name, const AtomicString& event_id, const String& data) { … }

CORE_EXPORT void WillLoadXHRImpl(ExecutionContext*, const AtomicString&, const KURL&, bool, const HTTPHeaderMap&, bool);
inline void WillLoadXHR(ExecutionContext* param_execution_context, const AtomicString& method, const KURL& url, bool async, const HTTPHeaderMap& headers, bool include_credentials) { … }

CORE_EXPORT void DidFinishXHRImpl(ExecutionContext*, XMLHttpRequest*);
inline void DidFinishXHR(ExecutionContext* param_execution_context, XMLHttpRequest* xhr) { … }

CORE_EXPORT void DidFinishSyncXHRImpl(ExecutionContext*, const base::TimeDelta);
inline void DidFinishSyncXHR(ExecutionContext* context, const base::TimeDelta blocking_time) { … }

CORE_EXPORT void ScriptImportedImpl(ExecutionContext*, uint64_t, const String&);
inline void ScriptImported(ExecutionContext* param_execution_context, uint64_t identifier, const String& source_string) { … }

CORE_EXPORT void ScriptExecutionBlockedByCSPImpl(ExecutionContext*, const String&);
inline void ScriptExecutionBlockedByCSP(ExecutionContext* param_execution_context, const String& directive_text) { … }

CORE_EXPORT void DidReceiveScriptResponseImpl(ExecutionContext*, uint64_t);
inline void DidReceiveScriptResponse(ExecutionContext* param_execution_context, uint64_t identifier) { … }

CORE_EXPORT void DomContentLoadedEventFiredImpl(LocalFrame*);
inline void DomContentLoadedEventFired(LocalFrame* param_local_frame) { … }

CORE_EXPORT void LoadEventFiredImpl(LocalFrame*);
inline void LoadEventFired(LocalFrame* param_local_frame) { … }

CORE_EXPORT void FrameAttachedToParentImpl(LocalFrame*, const std::optional<AdScriptIdentifier>&);
inline void FrameAttachedToParent(LocalFrame* param_local_frame, const std::optional<AdScriptIdentifier>& ad_script_on_stack) { … }

CORE_EXPORT void FrameDetachedFromParentImpl(LocalFrame*, FrameDetachType);
inline void FrameDetachedFromParent(LocalFrame* param_local_frame, FrameDetachType param_frame_detach_type) { … }

CORE_EXPORT void FrameSubtreeWillBeDetachedImpl(LocalFrame*, Frame*);
inline void FrameSubtreeWillBeDetached(LocalFrame* param_local_frame, Frame* param_frame) { … }

CORE_EXPORT void DidStartProvisionalLoadImpl(LocalFrame*);
inline void DidStartProvisionalLoad(LocalFrame* param_local_frame) { … }

CORE_EXPORT void DidFailProvisionalLoadImpl(LocalFrame*);
inline void DidFailProvisionalLoad(LocalFrame* param_local_frame) { … }

CORE_EXPORT void WillCommitLoadImpl(LocalFrame*, DocumentLoader*);
inline void WillCommitLoad(LocalFrame* param_local_frame, DocumentLoader* param_document_loader) { … }

CORE_EXPORT void DidCommitLoadImpl(LocalFrame*, DocumentLoader*);
inline void DidCommitLoad(LocalFrame* param_local_frame, DocumentLoader* param_document_loader) { … }

CORE_EXPORT void DidNavigateWithinDocumentImpl(LocalFrame*, blink::mojom::SameDocumentNavigationType);
inline void DidNavigateWithinDocument(LocalFrame* param_local_frame, blink::mojom::SameDocumentNavigationType param_blink) { … }

CORE_EXPORT void DidRestoreFromBackForwardCacheImpl(LocalFrame*);
inline void DidRestoreFromBackForwardCache(LocalFrame* param_local_frame) { … }

CORE_EXPORT void DidOpenDocumentImpl(LocalFrame*, DocumentLoader*);
inline void DidOpenDocument(LocalFrame* param_local_frame, DocumentLoader* param_document_loader) { … }

CORE_EXPORT void WillCreateDocumentParserImpl(Document*, bool&);
inline void WillCreateDocumentParser(Document* param_document, bool& force_sync_parsing) { … }

CORE_EXPORT void FrameDocumentUpdatedImpl(LocalFrame*);
inline void FrameDocumentUpdated(LocalFrame* param_local_frame) { … }

CORE_EXPORT void FrameOwnerContentUpdatedImpl(LocalFrame*, HTMLFrameOwnerElement*);
inline void FrameOwnerContentUpdated(LocalFrame* param_local_frame, HTMLFrameOwnerElement* param_html_frame_owner_element) { … }

CORE_EXPORT void FrameStartedLoadingImpl(LocalFrame*);
inline void FrameStartedLoading(LocalFrame* param_local_frame) { … }

CORE_EXPORT void FrameStoppedLoadingImpl(LocalFrame*);
inline void FrameStoppedLoading(LocalFrame* param_local_frame) { … }

CORE_EXPORT void FrameRequestedNavigationImpl(LocalFrame*, Frame*, const KURL&, ClientNavigationReason, NavigationPolicy);
inline void FrameRequestedNavigation(LocalFrame* param_local_frame, Frame* target_frame, const KURL& url, ClientNavigationReason reason, NavigationPolicy policy) { … }

CORE_EXPORT void FrameScheduledNavigationImpl(LocalFrame*, const KURL&, base::TimeDelta, ClientNavigationReason);
inline void FrameScheduledNavigation(LocalFrame* param_local_frame, const KURL& url, base::TimeDelta delay, ClientNavigationReason reason) { … }

CORE_EXPORT void FrameClearedScheduledNavigationImpl(LocalFrame*);
inline void FrameClearedScheduledNavigation(LocalFrame* param_local_frame) { … }

CORE_EXPORT void WillCreateWebSocketImpl(ExecutionContext*, uint64_t, const KURL&, const String&, std::optional<base::UnguessableToken>*);
inline void WillCreateWebSocket(ExecutionContext* param_execution_context, uint64_t identifier, const KURL& request_url, const String& protocol, std::optional<base::UnguessableToken>* devtools_token) { … }

CORE_EXPORT void WillSendWebSocketHandshakeRequestImpl(ExecutionContext*, uint64_t, network::mojom::blink::WebSocketHandshakeRequest*);
inline void WillSendWebSocketHandshakeRequest(ExecutionContext* param_execution_context, uint64_t identifier, network::mojom::blink::WebSocketHandshakeRequest* request) { … }

CORE_EXPORT void DidReceiveWebSocketHandshakeResponseImpl(ExecutionContext*, uint64_t, network::mojom::blink::WebSocketHandshakeRequest*, network::mojom::blink::WebSocketHandshakeResponse*);
inline void DidReceiveWebSocketHandshakeResponse(ExecutionContext* param_execution_context, uint64_t identifier, network::mojom::blink::WebSocketHandshakeRequest* request, network::mojom::blink::WebSocketHandshakeResponse* response) { … }

CORE_EXPORT void DidCloseWebSocketImpl(ExecutionContext*, uint64_t);
inline void DidCloseWebSocket(ExecutionContext* param_execution_context, uint64_t identifier) { … }

CORE_EXPORT void DidReceiveWebSocketMessageImpl(ExecutionContext*, uint64_t, int, bool, const Vector<base::span<const char>>&);
inline void DidReceiveWebSocketMessage(ExecutionContext* param_execution_context, uint64_t identifier, int opcode, bool masked, const Vector<base::span<const char>>& data) { … }

CORE_EXPORT void DidSendWebSocketMessageImpl(ExecutionContext*, uint64_t, int, bool, const char*, size_t);
inline void DidSendWebSocketMessage(ExecutionContext* param_execution_context, uint64_t identifier, int opcode, bool masked, const char* payload, size_t payload_length) { … }

CORE_EXPORT void DidReceiveWebSocketMessageErrorImpl(ExecutionContext*, uint64_t, const String&);
inline void DidReceiveWebSocketMessageError(ExecutionContext* param_execution_context, uint64_t identifier, const String& error_message) { … }

CORE_EXPORT void WebTransportCreatedImpl(ExecutionContext*, uint64_t, const KURL&);
inline void WebTransportCreated(ExecutionContext* param_execution_context, uint64_t transport_id, const KURL& request_url) { … }

CORE_EXPORT void WebTransportConnectionEstablishedImpl(ExecutionContext*, uint64_t);
inline void WebTransportConnectionEstablished(ExecutionContext* param_execution_context, uint64_t transport_id) { … }

CORE_EXPORT void WebTransportClosedImpl(ExecutionContext*, uint64_t);
inline void WebTransportClosed(ExecutionContext* param_execution_context, uint64_t transport_id) { … }

CORE_EXPORT void WillCreateP2PSocketUdpImpl(ExecutionContext*, std::optional<base::UnguessableToken>*);
inline void WillCreateP2PSocketUdp(ExecutionContext* param_execution_context, std::optional<base::UnguessableToken>* devtools_token) { … }

CORE_EXPORT void LayerTreeDidChangeImpl(LocalFrame*);
inline void LayerTreeDidChange(LocalFrame* param_local_frame) { … }

CORE_EXPORT void LayerTreePaintedImpl(LocalFrame*);
inline void LayerTreePainted(LocalFrame* param_local_frame) { … }

CORE_EXPORT void PseudoElementCreatedImpl(PseudoElement*);
inline void PseudoElementCreated(PseudoElement* param_pseudo_element) { … }

CORE_EXPORT void TopLayerElementsChangedImpl(Document*);
inline void TopLayerElementsChanged(Document* param_document) { … }

CORE_EXPORT void PseudoElementDestroyedImpl(PseudoElement*);
inline void PseudoElementDestroyed(PseudoElement* param_pseudo_element) { … }

CORE_EXPORT void DidCreateAnimationImpl(Document*, unsigned);
inline void DidCreateAnimation(Document* param_document, unsigned param_unsigned) { … }

CORE_EXPORT void AnimationUpdatedImpl(Document*, Animation*);
inline void AnimationUpdated(Document* param_document, Animation* param_animation) { … }

CORE_EXPORT void WindowOpenImpl(ExecutionContext*, const KURL&, const AtomicString&, const WebWindowFeatures&, bool);
inline void WindowOpen(ExecutionContext* param_execution_context, const KURL& url, const AtomicString& window_name, const WebWindowFeatures& window_features, bool user_gestrue) { … }

CORE_EXPORT void ConsoleMessageAddedImpl(ExecutionContext*, ConsoleMessage*);
inline void ConsoleMessageAdded(ExecutionContext* param_execution_context, ConsoleMessage* param_console_message) { … }

CORE_EXPORT void InspectorIssueAddedImpl(CoreProbeSink*, protocol::Audits::InspectorIssue*);
inline void InspectorIssueAdded(CoreProbeSink* param_core_probe_sink, protocol::Audits::InspectorIssue* param_protocol) { … }

CORE_EXPORT void WillRunJavaScriptDialogImpl(LocalFrame*);
inline void WillRunJavaScriptDialog(LocalFrame* frame) { … }

CORE_EXPORT void DidRunJavaScriptDialogImpl(LocalFrame*);
inline void DidRunJavaScriptDialog(LocalFrame* frame) { … }

CORE_EXPORT void DocumentWriteFetchScriptImpl(Document*);
inline void DocumentWriteFetchScript(Document* param_document) { … }

CORE_EXPORT void DidChangeViewportImpl(LocalFrame*);
inline void DidChangeViewport(LocalFrame* document) { … }

CORE_EXPORT void BreakableLocationImpl(ExecutionContext*, const char*);
inline void BreakableLocation(ExecutionContext* context, const char* name) { … }

CORE_EXPORT void WillHandlePromiseImpl(ExecutionContext*, ScriptState*, bool, const char*, const String&, const String&);
inline void WillHandlePromise(ExecutionContext* context, ScriptState* script_state, bool resolving, const char* class_like_name, const String& property_like_name, const String& script_url) { … }

class CORE_EXPORT RecalculateStyle : public ProbeBase { … };

class CORE_EXPORT UpdateLayout : public ProbeBase { … };

class CORE_EXPORT EvaluateScriptBlock : public ProbeBase { … };

class CORE_EXPORT ExecuteScript : public ProbeBase { … };

class CORE_EXPORT CallFunction : public ProbeBase { … };

class CORE_EXPORT UserCallback : public ProbeBase { … };

class CORE_EXPORT InvokeCallback : public ProbeBase { … };

class CORE_EXPORT InvokeEventHandler : public ProbeBase { … };

class CORE_EXPORT V8Compile : public ProbeBase { … };

class CORE_EXPORT ParseHTML : public ProbeBase { … };

CORE_EXPORT void ForcePseudoStateImpl(Element*, CSSSelector::PseudoType, bool*);
inline void ForcePseudoState(Element* element, CSSSelector::PseudoType pseudo_state, bool* result) { … }

CORE_EXPORT void ShouldForceCorsPreflightImpl(ExecutionContext*, bool*);
inline void ShouldForceCorsPreflight(ExecutionContext* param_execution_context, bool* result) { … }

CORE_EXPORT void ShouldBlockRequestImpl(CoreProbeSink*, const KURL&, bool*);
inline void ShouldBlockRequest(CoreProbeSink* param_core_probe_sink, const KURL& param_kurl, bool* result) { … }

CORE_EXPORT void ShouldBypassServiceWorkerImpl(ExecutionContext*, bool*);
inline void ShouldBypassServiceWorker(ExecutionContext* context, bool* result) { … }

CORE_EXPORT void ConsoleTimeStampImpl(v8::Isolate*, v8::Local<v8::String>);
inline void ConsoleTimeStamp(v8::Isolate* isolate, v8::Local<v8::String> label) { … }

CORE_EXPORT void WillStartDebuggerTaskImpl(CoreProbeSink*);
inline void WillStartDebuggerTask(CoreProbeSink* param_core_probe_sink) { … }

CORE_EXPORT void DidFinishDebuggerTaskImpl(CoreProbeSink*);
inline void DidFinishDebuggerTask(CoreProbeSink* param_core_probe_sink) { … }

CORE_EXPORT void LifecycleEventImpl(LocalFrame*, DocumentLoader*, const char*, double);
inline void LifecycleEvent(LocalFrame* param_local_frame, DocumentLoader* param_document_loader, const char* name, double timestamp) { … }

CORE_EXPORT void PaintTimingImpl(Document*, const char*, double);
inline void PaintTiming(Document* param_document, const char* name, double timestamp) { … }

CORE_EXPORT void DidCreateAudioContextImpl(ExecutionContext*);
inline void DidCreateAudioContext(ExecutionContext* param_execution_context) { … }

CORE_EXPORT void DidCloseAudioContextImpl(ExecutionContext*);
inline void DidCloseAudioContext(ExecutionContext* param_execution_context) { … }

CORE_EXPORT void DidResumeAudioContextImpl(ExecutionContext*);
inline void DidResumeAudioContext(ExecutionContext* param_execution_context) { … }

CORE_EXPORT void DidSuspendAudioContextImpl(ExecutionContext*);
inline void DidSuspendAudioContext(ExecutionContext* param_execution_context) { … }

CORE_EXPORT void DidProduceCompilationCacheImpl(CoreProbeSink*, const ClassicScript&, v8::Local<v8::Script>);
inline void DidProduceCompilationCache(CoreProbeSink* param_core_probe_sink, const ClassicScript& param_classic_script, v8::Local<v8::Script> script) { … }

CORE_EXPORT void ApplyCompilationModeOverrideImpl(ExecutionContext*, const ClassicScript&, v8::ScriptCompiler::CachedData**, v8::ScriptCompiler::CompileOptions*);
inline void ApplyCompilationModeOverride(ExecutionContext* param_execution_context, const ClassicScript& param_classic_script, v8::ScriptCompiler::CachedData** cached_data, v8::ScriptCompiler::CompileOptions* param_v8) { … }

CORE_EXPORT void NodeCreatedImpl(Node*);
inline void NodeCreated(Node* node) { … }

CORE_EXPORT void FileChooserOpenedImpl(LocalFrame*, HTMLInputElement*, bool, bool*);
inline void FileChooserOpened(LocalFrame* frame, HTMLInputElement* element, bool multiple, bool* intercepted) { … }

CORE_EXPORT void PlayerErrorsRaisedImpl(ExecutionContext*, String, const Vector<InspectorPlayerError>&);
inline void PlayerErrorsRaised(ExecutionContext* context, String player_id, const Vector<InspectorPlayerError>& errors) { … }

CORE_EXPORT void PlayerEventsAddedImpl(ExecutionContext*, String, const Vector<InspectorPlayerEvent>&);
inline void PlayerEventsAdded(ExecutionContext* context, String player_id, const Vector<InspectorPlayerEvent>& events) { … }

CORE_EXPORT void PlayerMessagesLoggedImpl(ExecutionContext*, String, const Vector<InspectorPlayerMessage>&);
inline void PlayerMessagesLogged(ExecutionContext* context, String player_id, const Vector<InspectorPlayerMessage>& messages) { … }

CORE_EXPORT void PlayerPropertiesChangedImpl(ExecutionContext*, String, const Vector<InspectorPlayerProperty>&);
inline void PlayerPropertiesChanged(ExecutionContext* context, String player_id, const Vector<InspectorPlayerProperty>& properties) { … }

CORE_EXPORT void PlayersCreatedImpl(ExecutionContext*, const Vector<WebString>&);
inline void PlayersCreated(ExecutionContext* context, const Vector<WebString>& players) { … }

CORE_EXPORT void SetDevToolsIdsImpl(CoreProbeSink*, ResourceRequest&, const FetchInitiatorInfo&);
inline void SetDevToolsIds(CoreProbeSink* param_core_probe_sink, ResourceRequest& request, const FetchInitiatorInfo& param_fetch_initiator_info) { … }

CORE_EXPORT void DidMutateStyleSheetImpl(Document*, CSSStyleSheet*);
inline void DidMutateStyleSheet(Document* param_document, CSSStyleSheet* style_sheet) { … }

CORE_EXPORT void DidReplaceStyleSheetTextImpl(Document*, CSSStyleSheet*, const String&);
inline void DidReplaceStyleSheetText(Document* param_document, CSSStyleSheet* style_sheet, const String& text) { … }

CORE_EXPORT void GetTextPositionImpl(Document*, wtf_size_t, const String*, TextPosition*);
inline void GetTextPosition(Document* param_document, wtf_size_t offset, const String* text, TextPosition* result) { … }

CORE_EXPORT void LocalFontsEnabledImpl(ExecutionContext*, bool*);
inline void LocalFontsEnabled(ExecutionContext* param_execution_context, bool* result) { … }

CORE_EXPORT void DidUpdateComputedStyleImpl(Element*, const ComputedStyle*, const ComputedStyle*);
inline void DidUpdateComputedStyle(Element* param_element, const ComputedStyle* old_style, const ComputedStyle* new_style) { … }

CORE_EXPORT void GetDisabledImageTypesImpl(ExecutionContext*, HashSet<String>*);
inline void GetDisabledImageTypes(ExecutionContext* param_execution_context, HashSet<String>* result) { … }

CORE_EXPORT void OnContentSecurityPolicyViolationImpl(ExecutionContext*, const blink::ContentSecurityPolicyViolationType);
inline void OnContentSecurityPolicyViolation(ExecutionContext* context, const blink::ContentSecurityPolicyViolationType violationType) { … }

CORE_EXPORT void IsCacheDisabledImpl(ExecutionContext*, bool*);
inline void IsCacheDisabled(ExecutionContext* param_execution_context, bool* is_cache_disabled) { … }

CORE_EXPORT void PerformanceEntryAddedImpl(ExecutionContext*, PerformanceEntry*);
inline void PerformanceEntryAdded(ExecutionContext* param_execution_context, PerformanceEntry* param_performance_entry) { … }

CORE_EXPORT void ApplyAutomationOverrideImpl(ExecutionContext*, bool&);
inline void ApplyAutomationOverride(ExecutionContext* param_execution_context, bool& enabled) { … }

CORE_EXPORT void DidAddSpeculationRuleSetImpl(Document&, const SpeculationRuleSet&);
inline void DidAddSpeculationRuleSet(Document& param_document, const SpeculationRuleSet& rule_set) { … }

CORE_EXPORT void DidRemoveSpeculationRuleSetImpl(Document&, const SpeculationRuleSet&);
inline void DidRemoveSpeculationRuleSet(Document& param_document, const SpeculationRuleSet& rule_set) { … }

CORE_EXPORT void SpeculationCandidatesUpdatedImpl(Document&, const HeapVector<Member<SpeculationCandidate>>&);
inline void SpeculationCandidatesUpdated(Document& param_document, const HeapVector<Member<SpeculationCandidate>>& candidates) { … }

CORE_EXPORT void DidInitializeFrameWidgetImpl(LocalFrame*);
inline void DidInitializeFrameWidget(LocalFrame* document) { … }

} // namespace probe
} // namespace blink

#endif // THIRD_PARTY_BLINK_RENDERER_CORE_CORE_PROBES_INL_H_
chromium/out/Default/gen/third_party/blink/renderer/core/core_probes_inl.h
