1. Introduction
1.1. Overview
This section is non-normative.
When a user engages with a website, they expect their actions to cause changes to the website quickly. In fact, research suggests that any user input that is not handled within 100ms is considered slow. Therefore, it is important to surface performance timing information about input events that could not achieve those guidelines.
A
common
way
to
monitor
event
latency
consists
of
registering
an
event
listener.
The
timestamp
at
which
the
event
was
created
can
be
obtained
via
the
event’s
timeStamp
.
In
addition,
performance.now()
could
be
called
both
at
the
beginning
and
at
the
end
of
the
event
handler
logic.
By
subtracting
the
hardware
timestamp
from
the
timestamp
obtained
at
the
beginning
of
the
event
handler,
the
developer
can
compute
the
input
delay
:
the
time
it
takes
for
an
input
to
start
being
processed.
By
subtracting
the
timestamp
obtained
at
the
beginning
of
the
event
handler
from
the
timestamp
obtained
at
the
end
of
the
event
handler,
the
developer
can
compute
the
amount
of
synchronous
work
performed
in
the
event
handler.
Finally,
when
inputs
are
handled
synchronously,
the
duration
from
event
hardware
timestamp
to
the
next
paint
after
the
event
is
handled
is
a
useful
user
experience
metric.
This approach has several fundamental flaws. First, requiring event listeners precludes measuring event latency very early in the page load because listeners might not be registered yet. Second, developers who are only interested in input delay might be forced to add new listeners to events that originally did not have them. This adds unnecessary performance overhead to the event latency calculation. And lastly, it would be very hard to measure asynchronous work caused by the event via this approach.
This specification provides an alternative to event latency monitoring that solves some of these problems. Since the user agent computes the timestamps, there is no need for event listeners in order to measure performance. This means that even events that occur very early in the page load can be captured. This also enables visibility into slow events without requiring analytics providers to attempt to patch and subscribe to every conceivable event. In addition to this, the website’s performance will not suffer from the overhead of unneeded event listeners. Finally, this specification allows developers to obtain detailed information about the timing of the rendering that occurs right after the event has been processed. This can be useful to measure the overhead of website modifications that are triggered by events.
1.2. Interactions
This section is non-normative.
A
single
user
Interaction
(sometimes
called
a
Gesture)
is
typically
made
up
of
multiple
physical
hardware
input
events.
Each
physical
input
event
might
cause
the
User
Agent
to
dispatch
several
UIEvent
s,
and
each
of
those
might
trigger
multiple
custom
event
listeners,
or
trigger
distinct
default
actions.
For example, a single user "tap" interaction with a touchscreen device is actually made up of a sequence of physical input events:
-
a touch start,
-
a tiny amount of touch movement,
-
a touch end.
Those
physical
input
events
might
dispatch
a
series
of
UIEvent
s:
These
individual
UIEvent
s
will
each
become
candidates
for
their
own
PerformanceEventTiming
entry
reporting,
which
is
useful
for
detailed
timing.
Note:
pointermove
and
touchmove
are
not
currently
considered
for
Event
Timing
.
However,
this
specification
also
defines
a
mechanism
for
grouping
related
PerformanceEventTiming
s
into
Interaction
s
via
an
interactionId
.
This
mechanism
can
be
used
to
define
a
page
responsiveness
metric
called
Interaction
to
Next
Paint
(INP)
.
The
INP
explainer
describes
how
to
derive
this
metric
from
Event
Timing
entries.
1.3. First Input
This section is non-normative.
The
very
first
user
Interaction
typically
has
a
disproportionate
impact
on
user
experience,
and
is
also
often
disproportionately
slow.
To
that
effect,
the
Event
Timing
API
exposes
timing
information
about
the
first
input
of
a
Window
,
defined
as
the
first
PerformanceEventTiming
entry
with
a
non-0
interactionId
.
Unlike
most
PerformanceEventTiming
s,
the
first
input
entry
is
reported
even
if
it
does
not
exceed
a
provided
durationThreshold
,
and
is
buffered
even
if
it
does
not
exceed
the
default
duration
threshold
of
104ms.
This
mechanism
can
be
used
to
define
a
page
responsiveness
metric
called
First
Input
Delay
(FID)
.
This also allows developers to better measure percentiles and performance improvements, by including data even from pages which are always very responsive, without having to register event handlers.
1.4. Events exposed
The Event Timing API exposes timing information only for certain events.
-
If event ’s
isTrustedattribute value is set to false, return false. -
If event ’s
typeis one of the following:auxclick,click,contextmenu,dblclick,mousedown,mouseenter,mouseleave,mouseout,mouseover,mouseup,pointerover,pointerenter,pointerdown,pointerup,pointercancel,pointerout,pointerleave,gotpointercapture,lostpointercapture,touchstart,touchend,touchcancel,keydown,keypress,keyup,beforeinput,input,compositionstart,compositionupdate,compositionend,dragstart,dragend,dragenter,dragleave,dragover,drop, return true. -
Return false.
Note:
mousemove
,
pointermove
,
pointerrawupdate
,
touchmove
,
wheel
,
and
drag
are
excluded
because
these
are
"continuous"
events.
The
current
API
does
not
have
enough
guidance
on
how
to
count
and
aggregate
these
events
to
obtain
meaningful
performance
metrics
based
on
entries.
Therefore,
these
event
types
are
not
exposed.
1.5. When events are measured
This section is non-normative. It explains at a high level the information that is exposed in the § 3 Processing model section.
Event timing information is only exposed for certain events, and only when the time difference between user input and paint operations that follow input processing exceeds a certain duration threshold.
The
Event
Timing
API
exposes
a
duration
value,
which
is
meant
to
be
the
time
from
when
the
physical
user
input
occurs
(estimated
via
the
Event
’s
timeStamp
)
to
the
next
time
the
rendering
of
the
Event
’s
relevant
global
object
’s
associated
Document
is
updated.
This
value
is
provided
with
8
millisecond
granularity.
By
default,
the
Event
Timing
API
buffers
and
exposes
entries
when
the
duration
is
104
or
greater,
but
a
developer
can
set
up
a
PerformanceObserver
to
observe
future
entries
with
a
different
threshold.
Note
that
this
does
not
change
the
entries
that
are
buffered
and
hence
the
buffered
flag
only
enables
receiving
past
entries
with
duration
greater
than
or
equal
to
the
default
threshold.
An
Event
’s
delay
is
the
difference
between
the
time
when
the
browser
is
about
to
run
event
handlers
for
the
event
and
the
Event
’s
timeStamp
.
The
former
point
in
time
is
exposed
as
the
PerformanceEventTiming
’s
processingStart
,
whereas
the
latter
is
exposed
as
PerformanceEventTiming
’s
startTime
.
Therefore,
an
Event
’s
delay
can
be
computed
as
.
processingStart
startTime
Note
that
the
Event
Timing
API
creates
entries
for
events
regardless
of
whether
they
have
any
event
listeners.
In
particular,
the
first
click
or
the
first
key
might
not
be
the
user
actually
trying
to
interact
with
the
page
functionality;
many
users
do
things
like
select
text
while
they’re
reading
or
click
in
blank
areas
to
control
what
has
focus.
This
is
a
design
choice
to
capture
problems
with
pages
which
register
their
event
listeners
too
late
and
to
capture
performance
of
inputs
that
are
meaningful
despite
not
having
event
listeners,
such
as
hover
effects.
Developers
can
choose
to
ignore
such
entries
by
ignoring
those
with
essentially
zero
values
of
,
as
processingEnd
processingStart
processingEnd
is
the
time
when
the
event
dispatch
algorithm
algorithm
has
concluded.
1.6. Usage example
const observer= new PerformanceObserver( function ( list, obs) { for ( let entryof list. getEntries()) { // Input Delay const inputDelay= entry. processingStart- entry. startTime; // Processing duration const processingDuration= entry. processingEnd- entry. processingStart; // Presentation Delay (approximate) const presentationDelay= Math. max( 0 , entry. startTime+ entry. duration- entry. processingEnd); // Obtain some information about the target of this event, such as the id. const targetId= entry. target? entry. target. id: 'unknown-target' ; console. log( entry. entryType, entry. name, entry. duration, { inputDelay, processingDuration, presentationDelay}); } }); observer. observe({ type: 'first-input' , buffered: true }); observer. observe({ type: 'event' , buffered: true , durationThreshold: 40 });
The
following
example
computes
a
dictionary
mapping
interactionId
to
the
maximum
duration
of
any
of
its
events.
This
dictionary
can
later
be
aggregated
and
reported
to
analytics.
let maxDurations= {}; new PerformanceObserver( list=> { for ( let entryof list. getEntries()) { if ( entry. interactionId> 0 ) { let id= entry. interactionId; if ( ! maxDurations[ id]) { maxDurations[ id] = entry. duration; } else { maxDurations[ id] = Math. max( maxDurations[ id], entry. duration); } } } }). observe({ type: 'event' , buffered: true , durationThreshold: 16 });
The following are sample use cases that could be achieved by using this API:
-
Gather first input delay data on a website and track its performance over time.
-
Clicking a button changes the sorting order on a table. Measure how long it takes from the click until we display reordered content.
-
A user drags a slider to control volume. Measure the latency to drag the slider.
-
Hovering a menu item triggers a flyout menu. Measure the latency for the flyout to appear.
-
Measure the 75’th percentile of the latency of the first user click (whenever click happens to be the first user interaction).
2. Event Timing
Event Timing adds the following interfaces:
2.1.
PerformanceEventTiming
interface
[Exposed =Window ]interface :PerformanceEventTiming PerformanceEntry {readonly attribute DOMHighResTimeStamp processingStart ;readonly attribute DOMHighResTimeStamp processingEnd ;readonly attribute boolean cancelable ;readonly attribute Node ?;target readonly attribute DOMString targetSelector ;readonly attribute unsigned long long interactionId ; [Default ]object (); };toJSON
A
PerformanceEventTiming
object
reports
timing
information
about
one
associated
Event
.
Each
PerformanceEventTiming
object
has
these
associated
concepts,
all
of
which
are
initially
set
to
:
-
An eventTarget containing the associated
Node.
The
target
attribute’s
getter
must
perform
the
following
steps:
-
If this ’s eventTarget is not exposed for paint timing given null, return null.
-
Return this ’s eventTarget .
Note:
A
user
agent
implementing
the
Event
Timing
API
would
need
to
include
"
first
"
and
"
event
"
in
supportedEntryTypes
for
Window
contexts.
This
allows
developers
to
detect
support
for
event
timing.
This
remainder
of
this
section
is
non-normative.
The
values
of
the
attributes
of
PerformanceEventTiming
are
set
in
the
processing
model
in
§ 3
Processing
model
.
This
section
provides
an
informative
summary
of
how
they
will
be
set.
PerformanceEventTiming
extends
the
following
attributes
of
the
PerformanceEntry
interface:
-
name -
The
nameattribute’s getter provides the associated event ’stype. -
entryType -
The
entryTypeattribute’s getter returns "event" (for long events) or "first" (for the first user interaction).- input -
startTime -
The
startTimeattribute’s getter returns the associated event ’stimeStamp. -
duration -
The
durationattribute’s getter returns the difference between the next time the update the rendering steps are completed for the associated event ’sDocumentafter the associated event has been dispatched, and thestartTime, rounded to the nearest 8ms.
PerformanceEventTiming
has
the
following
additional
attributes:
-
processingStart -
The
processingStartattribute’s getter returns a timestamp captured at the beginning of the event dispatch algorithm . This is when event handlers are about to be executed. -
processingEnd -
The
processingEndattribute’s getter returns a timestamp captured at the end of the event dispatch algorithm . This is when event handlers have finished executing. It’s equal toprocessingStartwhen there are no such event handlers. -
cancelable -
The
cancelableattribute’s getter returns the associated event ’scancelableattribute value. -
target -
The
targetattribute’s getter returns the associated event ’s lasttargetwhen suchNodeis not disconnected nor in the shadow DOM. -
targetSelector -
The
targetSelectorattribute’s getter returns a string that identifies the associated event ’s lasttarget. -
interactionId -
The
interactionIdattribute’s getter returns a number that uniquely identifies the userInteractionwhich triggered the associated event . This attribute is 0 unless the associated event ’stypeattribute value is one of:-
A
pointerdown,pointerup, orclick, and belongs to a tap or drag gesture. Note thatpointerdownthat ends in scroll is excluded.
-
2.2.
EventCounts
interface
[Exposed =Window ]interface {EventCounts readonly maplike <DOMString ,unsigned long long >; };
The
EventCounts
object
is
a
map
where
the
keys
are
event
types
and
the
values
are
the
number
of
events
that
have
been
dispatched
that
are
of
that
type
.
Only
events
whose
type
is
supported
by
PerformanceEventTiming
entries
(see
section
§ 1.4
Events
exposed
)
are
counted
via
this
map.
2.3.
Extensions
to
the
Performance
interface
[Exposed =Window ]partial interface Performance { [SameObject ]readonly attribute EventCounts ;eventCounts readonly attribute unsigned long long ; };interactionCount
The
eventCounts
attribute’s
getter
returns
this
’s
relevant
global
object
’s
eventCounts
.
The
interactionCount
attribute’s
getter
returns
this
’s
relevant
global
object
’s
interactionCount
.
3. Processing model
3.1. Modifications to the DOM specification
This section will be removed once [DOM] has been modified.
Right after step 1, we add the following steps:
-
Let interactionId be the result of computing interactionId given event .
-
Let timingEntry be the result of initializing event timing given event , the current high resolution time , and interactionId .
Right before the returning step of that algorithm, add the following step:
-
Finalize event timing passing timingEntry , event , target , and the current high resolution time as inputs.
Note:
If
a
user
agent
skips
the
event
dispatch
algorithm
,
it
can
still
choose
to
include
an
entry
for
that
Event
.
In
this
case,
it
will
estimate
the
value
of
processingStart
and
set
the
processingEnd
to
the
same
value.
3.2. Modifications to the HTML specification
This section will be removed once [HTML] has been modified.
Each
Window
has
the
following
associated
concepts:
-
entries to be queued , a list that stores
PerformanceEventTimingobjects, which will initially be empty. -
has dispatched input event , a boolean which is initially set to false.
-
user interaction value , an integer which is initially set to a random integer between 100 and 10000.
Note: The user interaction value is set to a random integer instead of 0 so that developers do not rely on it to count the number of interactions in the page. By starting at a random value, developers are less likely to use it as the source of truth for the number of interactions that have occurred in the page.
-
pending key downs , a map of integers to
PerformanceEventTimingswhich is initially empty. -
pointer interaction value map , a map of integers which is initially empty.
-
pending pointer downs , a map of integers to
PerformanceEventTimingswhich is initially empty. -
is contextmenu triggered , a boolean which is initially set to false.
-
eventCounts , a map with entries of the form type → numEvents . This means that there have been numEvents dispatched such that their
typeattribute value is equal to type . Upon construction of aPerformanceobject whose relevant global object is aWindow, its eventCounts must be initialized to a map containing 0s for all event types that the user agent supports from the list described in § 1.4 Events exposed . -
interactionCount , an integer which counts the total number of distinct user interactions, for which there was a unique
interactionIdcomputed via computing interactionId .
-
For each fully active
Documentin docs , invoke the algorithm to dispatch pending Event Timing entries for thatDocument.
3.3. Modifications to the Performance Timeline specification
This section will be removed once [PERFORMANCE-TIMELINE-2] had been modified.
The
PerformanceObserverInit
dictionary
is
augmented:
partial dictionary PerformanceObserverInit {DOMHighResTimeStamp ; };durationThreshold
3.4. Should add PerformanceEventTiming
Note:
The
following
algorithm
is
used
in
the
[PERFORMANCE-TIMELINE-2]
specification
to
determine
when
a
PerformanceEventTiming
entry
needs
to
be
added
to
the
buffer
of
a
PerformanceObserver
or
to
the
performance
timeline,
as
described
in
the
registry
.
PerformanceEventTiming
entry
and
a
PerformanceObserverInit
options
,
to
determine
if
we
should
add
PerformanceEventTiming
,
with
entry
and
optionally
options
as
inputs,
run
the
following
steps:
-
If entry ’s
entryTypeattribute value equals to "first", return true.- input -
Assert that entry ’s
entryTypeattribute value equals "event". -
Let minDuration be computed as follows:
-
If options is not present or if options ’s
durationThresholdis not present, let minDuration be 104. -
Otherwise, let minDuration be the maximum between 16 and options ’s
durationThresholdvalue.
-
-
If entry ’s
durationattribute value is greater than or equal to minDuration , return true. -
Otherwise, return false.
3.5. Increasing interaction count
Window
window
object,
perform
the
following
steps:
-
Increase window ’s user interaction value value by a small number chosen by the user agent.
-
Let interactionCount be window ’s interactionCount .
-
Set interactionCount to interactionCount + 1.
Note: The user interaction value is increased by a small number chosen by the user agent instead of 1 to discourage developers from considering it as a counter of the number of user interactions that have occurred in the web application. This allows the user agent to choose to eagerly assign a user interaction value (i.e. at pointerdown) and then discard it (i.e. after pointercancel), rather than to lazily compute it.
A
user
agent
may
choose
to
increase
it
by
a
small
random
integer
every
time,
or
choose
a
constant.
A
user
agent
must
not
use
a
shared
global
user
interaction
value
s
for
all
Windows
,
because
this
could
introduce
cross-origin
leaks.
3.6. Computing interactionId
-
If event ’s
isTrustedattribute value is false, return 0. -
Let type be event ’s
typeattribute value. -
If type is not one among
keyup,compositionstart,input,pointercancel,pointerup,click, orcontextmenu, return 0.Note:
keydownandpointerdownare marked pending in finalize event timing , and then updated later when computing interactionId for future events (likekeyupandpointerup). -
Let window be event ’s relevant global object .
-
Let pendingKeyDowns be window ’s pending key downs .
-
Let pointerMap be window ’s pointer interaction value map .
-
Let pendingPointerDowns be window ’s pending pointer downs .
-
If type is
keyup:-
If event ’s
isComposingattribute value is true, return 0. -
Let code be event ’s
keyCodeattribute value. -
If pendingKeyDowns [ code ] does not exist, return 0.
-
Let entry be pendingKeyDowns [ code ].
-
Increase interaction count on window .
-
Let interactionId be window ’s user interaction value value.
-
Set entry ’s
interactionIdto interactionId . -
Add entry to window ’s entries to be queued .
-
Remove pendingKeyDowns [ code ].
-
Return interactionId .
-
-
If type is
compositionstart:-
For each entry in the values of pendingKeyDowns :
-
Append entry to window ’s entries to be queued .
-
-
Clear pendingKeyDowns .
-
Return 0.
-
-
If type is
input:-
If event is not an instance of
InputEvent, return 0. Note: This check is done to excludeEventsfor which thetypeisinputbut that are not about modified text content. -
If event ’s
isComposingattribute value is false, return 0. -
Increase interaction count on window .
-
Return window ’s user interaction value .
-
-
Otherwise ( type is
pointercancel,pointerup,click, orcontextmenu):-
Let pointerId be event ’s
pointerIdattribute value. -
If type is
click:-
If pointerMap [ pointerId ] does not exist, return 0.
-
Let value be pointerMap [ pointerId ].
-
Remove pointerMap [ pointerId ].
-
Return value .
-
-
Assert that type is
pointerup,pointercancel, orcontextmenu. -
If pendingPointerDowns [ pointerId ] does not exist:
-
If type is
contextmenu, return window ’s user interaction value . -
If type is
pointerupand window ’s is contextmenu triggered flag is true:-
Set window ’s is contextmenu triggered flag to false.
-
Return window ’s user interaction value .
-
-
Otherwise, return 0.
-
-
Let pointerDownEntry be pendingPointerDowns [ pointerId ].
-
Assert that pointerDownEntry is a
PerformanceEventTimingentry. -
If type is
pointeruporcontextmenu:-
Increase interaction count on window .
-
Set pointerMap [ pointerId ] to window ’s user interaction value .
-
Set pointerDownEntry ’s
interactionIdto pointerMap [ pointerId ].
-
-
Append pointerDownEntry to window ’s entries to be queued .
-
Remove pendingPointerDowns [ pointerId ].
-
If type is
contextmenu, set window ’s is contextmenu triggered to true. -
If type is
pointercancel, return 0. -
Return pointerMap [ pointerId ].
-
Note:
The
algorithm
attempts
to
assign
events
to
the
corresponding
interaction
IDs.
For
keyboard
events,
a
keydown
triggers
a
new
interaction
ID,
whereas
a
keyup
has
to
match
its
ID
with
a
previous
keydown
.
For
pointer
events,
when
we
get
a
pointerdown
we
have
to
wait
until
pointercancel
or
pointerup
occur
to
know
its
interactionId
.
We
try
to
match
click
with
a
previous
interaction
ID
from
a
pointerdown
.
If
pointercancel
or
pointerup
happens,
we’ll
be
ready
to
set
the
interactionId
for
the
stored
entry
corresponding
to
pointerdown
.
If
it
is
pointercancel
,
this
means
we
do
not
want
to
assign
a
new
interaction
ID
to
the
pointerdown
.
If
it
is
pointerup
,
we
compute
a
new
interaction
ID
and
set
it
on
both
the
pointerdown
and
the
pointerup
(and
later,
the
click
if
it
occurs).
3.7. Initialize event timing
-
If the algorithm to determine if event should be considered for Event Timing returns false, then return null.
-
Let timingEntry be a new
PerformanceEventTimingobject with event ’s relevant realm . -
Set timingEntry ’s
entryTypeto "event". -
Set timingEntry ’s
startTimeto event ’stimeStampattribute value. -
Set timingEntry ’s
processingStartto processingStart . -
Set timingEntry ’s
cancelableto event ’scancelableattribute value. -
Set timingEntry ’s
interactionIdto interactionId . -
Return timingEntry .
3.8. Finalize event timing
-
If timingEntry is null, then return.
-
Let relevantGlobal be target ’s relevant global object .
-
Set timingEntry ’s
processingEndto processingEnd . -
Assert that target implements
Node.Note: This assertion holds due to the types of events supported by the Event Timing API.
-
Set timingEntry ’s eventTarget to target .
Note: This will set eventTarget to the last event target. So if retargeting occurs, the last target, closest to the root , will be used.
-
Set timingEntry ’s
targetSelectorto the result of running the algorithm to generate a CSS selector with target as input. -
If event ’s
typeattribute value ispointerdown:-
Let pendingPointerDowns be relevantGlobal ’s pending pointer downs .
-
Let pointerId be event ’s
pointerId. -
If pendingPointerDowns [ pointerId ] exists:
-
Let previousPointerDownEntry be pendingPointerDowns [ pointerId ].
-
Add previousPointerDownEntry to relevantGlobal ’s entries to be queued .
-
-
Set pendingPointerDowns [ pointerId ] to timingEntry .
-
Set relevantGlobal ’s is contextmenu triggered to false.
-
-
Otherwise, if event ’s
typeattribute value iskeydown:-
If event ’s
isComposingattribute value is:true -
Append timingEntry to relevantGlobal ’s entries to be queued .
-
Return.
-
-
Let pendingKeyDowns be relevantGlobal ’s pending key downs .
-
Let code be event ’s
keyCodeattribute value. -
If pendingKeyDowns [ code ] exists:
-
Let previousKeyDownEntry be pendingKeyDowns [ code ].
-
If code is not 229:
-
Increase relevantGlobal ’s user interaction value value by a small number chosen by the user agent.
-
Set previousKeyDownEntry ’s
interactionIdto relevantGlobal ’s user interaction value .
Note: 229 is a special case since it corresponds to IME keyboard events. Sometimes multiple of these are sent by the user agent, and they do not correspond to holding a key down repeatedly.
-
-
Add previousKeyDownEntry to relevantGlobal ’s entries to be queued .
-
-
Set pendingKeyDowns [ code ] to timingEntry .
-
-
Otherwise:
-
Append timingEntry to relevantGlobal ’s entries to be queued .
-
3.9. Dispatch pending Event Timing entries
Document
doc
,
run
the
following
steps:
-
Let window be doc ’s relevant global object .
-
Let renderingTimestamp be the current high resolution time .
-
For each timingEntry in window ’s entries to be queued :
-
Set event timing entry duration passing timingEntry , window , and renderingTimestamp .
-
If timingEntry ’s
durationattribute value is greater than or equal to 16, then queue timingEntry .
-
-
Set window ’s entries to be queued to an empty list.
-
For each pendingPointerDownEntry in the values from window ’s pending pointer downs :
-
Set event timing entry duration passing pendingPointerDownEntry , window , and renderingTimestamp .
-
-
For each pendingKeyDownEntry in the values from window ’s pending key downs :
-
Set event timing entry duration passing pendingKeyDownEntry , window , and renderingTimestamp .
-
PerformanceEventTiming
timingEntry
,
a
Window
window
,
and
a
DOMHighResTimeStamp
renderingTimestamp
,
perform
the
following
steps:
-
If timingEntry ’s
durationattribute value is nonzero, return. -
Let start be timingEntry ’s
startTimeattribute value. -
Set timingEntry ’s
durationto aDOMHighResTimeStampresulting fromrenderingTimestamp, with granularity of 8ms or less.- start -
Let name be timingEntry ’s
nameattribute value. -
Perform the following steps to update the event counts:
-
Let eventCounts be window ’s eventCounts .
-
Assert that eventCounts contains name .
-
Set eventCounts [ name ] to eventCounts [ name ] + 1.
-
-
If window ’s has dispatched input event is false, and timingEntry ’s
interactionIdis not 0, run the following steps:-
Let firstInputEntry be a copy of timingEntry .
-
Set firstInputEntry ’s
entryTypeto "first".- input -
queue firstInputEntry .
-
Set window ’s has dispatched input event to true.
-
3.10. Target Selectors
EventTarget
target
,
run
the
following
steps:
-
If target is a
Node, run the following steps:-
Let selector be a string with an initial value of target ’s
nodeName. -
If target is an
Element, run the following steps:-
If target has an `id` attribute, set selector to the concatenation of « selector , "#", the value of the `id` attribute ».
-
Otherwise, if target has a `src` attribute, set selector to the concatenation of « selector , "[src=", the value of the `src` attribute, "]" ».
-
-
Return selector .
-
-
Otherwise, return an empty string.
4. Security & privacy considerations
We
would
not
like
to
introduce
more
high
resolution
timers
to
the
web
platform
due
to
the
security
concerns
entailed
by
such
timers.
Event
handler
timestamps
have
the
same
accuracy
as
performance.now()
.
Since
processingStart
and
processingEnd
could
be
computed
without
using
this
API,
exposing
these
attributes
does
not
produce
new
attack
surfaces.
Thus,
duration
is
the
only
one
which
requires
further
consideration.
The
duration
has
an
8
millisecond
granularity
(it
is
computed
as
such
by
performing
rounding).
Thus,
a
high
resolution
timer
cannot
be
produced
from
these
timestamps.
However,
it
does
introduce
new
information
that
is
not
readily
available
to
web
developers:
the
time
pixels
draw
after
an
event
has
been
processed.
We
do
not
find
security
or
privacy
concerns
with
exposing
the
timestamp,
especially
given
its
granularity.
In
an
effort
to
expose
the
minimal
amount
of
new
information
that
is
useful,
we
decided
to
pick
8
milliseconds
as
the
granularity.
This
allows
relatively
precise
timing
even
for
120Hz
displays.
The
choice
of
104ms
as
the
default
cutoff
value
for
the
duration
is
just
the
first
multiple
of
8
greater
than
100ms.
An
event
whose
rounded
duration
is
greater
than
or
equal
to
104ms
will
have
its
pre-rounded
duration
greater
than
or
equal
to
100ms.
Such
events
are
not
handled
within
100ms
and
will
likely
negatively
impact
user
experience.
The
choice
of
16ms
as
the
minimum
value
allowed
for
durationThreshold
is
because
it
enables
the
typical
use-case
of
making
sure
that
the
response
is
smooth.
In
120Hz
displays,
a
response
that
skips
more
than
a
single
frame
will
be
at
least
16ms,
so
the
entry
corresponding
to
this
user
input
will
be
surfaced
in
the
API
under
the
minimum
value.