Performance Timeline

This extends the Performance interface from [HR-TIME-3] and hosts performance related attributes and methods used to retrieve the performance metric data from the Performance Timeline.

WebIDLdictionary PerformanceEntryOptions { DOMString type; DOMString name; boolean includeFrames; }; partial interface Performance { PerformanceEntryList getEntries (optional PerformanceEntryOptions options = {}); PerformanceEntryList getEntriesByType (DOMString type); PerformanceEntryList getEntriesByName (DOMString name, optional DOMString type); }; typedef sequence<PerformanceEntry> PerformanceEntryList;

The PerformanceEntryList represents a sequence of PerformanceEntry, providing developers with all the convenience methods found on JavaScript arrays.

WebIDLdictionary PerformanceObserverCallbackOptions { unsigned long long droppedEntriesCount; };

droppedEntriesCount

An integer representing the dropped entries count for the entry types that the observer is observing when the PerformanceObserver's requires dropped entries is set.

The observe() method instructs the user agent to register the observer and must run these steps:

1. Let relevantGlobal be this's relevant global object.
2. If options's entryTypes and type members are both omitted, then throw a "TypeError".
3. If options's entryTypes is present and any other member is also present, then throw a "TypeError".
4. Update or check this's observer type by running these steps:
   1. If this's observer type is "undefined":
      1. If options's entryTypes member is present, then set this's observer type to "multiple".
      2. If options's type member is present, then set this's observer type to "single".
   2. If this's observer type is "single" and options's entryTypes member is present, then throw an "InvalidModificationError".
   3. If this's observer type is "multiple" and options's type member is present, then throw an "InvalidModificationError".
5. Set this's requires dropped entries to true.
6. If this's observer type is "multiple", run the following steps:
   1. Let entry types be options's entryTypes sequence.
   2. Remove all types from entry types that are not contained in relevantGlobal's frozen array of supported entry types. The user agent SHOULD notify developers if entry types is modified. For example, a console warning listing removed types might be appropriate.
   3. If the resulting entry types sequence is an empty sequence, abort these steps. The user agent SHOULD notify developers when the steps are aborted to notify that registration has been aborted. For example, a console warning might be appropriate.
   4. If the list of registered performance observer objects of relevantGlobal contains a registered performance observer whose observer is this, replace its options list with a list containing options as its only item.
   5. Otherwise, create and append a registered performance observer object to the list of registered performance observer objects of relevantGlobal, with observer set to this and options list set to a list containing options as its only item.
7. Otherwise, run the following steps:
   1. Assert that this's observer type is "single".
   2. If options's type is not contained in the relevantGlobal's frozen array of supported entry types, abort these steps. The user agent SHOULD notify developers when this happens, for instance via a console warning.
   3. If the list of registered performance observer objects of relevantGlobal contains a registered performance observer obs whose observer is this:
      1. If obs's options list contains a PerformanceObserverInit item currentOptions whose type is equal to options's type, replace currentOptions with options in obs's options list.
      2. Otherwise, append options to obs's options list.
   4. Otherwise, create and append a registered performance observer object to the list of registered performance observer objects of relevantGlobal, with observer set to the this and options list set to a list containing options as its only item.
   5. If options's buffered flag is set:
      1. Let tuple be the relevant performance entry tuple of options's type and relevantGlobal.

      2. For each entry in tuple's performance entry buffer:

         1. If should add entry with entry and options as parameters returns true, append entry to the observer buffer.
      3. Queue the PerformanceObserver task with relevantGlobal as input.

WebIDLdictionary PerformanceObserverInit { sequence<DOMString> entryTypes; DOMString type; boolean buffered; boolean includeFrames; };

WebIDL[Exposed=(Window,Worker)] interface PerformanceObserverEntryList { PerformanceEntryList getEntries(); PerformanceEntryList getEntriesByType (DOMString type); PerformanceEntryList getEntriesByName (DOMString name, optional DOMString type); };

The takeRecords() method must return a copy of this's observer buffer, and also empty this's observer buffer.

The disconnect() method must do the following:

1. Remove this from the list of registered performance observer objects of relevant global object.
2. Empty this's observer buffer.
3. Empty this's options list.

Each global object has an associated frozen array of supported entry types, which is initialized to the FrozenArray created from the sequence of strings among the registry that are supported for the global object, in alphabetical order.

When supportedEntryTypes's attribute getter is called, run the following steps:

1. Let globalObject be the environment settings object's global object.
2. Return globalObject's frozen array of supported entry types.

To queue a PerformanceEntry (newEntry) with optional boolean traverse, run these steps:

