| // Copyright 2016 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "third_party/blink/renderer/core/frame/deprecation.h" |
| |
| #include "base/time/time.h" |
| #include "build/build_config.h" |
| #include "third_party/blink/public/mojom/feature_policy/feature_policy.mojom-blink.h" |
| #include "third_party/blink/public/mojom/reporting/reporting.mojom-blink.h" |
| #include "third_party/blink/public/platform/platform.h" |
| #include "third_party/blink/renderer/core/execution_context/execution_context.h" |
| #include "third_party/blink/renderer/core/frame/deprecation_report_body.h" |
| #include "third_party/blink/renderer/core/frame/frame_console.h" |
| #include "third_party/blink/renderer/core/frame/local_dom_window.h" |
| #include "third_party/blink/renderer/core/frame/local_frame.h" |
| #include "third_party/blink/renderer/core/frame/local_frame_client.h" |
| #include "third_party/blink/renderer/core/frame/report.h" |
| #include "third_party/blink/renderer/core/frame/reporting_context.h" |
| #include "third_party/blink/renderer/core/inspector/console_message.h" |
| #include "third_party/blink/renderer/core/loader/document_loader.h" |
| #include "third_party/blink/renderer/core/origin_trials/origin_trial_context.h" |
| #include "third_party/blink/renderer/core/page/page.h" |
| #include "third_party/blink/renderer/core/workers/worker_or_worklet_global_scope.h" |
| #include "third_party/blink/renderer/platform/heap/heap.h" |
| #include "third_party/blink/renderer/platform/runtime_enabled_features.h" |
| #include "third_party/blink/renderer/platform/wtf/date_math.h" |
| |
| namespace blink { |
| |
| namespace { |
| |
| const char kChromeLoadTimesNavigationTiming[] = |
| "chrome.loadTimes() is deprecated, instead use standardized API: " |
| "Navigation Timing 2. " |
| "https://www.chromestatus.com/features/5637885046816768."; |
| const char kChromeLoadTimesNextHopProtocol[] = |
| "chrome.loadTimes() is deprecated, instead use standardized API: " |
| "nextHopProtocol in Navigation Timing 2. " |
| "https://www.chromestatus.com/features/5637885046816768."; |
| |
| const char kChromeLoadTimesPaintTiming[] = |
| "chrome.loadTimes() is deprecated, instead use standardized API: " |
| "Paint Timing. " |
| "https://www.chromestatus.com/features/5637885046816768."; |
| |
| enum Milestone { |
| kUnknown, |
| kM61 = 61, |
| kM62 = 62, |
| kM64 = 64, |
| kM65 = 65, |
| kM70 = 70, |
| kM71 = 71, |
| kM72 = 72, |
| kM75 = 75, |
| kM76 = 76, |
| kM77 = 77, |
| kM78 = 78, |
| kM79 = 79, |
| kM80 = 80, |
| kM81 = 81, |
| kM82 = 82, |
| kM83 = 83, |
| kM84 = 84, |
| kM85 = 85, |
| kM86 = 86, |
| kM87 = 87, |
| kM88 = 88, |
| kM89 = 89, |
| kM90 = 90, |
| kM91 = 91, |
| kM92 = 92, |
| kM93 = 93, |
| kM94 = 94, |
| kM95 = 95, |
| kM96 = 96, |
| }; |
| |
| // Returns estimated milestone dates as milliseconds since January 1, 1970. |
| base::Time::Exploded MilestoneDate(Milestone milestone) { |
| // These are the Estimated Stable Dates: |
| // https://www.chromium.org/developers/calendar |
| // All dates except for kUnknown are at 04:00:00 GMT. |
| switch (milestone) { |
| case kUnknown: |
| break; |
| case kM61: |
| return {2017, 9, 0, 5, 4}; |
| case kM62: |
| return {2017, 10, 0, 17, 4}; |
| case kM64: |
| return {2018, 1, 0, 23, 4}; |
| case kM65: |
| return {2018, 3, 0, 6, 4}; |
| case kM70: |
| return {2018, 10, 0, 16, 4}; |
| case kM71: |
| return {2018, 12, 0, 4, 4}; |
| case kM72: |
| return {2019, 1, 0, 29, 4}; |
| case kM75: |
| return {2019, 6, 0, 4, 4}; |
| case kM76: |
| return {2019, 7, 0, 30, 4}; |
| case kM77: |
| return {2019, 9, 0, 10, 4}; |
| case kM78: |
| return {2019, 10, 0, 22, 4}; |
| case kM79: |
| return {2019, 12, 0, 10, 4}; |
| case kM80: |
| return {2020, 2, 0, 4, 4}; |
| case kM81: |
| return {2020, 4, 0, 7, 4}; |
| case kM82: |
| // This release was cancelled, so this is the (new) M83 date. |
| // https://groups.google.com/a/chromium.org/d/msg/chromium-dev/N1NxbSVOZas/ySlEKDKkBgAJ |
| return {2020, 5, 0, 18, 4}; |
| case kM83: |
| return {2020, 5, 0, 18, 4}; |
| case kM84: |
| return {2020, 7, 0, 14, 4}; |
| case kM85: |
| return {2020, 8, 0, 25, 4}; |
| case kM86: |
| return {2020, 10, 0, 6, 4}; |
| case kM87: |
| return {2020, 11, 0, 17, 4}; |
| case kM88: |
| return {2021, 1, 0, 19, 4}; |
| case kM89: |
| return {2021, 3, 0, 2, 4}; |
| case kM90: |
| return {2021, 4, 0, 13, 4}; |
| case kM91: |
| return {2021, 5, 0, 25, 4}; |
| case kM92: |
| return {2021, 7, 0, 20, 4}; |
| case kM93: |
| return {2021, 8, 0, 31, 4}; |
| case kM94: |
| return {2021, 10, 0, 12, 4}; |
| case kM95: |
| return {2021, 11, 0, 30, 4}; |
| case kM96: |
| return {2022, 1, 0, 25, 4}; |
| } |
| |
| NOTREACHED(); |
| return {1970, 1, 0, 1, 0}; |
| } |
| |
| // Returns estimated milestone dates as human-readable strings. |
| String MilestoneString(Milestone milestone) { |
| if (milestone == kUnknown) |
| return ""; |
| base::Time::Exploded date = MilestoneDate(milestone); |
| return String::Format("M%d, around %s %d", milestone, |
| WTF::kMonthFullName[date.month - 1], date.year); |
| } |
| |
| struct DeprecationInfo { |
| String id; |
| Milestone anticipated_removal; |
| String message; |
| }; |
| |
| String ReplacedBy(const char* feature, const char* replacement) { |
| return String::Format("%s is deprecated. Please use %s instead.", feature, |
| replacement); |
| } |
| |
| String WillBeRemoved(const char* feature, |
| Milestone milestone, |
| const char* details) { |
| return String::Format( |
| "%s is deprecated and will be removed in %s. See " |
| "https://www.chromestatus.com/features/%s for more details.", |
| feature, MilestoneString(milestone).Ascii().c_str(), details); |
| } |
| |
| String ReplacedWillBeRemoved(const char* feature, |
| const char* replacement, |
| Milestone milestone, |
| const char* details) { |
| return String::Format( |
| "%s is deprecated and will be removed in %s. Please use %s instead. See " |
| "https://www.chromestatus.com/features/%s for more details.", |
| feature, MilestoneString(milestone).Ascii().c_str(), replacement, |
| details); |
| } |
| |
| DeprecationInfo GetDeprecationInfo(WebFeature feature) { |
| switch (feature) { |
| // Quota |
| case WebFeature::kPrefixedStorageInfo: |
| return {"PrefixedStorageInfo", kUnknown, |
| ReplacedBy("'window.webkitStorageInfo'", |
| "'navigator.webkitTemporaryStorage' or " |
| "'navigator.webkitPersistentStorage'")}; |
| |
| case WebFeature::kPrefixedVideoSupportsFullscreen: |
| return {"PrefixedVideoSupportsFullscreen", kUnknown, |
| ReplacedBy("'HTMLVideoElement.webkitSupportsFullscreen'", |
| "'Document.fullscreenEnabled'")}; |
| |
| case WebFeature::kPrefixedVideoDisplayingFullscreen: |
| return {"PrefixedVideoDisplayingFullscreen", kUnknown, |
| ReplacedBy("'HTMLVideoElement.webkitDisplayingFullscreen'", |
| "'Document.fullscreenElement'")}; |
| |
| case WebFeature::kPrefixedVideoEnterFullscreen: |
| return {"PrefixedVideoEnterFullscreen", kUnknown, |
| ReplacedBy("'HTMLVideoElement.webkitEnterFullscreen()'", |
| "'Element.requestFullscreen()'")}; |
| |
| case WebFeature::kPrefixedVideoExitFullscreen: |
| return {"PrefixedVideoExitFullscreen", kUnknown, |
| ReplacedBy("'HTMLVideoElement.webkitExitFullscreen()'", |
| "'Document.exitFullscreen()'")}; |
| |
| case WebFeature::kPrefixedVideoEnterFullScreen: |
| return {"PrefixedVideoEnterFullScreen", kUnknown, |
| ReplacedBy("'HTMLVideoElement.webkitEnterFullScreen()'", |
| "'Element.requestFullscreen()'")}; |
| |
| case WebFeature::kPrefixedVideoExitFullScreen: |
| return {"PrefixedVideoExitFullScreen", kUnknown, |
| ReplacedBy("'HTMLVideoElement.webkitExitFullScreen()'", |
| "'Document.exitFullscreen()'")}; |
| |
| case WebFeature::kPrefixedRequestAnimationFrame: |
| return {"PrefixedRequestAnimationFrame", kUnknown, |
| "'webkitRequestAnimationFrame' is vendor-specific. Please use " |
| "the standard 'requestAnimationFrame' instead."}; |
| |
| case WebFeature::kPrefixedCancelAnimationFrame: |
| return {"PrefixedCancelAnimationFrame", kUnknown, |
| "'webkitCancelAnimationFrame' is vendor-specific. Please use the " |
| "standard 'cancelAnimationFrame' instead."}; |
| |
| case WebFeature::kPictureSourceSrc: |
| return {"PictureSourceSrc", kUnknown, |
| "<source src> with a <picture> parent is invalid and therefore " |
| "ignored. Please use <source srcset> instead."}; |
| |
| case WebFeature::kXMLHttpRequestSynchronousInNonWorkerOutsideBeforeUnload: |
| return {"XMLHttpRequestSynchronousInNonWorkerOutsideBeforeUnload", |
| kUnknown, |
| "Synchronous XMLHttpRequest on the main thread is deprecated " |
| "because of its detrimental effects to the end user's " |
| "experience. For more help, check https://xhr.spec.whatwg.org/."}; |
| |
| case WebFeature::kPrefixedWindowURL: |
| return {"PrefixedWindowURL", kUnknown, |
| ReplacedBy("'webkitURL'", "'URL'")}; |
| |
| case WebFeature::kRangeExpand: |
| return {"RangeExpand", kUnknown, |
| ReplacedBy("'Range.expand()'", "'Selection.modify()'")}; |
| |
| // Blocked subresource requests: |
| case WebFeature::kLegacyProtocolEmbeddedAsSubresource: |
| return {"LegacyProtocolEmbeddedAsSubresource", kUnknown, |
| "Subresource requests using legacy protocols (like `ftp:`) " |
| "are blocked. Please deliver web-accessible resources over " |
| "modern protocols like HTTPS. See " |
| "https://www.chromestatus.com/feature/5709390967472128 for " |
| "details."}; |
| |
| case WebFeature::kRequestedSubresourceWithEmbeddedCredentials: |
| return {"RequestedSubresourceWithEmbeddedCredentials", kUnknown, |
| "Subresource requests whose URLs contain embedded credentials " |
| "(e.g. `https://user:pass@host/`) are blocked. See " |
| "https://www.chromestatus.com/feature/5669008342777856 for more " |
| "details."}; |
| |
| // Powerful features on insecure origins (https://goo.gl/rStTGz) |
| case WebFeature::kGeolocationInsecureOrigin: |
| case WebFeature::kGeolocationInsecureOriginIframe: |
| return {"GeolocationInsecureOrigin", kUnknown, |
| "getCurrentPosition() and watchPosition() no longer work on " |
| "insecure origins. To use this feature, you should consider " |
| "switching your application to a secure origin, such as HTTPS. " |
| "See https://goo.gl/rStTGz for more details."}; |
| |
| case WebFeature::kGeolocationInsecureOriginDeprecatedNotRemoved: |
| case WebFeature::kGeolocationInsecureOriginIframeDeprecatedNotRemoved: |
| return {"GeolocationInsecureOriginDeprecatedNotRemoved", kUnknown, |
| "getCurrentPosition() and watchPosition() are deprecated on " |
| "insecure origins. To use this feature, you should consider " |
| "switching your application to a secure origin, such as HTTPS. " |
| "See https://goo.gl/rStTGz for more details."}; |
| |
| case WebFeature::kGetUserMediaInsecureOrigin: |
| case WebFeature::kGetUserMediaInsecureOriginIframe: |
| return { |
| "GetUserMediaInsecureOrigin", kUnknown, |
| "getUserMedia() no longer works on insecure origins. To use this " |
| "feature, you should consider switching your application to a " |
| "secure origin, such as HTTPS. See https://goo.gl/rStTGz for more " |
| "details."}; |
| |
| case WebFeature::kMediaSourceAbortRemove: |
| return { |
| "MediaSourceAbortRemove", kUnknown, |
| "Using SourceBuffer.abort() to abort remove()'s asynchronous " |
| "range removal is deprecated due to specification change. Support " |
| "will be removed in the future. You should instead await " |
| "'updateend'. abort() is intended to only abort an asynchronous " |
| "media append or reset parser state. See " |
| "https://www.chromestatus.com/features/6107495151960064 for more " |
| "details."}; |
| |
| case WebFeature::kMediaSourceDurationTruncatingBuffered: |
| return { |
| "MediaSourceDurationTruncatingBuffered", kUnknown, |
| "Setting MediaSource.duration below the highest presentation " |
| "timestamp of any buffered coded frames is deprecated due to " |
| "specification change. Support for implicit removal of truncated " |
| "buffered media will be removed in the future. You should instead " |
| "perform explicit remove(newDuration, oldDuration) on all " |
| "sourceBuffers, where newDuration < oldDuration. See " |
| "https://www.chromestatus.com/features/6107495151960064 for more " |
| "details."}; |
| |
| case WebFeature::kApplicationCacheAPIInsecureOrigin: |
| case WebFeature::kApplicationCacheManifestSelectInsecureOrigin: |
| return {"ApplicationCacheAPIInsecureOrigin", kM70, |
| "Application Cache was previously restricted to secure origins " |
| "only from M70 on but now secure origin use is deprecated and " |
| "will be removed in M82. Please shift your use case over to " |
| "Service Workers."}; |
| |
| case WebFeature::kApplicationCacheAPISecureOrigin: |
| return { |
| "ApplicationCacheAPISecureOrigin", kM85, |
| WillBeRemoved("Application Cache API use", kM85, "6192449487634432")}; |
| |
| case WebFeature::kApplicationCacheManifestSelectSecureOrigin: |
| return {"ApplicationCacheAPISecureOrigin", kM85, |
| WillBeRemoved("Application Cache API manifest selection", kM85, |
| "6192449487634432")}; |
| |
| case WebFeature::kNotificationInsecureOrigin: |
| case WebFeature::kNotificationAPIInsecureOriginIframe: |
| case WebFeature::kNotificationPermissionRequestedInsecureOrigin: |
| return {"NotificationInsecureOrigin", kUnknown, |
| "The Notification API may no longer be used from insecure " |
| "origins. " |
| "You should consider switching your application to a secure " |
| "origin, " |
| "such as HTTPS. See https://goo.gl/rStTGz for more details."}; |
| |
| case WebFeature::kNotificationPermissionRequestedIframe: |
| return {"NotificationPermissionRequestedIframe", kUnknown, |
| "Permission for the Notification API may no longer be requested " |
| "from " |
| "a cross-origin iframe. You should consider requesting " |
| "permission " |
| "from a top-level frame or opening a new window instead. See " |
| "https://www.chromestatus.com/feature/6451284559265792 for more " |
| "details."}; |
| |
| case WebFeature::kCSSSelectorInternalMediaControlsOverlayCastButton: |
| return {"CSSSelectorInternalMediaControlsOverlayCastButton", kUnknown, |
| "The disableRemotePlayback attribute should be used in order to " |
| "disable the default Cast integration instead of using " |
| "-internal-media-controls-overlay-cast-button selector. See " |
| "https://www.chromestatus.com/feature/5714245488476160 for more " |
| "details."}; |
| |
| case WebFeature::kSelectionAddRangeIntersect: |
| return { |
| "SelectionAddRangeIntersect", kUnknown, |
| "The behavior that Selection.addRange() merges existing Range and " |
| "the specified Range was removed. See " |
| "https://www.chromestatus.com/features/6680566019653632 for more " |
| "details."}; |
| |
| case WebFeature::kRtcpMuxPolicyNegotiate: |
| return {"RtcpMuxPolicyNegotiate", kM62, |
| String::Format("The rtcpMuxPolicy option is being considered for " |
| "removal and may be removed no earlier than %s. " |
| "If you depend on it, " |
| "please see " |
| "https://www.chromestatus.com/features/" |
| "5654810086866944 " |
| "for more details.", |
| MilestoneString(kM62).Ascii().c_str())}; |
| |
| case WebFeature::kCanRequestURLHTTPContainingNewline: |
| return { |
| "CanRequestURLHTTPContainingNewline", kUnknown, |
| "Resource requests whose URLs contained both removed whitespace " |
| "(`\\n`, `\\r`, `\\t`) characters and less-than characters (`<`) " |
| "are blocked. Please remove newlines and encode less-than " |
| "characters from places like element attribute values in order to " |
| "load these resources. See " |
| "https://www.chromestatus.com/feature/5735596811091968 for more " |
| "details."}; |
| |
| case WebFeature::kHTMLImports: |
| return {"HTMLImports", kUnknown, |
| "The HTML Imports feature has been removed. See " |
| "https://www.chromestatus.com/feature/5144752345317376 for more " |
| "details."}; |
| |
| case WebFeature::kLocalCSSFileExtensionRejected: |
| return {"LocalCSSFileExtensionRejected", kM64, |
| String("CSS cannot be loaded from `file:` URLs unless they end " |
| "in a `.css` file extension.")}; |
| |
| case WebFeature::kChromeLoadTimesRequestTime: |
| case WebFeature::kChromeLoadTimesStartLoadTime: |
| case WebFeature::kChromeLoadTimesCommitLoadTime: |
| case WebFeature::kChromeLoadTimesFinishDocumentLoadTime: |
| case WebFeature::kChromeLoadTimesFinishLoadTime: |
| case WebFeature::kChromeLoadTimesNavigationType: |
| case WebFeature::kChromeLoadTimesConnectionInfo: |
| return {"ChromeLoadTimesConnectionInfo", kUnknown, |
| kChromeLoadTimesNavigationTiming}; |
| |
| case WebFeature::kChromeLoadTimesFirstPaintTime: |
| case WebFeature::kChromeLoadTimesFirstPaintAfterLoadTime: |
| return {"ChromeLoadTimesFirstPaintAfterLoadTime", kUnknown, |
| kChromeLoadTimesPaintTiming}; |
| |
| case WebFeature::kChromeLoadTimesWasFetchedViaSpdy: |
| case WebFeature::kChromeLoadTimesWasNpnNegotiated: |
| case WebFeature::kChromeLoadTimesNpnNegotiatedProtocol: |
| case WebFeature::kChromeLoadTimesWasAlternateProtocolAvailable: |
| return {"ChromeLoadTimesWasAlternateProtocolAvailable", kUnknown, |
| kChromeLoadTimesNextHopProtocol}; |
| |
| case WebFeature::kMediaElementSourceOnOfflineContext: |
| return {"MediaElementAudioSourceNode", kM71, |
| WillBeRemoved("Creating a MediaElementAudioSourceNode on an " |
| "OfflineAudioContext", |
| kM71, "5258622686724096")}; |
| |
| case WebFeature::kMediaStreamDestinationOnOfflineContext: |
| return {"MediaStreamAudioDestinationNode", kM71, |
| WillBeRemoved("Creating a MediaStreamAudioDestinationNode on an " |
| "OfflineAudioContext", |
| kM71, "5258622686724096")}; |
| |
| case WebFeature::kMediaStreamSourceOnOfflineContext: |
| return { |
| "MediaStreamAudioSourceNode", kM71, |
| WillBeRemoved( |
| "Creating a MediaStreamAudioSourceNode on an OfflineAudioContext", |
| kM71, "5258622686724096")}; |
| |
| case WebFeature::kTextToSpeech_SpeakDisallowedByAutoplay: |
| return { |
| "TextToSpeech_DisallowedByAutoplay", kM71, |
| String::Format("speechSynthesis.speak() without user activation is " |
| "no longer allowed since %s. See " |
| "https://www.chromestatus.com/feature/" |
| "5687444770914304 for more details", |
| MilestoneString(kM71).Ascii().c_str())}; |
| |
| case WebFeature::kRTCPeerConnectionComplexPlanBSdpUsingDefaultSdpSemantics: |
| return {"RTCPeerConnectionComplexPlanBSdpUsingDefaultSdpSemantics", kM72, |
| String::Format( |
| "\"Complex\" Plan B SDP detected! Chrome will switch the " |
| "default sdpSemantics in %s from 'plan-b' to the " |
| "standardized 'unified-plan' format and this peer connection " |
| "is relying on the default sdpSemantics. This SDP is not " |
| "compatible with Unified Plan and will be rejected by " |
| "clients expecting Unified Plan. For more information about " |
| "how to prepare for the switch, see " |
| "https://webrtc.org/web-apis/chrome/unified-plan/.", |
| MilestoneString(kM72).Ascii().c_str())}; |
| |
| case WebFeature::kNoSysexWebMIDIWithoutPermission: |
| return {"NoSysexWebMIDIWithoutPermission", kM82, |
| String::Format( |
| "Web MIDI will ask a permission to use even if the sysex is " |
| "not specified in the MIDIOptions since around %s. See " |
| "https://www.chromestatus.com/feature/5138066234671104 for " |
| "more details.", |
| MilestoneString(kM82).Ascii().c_str())}; |
| |
| case WebFeature::kCustomCursorIntersectsViewport: |
| return { |
| "CustomCursorIntersectsViewport", kM75, |
| WillBeRemoved( |
| "Custom cursors with size greater than 32x32 DIP intersecting " |
| "native UI", |
| kM75, "5825971391299584")}; |
| |
| case WebFeature::kXRSupportsSession: |
| return {"XRSupportsSession", kM80, |
| ReplacedBy( |
| "supportsSession()", |
| "isSessionSupported() and check the resolved boolean value")}; |
| |
| case WebFeature::kObsoleteWebrtcTlsVersion: |
| return {"ObsoleteWebRtcCipherSuite", kM81, |
| String::Format( |
| "Your partner is negotiating an obsolete (D)TLS version. " |
| "Support for this will be removed in %s. " |
| "Please check with your partner to have this fixed.", |
| MilestoneString(kM81).Ascii().c_str())}; |
| |
| case WebFeature::kCssStyleSheetReplaceWithImport: |
| return { |
| "CssStyleSheetReplaceWithImport", kM84, |
| String::Format( |
| "Support for calls to CSSStyleSheet.replace() with stylesheet " |
| "text that includes @import has been deprecated, and will be " |
| "removed in %s. See " |
| "https://chromestatus.com/feature/4735925877735424 for more " |
| "details.", |
| MilestoneString(kM84).Ascii().c_str())}; |
| |
| case WebFeature::kV8SharedArrayBufferConstructedWithoutIsolation: |
| return { |
| "SharedArrayBufferConstructedWithoutIsolation", kM91, |
| String::Format( |
| "SharedArrayBuffer will require cross-origin isolation as of " |
| "%s. See " |
| "https://developer.chrome.com/blog/enabling-shared-array-buffer/" |
| " for more details.", |
| MilestoneString(kM91).Ascii().c_str())}; |
| |
| case WebFeature::kV8RTCRtpSender_CreateEncodedAudioStreams_Method: |
| return {"V8RTCRtpSender_CreateEncodedAudioStreams_Method", kM88, |
| ReplacedWillBeRemoved("RTCRtpSender.createEncodedAudioStreams", |
| "RTCRtpSender.createEncodedStreams", kM88, |
| "6321945865879552")}; |
| |
| case WebFeature::kV8RTCRtpSender_CreateEncodedVideoStreams_Method: |
| return {"V8RTCRtpSender_CreateEncodedVideoStreams_Method", kM88, |
| ReplacedWillBeRemoved("RTCRtpSender.createEncodedVideoStreams", |
| "RTCRtpSender.createEncodedStreams", kM88, |
| "6321945865879552")}; |
| |
| case WebFeature::kV8RTCRtpReceiver_CreateEncodedAudioStreams_Method: |
| return {"V8RTCRtpReceiver_CreateEncodedAudioStreams_Method", kM88, |
| ReplacedWillBeRemoved("RTCRtpReceiver.createEncodedAudioStreams", |
| "RTCRtpReceiver.createEncodedStreams", kM88, |
| "6321945865879552")}; |
| |
| case WebFeature::kV8RTCRtpReceiver_CreateEncodedVideoStreams_Method: |
| return {"V8RTCRtpReceiver_CreateEncodedVideoStreams_Method", kM88, |
| ReplacedWillBeRemoved("RTCRtpReceiver.createEncodedVideoStreams", |
| "RTCRtpReceiver.createEncodedStreams", kM88, |
| "6321945865879552")}; |
| |
| case WebFeature::kForceEncodedAudioInsertableStreams: |
| return {"ForceEncodedAudioInsertableStreams", kM88, |
| ReplacedWillBeRemoved( |
| "RTCConfiguration.forceEncodedAudioInsertableStreams", |
| "RTCConfiguration.encodedInsertableStreams", kM88, |
| "6321945865879552")}; |
| |
| case WebFeature::kForceEncodedVideoInsertableStreams: |
| return {"ForceEncodedVideoInsertableStreams", kM88, |
| ReplacedWillBeRemoved( |
| "RTCConfiguration.forceEncodedVideoInsertableStreams", |
| "RTCConfiguration.encodedInsertableStreams", kM88, |
| "6321945865879552")}; |
| |
| case WebFeature::kRTCConstraintEnableRtpDataChannelsFalse: |
| case WebFeature::kRTCConstraintEnableRtpDataChannelsTrue: |
| return { |
| "RTP data channel", kM88, |
| "RTP data channels are no longer supported. " |
| "The \"RtpDataChannels\" constraint is currently ignored, and may " |
| "cause an error at a later date."}; |
| |
| case WebFeature::kCSSSelectorWebkitDetailsMarker: |
| if (!RuntimeEnabledFeatures::SummaryListItemEnabled()) |
| return {"NotDeprecated", kUnknown, ""}; |
| return {"CSSSeelctorWebKitDetailsMarker", kM89, |
| ReplacedBy("::-webkit-details-marker pseudo element selector", |
| "::marker") + |
| " See https://chromestatus.com/feature/6730096436051968 for " |
| "more details."}; |
| |
| case WebFeature::kV8SpeechRecognitionEvent_Interpretation_AttributeGetter: |
| return {"V8SpeechRecognitionEvent_Interpretation_AttributeGetter", kM91, |
| WillBeRemoved("SpeechRecognitionEvent's interpretation attribute", |
| kM91, "5769608873115648")}; |
| |
| case WebFeature::kV8SpeechRecognitionEvent_Emma_AttributeGetter: |
| return {"V8SpeechRecognitionEvent_Emma_AttributeGetter", kM91, |
| WillBeRemoved("SpeechRecognitionEvent's emma attribute", kM91, |
| "5769608873115648")}; |
| |
| case WebFeature::kRTCPeerConnectionSdpSemanticsPlanB: |
| return {"RTCPeerConnectionSdpSemanticsPlanB", kM93, |
| "Plan B SDP semantics, which is used when constructing an " |
| "RTCPeerConnection with {sdpSemantics:\"plan-b\"}, is a legacy " |
| "version of the Session Description Protocol that has severe " |
| "compatibility issues on modern browsers. The standardized SDP " |
| "format, \"unified-plan\", has been used by default since M72 " |
| "(January, 2019). Dropping support for Plan B is targeted for " |
| "M93 (Canary: July 15, 2021; Stable: August 24, 2021)."}; |
| |
| case WebFeature::kRTCPeerConnectionSdpSemanticsPlanBWithReverseOriginTrial: |
| return {"RTCPeerConnectionSdpSemanticsPlanBWithReverseOriginTrial", kM96, |
| "Plan B SDP semantics, which is used when constructing an " |
| "RTCPeerConnection with {sdpSemantics:\"plan-b\"}, is a legacy " |
| "version of the Session Description Protocol that has severe " |
| "compatibility issues on modern browsers. The standardized SDP " |
| "format, \"unified-plan\", has been used by default since M72 " |
| "(January, 2019). Dropping support for Plan B is targeted for " |
| "M93 (Canary: July 15, 2021; Stable: August 24, 2021), but " |
| "because you have opted in to the Reverse Origin Trial, you have " |
| "until M96 (Canary: November, 2021; Stable: January, 2022)."}; |
| |
| case WebFeature::kAddressSpaceUnknownNonSecureContextEmbeddedPrivate: |
| case WebFeature::kAddressSpaceUnknownNonSecureContextEmbeddedLocal: |
| case WebFeature::kAddressSpacePublicNonSecureContextEmbeddedPrivate: |
| case WebFeature::kAddressSpacePublicNonSecureContextEmbeddedLocal: |
| case WebFeature::kAddressSpacePrivateNonSecureContextEmbeddedLocal: |
| return {"InsecurePrivateNetworkSubresourceRequest", kM92, |
| "The website requested a subresource from a " |
| "network that it could only access because of its users' " |
| "privileged network position. These requests expose non-public " |
| "devices and servers to the internet, increasing the risk of a " |
| "cross-site request forgery (CSRF) attack, and/or information " |
| "leakage. To mitigate these risks, Chrome deprecates requests to " |
| "non-public subresources when initiated from non-secure " |
| "contexts, and will start blocking them in Chrome 92 (July " |
| "2021). See https://chromestatus.com/feature/5436853517811712 " |
| "for more details."}; |
| |
| // Features that aren't deprecated don't have a deprecation message. |
| default: |
| return {"NotDeprecated", kUnknown, ""}; |
| } |
| } |
| |
| Report* CreateReportInternal(const KURL& context_url, |
| const DeprecationInfo& info) { |
| base::Optional<base::Time> optional_removal_date; |
| if (info.anticipated_removal != kUnknown) { |
| base::Time removal_date; |
| bool result = base::Time::FromUTCExploded( |
| MilestoneDate(info.anticipated_removal), &removal_date); |
| DCHECK(result); |
| optional_removal_date = removal_date; |
| } |
| DeprecationReportBody* body = MakeGarbageCollected<DeprecationReportBody>( |
| info.id, optional_removal_date, info.message); |
| return MakeGarbageCollected<Report>(ReportType::kDeprecation, context_url, |
| body); |
| } |
| |
| } // anonymous namespace |
| |
| Deprecation::Deprecation() : mute_count_(0) {} |
| |
| void Deprecation::ClearSuppression() { |
| css_property_deprecation_bits_.reset(); |
| features_deprecation_bits_.reset(); |
| } |
| |
| void Deprecation::MuteForInspector() { |
| mute_count_++; |
| } |
| |
| void Deprecation::UnmuteForInspector() { |
| mute_count_--; |
| } |
| |
| void Deprecation::Suppress(CSSPropertyID unresolved_property) { |
| DCHECK(IsCSSPropertyIDWithName(unresolved_property)); |
| css_property_deprecation_bits_.set(static_cast<size_t>(unresolved_property)); |
| } |
| |
| bool Deprecation::IsSuppressed(CSSPropertyID unresolved_property) { |
| DCHECK(IsCSSPropertyIDWithName(unresolved_property)); |
| return css_property_deprecation_bits_[static_cast<size_t>( |
| unresolved_property)]; |
| } |
| |
| void Deprecation::SetReported(WebFeature feature) { |
| features_deprecation_bits_.set(static_cast<size_t>(feature)); |
| } |
| |
| bool Deprecation::GetReported(WebFeature feature) const { |
| return features_deprecation_bits_[static_cast<size_t>(feature)]; |
| } |
| |
| void Deprecation::WarnOnDeprecatedProperties( |
| const LocalFrame* frame, |
| CSSPropertyID unresolved_property) { |
| Page* page = frame ? frame->GetPage() : nullptr; |
| if (!page || page->GetDeprecation().mute_count_ || |
| page->GetDeprecation().IsSuppressed(unresolved_property)) |
| return; |
| |
| String message = DeprecationMessage(unresolved_property); |
| if (!message.IsEmpty()) { |
| page->GetDeprecation().Suppress(unresolved_property); |
| auto* console_message = MakeGarbageCollected<ConsoleMessage>( |
| mojom::ConsoleMessageSource::kDeprecation, |
| mojom::ConsoleMessageLevel::kWarning, message); |
| frame->Console().AddMessage(console_message); |
| } |
| } |
| |
| String Deprecation::DeprecationMessage(CSSPropertyID unresolved_property) { |
| // TODO: Add a switch here when there are properties that we intend to |
| // deprecate. |
| // Returning an empty string for now. |
| return g_empty_string; |
| } |
| |
| void Deprecation::CountDeprecationCrossOriginIframe(LocalDOMWindow* window, |
| WebFeature feature) { |
| DCHECK(window); |
| if (!window->GetFrame()) |
| return; |
| |
| // Check to see if the frame can script into the top level context. |
| Frame& top = window->GetFrame()->Tree().Top(); |
| if (!window->GetSecurityOrigin()->CanAccess( |
| top.GetSecurityContext()->GetSecurityOrigin())) { |
| CountDeprecation(window, feature); |
| } |
| } |
| |
| void Deprecation::CountDeprecation(ExecutionContext* context, |
| WebFeature feature) { |
| if (!context) |
| return; |
| |
| Deprecation* deprecation = nullptr; |
| if (auto* window = DynamicTo<LocalDOMWindow>(context)) { |
| if (window->GetFrame()) |
| deprecation = &window->GetFrame()->GetPage()->GetDeprecation(); |
| } else if (auto* scope = DynamicTo<WorkerOrWorkletGlobalScope>(context)) { |
| // TODO(crbug.com/1146824): Remove this once PlzDedicatedWorker and |
| // PlzServiceWorker ship. |
| if (!scope->IsInitialized()) { |
| return; |
| } |
| deprecation = &scope->GetDeprecation(); |
| } |
| |
| if (!deprecation || deprecation->mute_count_ || |
| deprecation->GetReported(feature)) { |
| return; |
| } |
| deprecation->SetReported(feature); |
| |
| // Don't count usage of WebComponentsV0 for chrome:// URLs, but still report |
| // the deprecation messages. |
| // Note that this only applies to HTML Imports, as Shadow DOM v0 and Custom |
| // Elements v0 have both now been removed. |
| bool count_usage = true; |
| if (context->Url().ProtocolIs("chrome") && |
| feature == WebFeature::kHTMLImports) { |
| count_usage = false; |
| } |
| if (count_usage) |
| context->CountUse(feature); |
| |
| const DeprecationInfo info = GetDeprecationInfo(feature); |
| |
| // Send the deprecation message to the console as a warning. |
| DCHECK(!info.message.IsEmpty()); |
| auto* console_message = MakeGarbageCollected<ConsoleMessage>( |
| mojom::ConsoleMessageSource::kDeprecation, |
| mojom::ConsoleMessageLevel::kWarning, info.message); |
| context->AddConsoleMessage(console_message); |
| |
| Report* report = CreateReportInternal(context->Url(), info); |
| |
| // Send the deprecation report to the Reporting API and any |
| // ReportingObservers. |
| ReportingContext::From(context)->QueueReport(report); |
| } |
| |
| // static |
| String Deprecation::DeprecationMessage(WebFeature feature) { |
| return GetDeprecationInfo(feature).message; |
| } |
| |
| } // namespace blink |
