core_probes_impl.cc | 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_impl.cc.tmpl
// and input files:
//   core_probes.pidl


#include "third_party/blink/renderer/core/core_probes_inl.h"
#include "third_party/blink/renderer/core/core_probe_sink.h"
#include "third_party/blink/renderer/core/frame/ad_tracker.h"
#include "third_party/blink/renderer/core/frame/animation_frame_timing_monitor.h"
#include "third_party/blink/renderer/core/inspector/devtools_session.h"
#include "third_party/blink/renderer/core/inspector/inspector_animation_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_audits_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_css_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_dom_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_dom_debugger_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_dom_snapshot_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_emulation_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_event_breakpoints_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_issue_reporter.h"
#include "third_party/blink/renderer/core/inspector/inspector_layer_tree_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_log_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_media_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_network_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_overlay_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_page_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_performance_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_performance_timeline_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_preload_agent.h"
#include "third_party/blink/renderer/core/inspector/inspector_trace_events.h"
#include "third_party/blink/renderer/core/lcp_critical_path_predictor/lcp_script_observer.h"
#include "third_party/blink/renderer/core/frame/performance_monitor.h"
#include "base/synchronization/lock.h"

namespace blink {

namespace {

base::Lock& AgentCountLock() { … }

}  // namespace

// static
std::atomic<unsigned> CoreProbeSink::s_existingAgents;

CoreProbeSink::CoreProbeSink() { … }

CoreProbeSink::~CoreProbeSink() { … }


// static
unsigned CoreProbeSink::s_numSinksWithAdTracker = …;

void CoreProbeSink::AddAdTracker(AdTracker* agent) { … }

void CoreProbeSink::RemoveAdTracker(AdTracker* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithAnimationFrameTimingMonitor = …;

void CoreProbeSink::AddAnimationFrameTimingMonitor(AnimationFrameTimingMonitor* agent) { … }

void CoreProbeSink::RemoveAnimationFrameTimingMonitor(AnimationFrameTimingMonitor* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithDevToolsSession = …;

void CoreProbeSink::AddDevToolsSession(DevToolsSession* agent) { … }

void CoreProbeSink::RemoveDevToolsSession(DevToolsSession* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorAnimationAgent = …;

void CoreProbeSink::AddInspectorAnimationAgent(InspectorAnimationAgent* agent) { … }

void CoreProbeSink::RemoveInspectorAnimationAgent(InspectorAnimationAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorAuditsAgent = …;

void CoreProbeSink::AddInspectorAuditsAgent(InspectorAuditsAgent* agent) { … }

void CoreProbeSink::RemoveInspectorAuditsAgent(InspectorAuditsAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorCSSAgent = …;

void CoreProbeSink::AddInspectorCSSAgent(InspectorCSSAgent* agent) { … }

void CoreProbeSink::RemoveInspectorCSSAgent(InspectorCSSAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorDOMAgent = …;

void CoreProbeSink::AddInspectorDOMAgent(InspectorDOMAgent* agent) { … }

void CoreProbeSink::RemoveInspectorDOMAgent(InspectorDOMAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorDOMDebuggerAgent = …;

void CoreProbeSink::AddInspectorDOMDebuggerAgent(InspectorDOMDebuggerAgent* agent) { … }

void CoreProbeSink::RemoveInspectorDOMDebuggerAgent(InspectorDOMDebuggerAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorDOMSnapshotAgent = …;

void CoreProbeSink::AddInspectorDOMSnapshotAgent(InspectorDOMSnapshotAgent* agent) { … }

void CoreProbeSink::RemoveInspectorDOMSnapshotAgent(InspectorDOMSnapshotAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorEmulationAgent = …;

void CoreProbeSink::AddInspectorEmulationAgent(InspectorEmulationAgent* agent) { … }

void CoreProbeSink::RemoveInspectorEmulationAgent(InspectorEmulationAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorEventBreakpointsAgent = …;

void CoreProbeSink::AddInspectorEventBreakpointsAgent(InspectorEventBreakpointsAgent* agent) { … }

void CoreProbeSink::RemoveInspectorEventBreakpointsAgent(InspectorEventBreakpointsAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorIssueReporter = …;

void CoreProbeSink::AddInspectorIssueReporter(InspectorIssueReporter* agent) { … }

void CoreProbeSink::RemoveInspectorIssueReporter(InspectorIssueReporter* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorLayerTreeAgent = …;

void CoreProbeSink::AddInspectorLayerTreeAgent(InspectorLayerTreeAgent* agent) { … }

void CoreProbeSink::RemoveInspectorLayerTreeAgent(InspectorLayerTreeAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorLogAgent = …;

void CoreProbeSink::AddInspectorLogAgent(InspectorLogAgent* agent) { … }

void CoreProbeSink::RemoveInspectorLogAgent(InspectorLogAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorMediaAgent = …;

void CoreProbeSink::AddInspectorMediaAgent(InspectorMediaAgent* agent) { … }

void CoreProbeSink::RemoveInspectorMediaAgent(InspectorMediaAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorNetworkAgent = …;

void CoreProbeSink::AddInspectorNetworkAgent(InspectorNetworkAgent* agent) { … }

void CoreProbeSink::RemoveInspectorNetworkAgent(InspectorNetworkAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorOverlayAgent = …;

void CoreProbeSink::AddInspectorOverlayAgent(InspectorOverlayAgent* agent) { … }

void CoreProbeSink::RemoveInspectorOverlayAgent(InspectorOverlayAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorPageAgent = …;

void CoreProbeSink::AddInspectorPageAgent(InspectorPageAgent* agent) { … }

void CoreProbeSink::RemoveInspectorPageAgent(InspectorPageAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorPerformanceAgent = …;

void CoreProbeSink::AddInspectorPerformanceAgent(InspectorPerformanceAgent* agent) { … }

void CoreProbeSink::RemoveInspectorPerformanceAgent(InspectorPerformanceAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorPerformanceTimelineAgent = …;

void CoreProbeSink::AddInspectorPerformanceTimelineAgent(InspectorPerformanceTimelineAgent* agent) { … }

void CoreProbeSink::RemoveInspectorPerformanceTimelineAgent(InspectorPerformanceTimelineAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorPreloadAgent = …;

void CoreProbeSink::AddInspectorPreloadAgent(InspectorPreloadAgent* agent) { … }

void CoreProbeSink::RemoveInspectorPreloadAgent(InspectorPreloadAgent* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithInspectorTraceEvents = …;

void CoreProbeSink::AddInspectorTraceEvents(InspectorTraceEvents* agent) { … }

void CoreProbeSink::RemoveInspectorTraceEvents(InspectorTraceEvents* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithLCPScriptObserver = …;

void CoreProbeSink::AddLCPScriptObserver(LCPScriptObserver* agent) { … }

void CoreProbeSink::RemoveLCPScriptObserver(LCPScriptObserver* agent) { … }


// static
unsigned CoreProbeSink::s_numSinksWithPerformanceMonitor = …;

void CoreProbeSink::AddPerformanceMonitor(PerformanceMonitor* agent) { … }

void CoreProbeSink::RemovePerformanceMonitor(PerformanceMonitor* agent) { … }

void CoreProbeSink::Trace(Visitor* visitor) const
{ … }

namespace probe {

void DidClearDocumentOfWindowObjectImpl(LocalFrame* param_local_frame) { … }

void DidCreateMainWorldContextImpl(LocalFrame* param_local_frame) { … }

void WillInsertDOMNodeImpl(Node* parent) { … }

void DidInsertDOMNodeImpl(Node* param_node) { … }

void WillRemoveDOMNodeImpl(Node* param_node) { … }

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

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

void DidRemoveDOMAttrImpl(Element* param_element, const QualifiedName& name) { … }

void WillChangeStyleElementImpl(Element* param_element) { … }

void CharacterDataModifiedImpl(CharacterData* param_character_data) { … }

void DidInvalidateStyleAttrImpl(Node* param_node) { … }

void DidPerformSlotDistributionImpl(HTMLSlotElement* param_html_slot_element) { … }

void DocumentDetachedImpl(Document* param_document) { … }

void ActiveStyleSheetsUpdatedImpl(Document* param_document) { … }

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

void MediaQueryResultChangedImpl(Document* param_document) { … }

void DidPushShadowRootImpl(Element* host, ShadowRoot* param_shadow_root) { … }

void WillPopShadowRootImpl(Element* host, ShadowRoot* param_shadow_root) { … }

void WillSendXMLHttpOrFetchNetworkRequestImpl(ExecutionContext* param_execution_context, const String& url) { … }

void DidCreateCanvasContextImpl(Document* param_document) { … }

void DidCreateOffscreenCanvasContextImpl(OffscreenCanvas* param_offscreen_canvas) { … }

void DidFireWebGLErrorImpl(Element* param_element, const String& error_name) { … }

void DidFireWebGLWarningImpl(Element* param_element) { … }

void DidFireWebGLErrorOrWarningImpl(Element* param_element, const String& message) { … }

void DidResizeMainFrameImpl(LocalFrame* param_local_frame) { … }

void ApplyAcceptLanguageOverrideImpl(ExecutionContext* param_execution_context, String* accept_language) { … }

void ApplyAcceptLanguageOverrideImpl(CoreProbeSink* param_core_probe_sink, String* accept_language) { … }

void ApplyHardwareConcurrencyOverrideImpl(CoreProbeSink* param_core_probe_sink, unsigned int& hardware_concurrency) { … }

void ApplyUserAgentOverrideImpl(CoreProbeSink* param_core_probe_sink, String* user_agent) { … }

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

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

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

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

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

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

void MarkResourceAsCachedImpl(LocalFrame* param_local_frame, DocumentLoader* param_document_loader, uint64_t identifier) { … }

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

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

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

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

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

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

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

void WillSendEventSourceRequestImpl(ExecutionContext* param_execution_context) { … }

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

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

void DidFinishXHRImpl(ExecutionContext* param_execution_context, XMLHttpRequest* xhr) { … }

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

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

void ScriptExecutionBlockedByCSPImpl(ExecutionContext* param_execution_context, const String& directive_text) { … }

void DidReceiveScriptResponseImpl(ExecutionContext* param_execution_context, uint64_t identifier) { … }

void DomContentLoadedEventFiredImpl(LocalFrame* param_local_frame) { … }

void LoadEventFiredImpl(LocalFrame* param_local_frame) { … }

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

void FrameDetachedFromParentImpl(LocalFrame* param_local_frame, FrameDetachType param_frame_detach_type) { … }

void FrameSubtreeWillBeDetachedImpl(LocalFrame* param_local_frame, Frame* param_frame) { … }

void DidStartProvisionalLoadImpl(LocalFrame* param_local_frame) { … }

void DidFailProvisionalLoadImpl(LocalFrame* param_local_frame) { … }

void WillCommitLoadImpl(LocalFrame* param_local_frame, DocumentLoader* param_document_loader) { … }

void DidCommitLoadImpl(LocalFrame* param_local_frame, DocumentLoader* param_document_loader) { … }

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

void DidRestoreFromBackForwardCacheImpl(LocalFrame* param_local_frame) { … }

void DidOpenDocumentImpl(LocalFrame* param_local_frame, DocumentLoader* param_document_loader) { … }

void WillCreateDocumentParserImpl(Document* param_document, bool& force_sync_parsing) { … }

void FrameDocumentUpdatedImpl(LocalFrame* param_local_frame) { … }

void FrameOwnerContentUpdatedImpl(LocalFrame* param_local_frame, HTMLFrameOwnerElement* param_html_frame_owner_element) { … }

void FrameStartedLoadingImpl(LocalFrame* param_local_frame) { … }

void FrameStoppedLoadingImpl(LocalFrame* param_local_frame) { … }

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

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

void FrameClearedScheduledNavigationImpl(LocalFrame* param_local_frame) { … }

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

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

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

void DidCloseWebSocketImpl(ExecutionContext* param_execution_context, uint64_t identifier) { … }

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

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

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

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

void WebTransportConnectionEstablishedImpl(ExecutionContext* param_execution_context, uint64_t transport_id) { … }

void WebTransportClosedImpl(ExecutionContext* param_execution_context, uint64_t transport_id) { … }

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

void LayerTreeDidChangeImpl(LocalFrame* param_local_frame) { … }

void LayerTreePaintedImpl(LocalFrame* param_local_frame) { … }

void PseudoElementCreatedImpl(PseudoElement* param_pseudo_element) { … }

void TopLayerElementsChangedImpl(Document* param_document) { … }

void PseudoElementDestroyedImpl(PseudoElement* param_pseudo_element) { … }

void DidCreateAnimationImpl(Document* param_document, unsigned param_unsigned) { … }

void AnimationUpdatedImpl(Document* param_document, Animation* param_animation) { … }

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

void ConsoleMessageAddedImpl(ExecutionContext* param_execution_context, ConsoleMessage* param_console_message) { … }

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

void WillRunJavaScriptDialogImpl(LocalFrame* frame) { … }

void DidRunJavaScriptDialogImpl(LocalFrame* frame) { … }

void DocumentWriteFetchScriptImpl(Document* param_document) { … }

void DidChangeViewportImpl(LocalFrame* document) { … }

void BreakableLocationImpl(ExecutionContext* context, const char* name) { … }

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

RecalculateStyle::RecalculateStyle(Document* document) : … { … }

RecalculateStyle::~RecalculateStyle() { … }

UpdateLayout::UpdateLayout(Document* document) : … { … }

UpdateLayout::~UpdateLayout() { … }

EvaluateScriptBlock::EvaluateScriptBlock(ScriptState* script_state, std::reference_wrapper<std::remove_reference_t<const KURL&>> source_url, bool is_module, bool sanitize) : … { … }

EvaluateScriptBlock::~EvaluateScriptBlock() { … }

ExecuteScript::ExecuteScript(ExecutionContext* context, v8::Local<v8::Context> v8_context, std::reference_wrapper<std::remove_reference_t<const String&>> script_url, int script_id) : … { … }

ExecuteScript::~ExecuteScript() { … }

CallFunction::CallFunction(ExecutionContext* context, v8::Local<v8::Context> v8_context, v8::Local<v8::Function> function, int depth) : … { … }

CallFunction::~CallFunction() { … }

UserCallback::UserCallback(ExecutionContext* context, const char* name, AtomicString atomic_name, bool recurring, EventTarget* event_target, Event* event, EventListener* listener) : … { … }

UserCallback::~UserCallback() { … }

InvokeCallback::InvokeCallback(ScriptState* script_state, const char* name, CallbackFunctionBase* callback, v8::MaybeLocal<v8::Value> function) : … { … }

InvokeCallback::~InvokeCallback() { … }

InvokeEventHandler::InvokeEventHandler(ScriptState* script_state, Event* event, JSBasedEventListener* listener) : … { … }

InvokeEventHandler::~InvokeEventHandler() { … }

V8Compile::V8Compile(ExecutionContext* context, std::reference_wrapper<std::remove_reference_t<const String&>> file_name, int line, int column) : … { … }

V8Compile::~V8Compile() { … }

ParseHTML::ParseHTML(Document* document, HTMLDocumentParser* parser) : … { … }

ParseHTML::~ParseHTML() { … }

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

void ShouldForceCorsPreflightImpl(ExecutionContext* param_execution_context, bool* result) { … }

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

void ShouldBypassServiceWorkerImpl(ExecutionContext* context, bool* result) { … }

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

void WillStartDebuggerTaskImpl(CoreProbeSink* param_core_probe_sink) { … }

void DidFinishDebuggerTaskImpl(CoreProbeSink* param_core_probe_sink) { … }

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

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

void DidCreateAudioContextImpl(ExecutionContext* param_execution_context) { … }

void DidCloseAudioContextImpl(ExecutionContext* param_execution_context) { … }

void DidResumeAudioContextImpl(ExecutionContext* param_execution_context) { … }

void DidSuspendAudioContextImpl(ExecutionContext* param_execution_context) { … }

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

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

void NodeCreatedImpl(Node* node) { … }

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

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

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

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

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

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

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

void DidMutateStyleSheetImpl(Document* param_document, CSSStyleSheet* style_sheet) { … }

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

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

void LocalFontsEnabledImpl(ExecutionContext* param_execution_context, bool* result) { … }

void DidUpdateComputedStyleImpl(Element* param_element, const ComputedStyle* old_style, const ComputedStyle* new_style) { … }

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

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

void IsCacheDisabledImpl(ExecutionContext* param_execution_context, bool* is_cache_disabled) { … }

void PerformanceEntryAddedImpl(ExecutionContext* param_execution_context, PerformanceEntry* param_performance_entry) { … }

void ApplyAutomationOverrideImpl(ExecutionContext* param_execution_context, bool& enabled) { … }

void DidAddSpeculationRuleSetImpl(Document& param_document, const SpeculationRuleSet& rule_set) { … }

void DidRemoveSpeculationRuleSetImpl(Document& param_document, const SpeculationRuleSet& rule_set) { … }

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

void DidInitializeFrameWidgetImpl(LocalFrame* document) { … }


} // namespace probe
} // namespace blink
chromium/out/Default/gen/third_party/blink/renderer/core/core_probes_impl.cc
