REGRESSION (r243606): Interacting with date and time pickers hangs the UI process...
[WebKit-https.git] / Source / WebCore / html / MediaElementSession.cpp
1 /*
2  * Copyright (C) 2014 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27
28 #if ENABLE(VIDEO)
29
30 #include "MediaElementSession.h"
31
32 #include "Document.h"
33 #include "DocumentLoader.h"
34 #include "Frame.h"
35 #include "FrameView.h"
36 #include "FullscreenManager.h"
37 #include "HTMLAudioElement.h"
38 #include "HTMLMediaElement.h"
39 #include "HTMLNames.h"
40 #include "HTMLVideoElement.h"
41 #include "HitTestResult.h"
42 #include "Logging.h"
43 #include "Page.h"
44 #include "PlatformMediaSessionManager.h"
45 #include "Quirks.h"
46 #include "RenderMedia.h"
47 #include "RenderView.h"
48 #include "ScriptController.h"
49 #include "Settings.h"
50 #include "SourceBuffer.h"
51 #include <wtf/text/StringBuilder.h>
52
53 #if PLATFORM(IOS_FAMILY)
54 #include "AudioSession.h"
55 #include "RuntimeApplicationChecks.h"
56 #include <wtf/spi/darwin/dyldSPI.h>
57 #endif
58
59 namespace WebCore {
60
61 static const Seconds clientDataBufferingTimerThrottleDelay { 100_ms };
62 static const Seconds elementMainContentCheckInterval { 250_ms };
63
64 static bool isElementRectMostlyInMainFrame(const HTMLMediaElement&);
65 static bool isElementLargeEnoughForMainContent(const HTMLMediaElement&, MediaSessionMainContentPurpose);
66 static bool isElementMainContentForPurposesOfAutoplay(const HTMLMediaElement&, bool shouldHitTestMainFrame);
67
68 #if !RELEASE_LOG_DISABLED
69 static String restrictionNames(MediaElementSession::BehaviorRestrictions restriction)
70 {
71     StringBuilder restrictionBuilder;
72 #define CASE(restrictionType) \
73     if (restriction & MediaElementSession::restrictionType) { \
74         if (!restrictionBuilder.isEmpty()) \
75             restrictionBuilder.appendLiteral(", "); \
76         restrictionBuilder.append(#restrictionType); \
77     } \
78
79     CASE(NoRestrictions)
80     CASE(RequireUserGestureForLoad)
81     CASE(RequireUserGestureForVideoRateChange)
82     CASE(RequireUserGestureForAudioRateChange)
83     CASE(RequireUserGestureForFullscreen)
84     CASE(RequirePageConsentToLoadMedia)
85     CASE(RequirePageConsentToResumeMedia)
86     CASE(RequireUserGestureToShowPlaybackTargetPicker)
87     CASE(WirelessVideoPlaybackDisabled)
88     CASE(RequireUserGestureToAutoplayToExternalDevice)
89     CASE(AutoPreloadingNotPermitted)
90     CASE(InvisibleAutoplayNotPermitted)
91     CASE(OverrideUserGestureRequirementForMainContent)
92     CASE(RequireUserGestureToControlControlsManager)
93     CASE(RequirePlaybackToControlControlsManager)
94     CASE(RequireUserGestureForVideoDueToLowPowerMode)
95
96     return restrictionBuilder.toString();
97 }
98 #endif
99
100 static bool pageExplicitlyAllowsElementToAutoplayInline(const HTMLMediaElement& element)
101 {
102     Document& document = element.document();
103     Page* page = document.page();
104     return document.isMediaDocument() && !document.ownerElement() && page && page->allowsMediaDocumentInlinePlayback();
105 }
106
107 MediaElementSession::MediaElementSession(HTMLMediaElement& element)
108     : PlatformMediaSession(element)
109     , m_element(element)
110     , m_restrictions(NoRestrictions)
111 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
112     , m_targetAvailabilityChangedTimer(*this, &MediaElementSession::targetAvailabilityChangedTimerFired)
113     , m_hasPlaybackTargets(PlatformMediaSessionManager::sharedManager().hasWirelessTargetsAvailable())
114 #endif
115     , m_mainContentCheckTimer(*this, &MediaElementSession::mainContentCheckTimerFired)
116     , m_clientDataBufferingTimer(*this, &MediaElementSession::clientDataBufferingTimerFired)
117 #if !RELEASE_LOG_DISABLED
118     , m_logIdentifier(element.logIdentifier())
119 #endif
120 {
121 }
122
123 void MediaElementSession::registerWithDocument(Document& document)
124 {
125 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
126     document.addPlaybackTargetPickerClient(*this);
127 #else
128     UNUSED_PARAM(document);
129 #endif
130 }
131
132 void MediaElementSession::unregisterWithDocument(Document& document)
133 {
134 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
135     document.removePlaybackTargetPickerClient(*this);
136 #else
137     UNUSED_PARAM(document);
138 #endif
139 }
140
141 void MediaElementSession::clientWillBeginAutoplaying()
142 {
143     PlatformMediaSession::clientWillBeginAutoplaying();
144     m_elementIsHiddenBecauseItWasRemovedFromDOM = false;
145     updateClientDataBuffering();
146 }
147
148 bool MediaElementSession::clientWillBeginPlayback()
149 {
150     if (!PlatformMediaSession::clientWillBeginPlayback())
151         return false;
152
153     m_elementIsHiddenBecauseItWasRemovedFromDOM = false;
154     updateClientDataBuffering();
155     return true;
156 }
157
158 bool MediaElementSession::clientWillPausePlayback()
159 {
160     if (!PlatformMediaSession::clientWillPausePlayback())
161         return false;
162
163     updateClientDataBuffering();
164     return true;
165 }
166
167 void MediaElementSession::visibilityChanged()
168 {
169     scheduleClientDataBufferingCheck();
170
171     if (m_element.elementIsHidden() && !m_element.isFullscreen())
172         m_elementIsHiddenUntilVisibleInViewport = true;
173     else if (m_element.isVisibleInViewport())
174         m_elementIsHiddenUntilVisibleInViewport = false;
175 }
176
177 void MediaElementSession::isVisibleInViewportChanged()
178 {
179     scheduleClientDataBufferingCheck();
180
181     if (m_element.isFullscreen() || m_element.isVisibleInViewport())
182         m_elementIsHiddenUntilVisibleInViewport = false;
183 }
184
185 void MediaElementSession::inActiveDocumentChanged()
186 {
187     m_elementIsHiddenBecauseItWasRemovedFromDOM = !m_element.inActiveDocument();
188     scheduleClientDataBufferingCheck();
189 }
190
191 void MediaElementSession::scheduleClientDataBufferingCheck()
192 {
193     if (!m_clientDataBufferingTimer.isActive())
194         m_clientDataBufferingTimer.startOneShot(clientDataBufferingTimerThrottleDelay);
195 }
196
197 void MediaElementSession::clientDataBufferingTimerFired()
198 {
199     INFO_LOG(LOGIDENTIFIER, "visible = ", m_element.elementIsHidden());
200
201     updateClientDataBuffering();
202
203 #if PLATFORM(IOS_FAMILY)
204     PlatformMediaSessionManager::sharedManager().configureWireLessTargetMonitoring();
205 #endif
206
207     if (state() != Playing || !m_element.elementIsHidden())
208         return;
209
210     PlatformMediaSessionManager::SessionRestrictions restrictions = PlatformMediaSessionManager::sharedManager().restrictions(mediaType());
211     if ((restrictions & PlatformMediaSessionManager::BackgroundTabPlaybackRestricted) == PlatformMediaSessionManager::BackgroundTabPlaybackRestricted)
212         pauseSession();
213 }
214
215 void MediaElementSession::updateClientDataBuffering()
216 {
217     if (m_clientDataBufferingTimer.isActive())
218         m_clientDataBufferingTimer.stop();
219
220     m_element.setBufferingPolicy(preferredBufferingPolicy());
221 }
222
223 void MediaElementSession::addBehaviorRestriction(BehaviorRestrictions restrictions)
224 {
225     if (restrictions & ~m_restrictions)
226         INFO_LOG(LOGIDENTIFIER, "adding ", restrictionNames(restrictions & ~m_restrictions));
227
228     m_restrictions |= restrictions;
229
230     if (restrictions & OverrideUserGestureRequirementForMainContent)
231         m_mainContentCheckTimer.startRepeating(elementMainContentCheckInterval);
232 }
233
234 void MediaElementSession::removeBehaviorRestriction(BehaviorRestrictions restriction)
235 {
236     if (restriction & RequireUserGestureToControlControlsManager) {
237         m_mostRecentUserInteractionTime = MonotonicTime::now();
238         if (auto page = m_element.document().page())
239             page->setAllowsPlaybackControlsForAutoplayingAudio(true);
240     }
241
242     if (!(m_restrictions & restriction))
243         return;
244
245     INFO_LOG(LOGIDENTIFIER, "removed ", restrictionNames(m_restrictions & restriction));
246     m_restrictions &= ~restriction;
247 }
248
249 SuccessOr<MediaPlaybackDenialReason> MediaElementSession::playbackPermitted() const
250 {
251     if (m_element.isSuspended()) {
252         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because element is suspended");
253         return MediaPlaybackDenialReason::InvalidState;
254     }
255
256     auto& document = m_element.document();
257     auto* page = document.page();
258     if (!page || page->mediaPlaybackIsSuspended()) {
259         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because media playback is suspended");
260         return MediaPlaybackDenialReason::PageConsentRequired;
261     }
262
263     if (document.isMediaDocument() && !document.ownerElement())
264         return { };
265
266     if (pageExplicitlyAllowsElementToAutoplayInline(m_element))
267         return { };
268
269     if (requiresFullscreenForVideoPlayback() && !fullscreenPermitted()) {
270         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because of fullscreen restriction");
271         return MediaPlaybackDenialReason::FullscreenRequired;
272     }
273
274     if (m_restrictions & OverrideUserGestureRequirementForMainContent && updateIsMainContent())
275         return { };
276
277 #if ENABLE(MEDIA_STREAM)
278     if (m_element.hasMediaStreamSrcObject()) {
279         if (document.isCapturing())
280             return { };
281         if (document.mediaState() & MediaProducer::IsPlayingAudio)
282             return { };
283     }
284 #endif
285
286     // FIXME: Why are we checking top-level document only for PerDocumentAutoplayBehavior?
287     const auto& topDocument = document.topDocument();
288     if (topDocument.mediaState() & MediaProducer::HasUserInteractedWithMediaElement && topDocument.quirks().needsPerDocumentAutoplayBehavior())
289         return { };
290
291     if (document.hasHadUserInteraction() && document.quirks().shouldAutoplayForArbitraryUserGesture())
292         return { };
293
294     if (m_restrictions & RequireUserGestureForVideoRateChange && m_element.isVideo() && !document.processingUserGestureForMedia()) {
295         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because a user gesture is required for video rate change restriction");
296         return MediaPlaybackDenialReason::UserGestureRequired;
297     }
298
299     if (m_restrictions & RequireUserGestureForAudioRateChange && (!m_element.isVideo() || m_element.hasAudio()) && !m_element.muted() && m_element.volume() && !document.processingUserGestureForMedia()) {
300         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because a user gesture is required for audio rate change restriction");
301         return MediaPlaybackDenialReason::UserGestureRequired;
302     }
303
304     if (m_restrictions & RequireUserGestureForVideoDueToLowPowerMode && m_element.isVideo() && !document.processingUserGestureForMedia()) {
305         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because of video low power mode restriction");
306         return MediaPlaybackDenialReason::UserGestureRequired;
307     }
308
309     return { };
310 }
311
312 bool MediaElementSession::autoplayPermitted() const
313 {
314     const Document& document = m_element.document();
315     if (document.backForwardCacheState() != Document::NotInBackForwardCache)
316         return false;
317     if (document.activeDOMObjectsAreSuspended())
318         return false;
319
320     if (!hasBehaviorRestriction(MediaElementSession::InvisibleAutoplayNotPermitted))
321         return true;
322
323     // If the media element is audible, allow autoplay even when not visible as pausing it would be observable by the user.
324     if ((!m_element.isVideo() || m_element.hasAudio()) && !m_element.muted() && m_element.volume())
325         return true;
326
327     auto* renderer = m_element.renderer();
328     if (!renderer) {
329         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because element has no renderer");
330         return false;
331     }
332     if (renderer->style().visibility() != Visibility::Visible) {
333         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because element is not visible");
334         return false;
335     }
336     if (renderer->view().frameView().isOffscreen()) {
337         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because frame is offscreen");
338         return false;
339     }
340     if (renderer->visibleInViewportState() != VisibleInViewportState::Yes) {
341         ALWAYS_LOG(LOGIDENTIFIER, "Returning FALSE because element is not visible in the viewport");
342         return false;
343     }
344     return true;
345 }
346
347 bool MediaElementSession::dataLoadingPermitted() const
348 {
349     if (m_restrictions & OverrideUserGestureRequirementForMainContent && updateIsMainContent())
350         return true;
351
352     if (m_restrictions & RequireUserGestureForLoad && !m_element.document().processingUserGestureForMedia()) {
353         INFO_LOG(LOGIDENTIFIER, "returning FALSE");
354         return false;
355     }
356
357     return true;
358 }
359
360 MediaPlayer::BufferingPolicy MediaElementSession::preferredBufferingPolicy() const
361 {
362     if (isSuspended())
363         return MediaPlayer::BufferingPolicy::MakeResourcesPurgeable;
364
365     if (bufferingSuspended())
366         return MediaPlayer::BufferingPolicy::LimitReadAhead;
367
368     if (state() == PlatformMediaSession::Playing)
369         return MediaPlayer::BufferingPolicy::Default;
370
371     if (shouldOverrideBackgroundLoadingRestriction())
372         return MediaPlayer::BufferingPolicy::Default;
373
374 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
375     if (m_shouldPlayToPlaybackTarget)
376         return MediaPlayer::BufferingPolicy::Default;
377 #endif
378
379     if (m_elementIsHiddenUntilVisibleInViewport || m_elementIsHiddenBecauseItWasRemovedFromDOM || m_element.elementIsHidden())
380         return MediaPlayer::BufferingPolicy::MakeResourcesPurgeable;
381
382     return MediaPlayer::BufferingPolicy::Default;
383 }
384
385 bool MediaElementSession::fullscreenPermitted() const
386 {
387     if (m_restrictions & RequireUserGestureForFullscreen && !m_element.document().processingUserGestureForMedia()) {
388         INFO_LOG(LOGIDENTIFIER, "returning FALSE");
389         return false;
390     }
391
392     return true;
393 }
394
395 bool MediaElementSession::pageAllowsDataLoading() const
396 {
397     Page* page = m_element.document().page();
398     if (m_restrictions & RequirePageConsentToLoadMedia && page && !page->canStartMedia()) {
399         INFO_LOG(LOGIDENTIFIER, "returning FALSE");
400         return false;
401     }
402
403     return true;
404 }
405
406 bool MediaElementSession::pageAllowsPlaybackAfterResuming() const
407 {
408     Page* page = m_element.document().page();
409     if (m_restrictions & RequirePageConsentToResumeMedia && page && !page->canStartMedia()) {
410         INFO_LOG(LOGIDENTIFIER, "returning FALSE");
411         return false;
412     }
413
414     return true;
415 }
416
417 bool MediaElementSession::canShowControlsManager(PlaybackControlsPurpose purpose) const
418 {
419     if (m_element.isSuspended() || !m_element.inActiveDocument()) {
420         INFO_LOG(LOGIDENTIFIER, "returning FALSE: isSuspended()");
421         return false;
422     }
423
424     if (m_element.isFullscreen()) {
425         INFO_LOG(LOGIDENTIFIER, "returning TRUE: is fullscreen");
426         return true;
427     }
428
429     if (m_element.muted()) {
430         INFO_LOG(LOGIDENTIFIER, "returning FALSE: muted");
431         return false;
432     }
433
434     if (m_element.document().isMediaDocument() && (m_element.document().frame() && m_element.document().frame()->isMainFrame())) {
435         INFO_LOG(LOGIDENTIFIER, "returning TRUE: is media document");
436         return true;
437     }
438
439     if (client().presentationType() == Audio) {
440         if (!hasBehaviorRestriction(RequireUserGestureToControlControlsManager) || m_element.document().processingUserGestureForMedia()) {
441             INFO_LOG(LOGIDENTIFIER, "returning TRUE: audio element with user gesture");
442             return true;
443         }
444
445         if (m_element.isPlaying() && allowsPlaybackControlsForAutoplayingAudio()) {
446             INFO_LOG(LOGIDENTIFIER, "returning TRUE: user has played media before");
447             return true;
448         }
449
450         INFO_LOG(LOGIDENTIFIER, "returning FALSE: audio element is not suitable");
451         return false;
452     }
453
454     if (purpose == PlaybackControlsPurpose::ControlsManager && !isElementRectMostlyInMainFrame(m_element)) {
455         INFO_LOG(LOGIDENTIFIER, "returning FALSE: not in main frame");
456         return false;
457     }
458
459     if (!m_element.hasAudio() && !m_element.hasEverHadAudio()) {
460         INFO_LOG(LOGIDENTIFIER, "returning FALSE: no audio");
461         return false;
462     }
463
464     if (!playbackPermitted()) {
465         INFO_LOG(LOGIDENTIFIER, "returning FALSE: playback not permitted");
466         return false;
467     }
468
469     if (!hasBehaviorRestriction(RequireUserGestureToControlControlsManager) || m_element.document().processingUserGestureForMedia()) {
470         INFO_LOG(LOGIDENTIFIER, "returning TRUE: no user gesture required");
471         return true;
472     }
473
474     if (purpose == PlaybackControlsPurpose::ControlsManager && hasBehaviorRestriction(RequirePlaybackToControlControlsManager) && !m_element.isPlaying()) {
475         INFO_LOG(LOGIDENTIFIER, "returning FALSE: needs to be playing");
476         return false;
477     }
478
479     if (!m_element.hasEverNotifiedAboutPlaying()) {
480         INFO_LOG(LOGIDENTIFIER, "returning FALSE: hasn't fired playing notification");
481         return false;
482     }
483
484 #if ENABLE(FULLSCREEN_API)
485     // Elements which are not descendents of the current fullscreen element cannot be main content.
486     auto* fullscreenElement = m_element.document().fullscreenManager().currentFullscreenElement();
487     if (fullscreenElement && !m_element.isDescendantOf(*fullscreenElement)) {
488         INFO_LOG(LOGIDENTIFIER, "returning FALSE: outside of full screen");
489         return false;
490     }
491 #endif
492
493     // Only allow the main content heuristic to forbid videos from showing up if our purpose is the controls manager.
494     if (purpose == PlaybackControlsPurpose::ControlsManager && m_element.isVideo()) {
495         if (!m_element.renderer()) {
496             INFO_LOG(LOGIDENTIFIER, "returning FALSE: no renderer");
497             return false;
498         }
499
500         if (!m_element.hasVideo() && !m_element.hasEverHadVideo()) {
501             INFO_LOG(LOGIDENTIFIER, "returning FALSE: no video");
502             return false;
503         }
504
505         if (isLargeEnoughForMainContent(MediaSessionMainContentPurpose::MediaControls)) {
506             INFO_LOG(LOGIDENTIFIER, "returning TRUE: is main content");
507             return true;
508         }
509     }
510
511     if (purpose == PlaybackControlsPurpose::NowPlaying) {
512         INFO_LOG(LOGIDENTIFIER, "returning TRUE: potentially plays audio");
513         return true;
514     }
515
516     INFO_LOG(LOGIDENTIFIER, "returning FALSE: no user gesture");
517     return false;
518 }
519
520 bool MediaElementSession::isLargeEnoughForMainContent(MediaSessionMainContentPurpose purpose) const
521 {
522     return isElementLargeEnoughForMainContent(m_element, purpose);
523 }
524
525 bool MediaElementSession::isMainContentForPurposesOfAutoplayEvents() const
526 {
527     return isElementMainContentForPurposesOfAutoplay(m_element, false);
528 }
529
530 MonotonicTime MediaElementSession::mostRecentUserInteractionTime() const
531 {
532     return m_mostRecentUserInteractionTime;
533 }
534
535 bool MediaElementSession::wantsToObserveViewportVisibilityForMediaControls() const
536 {
537     return isLargeEnoughForMainContent(MediaSessionMainContentPurpose::MediaControls);
538 }
539
540 bool MediaElementSession::wantsToObserveViewportVisibilityForAutoplay() const
541 {
542     return m_element.isVideo();
543 }
544
545 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
546 void MediaElementSession::showPlaybackTargetPicker()
547 {
548     INFO_LOG(LOGIDENTIFIER);
549
550     auto& document = m_element.document();
551     if (m_restrictions & RequireUserGestureToShowPlaybackTargetPicker && !document.processingUserGestureForMedia()) {
552         INFO_LOG(LOGIDENTIFIER, "returning early because of permissions");
553         return;
554     }
555
556     if (!document.page()) {
557         INFO_LOG(LOGIDENTIFIER, "returning early because page is NULL");
558         return;
559     }
560
561 #if !PLATFORM(IOS_FAMILY)
562     if (m_element.readyState() < HTMLMediaElementEnums::HAVE_METADATA) {
563         INFO_LOG(LOGIDENTIFIER, "returning early because element is not playable");
564         return;
565     }
566 #endif
567
568     auto& audioSession = AudioSession::sharedSession();
569     document.showPlaybackTargetPicker(*this, is<HTMLVideoElement>(m_element), audioSession.routeSharingPolicy(), audioSession.routingContextUID());
570 }
571
572 bool MediaElementSession::hasWirelessPlaybackTargets() const
573 {
574     INFO_LOG(LOGIDENTIFIER, "returning ", m_hasPlaybackTargets);
575
576     return m_hasPlaybackTargets;
577 }
578
579 bool MediaElementSession::wirelessVideoPlaybackDisabled() const
580 {
581     if (!m_element.document().settings().allowsAirPlayForMediaPlayback()) {
582         INFO_LOG(LOGIDENTIFIER, "returning TRUE because of settings");
583         return true;
584     }
585
586     if (m_element.hasAttributeWithoutSynchronization(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) {
587         INFO_LOG(LOGIDENTIFIER, "returning TRUE because of attribute");
588         return true;
589     }
590
591 #if PLATFORM(IOS_FAMILY)
592     auto& legacyAirplayAttributeValue = m_element.attributeWithoutSynchronization(HTMLNames::webkitairplayAttr);
593     if (equalLettersIgnoringASCIICase(legacyAirplayAttributeValue, "deny")) {
594         INFO_LOG(LOGIDENTIFIER, "returning TRUE because of legacy attribute");
595         return true;
596     }
597     if (equalLettersIgnoringASCIICase(legacyAirplayAttributeValue, "allow")) {
598         INFO_LOG(LOGIDENTIFIER, "returning FALSE because of legacy attribute");
599         return false;
600     }
601 #endif
602
603     if (m_element.document().settings().remotePlaybackEnabled() && m_element.hasAttributeWithoutSynchronization(HTMLNames::disableremoteplaybackAttr)) {
604         LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of RemotePlayback attribute");
605         return true;
606     }
607
608     auto player = m_element.player();
609     if (!player)
610         return true;
611
612     bool disabled = player->wirelessVideoPlaybackDisabled();
613     INFO_LOG(LOGIDENTIFIER, "returning ", disabled, " because media engine says so");
614     
615     return disabled;
616 }
617
618 void MediaElementSession::setWirelessVideoPlaybackDisabled(bool disabled)
619 {
620     if (disabled)
621         addBehaviorRestriction(WirelessVideoPlaybackDisabled);
622     else
623         removeBehaviorRestriction(WirelessVideoPlaybackDisabled);
624
625     auto player = m_element.player();
626     if (!player)
627         return;
628
629     INFO_LOG(LOGIDENTIFIER, disabled);
630     player->setWirelessVideoPlaybackDisabled(disabled);
631 }
632
633 void MediaElementSession::setHasPlaybackTargetAvailabilityListeners(bool hasListeners)
634 {
635     INFO_LOG(LOGIDENTIFIER, hasListeners);
636
637 #if PLATFORM(IOS_FAMILY)
638     m_hasPlaybackTargetAvailabilityListeners = hasListeners;
639     PlatformMediaSessionManager::sharedManager().configureWireLessTargetMonitoring();
640 #else
641     UNUSED_PARAM(hasListeners);
642     m_element.document().playbackTargetPickerClientStateDidChange(*this, m_element.mediaState());
643 #endif
644 }
645
646 void MediaElementSession::setPlaybackTarget(Ref<MediaPlaybackTarget>&& device)
647 {
648     m_playbackTarget = WTFMove(device);
649     client().setWirelessPlaybackTarget(*m_playbackTarget.copyRef());
650 }
651
652 void MediaElementSession::targetAvailabilityChangedTimerFired()
653 {
654     client().wirelessRoutesAvailableDidChange();
655 }
656
657 void MediaElementSession::externalOutputDeviceAvailableDidChange(bool hasTargets)
658 {
659     if (m_hasPlaybackTargets == hasTargets)
660         return;
661
662     INFO_LOG(LOGIDENTIFIER, hasTargets);
663
664     m_hasPlaybackTargets = hasTargets;
665     m_targetAvailabilityChangedTimer.startOneShot(0_s);
666 }
667
668 bool MediaElementSession::isPlayingToWirelessPlaybackTarget() const
669 {
670 #if !PLATFORM(IOS_FAMILY)
671     if (!m_playbackTarget || !m_playbackTarget->hasActiveRoute())
672         return false;
673 #endif
674
675     return client().isPlayingToWirelessPlaybackTarget();
676 }
677
678 void MediaElementSession::setShouldPlayToPlaybackTarget(bool shouldPlay)
679 {
680     INFO_LOG(LOGIDENTIFIER, shouldPlay);
681     m_shouldPlayToPlaybackTarget = shouldPlay;
682     updateClientDataBuffering();
683     client().setShouldPlayToPlaybackTarget(shouldPlay);
684 }
685
686 void MediaElementSession::playbackTargetPickerWasDismissed()
687 {
688     INFO_LOG(LOGIDENTIFIER);
689     client().playbackTargetPickerWasDismissed();
690 }
691
692 void MediaElementSession::mediaStateDidChange(MediaProducer::MediaStateFlags state)
693 {
694     m_element.document().playbackTargetPickerClientStateDidChange(*this, state);
695 }
696 #endif
697
698 MediaPlayer::Preload MediaElementSession::effectivePreloadForElement() const
699 {
700     MediaPlayer::Preload preload = m_element.preloadValue();
701
702     if (pageExplicitlyAllowsElementToAutoplayInline(m_element))
703         return preload;
704
705     if (m_restrictions & AutoPreloadingNotPermitted) {
706         if (preload > MediaPlayer::MetaData)
707             return MediaPlayer::MetaData;
708     }
709
710     return preload;
711 }
712
713 bool MediaElementSession::requiresFullscreenForVideoPlayback() const
714 {
715     if (pageExplicitlyAllowsElementToAutoplayInline(m_element))
716         return false;
717
718     if (is<HTMLAudioElement>(m_element))
719         return false;
720
721     if (m_element.document().isMediaDocument()) {
722         ASSERT(is<HTMLVideoElement>(m_element));
723         const HTMLVideoElement& videoElement = *downcast<const HTMLVideoElement>(&m_element);
724         if (m_element.readyState() < HTMLVideoElement::HAVE_METADATA || !videoElement.hasEverHadVideo())
725             return false;
726     }
727
728     if (m_element.isTemporarilyAllowingInlinePlaybackAfterFullscreen())
729         return false;
730
731     if (!m_element.document().settings().allowsInlineMediaPlayback())
732         return true;
733
734     if (!m_element.document().settings().inlineMediaPlaybackRequiresPlaysInlineAttribute())
735         return false;
736
737 #if PLATFORM(IOS_FAMILY)
738     if (IOSApplication::isIBooks())
739         return !m_element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr) && !m_element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr);
740     if (dyld_get_program_sdk_version() < DYLD_IOS_VERSION_10_0)
741         return !m_element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr);
742 #endif
743
744     if (m_element.document().isMediaDocument() && m_element.document().ownerElement())
745         return false;
746
747     return !m_element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr);
748 }
749
750 bool MediaElementSession::allowsAutomaticMediaDataLoading() const
751 {
752     if (pageExplicitlyAllowsElementToAutoplayInline(m_element))
753         return true;
754
755     if (m_element.document().settings().mediaDataLoadsAutomatically())
756         return true;
757
758     return false;
759 }
760
761 void MediaElementSession::mediaEngineUpdated()
762 {
763     INFO_LOG(LOGIDENTIFIER);
764
765 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
766     if (m_restrictions & WirelessVideoPlaybackDisabled)
767         setWirelessVideoPlaybackDisabled(true);
768     if (m_playbackTarget)
769         client().setWirelessPlaybackTarget(*m_playbackTarget.copyRef());
770     if (m_shouldPlayToPlaybackTarget)
771         client().setShouldPlayToPlaybackTarget(true);
772 #endif
773     
774 }
775
776 void MediaElementSession::resetPlaybackSessionState()
777 {
778     m_mostRecentUserInteractionTime = MonotonicTime();
779     addBehaviorRestriction(RequireUserGestureToControlControlsManager | RequirePlaybackToControlControlsManager);
780 }
781
782 void MediaElementSession::suspendBuffering()
783 {
784     updateClientDataBuffering();
785 }
786
787 void MediaElementSession::resumeBuffering()
788 {
789     updateClientDataBuffering();
790 }
791
792 bool MediaElementSession::bufferingSuspended() const
793 {
794     if (auto* page = m_element.document().page())
795         return page->mediaBufferingIsSuspended();
796     return true;
797 }
798
799 bool MediaElementSession::allowsPictureInPicture() const
800 {
801     return m_element.document().settings().allowsPictureInPictureMediaPlayback();
802 }
803
804 #if PLATFORM(IOS_FAMILY)
805 bool MediaElementSession::requiresPlaybackTargetRouteMonitoring() const
806 {
807     return m_hasPlaybackTargetAvailabilityListeners && !m_element.elementIsHidden();
808 }
809 #endif
810
811 #if ENABLE(MEDIA_SOURCE)
812 size_t MediaElementSession::maximumMediaSourceBufferSize(const SourceBuffer& buffer) const
813 {
814     // A good quality 1080p video uses 8,000 kbps and stereo audio uses 384 kbps, so assume 95% for video and 5% for audio.
815     const float bufferBudgetPercentageForVideo = .95;
816     const float bufferBudgetPercentageForAudio = .05;
817
818     size_t maximum = buffer.document().settings().maximumSourceBufferSize();
819
820     // Allow a SourceBuffer to buffer as though it is audio-only even if it doesn't have any active tracks (yet).
821     size_t bufferSize = static_cast<size_t>(maximum * bufferBudgetPercentageForAudio);
822     if (buffer.hasVideo())
823         bufferSize += static_cast<size_t>(maximum * bufferBudgetPercentageForVideo);
824
825     // FIXME: we might want to modify this algorithm to:
826     // - decrease the maximum size for background tabs
827     // - decrease the maximum size allowed for inactive elements when a process has more than one
828     //   element, eg. so a page with many elements which are played one at a time doesn't keep
829     //   everything buffered after an element has finished playing.
830
831     return bufferSize;
832 }
833 #endif
834
835 static bool isElementMainContentForPurposesOfAutoplay(const HTMLMediaElement& element, bool shouldHitTestMainFrame)
836 {
837     Document& document = element.document();
838     if (!document.hasLivingRenderTree() || document.activeDOMObjectsAreStopped() || element.isSuspended() || !element.hasAudio() || !element.hasVideo())
839         return false;
840
841     // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content.
842     auto* renderer = element.renderer();
843     if (!renderer)
844         return false;
845
846     if (!isElementLargeEnoughForMainContent(element, MediaSessionMainContentPurpose::Autoplay))
847         return false;
848
849     // Elements which are hidden by style, or have been scrolled out of view, cannot be main content.
850     // But elements which have audio & video and are already playing should not stop playing because
851     // they are scrolled off the page.
852     if (renderer->style().visibility() != Visibility::Visible)
853         return false;
854     if (renderer->visibleInViewportState() != VisibleInViewportState::Yes && !element.isPlaying())
855         return false;
856
857     // Main content elements must be in the main frame.
858     if (!document.frame() || !document.frame()->isMainFrame())
859         return false;
860
861     auto& mainFrame = document.frame()->mainFrame();
862     if (!mainFrame.view() || !mainFrame.view()->renderView())
863         return false;
864
865     if (!shouldHitTestMainFrame)
866         return true;
867
868     // Hit test the area of the main frame where the element appears, to determine if the element is being obscured.
869     IntRect rectRelativeToView = element.clientRect();
870     ScrollPosition scrollPosition = mainFrame.view()->documentScrollPositionRelativeToViewOrigin();
871     IntRect rectRelativeToTopDocument(rectRelativeToView.location() + scrollPosition, rectRelativeToView.size());
872     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::AllowChildFrameContent | HitTestRequest::IgnoreClipping | HitTestRequest::DisallowUserAgentShadowContent);
873     HitTestResult result(rectRelativeToTopDocument.center());
874
875     // Elements which are obscured by other elements cannot be main content.
876     if (!mainFrame.document())
877         return false;
878     mainFrame.document()->hitTest(request, result);
879     result.setToNonUserAgentShadowAncestor();
880     RefPtr<Element> hitElement = result.targetElement();
881     if (hitElement != &element)
882         return false;
883
884     return true;
885 }
886
887 static bool isElementRectMostlyInMainFrame(const HTMLMediaElement& element)
888 {
889     if (!element.renderer())
890         return false;
891
892     auto documentFrame = makeRefPtr(element.document().frame());
893     if (!documentFrame)
894         return false;
895
896     auto mainFrameView = documentFrame->mainFrame().view();
897     if (!mainFrameView)
898         return false;
899
900     IntRect mainFrameRectAdjustedForScrollPosition = IntRect(-mainFrameView->documentScrollPositionRelativeToViewOrigin(), mainFrameView->contentsSize());
901     IntRect elementRectInMainFrame = element.clientRect();
902     auto totalElementArea = elementRectInMainFrame.area<RecordOverflow>();
903     if (totalElementArea.hasOverflowed())
904         return false;
905
906     elementRectInMainFrame.intersect(mainFrameRectAdjustedForScrollPosition);
907
908     return elementRectInMainFrame.area().unsafeGet() > totalElementArea.unsafeGet() / 2;
909 }
910
911 static bool isElementLargeRelativeToMainFrame(const HTMLMediaElement& element)
912 {
913     static const double minimumPercentageOfMainFrameAreaForMainContent = 0.9;
914     auto* renderer = element.renderer();
915     if (!renderer)
916         return false;
917
918     auto documentFrame = makeRefPtr(element.document().frame());
919     if (!documentFrame)
920         return false;
921
922     if (!documentFrame->mainFrame().view())
923         return false;
924
925     auto& mainFrameView = *documentFrame->mainFrame().view();
926     auto maxVisibleClientWidth = std::min(renderer->clientWidth().toInt(), mainFrameView.visibleWidth());
927     auto maxVisibleClientHeight = std::min(renderer->clientHeight().toInt(), mainFrameView.visibleHeight());
928
929     return maxVisibleClientWidth * maxVisibleClientHeight > minimumPercentageOfMainFrameAreaForMainContent * mainFrameView.visibleWidth() * mainFrameView.visibleHeight();
930 }
931
932 static bool isElementLargeEnoughForMainContent(const HTMLMediaElement& element, MediaSessionMainContentPurpose purpose)
933 {
934     static const double elementMainContentAreaMinimum = 400 * 300;
935     static const double maximumAspectRatio = purpose == MediaSessionMainContentPurpose::MediaControls ? 3 : 1.8;
936     static const double minimumAspectRatio = .5; // Slightly smaller than 9:16.
937
938     // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content.
939     auto* renderer = element.renderer();
940     if (!renderer)
941         return false;
942
943     double width = renderer->clientWidth();
944     double height = renderer->clientHeight();
945     double area = width * height;
946     double aspectRatio = width / height;
947
948     if (area < elementMainContentAreaMinimum)
949         return false;
950
951     if (aspectRatio >= minimumAspectRatio && aspectRatio <= maximumAspectRatio)
952         return true;
953
954     return isElementLargeRelativeToMainFrame(element);
955 }
956
957 void MediaElementSession::mainContentCheckTimerFired()
958 {
959     if (!hasBehaviorRestriction(OverrideUserGestureRequirementForMainContent))
960         return;
961
962     updateIsMainContent();
963 }
964
965 bool MediaElementSession::updateIsMainContent() const
966 {
967     if (m_element.isSuspended())
968         return false;
969
970     bool wasMainContent = m_isMainContent;
971     m_isMainContent = isElementMainContentForPurposesOfAutoplay(m_element, true);
972
973     if (m_isMainContent != wasMainContent)
974         m_element.updateShouldPlay();
975
976     return m_isMainContent;
977 }
978
979 bool MediaElementSession::allowsNowPlayingControlsVisibility() const
980 {
981     auto page = m_element.document().page();
982     return page && !page->isVisibleAndActive();
983 }
984
985 bool MediaElementSession::allowsPlaybackControlsForAutoplayingAudio() const
986 {
987     auto page = m_element.document().page();
988     return page && page->allowsPlaybackControlsForAutoplayingAudio();
989 }
990
991 String convertEnumerationToString(const MediaPlaybackDenialReason enumerationValue)
992 {
993     static const NeverDestroyed<String> values[] = {
994         MAKE_STATIC_STRING_IMPL("UserGestureRequired"),
995         MAKE_STATIC_STRING_IMPL("FullscreenRequired"),
996         MAKE_STATIC_STRING_IMPL("PageConsentRequired"),
997         MAKE_STATIC_STRING_IMPL("InvalidState"),
998     };
999     static_assert(static_cast<size_t>(MediaPlaybackDenialReason::UserGestureRequired) == 0, "MediaPlaybackDenialReason::UserGestureRequired is not 0 as expected");
1000     static_assert(static_cast<size_t>(MediaPlaybackDenialReason::FullscreenRequired) == 1, "MediaPlaybackDenialReason::FullscreenRequired is not 1 as expected");
1001     static_assert(static_cast<size_t>(MediaPlaybackDenialReason::PageConsentRequired) == 2, "MediaPlaybackDenialReason::PageConsentRequired is not 2 as expected");
1002     static_assert(static_cast<size_t>(MediaPlaybackDenialReason::InvalidState) == 3, "MediaPlaybackDenialReason::InvalidState is not 3 as expected");
1003     ASSERT(static_cast<size_t>(enumerationValue) < WTF_ARRAY_LENGTH(values));
1004     return values[static_cast<size_t>(enumerationValue)];
1005 }
1006     
1007 }
1008
1009 #endif // ENABLE(VIDEO)