1. Let interested observers be an initially empty set of PerformanceObserver objects.
2. Let entryType be newEntry’s entryType value.
3. Let relevantGlobal be newEntry's relevant global object.
4. Set newEntry's source to relevantGlobal.
5. For each registered performance observer regObs in relevantGlobal's list of registered performance observer objects:

   1. If regObs's options list contains a PerformanceObserverInit options whose entryTypes member includes entryType or whose type member equals to entryType:

      1. If should add entry with newEntry and options returns true, append regObs's observer to interested observers.
6. For each observer in interested observers:
   1. Append newEntry to observer's observer buffer.
7. Let tuple be the relevant performance entry tuple of entryType and relevantGlobal.
8. Let isBufferFull be the return value of the determine if a performance entry buffer is full algorithm with tuple as input.
9. Let shouldAdd be the result of should add entry with newEntry as input.
10. If isBufferFull is false and shouldAdd is true, append newEntry to tuple's performance entry buffer.
11. Queue the PerformanceObserver task with relevantGlobal as input.
12. If traverse is true:
    1. Let origins be the result of calling get-policy-value with `share-performance-timeline-with` and relevantGlobal's active document.
    2. For each browsing context context which is an ancestor browsing context of relevantGlobal's browsing context:
       1. If origins contains the token *, or origins contains context's origin, Queue a global task on the performance timeline task source with context's active window to queue a PerformanceEntry with newEntry.

When asked to queue the PerformanceObserver task, given relevantGlobal as input, run the following steps:

1. If relevantGlobal's performance observer task queued flag is set, terminate these steps.
2. Set relevantGlobal's performance observer task queued flag.
3. Queue a task that consists of running the following substeps. The task source for the queued task is the performance timeline task source.
   1. Unset performance observer task queued flag of relevantGlobal.
   2. Let notifyList be a copy of relevantGlobal's list of registered performance observer objects.
   3. For each registered performance observer object registeredObserver in notifyList, run these steps:
      1. Let po be registeredObserver's observer.
      2. Let entries be a copy of po’s observer buffer.
      3. If entries is empty, return.
      4. Empty po’s observer buffer.
      5. Let observerEntryList be a new PerformanceObserverEntryList, with its entry list set to entries.
      6. Let droppedEntriesCount be null.
      7. If po's requires dropped entries is set, perform the following steps:
         1. Set droppedEntriesCount to 0.
         2. For each PerformanceObserverInit item in registeredObserver's options list:
            1. For each DOMString entryType that appears either as item's type or in item's entryTypes:
               1. Let map be relevantGlobal's performance entry buffer map.
               2. Let tuple be the result of getting the value of entry on map given entryType as key.
               3. Increase droppedEntriesCount by tuple's dropped entries count.
         3. Set po's requires dropped entries to false.
      8. Let callbackOptions be a PerformanceObserverCallbackOptions with its droppedEntriesCount set to droppedEntriesCount if droppedEntriesCount is not null, otherwise unset.
      9. Call po’s observer callback with observerEntryList as the first argument, with po as the second argument and as callback this value, and with callbackOptions as the third argument. If this throws an exception, report the exception.

The performance timeline task queue is a low priority queue that, if possible, should be processed by the user agent during idle periods to minimize impact of performance monitoring code.

When asked to run the filter buffer map by name and type algorithm with optional name, type, and includeFrames, run the following steps:

1. Let result be an initially empty list.
2. Let map be the performance entry buffer map associated with the relevant global object of this.
3. Let tuple list be an empty list.
4. If type is not null, append the result of getting the value of entry on map given type as key to tuple list. Otherwise, assign the result of get the values on map to tuple list.
5. For each tuple in tuple list, run the following steps:
   1. Let buffer be tuple's performance entry buffer.
   2. If tuple's availableFromTimeline is false, continue to the next tuple.
   3. Let entries be the result of running filter buffer by name and type with buffer, name, type and includeFrames as inputs.
   4. For each entry in entries, append entry to result.
6. Sort results's entries in chronological order with respect to startTime
7. Return result.

When asked to run the filter buffer by name and type algorithm, with buffer, name, type and includeFrames as inputs, run the following steps:

1. Let result be an initially empty list.
2. For each PerformanceEntry entry in buffer, run the following steps:
   1. If includeFrames is not true and this's relevant global object is not the same as entry's source, continue to next entry.
   2. If type is not null and if type is not identical to entry's entryType attribute, continue to next entry.
   3. If name is not null and if name is not identical to entry's name attribute, continue to next entry.
   4. append entry to result.
3. Sort results's entries in chronological order with respect to startTime
4. Return result.

To determine if a performance entry buffer is full, with tuple as input, run the following steps:

1. Let num current entries be the size of tuple's performance entry buffer.
2. If num current entries is less than tuples's maxBufferSize, return false.
3. Increase tuple's dropped entries count by 1.
4. Return true.

This specification defines a configuration point with the name share-performance-timeline-with. Its type is set, and its default value is the empty set.

Set members must be strings representing origins, or the token *, representing all origins.