Search completed in 1.16 seconds.
Event.timeStamp - Web APIs
the
timestamp read-only property of the event interface returns the time (in milliseconds) at which the event was created.
... syntax time = event.
timestamp; value this value is the number of milliseconds elapsed from the beginning of the current document's lifetime till the event was created.
... in newer implementations, the value is a domhighres
timestamp accurate to 5 microseconds (0.005 ms).
...And 6 more matches
AudioContext.getOutputTimestamp() - Web APIs
the getoutput
timestamp() property of the audiocontext interface returns a new audio
timestamp object containing two audio
timestamp values relating to the current audio context.
... the two values are as follows: audio
timestamp.contexttime: the time of the sample frame currently being rendered by the audio output device (i.e., output audio stream position), in the same units and origin as the context's audiocontext.currenttime.
... audio
timestamp.performancetime: an estimation of the moment when the sample frame corresponding to the stored contexttime value was rendered by the audio output device, in the same units and origin as performance.now().
...And 5 more matches
DOMHighResTimeStamp - Web APIs
the domhighres
timestamp type is a double and is used to store a time value in milliseconds.
... // reduced time precision (2ms) in firefox 60 event.
timestamp // 1519211809934 // 1519211810362 // 1519211811670 // ...
... // reduced time precision with `privacy.resistfingerprinting` enabled event.
timestamp; // 1519129853500 // 1519129858900 // 1519129864400 // ...
...And 5 more matches
Notification.timestamp - Web APIs
the
timestamp read-only property of the notification interface returns a dom
timestamp, as specified in the
timestamp option of the notification() constructor.
... the notification's
timestamp can represent the time, in milliseconds since 00:00:00 utc on 1 january 1970, of the event for which the notification was created, or it can be an arbitrary
timestamp that you want associated with the notification.
... for example, a
timestamp for an upcoming meeting could be set in the future, whereas a
timestamp for a missed message could be set in the past.
...And 2 more matches
RTCRemoteOutboundRtpStreamStats.remoteTimestamp - Web APIs
the rtcremoteoutboundrtpstreamstats property remote
timestamp indicates the
timestamp on the remote peer at which these statistics were sent.
... this differs from
timestamp, which indicates the time at which the statistics were generated or received locally.
... syntax let remote
timestamp = rtcremoteoutboundrtpstreamstats.remote
timestamp; value a domhighres
timestamp value indicating the
timestamp on the remote peer at which it sent these statistics.
...And 2 more matches
RTCInboundRtpStreamStats.lastPacketReceivedTimestamp - Web APIs
the lastpacketreceived
timestamp property of the rtcinboundrtpstreamstats dictionary indicates the time at which the most recently received packet arrived from this source.
... syntax var lastpacket
timestamp = rtcinboundrtpstreamstats.lastpacketreceived
timestamp; value a domhighres
timestamp which specifies the time at which the most recently received packet arrived on this rtp stream.
... note: this value differs from the
timestamp, which represents the time at which the statistics object was created.
... specifications specification status comment identifiers for webrtc's statistics apithe definition of 'rtcinboundrtpstreamstats.lastpacketreceived
timestamp' in that specification.
RTCOutboundRtpStreamStats.lastPacketSentTimestamp - Web APIs
the lastpacketsent
timestamp property of the rtcoutboundrtpstreamstats dictionary indicates the time at which the rtcrtpsender described by this rtcoutboundrtpstreamstats object last transmitted a packet to the remote receiver.
... syntax var lastpacket
timestamp = rtcoutboundrtpstreamstats.lastpacketsent
timestamp; value a domhighres
timestamp which specifies the time at which the most recently received packet arrived on this rtp stream.
... note: this value differs from the
timestamp, which represents the time at which the statistics object was created.
... specifications specification status comment identifiers for webrtc's statistics apithe definition of 'rtcoutboundrtpstreamstats.lastpacketsent
timestamp' in that specification.
Sensor.timestamp - Web APIs
the
timestamp read-only property of the sensor interface returns the time stamp of the latest sensor reading.
... syntax var
timestamp = sensorinstance.
timestamp because sensor is a base class,
timestamp may only be read from one of its derived classes.
... value a domhighres
timestamp.
... specifications specification status comment generic sensor apithe definition of '
timestamp' in that specification.
SourceBuffer.timestampOffset - Web APIs
the
timestampoffset property of the sourcebuffer interface controls the offset applied to
timestamps inside media segments that are appended to the sourcebuffer.
... the initial value of
timestampoffset is 0.
... syntax var myoffset = sourcebuffer.
timestampoffset; sourcebuffer.
timestampoffset = 2.5; value a double, with the offset amount expressed in seconds.
... example tbd specifications specification status comment media source extensionsthe definition of '
timestampoffset' in that specification.
Gamepad.timestamp - Web APIs
the gamepad.
timestamp property of the gamepad interface returns a domhighres
timestamp representing the last time the data for this gamepad was updated.
... syntax readonly attribute domhighres
timestamp timestamp; example var gp = navigator.getgamepads()[0]; console.log(gp.
timestamp); value a domhighres
timestamp.
... specifications specification status comment gamepadthe definition of 'gamepad.
timestamp' in that specification.
GeolocationPosition.timestamp - Web APIs
the geolocationposition.
timestamp read-only property returns a dom
timestamp object, represents the date and the time of the creation of the geolocationposition object it belongs to.
... syntax var
timestamp = geolocationpositioninstance.
timestamp value a dom
timestamp object instance.
... specifications specification status comment geolocation apithe definition of 'geolocationposition.
timestamp' in that specification.
RTCIceCandidatePairStats.consentExpiredTimestamp - Web APIs
the rtcicecandidatepairstats property consentexpired
timestamp indicates the time at which the most recent stun binding response expired.
... syntax consentexpiration = rtcicecandidatepairstats.consentexpired
timestamp; value a domhighres
timestamp object that indicates the time at which the stun binding that allows the two peers described by this rtcicecandidatepair to communicate will expire (or the time at which the binding did expire, if the time has passed).
... specifications specification status comment identifiers for webrtc's statistics apithe definition of 'rtcicecandidatepairstats.consentexpired
timestamp' in that specification.
RTCIceCandidatePairStats.firstRequestTimestamp - Web APIs
the rtcicecandidatepairstats property firstrequest
timestamp specifies the time at which the first stun request was sent on the described candidate pair.
... syntax firstrequest
timestamp = rtcicecandidatepairstats.firstrequest
timestamp; value a domhighres
timestamp object indicating the
timestamp at which the first stun request was sent on the connection described by the described pair of candidates.
... you can use this value in combination with lastrequest
timestamp and requestssent to compute the average interval between consecutive connectivity checks: avgcheckinterval = (candidatepairstats.lastrequest
timestamp - candidatepairstats.firstrequest
timestamp) / candidatepairstats.requestssent; specifications specification status comment identifiers for webrtc's statistics apithe definition of 'rtcicecandidatepairstats.firstrequest
timestamp' in that specification.
RTCIceCandidatePairStats.lastPacketReceivedTimestamp - Web APIs
the rtcicecandidatepairstats property lastpacketreceived
timestamp indicates the time at which the connection described by the candidate pair last received a packet.
... syntax lastpacketreceived
timestamp = rtcicecandidatepairstats.lastpacketreceived
timestamp; value a domhighres
timestamp object indicating the
timestamp at which the connection described by pair of candidates last received a packet, stun packets excluded.
... specifications specification status comment identifiers for webrtc's statistics apithe definition of 'rtcicecandidatepairstats.lastpacketreceived
timestamp' in that specification.
RTCIceCandidateStats.lastPacketSentTimestamp - Web APIs
the rtcicecandidatepairstats property lastpacketsent
timestamp indicates the time at which the connection described by the candidate pair last sent a packet, not including stun packets.
... syntax lastpacketsent
timestamp = rtcicecandidatepairstats.lastpacketsent
timestamp; value a domhighres
timestamp object indicating the
timestamp at which the connection described by pair of candidates last sent a packet, stun packets excluded.
... specifications specification status comment identifiers for webrtc's statistics apithe definition of 'rtcicecandidatepairstats.lastpacketsent
timestamp' in that specification.
RTCIceCandidatePairStats.lastRequestTimestamp - Web APIs
the rtcicecandidatepairstats property lastrequest
timestamp indicates the time at which the most recent stun request was sent on the described candidate pair.
... syntax lastrequest
timestamp = rtcicecandidatepairstats.lastrequest
timestamp; value a domhighres
timestamp object indicating the
timestamp at which the last (most recent) stun request was sent on the connection indicated by the described pair of candidates.
... you can use this value in combination with firstrequest
timestamp and requestssent to compute the average interval between consecutive connectivity checks: avgcheckinterval = (candidatepairstats.lastrequest
timestamp - candidatepairstats.firstrequest
timestamp) / candidatepairstats.requestssent; specifications specification status comment identifiers for webrtc's statistics apithe definition of 'rtcicecandidatepairstats.lastrequest
timestamp' in that specification.
RTCIceCandidateStats.lastResponseTimestamp - Web APIs
the rtcicecandidatepairstats property lastresponse
timestamp indicates the time at which the last stun response was received on the described candidate pair.
... syntax lastresponse
timestamp = rtcicecandidatepairstats.lastresponse
timestamp; value a domhighres
timestamp object indicating the
timestamp at which the most recent stun response was received on the connection defined by the described pair of candidates.
... specifications specification status comment identifiers for webrtc's statistics apithe definition of 'rtcicecandidatepairstats.lastresponse
timestamp' in that specification.
RTCRtpContributingSource.rtpTimestamp - Web APIs
the read-only rtp
timestamp property of the rtcrtpcontributingsource interface returns a domhighres
timestamp indicating the source-generated time at which the media contained int he packet was first sampled or obtained.
... syntax let rtp
timestamp = rtcrtpcontributingsource.rtp
timestamp value an integer value specifiying a source-generated
timestamp indicating the time at which the media in this packet, scheduled for play out at the time indicated by
timestamp, was initially sampled or generated.
... specifications specification status comment webrtc 1.0: real-time communication between browsersthe definition of 'rtp
timestamp' in that specification.
RTCRtpContributingSource.timestamp - Web APIs
the read-only
timestamp property of the rtcrtpcontributingsource interface returns a domhighres
timestamp indicating the most recent time of playout of an rtp packet from the source.
... syntax var domhighres
timestamp = rtcrtpcontributingsource.
timestamp value a domhighres
timestamp which indicates the time at which the most recent rtp packet from the corresponding source was played out.
... specifications specification status comment webrtc 1.0: real-time communication between browsersthe definition of '
timestamp' in that specification.
RTCStats.timestamp - Web APIs
the
timestamp property of the rtcstats dictionary is a domhighres
timestamp object specifying the time at which the data in the object was sampled.
... syntax var
timestamp = rtcstats.
timestamp; value a domhighres
timestamp value indicating the time at which the activity described by the statistics in this object was recorded, in milliseconds elapsed since the beginning of january 1, 1970, utc.
... specifications specification status comment webrtc 1.0: real-time communication between browsersthe definition of 'rtcstats.
timestamp' in that specification.
Console.timeStamp() - Web APIs
you can optionally supply an argument to label the
timestamp, and this label will then be shown alongside the marker.
... syntax console.
timestamp(label); parameters label label for the
timestamp.
DOMTimeStamp - Web APIs
the dom
timestamp type represents an absolute or relative number of milliseconds, depending on the specification in which it appears.
... specifications specification status comment web idlthe definition of 'dom
timestamp' in that specification.
Index - Web APIs
132 audiocontext.getoutput
timestamp() api, audio, audiocontext, method, reference, web audio api, getoutput
timestamp, sound the getoutput
timestamp() property of the audiocontext interface returns a new audio
timestamp object containing two correlated context's audio stream position values.
... 246 baseaudiocontext.currenttime api, audiocontext, baseaudiocontext, property, reference, web audio api, currenttime the currenttime read-only property of the baseaudiocontext interface returns a double representing an ever-increasing hardware
timestamp in seconds that can be used for scheduling audio playback, visualizing timelines, etc.
... 298 blobevent.timecode api, blobevent, media, media stream recording, property, reference the timecode readonlyinline property of the blobevent interface a domhighres
timestamp indicating the difference between the
timestamp of the first chunk in data, and the
timestamp of the first chunk in the first blobevent produced by this recorder.
...And 64 more matches
PerformanceResourceTiming - Web APIs
the interface's properties create a resource loading timeline with high-resolution
timestamps for network events such as redirect start and end times, fetch start, dns lookup start and end times, response start and end times, etc..
... performanceentry.starttimeread only returns the
timestamp for the time a resource fetch started.
... performanceentry.durationread only returns a
timestamp that is the difference between the responseend and the starttime properties.
...And 12 more matches
Resource Timing API - Web APIs
the interface's properties create a resource loading timeline with high-resolution
timestamps for network events such as redirect start and end times, dns lookup start and end times, request start, response start and end times, etc.
... high-resolution
timestamps several of the resource timing properties return high-resolution
timestamps.
... these
timestamps have a domhighres
timestamp type and as its name implies, they represent a high-resolution point in time.
...And 11 more matches
PerformanceNavigationTiming - Web APIs
performanceentry.starttime read only returns a domhighres
timestamp with a value of "0".
... performanceentry.duration read only returns a
timestamp that is the difference between the performancenavigationtiming.loadeventend and performanceentry.starttime properties.
... the interface also supports the following properties: performancenavigationtiming.domcomplete read only a domhighres
timestamp representing a time value equal to the time immediately before the browser sets the current document readiness of the current document to complete.
...And 9 more matches
RTCIceCandidatePairStats - Web APIs
consentexpired
timestamp optional a domhighres
timestamp value indicating the time at which the most recent stun binding response expired.
... firstrequest
timestamp optional a domhighres
timestamp value which specifies the time at which the first stun request was sent from the local peer to the remote peer for this candidate pair.
... lastpacketreceived
timestamp optional a domhighres
timestamp value indicating the time at which the last packet was received by the local peer from the remote peer for this candidate pair.
...And 6 more matches
Anatomy of a video game - Game development
it is known as a domhighres
timestamp but, for all intents and purposes, consider it a floating point number.
... this value is not too useful alone, since it is relative to a fairly uninteresting event, but it can be subtracted from another
timestamp to accurately and precisely determine how much time elapsed between those two points.
... to acquire one of these
timestamps, you can call window.performance.now() and store the result as a variable.
...And 5 more matches
PerformanceEntry.startTime - Web APIs
the starttime property returns the first recorded
timestamp of the performance entry.
... the value returned by this property depends on the performance entry's type: "frame" - returns the
timestamp when the frame was started.
... "mark" - returns the
timestamp when the mark was created by a call to performance.mark().
...And 5 more matches
Waterfall - Firefox Developer Tools
timestamp a single call to console.
timestamp().
... label the argument passed to
timestamp().
... adding markers with the console api two markers are directly controlled by console api calls: "console" and "
timestamp".
...And 4 more matches
PerformanceEntry.duration - Web APIs
the duration property returns a
timestamp that is the duration of the performance entry.
... the value returned by this property depends on the performance entry's type: "frame" - returns a
timestamp indicating the difference between the starttimes of two successive frames.
... "measure" - returns the
timestamp that is the duration of the measure.
...And 4 more matches
Performance API - Web APIs
as such, the performance api defines a domhighres
timestamp type rather than using the date.now() interface.
... domhighres
timestamp the domhighres
timestamp type, as its name implies, represents a high resolution point in time.
... the unit of domhighres
timestamp is milliseconds and should be accurate to 5 µs (microseconds).
...And 4 more matches
Rendering and the WebXR frame animation callback - Web APIs
hardare vertical refresh rate when the browser is ready to refresh the <canvas> within which your webxr content is displayed, it calls your frame rendering callback, which uses the specified
timestamp and any other relevant data, such as models and textures, as well as application state, to render the scene—as it should appear at the specified time—into the webgl backbuffer.
...this is another reason the
timestamp passed into your render callback is useful.
...instead, it offers a way to convert positions and orientations into the scene's coordinate system, and it collects the viwer's position and orientation data from the xr hardware, converts it into the reference space you've configured, and delivers it to your frame rendering code with a
timestamp.
...And 4 more matches
Cooperative asynchronous JavaScript: Timeouts and intervals - Learn web development
a more accurate way would be to run starttime = date.now() to get a
timestamp of exactly when the user clicked the start button, and then do date.now() - starttime to get the number of milliseconds after the start button was clicked.
... including a
timestamp the actual callback passed to the requestanimationframe() function can be given a parameter, too: a
timestamp value, that represents the time since the requestanimationframe() started running.
...the general pattern you'd use looks something like this: let starttime = null; function draw(
timestamp) { if (!starttime) { starttime =
timestamp; } currenttime =
timestamp - starttime; // do something based on current time requestanimationframe(draw); } draw(); browser support requestanimationframe() is supported in more recent browsers than setinterval()/settimeout().
...And 3 more matches
HTTP logging
press the enter key after each one.: for 64-bit windows: set moz_log=
timestamp,rotate:200,nshttp:5,cache2:5,nssockettransport:5,nshostresolver:5,cookie:5 set moz_log_file=%temp%\log.txt "c:\program files\mozilla firefox\firefox.exe" for 32-bit windows: set moz_log=
timestamp,rotate:200,nshttp:5,cache2:5,nssockettransport:5,nshostresolver:5,cookie:5 set moz_log_file=%temp%\log.txt "c:\program files (x86)\mozilla firefox\firefox.exe" (these instructions assume that you...
... export moz_log=
timestamp,rotate:200,nshttp:5,cache2:5,nssockettransport:5,nshostresolver:5,cookie:5 export moz_log_file=/tmp/log.txt cd /path/to/firefox ./firefox reproduce the problem you're debugging.
... export moz_log=
timestamp,rotate:200,nshttp:5,cache2:5,nssockettransport:5,nshostresolver:5,cookie:5 export moz_log_file=~/desktop/log.txt cd /applications/firefox.app/contents/macos ./firefox-bin (the instructions assume that you've installed firefox directly into your startup disk's applications folder.
...And 2 more matches
Gecko Logging
raw print exactly what has been specified in the format string, without the process/thread/
timestamp, etc.
...
timestamp insert
timestamp at start of each log line.
... note: this option disables 'append' and forces '
timestamp'.
...And 2 more matches
Using the Performance API - Web APIs
the domhighres
timestamp type (a double) is used by all performance interfaces to hold such time values.
... additionally, there must be a way to create a
timestamp for a specific point in time; this is done with the now() method.
... high precision timing high precision timing is achieved by using the domhighres
timestamp type for time values.
...And 2 more matches
SourceBuffer - Web APIs
="151" y="1" width="120" height="50" fill="#f4f7f8" stroke="#d4dde4" stroke-width="2px" /><text x="211" y="30" font-size="12px" font-family="consolas,monaco,andale mono,monospace" fill="#4d4e53" text-anchor="middle" alignment-baseline="middle">sourcebuffer</text></a></svg></div> a:hover text { fill: #0095dd; pointer-events: all;} properties sourcebuffer.appendwindowend controls the
timestamp for the end of the append window.
... sourcebuffer.appendwindowstart controls the
timestamp for the start of the append window.
... this is a
timestamp range that can be used to filter what media data is appended to the sourcebuffer.
...And 2 more matches
User Timing API - Web APIs
the user timing interface allows the developer to create application specific
timestamps that are part of the browser's performance timeline.
...the mark is a
timestamp in the browser's performance timeline.
... starttime - set to the
timestamp when mark() was called.
...And 2 more matches
Window.requestAnimationFrame() - Web APIs
the callback method is passed a single argument, a domhighres
timestamp, which indicates the current time (based on the number of milliseconds since time origin).
... when callbacks queued by requestanimationframe() begin to fire multiple callbacks in a single frame, each receives the same
timestamp even though time has passed during the computation of every previous callback's workload.
... this
timestamp is a decimal number, in milliseconds, but with a minimal precision of 1ms (1000 µs).
...And 2 more matches
Makefiles - Best practices and suggestions
for ex, individual unit tests would invalidate all prior test activity whenever a test touched a
timestamp file in the directory to signal success.
... parallel make: add an explicit
timestamp dependency (.done) that make can synchronize threaded calls on to avoid a race condition.
... # transient directory for storing
timestamps ts=.ts ##################################################### ## extra dep needed to synchronize parallel execution ##################################################### $(ts): $(ts)/.done $(ts)/.done: $(mkdir) -p $(dir $@) touch $@ # "clean" target garbage_dirs += $(ts) maintain clean targets - makefiles should be able to remove all content that is generated so "make clean" will return the sandbox/directory back to a clean state.
... targets = foo bar tans
timestampdir = .ts all: $(
timestampdir) $(targets) %: %.c $(cc) -o $@ $< $(
timestampdir): $(mkdir) $@ # "clean" target garbage += $(targets) garbage_dirs += $(
timestampdir) wrapper check/unit tests with a enable_tests conditional so tests can be disabled on demand.
NSS 3.24 release notes
use this new function in place of ssl_configsecureserver, ssl_configsecureserverwithcertchain, ssl_setstapledocspresponses, and ssl_setsignedcert
timestamps.
...separate functions for configuring online certificate status protocol (ocsp) responses or signed certificate
timestamps are not needed, since these can be added to the optional sslextraservercertdata struct provided to ssl_configservercert.
...this struct contains supplementary information about a certificate, such as the intended type of the certificate, stapled ocsp responses, or signed certificate
timestamps (used for certificate transparency).
...(applications should instead use the new ssl_configservercert function.) ssl_setstapledocspresponses ssl_setsignedcert
timestamps ssl_configsecureserver ssl_configsecureserverwithcertchain deprecate the nss_findcertkeatype function, as it reports a misleading value for certificates that might be used for signing rather than key exchange.
Frame Timing API - Web APIs
performanceentry.starttime set to the domhighres
timestamp when the frame was started.
... performanceentry.duration set to a
timestamp indicating the difference between the starttimes of two successive frames.
... this data, particularly the duration
timestamp, can be used to help identify performance problems.
...each frame object's duration property returns the
timestamp of two consecutive frames.
performance.measure() - Web APIs
the measure() method creates a named
timestamp in the browser's performance entry buffer between marks, the navigation start time, or the current time.
...the named
timestamp is referred to as a measure.
... starttime - set to the start mark
timestamp.
... duration - set to a domhighres
timestamp that is the duration of the measure (typically, the end mark
timestamp minus the start mark
timestamp).
Performance - Web APIs
performance.timeorigin read only returns the high resolution
timestamp of the start time of the performance measurement.
... performance.mark() creates a
timestamp in the browser's performance entry buffer with the given name.
... performance.measure() creates a named
timestamp in the browser's performance entry buffer between two specified marks (known as the start mark and end mark, respectively).
... performance.now() returns a domhighres
timestamp representing the number of milliseconds elapsed since a reference instant.
PerformanceResourceTiming.connectEnd - Web APIs
the connectend read-only property returns the
timestamp immediately after the browser finishes establishing the connection to the server to retrieve the resource.
... the
timestamp value includes the time interval to establish the transport connection, as well as other time intervals such as ssl handshake and socks authentication.
... syntax resource.connectend; return value a domhighres
timestamp representing the time after a connection is established.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) { // check ea...
SourceBuffer.mode - Web APIs
the two available values are: segments: the media segment
timestamps determine the order in which the segments are played.
...segment
timestamps are generated automatically for the segments that observe this order.
...if
timestamps already exist for the media segments, then the value will be set to segments; if they don't, then the value will be set to sequence.
...it just means the play order will be fixed, and new
timestamps generated to reflect this.
Date() constructor - JavaScript
time value or
timestamp number value an integer value representing the number of milliseconds since january 1, 1970, 00:00:00 utc (the ecmascript epoch, equivalent to the unix epoch), with leap seconds ignored.
... keep in mind that most unix
timestamp functions are only accurate to the nearest second.
...
timestamp string datestring a string value representing a date, specified in a format recognized by the date.parse() method.
... (these formats are ietf-compliant rfc 2822
timestamps, and also strings in a version of iso8601.) note: parsing of date strings with the date constructor (and date.parse(), which works the same way) is strongly discouraged due to browser differences and inconsistencies.
places/bookmarks - Archive of obsolete content
updated a unix
timestamp indicating when the bookmark was last updated on the platform.
... updated a unix
timestamp indicating when the bookmark was last updated on the platform.
... updated a unix
timestamp indicating when the bookmark was last updated on the platform.
platform/xpcom - Archive of obsolete content
this example implements a logging service that just appends a
timestamp to all logged messages.
...after this, xpcom users can access the service using the getservice() api: var { class } = require('sdk/core/heritage'); var { unknown, service } = require('sdk/platform/xpcom'); var { cc, ci } = require('chrome'); var contractid = '@me.org/
timestampedlogger'; // implement the service by subclassing unknown var
timestampedlogger = class({ extends: unknown, get wrappedjsobject() this, log: function(message) { console.log(new date().gettime() + ' : ' + message); } }); // register the service using the contract id var service = service({ contract: contractid, component:
timestampedlogger }); // access the service using getserv...
...ice() var wrapper = cc[contractid].getservice(ci.nsisupports); var logger = wrapper.wrappedjsobject; logger.log('a
timestamped message'); by default, services are registered and unregistered automatically.
Promises - Archive of obsolete content
let info = yield os.file.stat(configpath); if (info.lastmodificationdate <=
timestamp) return;
timestamp = info.lastmodificationdate; // read the file as a utf-8 string, parse as json.
... config.indexstats = processor.stats; yield os.file.writeatomic(configpath, json.stringify(config), { tmppath: configpath + "." + math.random(), encoding: "utf-8" })
timestamp = new date; }); http requests http requests should, in nearly all circumstances, be made via the standard xmlhttprequest api.
... let [row] = yield db.execute( "select value from nodes where key = '
timestamp' \ order by value desc limit 1"); latest
timestamp = row.getresultbyindex(0); } finally { // make sure to close the database when finished.
Choosing the right approach - Learn web development
layed operation repeating operation multiple sequential operations multiple simultaneous operations no yes no (unless it is the same one) no code example a simple animated spinner; you can find this example live on github (see the source code also): const spinner = document.queryselector('div'); let rotatecount = 0; let starttime = null; let raf; function draw(
timestamp) { if(!starttime) { starttime =
timestamp; } rotatecount = (
timestamp - starttime) / 3; if(rotatecount > 359) { rotatecount %= 360; } spinner.style.transform = 'rotate(' + rotatecount + 'deg)'; raf = requestanimationframe(draw); } draw(); pitfalls you can't choose a specific framerate with requestanimationframe().
...t 24 full support 10prefixed prefixed implemented with the vendor prefix: webkitedge full support 12firefox full support 23notes full support 23notes notes callback parameter is a domhighres
timestamp.
... no support 11 — 42prefixed notes prefixed implemented with the vendor prefix: moznotes callback parameter is a dom
timestamp.
NSPR LOG MODULES
to enable all log module calls to pr_log, set the variable as follows: set nspr_log_modules=all:5
timestamp including
timestamp results in a
timestamp of the form "2015-01-15 21:24:26.049906 utc - " prefixing every logged line.
... examples log everything from the toolkit::storage component that happens, prefixing each line with the
timestamp when it was logged to the file /tmp/foo.log (which will be replaced each time the executable is run).
... set nspr_log_modules=
timestamp,mozstorage:5 set nspr_log_file=/tmp/foo.log logging with try server for mochitest, edit variable nspr_log_modules in testing/mochitest/runtests.py before pushing to try.
NSS 3.22 release notes
in ssl.h ssl_peersignedcert
timestamps - get signed_certificate_
timestamp tls extension data ssl_setsignedcert
timestamps - set signed_certificate_
timestamp tls extension data new types in secoidt.h the following are added to secoidtag: sec_oid_aes_128_gcm sec_oid_aes_192_gcm sec_oid_aes_256_gcm sec_oid_idea_cbc sec_oid_rc2_40_cbc sec_oid_des_40_cbc sec_oid_rc4_40 sec_oi...
... sec_oid_tls_ecdhe_ecdsa sec_oid_tls_ecdhe_rsa sec_oid_tls_ecdh_ecdsa sec_oid_tls_ecdh_rsa sec_oid_tls_ecdh_anon sec_oid_tls_rsa_export sec_oid_tls_dhe_rsa_export sec_oid_tls_dhe_dss_export sec_oid_tls_dh_rsa_export sec_oid_tls_dh_dss_export sec_oid_tls_dh_anon_export sec_oid_apply_ssl_policy in sslt.h ssl_signed_cert_
timestamp_xtn is added to sslextensiontype.
...hmac_sha512 - prf based on hmac with sha-256 for pbkdf ckp_pkcs5_pbkd2_hmac_sha512_224 - prf based on hmac with sha-512 truncated to 224 bits for pbkdf (not supported) ckp_pkcs5_pbkd2_hmac_sha512_256 - prf based on hmac with sha-512 truncated to 256 bits for pbkdf (not supported) in secoidt.h nss_use_alg_in_ssl nss_use_policy_in_ssl in ssl.h ssl_enable_signed_cert_
timestamps in sslt.h ssl_max_extensions is updated to 13 notable changes in nss 3.22 nss c++ tests are built by default, requiring a c++11 compiler.
Statistics API
var prefs = require("api-utils/preferences-service"); components.utils.import('resource://gre/modules/services.jsm'); function observer(subject, topic, json) { var data = json.parse(json); // process the data } prefs.set("javascript.options.mem.notify", true); services.obs.addobserver(observer, "garbage-collection-statistics", false); the toplevel json object contains these fields:
timestamp: integer (microseconds) - time at which the gc ended, measured from epoch.
... start_
timestamp: integer (microseconds) - time of slice start from epoch.
... end_
timestamp: integer (microseconds) - time of slice end from epoch.
Redis Tips
heartbeats and time-based event logs it's a common pattern to use numerical
timestamps for ranking members in a zset.
... here's what the zset contains now: > r.zrange('last-login', 0, -1, print); // remember, i defined 'print' above ["jparsons", "zcarter", "lloyd"] since this is a set, lloyd only appears once, with updated login
timestamp.
... expireat lets you specify the expiration date of a key in unix
timestamp.
nsIHttpActivityObserver
1.0 66 introduced gecko 1.8 inherits from: nsisupports last changed in gecko 1.8 (firefox 1.5 / thunderbird 1.5 / seamonkey 1.0) method overview void observeactivity(in nsisupports ahttpchannel, in pruint32 aactivitytype, in pruint32 aactivitysubtype, in prtime a
timestamp, in pruint64 aextrasizedata, in acstring aextrastringdata); attributes attribute type description isactive boolean true when the interface is active and should observe http activity, otherwise false.
...void observeactivity( in nsisupports ahttpchannel, in pruint32 aactivitytype, in pruint32 aactivitysubtype, in prtime a
timestamp, in pruint64 aextrasizedata, in acstring aextrastringdata ); parameters ahttpchannel the nsihttpchannel on which the activity occurred.
...a
timestamp the time at which the activity occurred, specified as microseconds elapsed since the epoch of midnight on january 1, 1970.
nsISmsService
to create an instance, use: var smsservice = components.classes["@mozilla.org/sms/smsservice;1"] .createinstance(components.interfaces.nsismsservice); method overview [implicit_jscontext] nsidommozsmsmessage createsmsmessage(in long id, in domstring delivery, in domstring sender, in domstring receiver, in domstring body, in jsval
timestamp, in bool read ); unsigned short getnumberofmessagesfortext(in domstring text); boolean hassupport(); void send(in domstring number, in domstring message, in long requestid, [optional] in unsigned long long processid); methods createsmsmessage() [implicit_jscontext] nsidommozsmsmessage createsmsmessage( in long id, in domstring delivery, in domstring sende...
...r, in domstring receiver, in domstring body, in jsval
timestamp, in bool read ); parameters id a number representing the id of the message.
...
timestamp a date object with the
timestamp of the message.
nsIWindowMediator
void updatewindow
timestamp(in nsixulwindow awindow); native code only!
... native code only!updatewindow
timestamp call this method when a window gains focus.
... void updatewindow
timestamp( in nsixulwindow awindow ); parameters awindow the window which has gained focus.
Web Console remoting - Firefox Developer Tools
the pageerror packet is: { "from": "conn0.console9", "type": "pageerror", "pageerror": { "errormessage": "referenceerror: foo is not defined", "sourcename": "http://localhost/~mihai/mozilla/test.js", "linetext": "", "linenumber": 6, "columnnumber": 0, "category": "content javascript", "
timestamp": 1347294508210, "error": false, "warning": false, "exception": true, "strict": false, "private": false, } } the packet is similar to nsiscripterror - for simplicity.
... for each console message we receive in the server, we send the following consoleapicall packet to the client: { "from": "conn0.console9", "type": "consoleapicall", "message": { "level": "error", "filename": "http://localhost/~mihai/mozilla/test.html", "linenumber": 149, "functionname": "", "
timestamp": 1347302713771, "private": false, "arguments": [ "error omg aloha ", { "type": "object", "classname": "htmlbodyelement", "actor": "conn0.consoleobj20" }, " 960 739 3.141592653589793 %a", "zuzu", { "type": "null" }, { "type": "undefined" } ] } } similar to how we send the page errors, here we send the actual console...
... the response packet: { "from": "conn0.console9", "input": "document", "result": { "type": "object", "classname": "htmldocument", "actor": "conn0.consoleobj20" "extensible": true, "frozen": false, "sealed": false }, "
timestamp": 1347306273605, "exception": null, "exceptionmessage": null, "helperresult": null } exception holds the json-ification of the exception thrown during evaluation.
EXT_disjoint_timer_query.queryCounterEXT() - Web APIs
must be ext.
timestamp_ext.
... examples var ext = gl.getextension('ext_disjoint_timer_query'); var startquery = ext.createqueryext(); var endquery = ext.createqueryext(); ext.querycounterext(startquery, ext.
timestamp_ext); // ...
... ext.querycounterext(endquery, ext.
timestamp_ext); specifications specification status comment ext_disjoint_timer_querythe definition of 'ext_disjoint_timer_query' in that specification.
PerformanceMeasure - Web APIs
entries of this type are created by calling performance.measure() to add a named domhighres
timestamp (the measure) between two marks to the browser's performance timeline.
... performanceentry.starttime returns a
timestamp given to the measure when performance.measure() was called.
... performanceentry.duration returns a domhighres
timestamp that is the duration of the measure (typically, the measure's end mark
timestamp minus its start mark
timestamp).
PerformanceResourceTiming.connectStart - Web APIs
the connectstart read-only property returns the
timestamp immediately before the user agent starts establishing the connection to the server to retrieve the resource.
... syntax resource.connectstart; return value a domhighres
timestamp immediately before the browser starts to establish the connection to the server to retrieve the resource.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) ...
PerformanceResourceTiming.domainLookupEnd - Web APIs
the domainlookupend read-only property returns the
timestamp immediately after the browser finishes the domain name lookup for the resource.
... syntax resource.domainlookupend; return value a domhighres
timestamp representing the time immediately after the browser finishes the domain name lookup for the resource.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) { // check ea...
PerformanceResourceTiming.domainLookupStart - Web APIs
the domainlookupstart read-only property returns the
timestamp immediately before the browser starts the domain name lookup for the resource.
... syntax resource.domainlookupstart; return value a domhighres
timestamp immediately before the browser starts the domain name lookup for the resource.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) ...
PerformanceResourceTiming.fetchStart - Web APIs
the fetchstart read-only property represents a
timestamp immediately before the browser starts to fetch the resource.
... syntax resource.fetchstart; return value a domhighres
timestamp immediately before the browser starts to fetch the resource.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) ...
PerformanceResourceTiming.redirectEnd - Web APIs
the redirectend read-only property returns a
timestamp immediately after receiving the last byte of the response of the last redirect.
... syntax resource.redirectend; return value a
timestamp immediately after receiving the last byte of the response of the last redirect.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) ...
PerformanceResourceTiming.redirectStart - Web APIs
the redirectstart read-only property returns a
timestamp representing the start time of the fetch which that initiates the redirect.
... syntax resource.redirectstart; return value a
timestamp representing the start time of the fetch which initiates the redirect.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) ...
PerformanceResourceTiming.requestStart - Web APIs
the requeststart read-only property returns a
timestamp of the time immediately before the browser starts requesting the resource from the server, cache, or local resource.
... syntax resource.requeststart; return value a domhighres
timestamp representing the time immediately before the browser starts requesting the resource from the server example in the following example, the value of the *start and *end properties of all "resource" type events are logged.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) { // check each property var supported = properties[i] in perfentry; if (supported) {...
PerformanceResourceTiming.responseEnd - Web APIs
the responseend read-only property returns a
timestamp immediately after the browser receives the last byte of the resource or immediately before the transport connection is closed, whichever comes first.
... syntax resource.responseend; return value a domhighres
timestamp immediately after the browser receives the last byte of the resource or immediately before the transport connection is closed, whichever comes first.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) ...
PerformanceResourceTiming.responseStart - Web APIs
the responsestart read-only property returns a
timestamp immediately after the browser receives the first byte of the response from the server, cache, or local resource.
... syntax resource.responsestart; return value a domhighres
timestamp immediately after the browser receives the first byte of the response from the server.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) ...
PerformanceResourceTiming.secureConnectionStart - Web APIs
the secureconnectionstart read-only property returns a
timestamp immediately before the browser starts the handshake process to secure the current connection.
... syntax resource.secureconnectionstart; return value if the resource is fetched over a secure connection, a domhighres
timestamp immediately before the browser starts the handshake process to secure the current connection.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart"]; for (var i=0; i < properties.length; i++) ...
PerformanceResourceTiming.workerStart - Web APIs
the workerstart read-only property of the performanceresourcetiming interface returns a domhighres
timestamp immediately before dispatching the fetchevent if a service worker thread is already running, or immediately before starting the service worker thread if it is not already running.
... syntax resource.workerstart; value a domhighres
timestamp.
... function print_performanceentries() { // use getentriesbytype() to just get the "resource" events var p = performance.getentriesbytype("resource"); for (var i=0; i < p.length; i++) { print_start_and_end_properties(p[i]); } } function print_start_and_end_properties(perfentry) { // print
timestamps of the performanceentry *start and *end properties properties = ["connectstart", "connectend", "domainlookupstart", "domainlookupend", "fetchstart", "redirectstart", "redirectend", "requeststart", "responsestart", "responseend", "secureconnectionstart", "workerstart"]; for (var i=0; i < propert...
RTCRemoteOutboundRtpStreamStats - Web APIs
remote
timestamp a domhighres
timestamp specifying the
timestamp (on the remote device) at which the statistics in the rtcremoteoutboundrtpstreamstats object were sent by the remote endpoint.
... this is different from the
timestamp found in the base rtcstats dictionary; it represents the time at which the object's statistics were received or generated by the local endpoint.
... usage notes the rtcremoteoutboundrtpstreamstats object's remote
timestamp proeprty provides statistics based on the received data's ntp
timestamp taken from an rtcp sender report (sr) block.
Using the Resource Timing API - Web APIs
the interface's properties create a resource loading timeline with high-resolution
timestamps for network events such as redirect start and end times, fetch start, dns lookup start and end times, response start and end times, etc.
... resource loading phases an application can get
timestamps for the various phases of resource loading such as redirection, dns lookup, and tcp connection setup.
...this requires the server providing the resource to send the timing-allow-origin http response header with a value specifying the origin or origins which are allowed to get the restricted
timestamp values.
Using the User Timing API - Web APIs
the user timing interface allows the developer to create application specific
timestamps that are part of the browser's performance timeline.
...the mark is a
timestamp in the browser's performance timeline.
...cleared all marks", 0); performance.clearmarks(); } } performance measures a measure performance entry type is named by the application and its
timestamp is placed between two named marks thus a measure is effectively a midpoint between two marks in the browser's performance timeline.
Geometry and reference spaces in WebXR - Web APIs
const radians_per_degree = math.pi / 180.0; let degreestoradians = (deg) => deg * radians_per_degree; let radianstodegrees = (rad) => rad / radians_per_degree; times and durations note that for security reasons, domhighres
timestamp usually introduces a small amount of imprecision to the clock in order to prevent it from being used in fingerprinting and timing-based attacks.
... all times and durations in webxr are measured using the domhighres
timestamp type, which is a double-precision floating-point value specifying the time in milliseconds relative to the starting time.
...the callback receives as one of its parameters a
timestamp indicating the time at which the frame takes place, and should perform all rendering for the corresponding animation frame.
Getting Started - Developer guides
you can also add an always-different get parameter, like a
timestamp or random number (see bypassing the cache) note 3: if the httprequest variable is used globally, competing functions calling makerequest() can overwrite each other, causing a race condition.
...le another simple example follows — here we are loading a text file via xhr, the structure of which is assumed to be like this: time: 312.05 time: 312.07 time: 312.10 time: 312.12 time: 312.14 time: 312.15 once the text file is loaded, we split() the items into an array at each newline character (\n — basically where each line break is in the text file), and then print the complete list of
timestamps, and the last
timestamp, onto the page.
...the idea would be that a server-side script of some kind would continually update the text file with new
timestamps, and our xhr code would be used to report the latest
timestamp on the client-side.
JavaScript timers - Archive of obsolete content
performance.now() performance.now() returns a
timestamp, measured in milliseconds, accurate to one thousandth of a millisecond.
... this
timestamp is equal to the number of milliseconds since the navigationstart attribute of the performance.timing interface.
Introducing the Audio API extension - Archive of obsolete content
the mozaudioavailable event has 2 attributes: framebuffer: framebuffer (i.e., an array) containing decoded audio sample data (i.e., floats) time:
timestamp for these samples measured from the start in seconds the framebuffer contains an array of audio samples.
... we can extend the previous example to visualize the
timestamp and the first two samples in a <div> element: <!doctype html> <html> <head> <title>javascript visualization example</title> </head> <body> <audio id="audio-element" src="revolve.ogg" controls="true" style="width: 512px;"> </audio> <pre id="raw">hello</pre> <script> function loadedmetadata() { channels = audio.mozchannels; rate = audio.mozsamplerate; framebufferlength = audio.mozframebuf...
Running Tamarin performance tests - Archive of obsolete content
avmplus command to use -a --asc compiler to use -g --globalabc deprecated but still works - use builtin.abc (used to be location of global.abc) -b --builtinabc location of builtin.abc -s --shellabc location of shell_toplevel.abc -x --exclude comma separated list of directories to skip -h --help display help and exit -t --notime do not generate
timestamps (cleaner diffs) -f --forcerebuild force rebuild all test files -c --config sets the config string [default os-tvm] -q --quiet display minimum output during testrun -l --log also log all output to given logfile --summaryonly only display final summary --rebuildtests rebuild the tests only - do not run against vm --showtimes shows the time for each test...
... --ascargs args to pass to asc on rebuild of test files --vmargs args to pass to vm --timeout max time to run all tests --testtimeout max time to let a test run, in sec (default -1 = never timeout) --html also create an html output file --notimecheck do not recompile .abc if
timestamp is older than .as --java location of java executable (default=java) --javaargs arguments to pass to java --random run tests in random order --seed explicitly specify random seed for --random -s --avm2 second avmplus command to use --avmname nickname for avm to use as column header --avm2name nickname for avm2 to use as column header --detail display results in 'old-style' format ...
Efficient animation for web games - Game development
requestanimationframe includes a domhighres
timestamp in its callback function prototype, which you definitely should use (as opposed to using the date object), as this will be the time the frame began rendering, and ought to make your animations look more fluid.
... you may have a callback that ends up looking something like this: var starttime = -1; var animationlength = 2000; // animation length in milliseconds function doanimation(
timestamp) { // calculate animation progress var progress = 0; if (starttime < 0) { starttime =
timestamp; } else { progress =
timestamp - starttime; } // do animation ...
Basic native form controls - Learn web development
this is used to create a form control that is invisible to the user, but is still sent to the server along with the rest of the form data once submitted — for example you might want to submit a
timestamp to the server stating when an order was placed.
... <input type="hidden" id="
timestamp" name="
timestamp" value="1286705410"> if you create such an element, it's required to set its name and value attributes.
MozBeforePaint
the
timestamp property of this event will be set to the time when the animation frame is sampled; this is relevant when trying to synchronize mozrequestanimationframe animations with smil animations or css transitions.
... <!doctype html> <html> <body> <div id="d" style="width:100px; height:100px; background:lime; position:relative;"></div> <script> var d = document.getelementbyid("d"); var start = window.mozanimationstarttime; function step(event) { var progress = event.
timestamp - start; d.style.left = math.min(progress/10, 200) + "px"; if (progress < 2000) { window.mozrequestanimationframe(); } else { window.removeeventlistener("mozbeforepaint", step, false); } } window.addeventlistener("mozbeforepaint", step, false); window.mozrequestanimationframe(); </script> </body> </html> as you can see, each time the mozbeforepaint event fires, our step() method...
The Publicity Stream API
since the
timestamp of the earliest event you want returned.
... before the
timestamp of the latest event you want returned.
imgIContainer
pruint16 gettype(); violates the xpcom interface guidelines void init(in print32 awidth, in print32 aheight, in imgicontainerobserver aobserver); obsolete since gecko 2.0 void lockimage(); void removeframe(in gfxiimageframe item); obsolete since gecko 1.9.2 void requestdecode(); void requestdiscard(); void requestrefresh([const] in
timestamp atime); violates the xpcom interface guidelines void resetanimation(); void restoredatadone(); native code only!
...void requestrefresh( [const] in
timestamp atime ); parameters atime missing description exceptions thrown missing exception missing description resetanimation() void resetanimation(); parameters none.
nsIAppStartup
getstartupinfo() returns a javascript object with events from startup and the
timestamps indicating when they occurred.
.../toolkit/app-startup;1"] .getservice(ci.nsiappstartup_mozilla_2_0).getstartupinfo(); var keys = object.keys(startupinfo); keys.sort(function(a, b) { return startupinfo[a] - startupinfo[b]; }); for each (var name in keys) { aconsoleservice.logstringmessage(name + ": " + startupinfo[name]); } to calculate how long startup took, compute the difference between the event's
timestamp and the
timestamp of the process event.
nsIDOMEvent
timestamp dom
timestamp used to specify the time (in milliseconds relative to the epoch) at which the event was created.
... due to the fact that some systems may not provide this information the value of
timestamp may be not available for all events.
nsIPermissionManager
void remove( in int64_t since ); parameters since epoch
timestamp.
... permission information stored after this
timestamp will be removed.
BlobEvent.timecode - Web APIs
the timecode readonlyinline property of the blobevent interface a domhighres
timestamp indicating the difference between the
timestamp of the first chunk in data, and the
timestamp of the first chunk in the first blobevent produced by this recorder.
... syntax var timecode = blobevent.timecode value a domhighres
timestamp.
BudgetState.time - Web APIs
the time read-only property of the budgetstate interface returns a
timestamp at which the budgetat value is valid.
... syntax var time = budgetstate.time value a
timestamp.
CustomEvent - Web APIs
event.
timestamp read only the time at which the event was created (in milliseconds).
...in addition, work is underway to change this to be a domhighres
timestamp instead.
EXT_disjoint_timer_query.getQueryEXT() - Web APIs
must be ext.
timestamp_ext or ext.time_elapsed_ext.
... examples var ext = gl.getextension('ext_disjoint_timer_query'); var startquery = ext.createqueryext(); ext.querycounterext(startquery, ext.
timestamp_ext); var currentquery = ext.getqueryext(ext.
timestamp_ext, ext.current_query_ext); specifications specification status comment ext_disjoint_timer_querythe definition of 'ext_disjoint_timer_query' in that specification.
Event - Web APIs
event.
timestamp read only the time at which the event was created (in milliseconds).
...in addition, work is underway to change this to be a domhighres
timestamp instead.
GlobalEventHandlers.onreset - Web APIs
example this example logs the current event.
timestamp whenever you reset the form.
...time stamp: ${event.
timestamp}`; } const form = document.getelementbyid('form'); const log = document.getelementbyid('log'); form.onreset = logreset; result specification specification status comment html living standardthe definition of 'onreset' in that specification.
HTMLFormElement: reset event - Web APIs
bubbles yes (although specified as a simple event that doesn't bubble) cancelable yes interface event event handler property globaleventhandlers.onreset examples this example uses eventtarget.addeventlistener() to listen for form resets, and logs the current event.
timestamp whenever that occurs.
...time stamp: ${event.
timestamp}`; } const form = document.getelementbyid('form'); const log = document.getelementbyid('log'); form.addeventlistener('reset', logreset); result specifications specification status comment html living standardthe definition of 'reset' in that specification.
HTMLFormElement: submit event - Web APIs
examples this example uses eventtarget.addeventlistener() to listen for form submit, and logs the current event.
timestamp whenever that occurs, then prevents the default action of submitting the form.
...time stamp: ${event.
timestamp}`; event.preventdefault(); } const form = document.getelementbyid('form'); const log = document.getelementbyid('log'); form.addeventlistener('submit', logsubmit); result specifications specification status comment html living standardthe definition of 'submit' in that specification.
IntersectionObserverEntry.time - Web APIs
the intersectionobserverentry interface's read-only time property is a domhighres
timestamp that indicates the time at which the intersection change occurred relative to the time at which the document was created.
... syntax var time = intersectionobserverentry.time; value a domhighres
timestamp which indicates the time at which the target element experienced the intersection change described by the intersectionobserverentry.
MediaSource.setLiveSeekableRange() - Web APIs
if the duration of the media source is positive infinity, then the timeranges object returned by the htmlmediaelement.seekable property will have a start
timestamp no greater than this value.
...if the duration of the media source is positive infinity, then the timeranges object returned by the htmlmediaelement.seekable property will have an end
timestamp no less than this value.
Metadata.modificationTime - Web APIs
syntax var modificationtime = metadata.modificationtime; value a date
timestamp indicating when the file system entry was last changed.
...once that file has been found, its metadata is obtained and the file's modification
timestamp year is compared to the current year.
performance.mark() - Web APIs
the mark() method creates a
timestamp in the browser's performance entry buffer with the given name.
... the application defined
timestamp can be retrieved by one of the performance interface's getentries*() methods (getentries(), getentriesbyname() or getentriesbytype()).
performance.now() - Web APIs
the performance.now() method returns a domhighres
timestamp, measured in milliseconds.
... syntax t = performance.now(); example const t0 = performance.now(); dosomething(); const t1 = performance.now(); console.log(`call to dosomething took ${t1 - t0} milliseconds.`); unlike other timing data available to javascript (for example date.now), the
timestamps returned by performance.now() are not limited to one-millisecond resolution.
Performance.timeOrigin - Web APIs
the timeorigin read-only property of the performance interface returns the high resolution
timestamp of the start time of the performance measurement.
... syntax var timeorigin = performance.timeorigin value a high resolution
timestamp.
PerformanceEntry - Web APIs
performanceentry.starttime read only a domhighres
timestamp representing the starting time for the performance metric.
... performanceentry.duration read only a domhighres
timestamp representing the time value of the duration of the performance event.
PerformanceFrameTiming - Web APIs
performanceentry.starttime returns the
timestamp when the frame was started.
... performanceentry.duration returns a
timestamp indicating the difference between the starttimes of two successive frames.
PerformanceMark - Web APIs
entries of this type are created by calling performance.mark() to add a named domhighres
timestamp (the mark) to the browser's performance timeline.
... performanceentry.starttime returns the domhighres
timestamp when performance.mark() was called.
PerformanceNavigationTiming.domComplete - Web APIs
the domcomplete read-only property returns a
timestamp representing the time value equal to the time immediately before the user agent sets the current document readiness of the current document to complete.
... syntax perfentry.domcomplete; return value a
timestamp representing a time value equal to the time immediately before the user agent sets the current document readiness of the current document to complete.
PerformanceNavigationTiming.domContentLoadedEventEnd - Web APIs
the domcontentloadedeventend read-only property returns a
timestamp representing the time value equal to the time immediately after the current document's domcontentloaded event completes.
... syntax perfentry.domcontentloadedeventend; return value a
timestamp representing the time value equal to the time immediately after the current document's domcontentloaded event completes.
PerformanceNavigationTiming.domContentLoadedEventStart - Web APIs
the domcontentloadedeventstart read-only property returns a
timestamp representing the time value equal to the time immediately before the user agent fires the domcontentloaded event at the current document.
... syntax perfentry.domcontentloadedeventstart; return value a
timestamp representing the time value equal to the time immediately before the user agent fires the domcontentloaded event at the current document.
PerformanceNavigationTiming.domInteractive - Web APIs
the dominteractive read-only property returns a
timestamp representing the time value equal to the time immediately before the user agent sets the current document readiness of the current document to interactive.
... syntax perfentry.dominteractive; return value a
timestamp representing the time value equal to the time immediately before the user agent sets the current document readiness of the current document to interactive.
PerformanceNavigationTiming.loadEventEnd - Web APIs
the loadeventend read-only property returns a
timestamp which is equal to the time when the load event of the current document is completed.
... syntax perfentry.loadeventend; return value a
timestamp representing the time when the load event of the current document is completed.
PerformanceNavigationTiming.loadEventStart - Web APIs
the loadeventstart read-only property returns a
timestamp representing the time value equal to the time immediately before the load event of the current document is fired.
... syntax perfentry.loadeventstart; return value a
timestamp representing a time value equal to the time immediately before the load event of the current document is fired.
PerformanceNavigationTiming.unloadEventEnd - Web APIs
the unloadeventend read-only property returns a
timestamp representing the time value equal to the time immediately after the user agent finishes the unload event of the previous document.
... syntax perfentry.unloadeventend; return value a
timestamp representing a time value equal to the time immediately after the user agent finishes the unload event of the previous document.
PerformanceNavigationTiming.unloadEventStart - Web APIs
the unloadeventstart read-only property returns a
timestamp representing the time value equal to the time immediately before the user agent starts the unload event of the previous document.
... syntax perfentry.unloadeventstart; return value a
timestamp representing the time value equal to the time immediately before the user agent starts the unload event of the previous document.
Performance Timeline - Web APIs
starttime a high resolution
timestamp representing the starting time for the performance entry.
... duration a high resolution
timestamp representing the time value of the duration of the performance event.
PushSubscription.expirationTime - Web APIs
the expirationtime read-only property of the pushsubscription interface returns a domhighres
timestamp of the subscription expiration time associated with the push subscription, if there is one, or null otherwise.
... syntax var expirationtime = pushsubscription.expirationtime value a domhighres
timestamp.
RTCInboundRtpStreamStats - Web APIs
lastpacketreceived
timestamp a domhighres
timestamp indicating the time at which the last packet was received for this source.
... the
timestamp property, on the other hand, indicates the time at which the statistics object was generated.
RTCOutboundRtpStreamStats - Web APIs
lastpacketsent
timestamp a domhighres
timestamp indicating the time at which the last packet was sent for this ssrc.
... the
timestamp property, on the other hand, indicates the time at which the rtcoutboundrtpstreamstats object was generated.
RTCPeerConnection.getStats() - Web APIs
window.setinterval(function() { mypeerconnection.getstats(null).then(stats => { let statsoutput = ""; stats.foreach(report => { statsoutput += `<h2>report: ${report.type}</h3>\n<strong>id:</strong> ${report.id}<br>\n` + `<strong>
timestamp:</strong> ${report.
timestamp}<br>\n`; // now the statistics for this report; we intentially drop the ones we // sorted to the top above object.keys(report).foreach(statname => { if (statname !== "id" && statname !== "
timestamp" && statname !== "type") { statsoutput += `<strong>${statname}:</strong> ${report[statname]}<br>\n`; } }); }); ...
...a section is created for each report with a header and all of the statistics below, with the type, id, and
timestamp handled specially to place them at the top of the list.
RTCRemoteOutboundRtpStreamStats.localId - Web APIs
remoteoutbound.type === "remote-outbound-rtp") { let startremoteoutbound = startreport.get(endremoteoutbound.id); if (startremoteoutbound) { let startinboundstats = findreportentry(startreport, "remoteid", startremoteoutbound.id); let endinboundstats = findreportentry(endreport, "remoteid", endremoteoutbound.id); let elapsedtime = (endremoteoutbound.
timestamp - startremoteoutbound.
timestamp) / 1000; /* in seconds */ let packetssent = endremoteoutbound.packetssent - startremoteoutbound.packetssent; let bytessent = endremoteoutbound.bytessent - startremoteoutbound.bytessent; let framesdecoded = endinboundstats.framesdecoded - startinboundstats.framesdecoded; let framerate = framesdecoded / elapsedtime; ...
... now we have all the raw statistics needed to calculate the information we want to display, so we do so: we calculate the amount of time—elapsedtime—that elapsed between the two reports being sent by subtracting the
timestamp startreport from that of endreport.
RTCRtpContributingSource - Web APIs
rtp
timestamp optional the rtp
timestamp of the media played out at the time indicated by
timestamp.
...
timestamp optional a domhighres
timestamp indicating the most recent time at which a frame originating from this source was delivered to the receiver's mediastreamtrack specifications specification status comment webrtc 1.0: real-time communication between browsersthe definition of 'rtcrtpcontributingsource' in that specification.
RTCStatsReport - Web APIs
properties common to all statistic categories all webrtc statistics objects are fundamentally based on the rtcstats dictionary, which provides the most fundamental information: the
timestamp, the statistic type string, and an id uniquely identifying the source of the data: id a domstring which uniquely identifies the object which was inspected to produce this object based on rtcstats.
...
timestamp a domhighres
timestamp object indicating the time at which the sample was taken for this statistics object.
SourceBuffer.appendWindowEnd - Web APIs
the appendwindowend property of the sourcebuffer interface controls the
timestamp for the end of the append window, a
timestamp range that can be used to filter what media data is appended to the sourcebuffer.
... coded media frames with
timestamps wthin this range will be appended, whereas those outside the range will be filtered out.
SourceBuffer.appendWindowStart - Web APIs
the appendwindowstart property of the sourcebuffer interface controls the
timestamp for the start of the append window, a
timestamp range that can be used to filter what media data is appended to the sourcebuffer.
... coded media frames with
timestamps wthin this range will be appended, whereas those outside the range will be filtered out.
Date - JavaScript
description the ecmascript epoch and
timestamps a javascript date is fundamentally specified as the number of milliseconds that have elapsed since midnight on january 1, 1970, utc.
... let today = new date() let birthday = new date('december 17, 1995 03:24:00') let birthday = new date('1995-12-17t03:24:00') let birthday = new date(1995, 11, 17) // the month is 0-indexed let birthday = new date(1995, 11, 17, 3, 24, 0) let birthday = new date(628021800000) // passing epoch
timestamp to get date, month and year or time let [month, date, year] = ( new date() ).tolocaledatestring().split("/") let [hour, minute, second] = ( new date() ).tolocaletimestring().slice(0,7).split(":") two digit years map to 1900 – 1999 in order to create and get dates between the years 0 and 99 the date.prototype.setfullyear() and date.prototype.getfullyear() methods should be used.
Certificate Transparency - Web security
implementation when certificates are submitted to a ct log, a signed certificate
timestamp (sct) is generated and returned.
...this can be accomplished via a number of different mechanisms: x.509v3 certificate extension which embeds signed certificate
timestamps directly into the leaf certificate a tls extension of type signed_certificate_
timestamp sent during the handshake ocsp stapling (that is, the status_request tls extension) and providing a signedcertificate
timestamplist with one or more scts with the x.509 certificate extension, the included scts are decided by the issuing ca.
Finding window handles - Archive of obsolete content
_data(browserwindow_madeintogdkwinptr, gptr.address()); console.info('rez_gwgud:', rez_gwgud, /*rez_gwgud.tostring(),*/ uneval(rez_gwgud)); // return is void so cant do .tostring on it var browserwindow_madeintogtkwindowptr = ctypes.cast(gptr, gtkwindow.ptr); // focusing window this way is better, so it maintains proper history in case you or some other app want to focus "most recent window" by
timestamp // var rez_gst = gdk_x11_get_server_time(browserwindow_madeintogdkwinptr); // console.info('rez_gst:', rez_gst, uneval(rez_gst)); // return is a number of ms since the computer (xserver) was on // var rez_gwpwt = gtk_window_present_with_time(browserwindow_madeintogtkwindowptr, rez_gst); // console.info('rez_gwaf:', rez_gwpwt, uneval(rez_gwpwt)); var rez_gwp = gtk_window_present(browserwindow_mad...
XPCOM Objects - Archive of obsolete content
floating point float boolean boolean, prbool void void
timestamps prtime this type is used to pass
timestamps measured in milliseconds, such as the output of the gettime() method in a javascript date object.
2006-11-03 - Archive of obsolete content
summary: mozilla.dev.apps.calendar - october 27 - november 3, 2006 announcements test day results the calendar qa team had a successful test day on tuesday discussions storage format for events storage format of
timestamps in lightning.
TTL - MDN Web Docs Glossary: Definitions of Web-related terms
ttl can refer either to : the lifetime of a packet in a network can do before being released the expiry time of cached data networking in networking, the ttl, embedded in the packet, is a usually defined as a number of hops or as an expiration
timestamp after which the packet is dropped.
Accessibility/LiveRegionDevGuide
the "purge by
timestamp" method will be used to remove old messages that are no longer deemed relevant while "purge by politeness" is used to satisfy the aria live politeness specification.
How to investigate Disconnect failures
check if firefox crashed: windows: [user]/appdata\roaming\mozilla\firefox\crash reports ubuntu: [user/home]/.mozilla/firefox/crash reports and there we can check by
timestamp if firefox crashed when we had the disconnect.
PopupNotifications.jsm
timeout a
timestamp (milliseconds since the epoch) indicating the earliest time after which the notification can be automatically dismissed.
Webapps.jsm
r: function(ahandler) unregisterupdatehandler: function(ahandler) notifyupdatehandlers: function(aapp, amanifest, azippath) _getappdir: function(aid) _writefile: function(apath, adata) dogetlist: function() doexport: function(amsg, amm) doimport: function(amsg, amm) doextractmanifest: function(amsg, amm) dolaunch: function (adata, amm) launch: function launch(amanifesturl, astartpoint, a
timestamp, aonsuccess, aonfailure) close: function close(aapp) canceldownload: function canceldownload(amanifesturl, aerror) startofflinecachedownload: function(amanifest, aapp, aprofiledir, aisupdate) computemanifesthash: function(amanifest) updateapphandlers: function(aoldmanifest, anewmanifest, aapp) checkforupdate: function(adata, amm) doinstall: function doinstall(adata, amm) doinstallpackage:...
DMD
identifier is a string that will be used for part of the filename (or a
timestamp will be used if it is an empty string); anonymize is a boolean that indicates if the memory reports should be anonymized; and minimize is a boolean that indicates if memory usage should be minimized first.
Gecko Profiler FAQ
in this view, the
timestamps of individual samples / stacks will not be meaningful.
TraceMalloc
tracemalloclog
timestamp(caption) - log a
timestamp event to the current log file, annotating the log even with the caption string.
Index
several keywords are available: o serverauth o clientauth o codesigning o emailprotection o
timestamp o ocspresponder o stepup o critical x.509 certificate extensions are described in rfc 5280.
NSS_3.12_release_notes.html
_x509_cert_issuer sec_oid_x509_freshest_crl sec_oid_x509_inhibit_any_policy sec_oid_x509_subject_info_access camellia oids (rfc3657) sec_oid_camellia_128_cbc sec_oid_camellia_192_cbc sec_oid_camellia_256_cbc pkcs 5 v2 oids sec_oid_pkcs5_pbkdf2 sec_oid_pkcs5_pbes2 sec_oid_pkcs5_pbmac1 sec_oid_hmac_sha1 sec_oid_hmac_sha224 sec_oid_hmac_sha256 sec_oid_hmac_sha384 sec_oid_hmac_sha512 sec_oid_pkix_
timestamping sec_oid_pkix_ca_repository sec_oid_iso_sha1_with_rsa_signature changed oids (see secoidt.h) sec_oid_pkcs12_key_usage changed to sec_oid_bogus_key_usage sec_oid_ansix962_ecdsa_signature_with_sha1_digest changed to sec_oid_ansix962_ecdsa_sha1_signature note: sec_oid_ansix962_ecdsa_signature_with_sha1_digest is also kept for compatibility reasons.
NSS 3.28 release notes
this includes a number of improvements to tls 1.3: the signed certificate
timestamp, used in certificate transparency, is supported in tls 1.3 (bug 1252745).
NSS 3.53 release notes
(bug 1618404, bug 1621159) if a builtin certificate has a cka_nss_server_distrust_after
timestamp before the sct or notbefore date of a certificate that builtin issued, then clients can elect not to trust it.
NSS tools : certutil
several keywords are available: + serverauth + clientauth + codesigning + emailprotection +
timestamp + ocspresponder + stepup + critical x.509 certificate extensions are described in rfc 5280.
certutil
several keywords are available: o serverauth o clientauth o codesigning o emailprotection o
timestamp o ocspresponder o stepup o critical x.509 certificate extensions are described in rfc 5280.
Monitoring HTTP activity
// define a reference to the interfacevar nsihttpactivityobserver = components.interfaces.nsihttpactivityobserver; var httpobserver = { observeactivity: function(ahttpchannel, aactivitytype, aactivitysubtype, a
timestamp, aextrasizedata, aextrastringdata) { if (aactivitytype == nsihttpactivityobserver.activity_type_http_transaction) { switch(aactivitysubtype) { case nsihttpactivityobserver.activity_subtype_response_header: // received response header break; case nsihttpactivityobserver.activity_subtype_response_complete: // received complet...
nsIMsgDBHdr
dateinseconds unsigned long readonly: indicates the date of this message as a unix
timestamp.
nsIScriptError
timestamp long long elapsed time, in milliseconds, from a platform-specific zero time to the time the message was created.
nsIScriptError2
timestamp long long elapsed time, in milliseconds, from a platform-specific zero time to the time the message was created.
LDAP Support
countryname _aimscreenname nscpaimscreenname webpage1 workurl webpage2 homeurl birthyear birthyear custom1 custom1 custom2 custom2 custom3 custom3 custom4 custom4 notes notes notes description prefermailformat xmozillausehtmlmail lastmodifieddate modify
timestamp custom ldap attributes thunderbird supports custom ldap attributes for various address book attributes.
WebIDL bindings
it has a
timestamp() method returning a double which represents a number of milliseconds since the epoch, as well as set
timestamp() methods that can be used to initialize it with a double
timestamp or a js date object.
Debugger.Memory - Firefox Developer Tools
for each collection slice that occurred, there is an entry in the collections array with the following form: { "start
timestamp":
timestamp, "end
timestamp":
timestamp, } here the
timestamp values are
timestamps of the gc slice’s start and end events.
Basic operations - Firefox Developer Tools
on the left, you'll see an entry for the new snapshot, including its
timestamp, size, and controls to save or clear this snapshot: clearing a snapshot to remove a snapshot, click the "x" icon: saving and loading snapshots if you close the memory tool, all unsaved snapshots will be discarded.
AudioContext - Web APIs
audiocontext.getoutput
timestamp() returns a new audio
timestamp object containing two audio
timestamp values relating to the current audio context.
BaseAudioContext.currentTime - Web APIs
the currenttime read-only property of the baseaudiocontext interface returns a double representing an ever-increasing hardware
timestamp in seconds that can be used for scheduling audio playback, visualizing timelines, etc.
BlobEvent - Web APIs
blobevent.timecode read only a domhighres
timestamp indicating the difference between the
timestamp of the first chunk in data and the
timestamp of the first chunk in the first blobevent produced by this recorder.
console - Web APIs
console.
timestamp() adds a marker to the browser's timeline or waterfall tool.
Document Object Model (DOM) - Web APIs
dom interfaces attr cdatasection characterdata childnode comment customevent document documentfragment documenttype domerror domexception domimplementation domstring dom
timestamp domstringlist domtokenlist element event eventtarget htmlcollection mutationobserver mutationrecord namednodemap node nodefilter nodeiterator nodelist nondocumenttypechildnode parentnode processinginstruction selection range text textdecoder textencoder timeranges treewalker url window worker xmldocument obsolete dom interfaces the document object model has ...
Element.innerHTML - Web APIs
function log(msg) { var logelem = document.queryselector(".log"); var time = new date(); var timestr = time.tolocaletimestring(); logelem.innerhtml += timestr + ": " + msg + "<br/>"; } log("logging mouse events inside this container..."); the log() function creates the log output by getting the current time from a date object using tolocaletimestring(), and building a string with the
timestamp and the message text.
Using the Frame Timing API - Web APIs
firefox's performance tool also includes a frame rate graph which provides
timestamps for each frame including the average frame rate and the minimum and maximum rates (for a specific recording session).
Gamepad - Web APIs
gamepad.
timestamp read only a domhighres
timestamp representing the last time the data for this gamepad was updated.
Using the Gamepad API - Web APIs
timestamp: this returns a domhighres
timestamp representing the last time the data for this gamepad was updated, allowing developers to determine if the axes and button data have been updated from the hardware.
GeolocationCoordinates.longitude - Web APIs
together with a dom
timestamp indicating a time of measurement, the geolocationcoordinates object is part of the geolocationposition interface, which is the object type returned by geolocation api functions that obtain and return a geographical position.
GeolocationPosition - Web APIs
geolocationposition.
timestamp read only secure context returns a dom
timestamp representing the time at which the location was retrieved.
Using the Geolocation API - Web APIs
the geolocationposition instance contains only two things, a coords property that contains the geolocationcoordinates instance, and a
timestamp property that contains a dom
timestamp instance representing the time at which the position data was retrieved.
Geolocation API - Web APIs
a geolocationposition instance is returned by a successful call to one of the methods contained inside geolocation, inside a success callback, and contains a
timestamp plus a geolocationcoordinates object instance.
HTMLModElement - Web APIs
htmlmodelement.datetime is a domstring reflecting the datetime html attribute, containing a date-and-time string representing a
timestamp for the change.
IdleDeadline.timeRemaining() - Web APIs
syntax timeremaining = idledeadline.timeremaining(); return value a domhighres
timestamp value (which is a floating-point number) representing the number of milliseconds the user agent estimates are left in the current idle period.
IdleDeadline - Web APIs
methods idledeadline.timeremaining() returns a domhighres
timestamp, which is a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period.
IntersectionObserverEntry - Web APIs
intersectionobserverentry.time read only a domhighres
timestamp indicating the time at which the intersection was recorded, relative to the intersectionobserver's time origin.
MIDIMessageEvent - Web APIs
note: even though the web midi api specifies a receivedtime property that returns a domhighres
timestamp, chrome (the only implementation at the time of writing) does not support that property since the basic event.
timestamp property already returns a domhighres
timestamp in chrome.
MediaSessionActionDetails.seekOffset - Web APIs
syntax let mediasessionactiondetails = { seekoffset: deltatimeinseconds }; let deltatime = mediasessionactiondetails.seekoffset; value a floating-point value indicating the time delta in seconds by which to move the playback position relative to its current
timestamp.
Navigator - Web APIs
in modern browsers this property now returns a fixed
timestamp as a privacy measure, e.g.
Notification - Web APIs
notification.
timestamp read only specifies the time at which a notification is created or applicable (past, present, or future).
PerformanceEventTiming - Web APIs
0 : infinity; document.addeventlistener('visibilitychange', (event) => { firsthiddentime = math.min(firsthiddentime, event.
timestamp); }, {once: true}); // sends the passed data to an analytics endpoint.
PushSubscription - Web APIs
pushsubscription.expirationtime read only a domhighres
timestamp of the subscription expiration time associated with the push subscription, if there is one, or null otherwise.
RTCDataChannel.send() - Web APIs
var pc = new rtcpeerconnection(); var dc = pc.createdatachannel("backchannel"); function sendmessage(msg) { let obj = { "message": msg, "
timestamp": new date() } dc.send(json.stringify(obj)); } specifications specification status comment webrtc 1.0: real-time communication between browsersthe definition of 'rtcdatachannel.send()' in that specification.
RTCIceCandidatePairStats.writable - Web APIs
note: this property was removed from the specification in early 2017 because you can determine whether or not an incoming ice request is available to read by checking to see if responsesreceived is greater than 0 and that the time specified by consentexpired
timestamp has not passed: if (icpstats.responsesreceived > 0 && icpstats.consentexpired
timestamp < performance.now()) { /* at least one ice response has been received */ } ...
RTCIceCandidateStats.deleted - Web APIs
window.setinterval(function() { mypeerconnection.getstats(null).then(stats => { let statsoutput = ""; stats.foreach(report => { if ((stats.type === "local-candidate" || stats.type === "remote.candidate") && !stats.deleted) { statsoutput += `<h2>report: ${report.type}</h3>\n<strong>id:</strong> ${report.id}<br>\n` + `<strong>
timestamp:</strong> ${report.
timestamp}<br>\n`; // now the statistics for this report; we intentially drop the ones we // sorted to the top above object.keys(report).foreach(statname => { if (statname !== "id" && statname !== "
timestamp" && statname !== "type") { statsoutput += `<strong>${statname}:</strong> ${report[statname]}<br>\n`; } });...
RTCIceCandidateStats.networkType - Web APIs
window.setinterval(function() { mypeerconnection.getstats(null).then(stats => { let statsoutput = ""; stats.foreach(report => { if ((stats.type === "local-candidate" || stats.type === "remote.candidate") && stats.networktype === "cellular") { statsoutput += `<h2>report: ${report.type}</h3>\n<strong>id:</strong> ${report.id}<br>\n` + `<strong>
timestamp:</strong> ${report.
timestamp}<br>\n`; // now the statistics for this report; we intentially drop the ones we // sorted to the top above object.keys(report).foreach(statname => { if (statname !== "id" && statname !== "
timestamp" && statname !== "type") { statsoutput += `<strong>${statname}:</strong> ${report[statname]}<br>\n`; } });...
RTCStats - Web APIs
timestamp a domhighres
timestamp object indicating the time at which the sample was taken for this statistics object.
Sensor - Web APIs
sensor.
timestamp read only returns the time stamp of the latest sensor reading.
VideoPlaybackQuality.creationTime - Web APIs
syntax value = videoplaybackquality.creationtime; value a domhighres
timestamp object which indicates the number of milliseconds that elapased between the time the browsing context was created and the time at which this sample of the video quality was obtained.
VideoPlaybackQuality - Web APIs
creationtime read only a domhighres
timestamp containing the time in miliseconds between the start of the navigation and the creation of the object.
Movement, orientation, and motion: A WebXR example - Web APIs
the time elapsed since the last frame was rendered (in seconds) is computed by subtracting the previous frame's
timestamp, lastframetime, from the current time as specified by the time parameter and then multiplying by 0.001 to convert milliseconds to seconds.
window.cancelAnimationFrame() - Web APIs
var myreq; function step(
timestamp) { var progress =
timestamp - start; d.style.left = math.min(progress / 10, 200) + 'px'; if (progress < 2000) { // it's important to update the requestid each time you're calling requestanimationframe myreq = requestanimationframe(step); } } myreq = requestanimationframe(step); // the cancelation uses the last requestid cancelanimationframe(myreq); specifications speci...
Window.onmozbeforepaint - Web APIs
the event handler receives as an input parameter an event whose
timestamp property is the time, in milliseconds since epoch, that is the "current time" for the current animation frame.
Using XMLHttpRequest - Web APIs
bypassing the cache a cross-browser compatible approach to bypassing the cache is appending a
timestamp to the url, being sure to include a "?" or "&" as appropriate.
XRFrameRequestCallback - Web APIs
syntax function xrframerequestcallback(time, xrframe){ // process xrframe here } xrsession.requestanimationframe(xrframerequestcallback) parameters domhighres
timestamp a
timestamp corresponding to the returned xrframe.
XRInputSourceEventInit.frame - Web APIs
the xrinputsourceeventinit dictionary's property frame specifies an xrframe providing information about the
timestamp at which the new input source event took place, as well as access to the xrframe method getpose() which can be used to map the coordinates of any xrreferencespace to the space in which the event took place.
Web APIs
d clipboardevent clipboarditem closeevent comment compositionevent constantsourcenode constrainboolean constraindomstring constraindouble constrainulong contentindex contentindexevent convolvernode countqueuingstrategy crashreportbody credential credentialscontainer crypto cryptokey cryptokeypair customelementregistry customevent d domconfiguration domerror domexception domhighres
timestamp domimplementation domimplementationlist domlocator dommatrix dommatrixreadonly domobject domparser dompoint dompointinit dompointreadonly domquad domrect domrectreadonly domstring domstringlist domstringmap dom
timestamp domtokenlist domuserdata datatransfer datatransferitem datatransferitemlist dedicatedworkerglobalscope delaynode deprecationreportbody devicelightevent devicemotio...
ARIA annotations - Accessibility
<!-- some kind of ui feature that needs an accessible description --> </div> aria-details is appropriate when linking to descriptions or annotations that are a bit more complex — rather than a simple text string, it might contain multiple bits of semantic information: <div id="detail-id"> <h2>a heading</h2> <p>an extended text description of some kind…</p> <p><time datetime="...">a
timestamp</time></p> </div> <div aria-details="detail-id"> <!-- some kind of ui feature that needs an accessible description --> </div> this difference really becomes apparent when you get to how the content is actually interpreted in the accessibility layer, and read out by screenreaders.
Overview of events and handlers - Developer guides
"eventprototype" : "objectprototype"; alert("we got a click event at " + ev.
timestamp + " with an argument object derived from: " + objkind ); }; and second register our function with the the button object, either on the scripting side using the dom (document object model) representation of the html page: var buttondomelement = document.queryselector('#buttonone'); buttondomelement.addeventlistener('click', example_click_handler); or within the html page by adding the function ...
<input type="date"> - HTML: Hypertext Markup Language
for example: var datecontrol = document.queryselector('input[type="date"]'); datecontrol.value = '2017-06-01'; console.log(datecontrol.value); // prints "2017-06-01" console.log(datecontrol.valueasnumber); // prints 1496275200000, a unix
timestamp this code finds the first <input> element whose type is date, and sets its value to 2017-06-01 (june 1st, 2017).
ETag - HTTP
often, a hash of the content, a hash of the last modification
timestamp, or just a revision number is used.
Expect-CT - HTTP
ct requirements can be satisfied via any one of the following mechanisms: x.509v3 certificate extension to allow embedding of signed certificate
timestamps issued by individual logs a tls extension of type signed_certificate_
timestamp sent during the handshake supporting ocsp stapling (that is, the status_request tls extension) and providing a signedcertificate
timestamplist when a site enables the expect-ct header, they are requesting that the browser check that any certificate for that site appears in public ct logs.
Expires - HTTP
header type response header forbidden header name no cors-safelisted response header yes syntax expires: <http-date> directives <http-date> an http-date
timestamp.
Set-Cookie - HTTP
expires=<date> optional the maximum lifetime of the cookie as an http-date
timestamp.