Revision 4f06a45252465792447f80b6559b17c4c4e9712c authored by Daniel Vogelheim on 10 April 2018, 13:07:39 UTC, committed by Chromium WPT Sync on 10 April 2018, 13:07:39 UTC
Allow control of the deprecation via runtime enabled features, with a first step for logging a warning to the console, and the second step to block it outright. Intent: https://groups.google.com/a/chromium.org/d/msg/blink-dev/35t5cJQ3J_Q/FH45dl0vAwAJ Change-Id: I1be1001cbbef152458119b1516750bb4f1d1e4de Reviewed-on: https://chromium-review.googlesource.com/975611 Commit-Queue: Daniel Vogelheim <vogelheim@chromium.org> Reviewed-by: Mike West <mkwst@chromium.org> Cr-Commit-Position: refs/heads/master@{#549495}
1 parent 069680c
webrtc-pc.idl
// GENERATED CONTENT - DO NOT EDIT
// Content of this file was automatically extracted from the WebRTC spec.
// See https://w3c.github.io/webrtc-pc/
dictionary RTCConfiguration {
sequence<RTCIceServer> iceServers;
RTCIceTransportPolicy iceTransportPolicy = "all";
RTCBundlePolicy bundlePolicy = "balanced";
RTCRtcpMuxPolicy rtcpMuxPolicy = "require";
DOMString peerIdentity;
sequence<RTCCertificate> certificates;
[EnforceRange]
octet iceCandidatePoolSize = 0;
};
enum RTCIceCredentialType {
"password",
"oauth"
};
dictionary RTCOAuthCredential {
required DOMString macKey;
required DOMString accessToken;
};
dictionary RTCIceServer {
required (DOMString or sequence<DOMString>) urls;
DOMString username;
(DOMString or RTCOAuthCredential) credential;
RTCIceCredentialType credentialType = "password";
};
enum RTCIceTransportPolicy {
"relay",
"all"
};
enum RTCBundlePolicy {
"balanced",
"max-compat",
"max-bundle"
};
enum RTCRtcpMuxPolicy {
// At risk due to lack of implementers' interest.
"negotiate",
"require"
};
dictionary RTCOfferAnswerOptions {
boolean voiceActivityDetection = true;
};
dictionary RTCOfferOptions : RTCOfferAnswerOptions {
boolean iceRestart = false;
};
dictionary RTCAnswerOptions : RTCOfferAnswerOptions {
};
enum RTCSignalingState {
"stable",
"have-local-offer",
"have-remote-offer",
"have-local-pranswer",
"have-remote-pranswer",
"closed"
};
enum RTCIceGatheringState {
"new",
"gathering",
"complete"
};
enum RTCPeerConnectionState {
"new",
"connecting",
"connected",
"disconnected",
"failed",
"closed"
};
enum RTCIceConnectionState {
"new",
"checking",
"connected",
"completed",
"disconnected",
"failed",
"closed"
};
[ Constructor (optional RTCConfiguration configuration), Exposed=Window]
interface RTCPeerConnection : EventTarget {
Promise<RTCSessionDescriptionInit> createOffer (optional RTCOfferOptions options);
Promise<RTCSessionDescriptionInit> createAnswer (optional RTCAnswerOptions options);
Promise<void> setLocalDescription (RTCSessionDescriptionInit description);
readonly attribute RTCSessionDescription? localDescription;
readonly attribute RTCSessionDescription? currentLocalDescription;
readonly attribute RTCSessionDescription? pendingLocalDescription;
Promise<void> setRemoteDescription (RTCSessionDescriptionInit description);
readonly attribute RTCSessionDescription? remoteDescription;
readonly attribute RTCSessionDescription? currentRemoteDescription;
readonly attribute RTCSessionDescription? pendingRemoteDescription;
Promise<void> addIceCandidate ((RTCIceCandidateInit or RTCIceCandidate) candidate);
readonly attribute RTCSignalingState signalingState;
readonly attribute RTCIceGatheringState iceGatheringState;
readonly attribute RTCIceConnectionState iceConnectionState;
readonly attribute RTCPeerConnectionState connectionState;
readonly attribute boolean? canTrickleIceCandidates;
static sequence<RTCIceServer> getDefaultIceServers ();
RTCConfiguration getConfiguration ();
void setConfiguration (RTCConfiguration configuration);
void close ();
attribute EventHandler onnegotiationneeded;
attribute EventHandler onicecandidate;
attribute EventHandler onicecandidateerror;
attribute EventHandler onsignalingstatechange;
attribute EventHandler oniceconnectionstatechange;
attribute EventHandler onicegatheringstatechange;
attribute EventHandler onconnectionstatechange;
};
partial interface RTCPeerConnection {
Promise<void> createOffer (RTCSessionDescriptionCallback successCallback, RTCPeerConnectionErrorCallback failureCallback, optional RTCOfferOptions options);
Promise<void> setLocalDescription (RTCSessionDescriptionInit description, VoidFunction successCallback, RTCPeerConnectionErrorCallback failureCallback);
Promise<void> createAnswer (RTCSessionDescriptionCallback successCallback, RTCPeerConnectionErrorCallback failureCallback);
Promise<void> setRemoteDescription (RTCSessionDescriptionInit description, VoidFunction successCallback, RTCPeerConnectionErrorCallback failureCallback);
Promise<void> addIceCandidate ((RTCIceCandidateInit or RTCIceCandidate) candidate, VoidFunction successCallback, RTCPeerConnectionErrorCallback failureCallback);
};
callback RTCPeerConnectionErrorCallback = void (DOMException error);
callback RTCSessionDescriptionCallback = void (RTCSessionDescriptionInit description);
partial dictionary RTCOfferOptions {
boolean offerToReceiveAudio;
boolean offerToReceiveVideo;
};
enum RTCSdpType {
"offer",
"pranswer",
"answer",
"rollback"
};
[ Constructor (RTCSessionDescriptionInit descriptionInitDict), Exposed=Window]
interface RTCSessionDescription {
readonly attribute RTCSdpType type;
readonly attribute DOMString sdp;
[Default] object toJSON();
};
dictionary RTCSessionDescriptionInit {
required RTCSdpType type;
DOMString sdp = "";
};
[ Constructor (optional RTCIceCandidateInit candidateInitDict), Exposed=Window]
interface RTCIceCandidate {
readonly attribute DOMString candidate;
readonly attribute DOMString? sdpMid;
readonly attribute unsigned short? sdpMLineIndex;
readonly attribute DOMString? foundation;
readonly attribute RTCIceComponent? component;
readonly attribute unsigned long? priority;
readonly attribute DOMString? ip;
readonly attribute RTCIceProtocol? protocol;
readonly attribute unsigned short? port;
readonly attribute RTCIceCandidateType? type;
readonly attribute RTCIceTcpCandidateType? tcpType;
readonly attribute DOMString? relatedAddress;
readonly attribute unsigned short? relatedPort;
readonly attribute DOMString? usernameFragment;
RTCIceCandidateInit toJSON();
};
dictionary RTCIceCandidateInit {
DOMString candidate = "";
DOMString? sdpMid = null;
unsigned short? sdpMLineIndex = null;
DOMString usernameFragment;
};
enum RTCIceProtocol {
"udp",
"tcp"
};
enum RTCIceTcpCandidateType {
"active",
"passive",
"so"
};
enum RTCIceCandidateType {
"host",
"srflx",
"prflx",
"relay"
};
[ Constructor (DOMString type, optional RTCPeerConnectionIceEventInit eventInitDict), Exposed=Window]
interface RTCPeerConnectionIceEvent : Event {
readonly attribute RTCIceCandidate? candidate;
readonly attribute DOMString? url;
};
dictionary RTCPeerConnectionIceEventInit : EventInit {
RTCIceCandidate? candidate;
DOMString? url;
};
[ Constructor (DOMString type, RTCPeerConnectionIceErrorEventInit eventInitDict), Exposed=Window]
interface RTCPeerConnectionIceErrorEvent : Event {
readonly attribute DOMString hostCandidate;
readonly attribute DOMString url;
readonly attribute unsigned short errorCode;
readonly attribute USVString errorText;
};
dictionary RTCPeerConnectionIceErrorEventInit : EventInit {
DOMString hostCandidate;
DOMString url;
required unsigned short errorCode;
USVString statusText;
};
enum RTCPriorityType {
"very-low",
"low",
"medium",
"high"
};
partial interface RTCPeerConnection {
static Promise<RTCCertificate> generateCertificate (AlgorithmIdentifier keygenAlgorithm);
};
dictionary RTCCertificateExpiration {
[EnforceRange]
DOMTimeStamp expires;
};
[Exposed=Window] interface RTCCertificate {
readonly attribute DOMTimeStamp expires;
static sequence<AlgorithmIdentifier> getSupportedAlgorithms();
sequence<RTCDtlsFingerprint> getFingerprints ();
};
partial interface RTCPeerConnection {
sequence<RTCRtpSender> getSenders ();
sequence<RTCRtpReceiver> getReceivers ();
sequence<RTCRtpTransceiver> getTransceivers ();
RTCRtpSender addTrack (MediaStreamTrack track, MediaStream... streams);
void removeTrack (RTCRtpSender sender);
RTCRtpTransceiver addTransceiver ((MediaStreamTrack or DOMString) trackOrKind, optional RTCRtpTransceiverInit init);
attribute EventHandler ontrack;
};
dictionary RTCRtpTransceiverInit {
RTCRtpTransceiverDirection direction = "sendrecv";
sequence<MediaStream> streams = [];
sequence<RTCRtpEncodingParameters> sendEncodings = [];
};
enum RTCRtpTransceiverDirection {
"sendrecv",
"sendonly",
"recvonly",
"inactive"
};
[Exposed=Window] interface RTCRtpSender {
readonly attribute MediaStreamTrack? track;
readonly attribute RTCDtlsTransport? transport;
readonly attribute RTCDtlsTransport? rtcpTransport;
static RTCRtpCapabilities getCapabilities (DOMString kind);
Promise<void> setParameters (optional RTCRtpParameters parameters);
RTCRtpParameters getParameters ();
Promise<void> replaceTrack (MediaStreamTrack? withTrack);
Promise<RTCStatsReport> getStats();
};
dictionary RTCRtpParameters {
DOMString transactionId;
sequence<RTCRtpEncodingParameters> encodings;
sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
RTCRtcpParameters rtcp;
sequence<RTCRtpCodecParameters> codecs;
RTCDegradationPreference degradationPreference;
};
dictionary RTCRtpEncodingParameters {
octet codecPayloadType;
RTCDtxStatus dtx;
boolean active = true;
RTCPriorityType priority = "low";
unsigned long ptime;
unsigned long maxBitrate;
double maxFramerate;
DOMString rid;
double scaleResolutionDownBy;
};
enum RTCDtxStatus {
"disabled",
"enabled"
};
enum RTCDegradationPreference {
"maintain-framerate",
"maintain-resolution",
"balanced"
};
dictionary RTCRtcpParameters {
DOMString cname;
boolean reducedSize;
};
dictionary RTCRtpHeaderExtensionParameters {
DOMString uri;
unsigned short id;
boolean encrypted;
};
dictionary RTCRtpCodecParameters {
octet payloadType;
DOMString mimeType;
unsigned long clockRate;
unsigned short channels;
DOMString sdpFmtpLine;
};
dictionary RTCRtpCapabilities {
sequence<RTCRtpCodecCapability> codecs;
sequence<RTCRtpHeaderExtensionCapability> headerExtensions;
};
dictionary RTCRtpCodecCapability {
DOMString mimeType;
unsigned long clockRate;
unsigned short channels;
DOMString sdpFmtpLine;
};
dictionary RTCRtpHeaderExtensionCapability {
DOMString uri;
};
[Exposed=Window] interface RTCRtpReceiver {
readonly attribute MediaStreamTrack track;
readonly attribute RTCDtlsTransport? transport;
readonly attribute RTCDtlsTransport? rtcpTransport;
static RTCRtpCapabilities getCapabilities (DOMString kind);
RTCRtpParameters getParameters ();
sequence<RTCRtpContributingSource> getContributingSources ();
sequence<RTCRtpSynchronizationSource> getSynchronizationSources ();
Promise<RTCStatsReport> getStats();
};
dictionary RTCRtpContributingSource {
required DOMHighResTimeStamp timestamp;
required unsigned long source;
double audioLevel;
};
dictionary RTCRtpSynchronizationSource : RTCRtpContributingSource {
boolean voiceActivityFlag;
};
[Exposed=Window] interface RTCRtpTransceiver {
readonly attribute DOMString? mid;
[SameObject]
readonly attribute RTCRtpSender sender;
[SameObject]
readonly attribute RTCRtpReceiver receiver;
readonly attribute boolean stopped;
attribute RTCRtpTransceiverDirection direction;
readonly attribute RTCRtpTransceiverDirection? currentDirection;
void stop ();
void setCodecPreferences (sequence<RTCRtpCodecCapability> codecs);
};
[Exposed=Window] interface RTCDtlsTransport : EventTarget {
readonly attribute RTCIceTransport transport;
readonly attribute RTCDtlsTransportState state;
sequence<ArrayBuffer> getRemoteCertificates ();
attribute EventHandler onstatechange;
attribute EventHandler onerror;
};
enum RTCDtlsTransportState {
"new",
"connecting",
"connected",
"closed",
"failed"
};
dictionary RTCDtlsFingerprint {
DOMString algorithm;
DOMString value;
};
[Exposed=Window] interface RTCIceTransport : EventTarget {
readonly attribute RTCIceRole role;
readonly attribute RTCIceComponent component;
readonly attribute RTCIceTransportState state;
readonly attribute RTCIceGathererState gatheringState;
sequence<RTCIceCandidate> getLocalCandidates ();
sequence<RTCIceCandidate> getRemoteCandidates ();
RTCIceCandidatePair? getSelectedCandidatePair ();
RTCIceParameters? getLocalParameters ();
RTCIceParameters? getRemoteParameters ();
attribute EventHandler onstatechange;
attribute EventHandler ongatheringstatechange;
attribute EventHandler onselectedcandidatepairchange;
};
dictionary RTCIceParameters {
DOMString usernameFragment;
DOMString password;
};
dictionary RTCIceCandidatePair {
RTCIceCandidate local;
RTCIceCandidate remote;
};
enum RTCIceGathererState {
"new",
"gathering",
"complete"
};
enum RTCIceTransportState {
"new",
"checking",
"connected",
"completed",
"disconnected",
"failed",
"closed"
};
enum RTCIceRole {
"controlling",
"controlled"
};
enum RTCIceComponent {
"rtp",
"rtcp"
};
[ Constructor (DOMString type, RTCTrackEventInit eventInitDict), Exposed=Window]
interface RTCTrackEvent : Event {
readonly attribute RTCRtpReceiver receiver;
readonly attribute MediaStreamTrack track;
[SameObject]
readonly attribute FrozenArray<MediaStream> streams;
readonly attribute RTCRtpTransceiver transceiver;
};
dictionary RTCTrackEventInit : EventInit {
required RTCRtpReceiver receiver;
required MediaStreamTrack track;
sequence<MediaStream> streams = [];
required RTCRtpTransceiver transceiver;
};
partial interface RTCPeerConnection {
readonly attribute RTCSctpTransport? sctp;
RTCDataChannel createDataChannel (USVString label, optional RTCDataChannelInit dataChannelDict);
attribute EventHandler ondatachannel;
};
[Exposed=Window] interface RTCSctpTransport {
readonly attribute RTCDtlsTransport transport;
readonly attribute RTCSctpTransportState state;
readonly attribute unrestricted double maxMessageSize;
attribute EventHandler onstatechange;
};
enum RTCSctpTransportState {
"new",
"connecting",
"connected",
"closed"
};
[Exposed=Window] interface RTCDataChannel : EventTarget {
readonly attribute USVString label;
readonly attribute boolean ordered;
readonly attribute unsigned short? maxPacketLifeTime;
readonly attribute unsigned short? maxRetransmits;
readonly attribute USVString protocol;
readonly attribute boolean negotiated;
readonly attribute unsigned short? id;
readonly attribute RTCPriorityType priority;
readonly attribute RTCDataChannelState readyState;
readonly attribute unsigned long bufferedAmount;
attribute unsigned long bufferedAmountLowThreshold;
attribute EventHandler onopen;
attribute EventHandler onbufferedamountlow;
attribute EventHandler onerror;
attribute EventHandler onclose;
void close ();
attribute EventHandler onmessage;
attribute DOMString binaryType;
void send (USVString data);
void send (Blob data);
void send (ArrayBuffer data);
void send (ArrayBufferView data);
};
dictionary RTCDataChannelInit {
boolean ordered = true;
unsigned short maxPacketLifeTime;
unsigned short maxRetransmits;
USVString protocol = "";
boolean negotiated = false;
[EnforceRange]
unsigned short id;
RTCPriorityType priority = "low";
};
enum RTCDataChannelState {
"connecting",
"open",
"closing",
"closed"
};
[ Constructor (DOMString type, RTCDataChannelEventInit eventInitDict), Exposed=Window]
interface RTCDataChannelEvent : Event {
readonly attribute RTCDataChannel channel;
};
dictionary RTCDataChannelEventInit : EventInit {
required RTCDataChannel channel;
};
partial interface RTCRtpSender {
readonly attribute RTCDTMFSender? dtmf;
};
[Exposed=Window] interface RTCDTMFSender : EventTarget {
void insertDTMF (DOMString tones, optional unsigned long duration = 100, optional unsigned long interToneGap = 70);
attribute EventHandler ontonechange;
readonly attribute boolean canInsertDTMF;
readonly attribute DOMString toneBuffer;
};
[ Constructor (DOMString type, RTCDTMFToneChangeEventInit eventInitDict), Exposed=Window]
interface RTCDTMFToneChangeEvent : Event {
readonly attribute DOMString tone;
};
dictionary RTCDTMFToneChangeEventInit : EventInit {
required DOMString tone;
};
partial interface RTCPeerConnection {
Promise<RTCStatsReport> getStats (optional MediaStreamTrack? selector = null);
attribute EventHandler onstatsended;
};
[Exposed=Window] interface RTCStatsReport {
readonly maplike<DOMString, object>;
};
dictionary RTCStats {
required DOMHighResTimeStamp timestamp;
required RTCStatsType type;
required DOMString id;
};
[ Constructor (DOMString type, RTCStatsEventInit
eventInitDict), Exposed=Window]
interface RTCStatsEvent : Event {
readonly attribute RTCStatsReport report;
};
[Global, Exposed=RTCIdentityProviderGlobalScope]
interface RTCIdentityProviderGlobalScope : WorkerGlobalScope {
readonly attribute RTCIdentityProviderRegistrar rtcIdentityProvider;
};
[Exposed=RTCIdentityProviderGlobalScope]
interface RTCIdentityProviderRegistrar {
void register (RTCIdentityProvider idp);
};
dictionary RTCIdentityProvider {
required GenerateAssertionCallback generateAssertion;
required ValidateAssertionCallback validateAssertion;
};
callback GenerateAssertionCallback = Promise<RTCIdentityAssertionResult>
(DOMString contents, DOMString origin, RTCIdentityProviderOptions options);
callback ValidateAssertionCallback = Promise<RTCIdentityValidationResult>
(DOMString assertion, DOMString origin);
dictionary RTCIdentityAssertionResult {
required RTCIdentityProviderDetails idp;
required DOMString assertion;
};
dictionary RTCIdentityProviderDetails {
required DOMString domain;
DOMString protocol = "default";
};
dictionary RTCIdentityValidationResult {
required DOMString identity;
required DOMString contents;
};
partial interface RTCPeerConnection {
void setIdentityProvider (DOMString provider, optional RTCIdentityProviderOptions options);
Promise<DOMString> getIdentityAssertion ();
readonly attribute Promise<RTCIdentityAssertion> peerIdentity;
readonly attribute DOMString? idpLoginUrl;
readonly attribute DOMString? idpErrorInfo;
};
dictionary RTCIdentityProviderOptions {
DOMString protocol = "default";
DOMString usernameHint;
DOMString peerIdentity;
};
[Constructor(DOMString idp, DOMString name), Exposed=Window]
interface RTCIdentityAssertion {
attribute DOMString idp;
attribute DOMString name;
};
partial dictionary MediaStreamConstraints {
DOMString peerIdentity;
};
partial interface MediaStreamTrack {
readonly attribute boolean isolated;
attribute EventHandler onisolationchange;
};
enum RTCErrorDetailType {
"data-channel-failure",
"dtls-failure",
"fingerprint-failure",
"idp-bad-script-failure",
"idp-execution-failure",
"idp-load-failure",
"idp-need-login",
"idp-timeout",
"idp-tls-failure",
"idp-token-expired",
"idp-token-invalid",
"sctp-failure",
"sdp-syntax-error",
"hardware-encoder-not-available",
"hardware-encoder-error"
};
[Exposed=Window,
Constructor (DOMString type, RTCErrorEventInit eventInitDict)]
interface RTCErrorEvent : Event {
readonly attribute RTCError? error;
};
dictionary RTCErrorEventInit : EventInit {
RTCError? error = null;
};
![swh spinner](/static/img/swh-spinner.gif)
Computing file changes ...