bcec194b6bbe6a4df356c2aa40e2ae1688491fa7
[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 "Frame.h"
34 #include "FrameView.h"
35 #include "HTMLAudioElement.h"
36 #include "HTMLMediaElement.h"
37 #include "HTMLNames.h"
38 #include "HTMLVideoElement.h"
39 #include "HitTestResult.h"
40 #include "Logging.h"
41 #include "MainFrame.h"
42 #include "Page.h"
43 #include "PlatformMediaSessionManager.h"
44 #include "RenderMedia.h"
45 #include "RenderView.h"
46 #include "ScriptController.h"
47 #include "Settings.h"
48 #include "SourceBuffer.h"
49 #include <wtf/CurrentTime.h>
50 #include <wtf/text/StringBuilder.h>
51
52 #if PLATFORM(IOS)
53 #include "AudioSession.h"
54 #include "RuntimeApplicationChecks.h"
55 #include <wtf/spi/darwin/dyldSPI.h>
56 #endif
57
58 namespace WebCore {
59
60 static const double elementMainContentCheckInterval = .250;
61
62 static bool isElementRectMostlyInMainFrame(const HTMLMediaElement&);
63 static bool isElementLargeEnoughForMainContent(const HTMLMediaElement&, MediaSessionMainContentPurpose);
64
65 #if !LOG_DISABLED
66 static String restrictionName(MediaElementSession::BehaviorRestrictions restriction)
67 {
68     StringBuilder restrictionBuilder;
69 #define CASE(restrictionType) \
70     if (restriction & MediaElementSession::restrictionType) { \
71         if (!restrictionBuilder.isEmpty()) \
72             restrictionBuilder.appendLiteral(", "); \
73         restrictionBuilder.append(#restrictionType); \
74     } \
75
76     CASE(NoRestrictions);
77     CASE(RequireUserGestureForLoad);
78     CASE(RequireUserGestureForVideoRateChange);
79     CASE(RequireUserGestureForAudioRateChange);
80     CASE(RequireUserGestureForFullscreen);
81     CASE(RequirePageConsentToLoadMedia);
82     CASE(RequirePageConsentToResumeMedia);
83 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
84     CASE(RequireUserGestureToShowPlaybackTargetPicker);
85     CASE(WirelessVideoPlaybackDisabled);
86 #endif
87     CASE(InvisibleAutoplayNotPermitted);
88     CASE(OverrideUserGestureRequirementForMainContent);
89
90     return restrictionBuilder.toString();
91 }
92 #endif
93
94 static bool pageExplicitlyAllowsElementToAutoplayInline(const HTMLMediaElement& element)
95 {
96     Document& document = element.document();
97     Page* page = document.page();
98     return document.isMediaDocument() && !document.ownerElement() && page && page->allowsMediaDocumentInlinePlayback();
99 }
100
101 MediaElementSession::MediaElementSession(HTMLMediaElement& element)
102     : PlatformMediaSession(element)
103     , m_element(element)
104     , m_restrictions(NoRestrictions)
105 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
106     , m_targetAvailabilityChangedTimer(*this, &MediaElementSession::targetAvailabilityChangedTimerFired)
107 #endif
108     , m_mainContentCheckTimer(*this, &MediaElementSession::mainContentCheckTimerFired)
109 {
110 }
111
112 void MediaElementSession::registerWithDocument(Document& document)
113 {
114 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
115     document.addPlaybackTargetPickerClient(*this);
116 #else
117     UNUSED_PARAM(document);
118 #endif
119 }
120
121 void MediaElementSession::unregisterWithDocument(Document& document)
122 {
123 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
124     document.removePlaybackTargetPickerClient(*this);
125 #else
126     UNUSED_PARAM(document);
127 #endif
128 }
129
130 void MediaElementSession::addBehaviorRestriction(BehaviorRestrictions restriction)
131 {
132     LOG(Media, "MediaElementSession::addBehaviorRestriction - adding %s", restrictionName(restriction).utf8().data());
133     m_restrictions |= restriction;
134
135     if (restriction & OverrideUserGestureRequirementForMainContent)
136         m_mainContentCheckTimer.startRepeating(elementMainContentCheckInterval);
137 }
138
139 void MediaElementSession::removeBehaviorRestriction(BehaviorRestrictions restriction)
140 {
141     if (restriction & RequireUserGestureToControlControlsManager) {
142         m_mostRecentUserInteractionTime = monotonicallyIncreasingTime();
143         if (auto page = m_element.document().page())
144             page->setAllowsPlaybackControlsForAutoplayingAudio(true);
145     }
146
147     LOG(Media, "MediaElementSession::removeBehaviorRestriction - removing %s", restrictionName(restriction).utf8().data());
148     m_restrictions &= ~restriction;
149 }
150
151 SuccessOr<MediaPlaybackDenialReason> MediaElementSession::playbackPermitted(const HTMLMediaElement& element) const
152 {
153     if (element.document().isMediaDocument() && !element.document().ownerElement())
154         return SuccessOr<MediaPlaybackDenialReason>();
155
156     if (pageExplicitlyAllowsElementToAutoplayInline(element))
157         return SuccessOr<MediaPlaybackDenialReason>();
158
159     if (requiresFullscreenForVideoPlayback(element) && !fullscreenPermitted(element)) {
160         LOG(Media, "MediaElementSession::playbackPermitted - returning FALSE because of fullscreen restriction");
161         return MediaPlaybackDenialReason::FullscreenRequired;
162     }
163
164     if (m_restrictions & OverrideUserGestureRequirementForMainContent && updateIsMainContent())
165         return SuccessOr<MediaPlaybackDenialReason>();
166
167     if (m_restrictions & RequireUserGestureForVideoRateChange && element.isVideo() && !ScriptController::processingUserGestureForMedia()) {
168         LOG(Media, "MediaElementSession::playbackPermitted - returning FALSE because of video rate change restriction");
169         return MediaPlaybackDenialReason::UserGestureRequired;
170     }
171
172     if (m_restrictions & RequireUserGestureForAudioRateChange && (!element.isVideo() || element.hasAudio()) && !element.muted() && !ScriptController::processingUserGestureForMedia()) {
173         LOG(Media, "MediaElementSession::playbackPermitted - returning FALSE because of audio rate change restriction");
174         return MediaPlaybackDenialReason::UserGestureRequired;
175     }
176
177     if (m_restrictions & RequireUserGestureForVideoDueToLowPowerMode && element.isVideo() && !ScriptController::processingUserGestureForMedia()) {
178         LOG(Media, "MediaElementSession::playbackPermitted - returning FALSE because of video low power mode restriction");
179         return MediaPlaybackDenialReason::UserGestureRequired;
180     }
181
182     return SuccessOr<MediaPlaybackDenialReason>();
183 }
184
185 bool MediaElementSession::autoplayPermitted() const
186 {
187     const Document& document = m_element.document();
188     if (document.pageCacheState() != Document::NotInPageCache)
189         return false;
190     if (document.activeDOMObjectsAreSuspended())
191         return false;
192
193     if (!hasBehaviorRestriction(MediaElementSession::InvisibleAutoplayNotPermitted))
194         return true;
195
196     auto* renderer = m_element.renderer();
197     if (!renderer)
198         return false;
199     if (renderer->style().visibility() != VISIBLE)
200         return false;
201     if (renderer->view().frameView().isOffscreen())
202         return false;
203     if (renderer->visibleInViewportState() != RenderElement::VisibleInViewport)
204         return false;
205     return true;
206 }
207
208 bool MediaElementSession::dataLoadingPermitted(const HTMLMediaElement&) const
209 {
210     if (m_restrictions & OverrideUserGestureRequirementForMainContent && updateIsMainContent())
211         return true;
212
213     if (m_restrictions & RequireUserGestureForLoad && !ScriptController::processingUserGestureForMedia()) {
214         LOG(Media, "MediaElementSession::dataLoadingPermitted - returning FALSE");
215         return false;
216     }
217
218     return true;
219 }
220
221 bool MediaElementSession::fullscreenPermitted(const HTMLMediaElement&) const
222 {
223     if (m_restrictions & RequireUserGestureForFullscreen && !ScriptController::processingUserGestureForMedia()) {
224         LOG(Media, "MediaElementSession::fullscreenPermitted - returning FALSE");
225         return false;
226     }
227
228     return true;
229 }
230
231 bool MediaElementSession::pageAllowsDataLoading(const HTMLMediaElement& element) const
232 {
233     Page* page = element.document().page();
234     if (m_restrictions & RequirePageConsentToLoadMedia && page && !page->canStartMedia()) {
235         LOG(Media, "MediaElementSession::pageAllowsDataLoading - returning FALSE");
236         return false;
237     }
238
239     return true;
240 }
241
242 bool MediaElementSession::pageAllowsPlaybackAfterResuming(const HTMLMediaElement& element) const
243 {
244     Page* page = element.document().page();
245     if (m_restrictions & RequirePageConsentToResumeMedia && page && !page->canStartMedia()) {
246         LOG(Media, "MediaElementSession::pageAllowsPlaybackAfterResuming - returning FALSE");
247         return false;
248     }
249
250     return true;
251 }
252
253 bool MediaElementSession::canShowControlsManager(PlaybackControlsPurpose purpose) const
254 {
255     if (m_element.isFullscreen()) {
256         LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Is fullscreen");
257         return true;
258     }
259
260     if (m_element.muted()) {
261         LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Muted");
262         return false;
263     }
264
265     if (m_element.document().isMediaDocument()) {
266         LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Is media document");
267         return true;
268     }
269
270     if (client().presentationType() == Audio) {
271         if (!hasBehaviorRestriction(RequireUserGestureToControlControlsManager) || ScriptController::processingUserGestureForMedia()) {
272             LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Audio element with user gesture");
273             return true;
274         }
275
276         if (m_element.isPlaying() && allowsPlaybackControlsForAutoplayingAudio()) {
277             LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: User has played media before");
278             return true;
279         }
280
281         LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Audio element is not suitable");
282         return false;
283     }
284
285     if (purpose == PlaybackControlsPurpose::ControlsManager && !isElementRectMostlyInMainFrame(m_element)) {
286         LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Not in main frame");
287         return false;
288     }
289
290     if (!m_element.hasAudio() && !m_element.hasEverHadAudio()) {
291         LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: No audio");
292         return false;
293     }
294
295     if (m_element.document().activeDOMObjectsAreSuspended()) {
296         LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: activeDOMObjectsAreSuspended()");
297         return false;
298     }
299
300     if (!playbackPermitted(m_element)) {
301         LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Playback not permitted");
302         return false;
303     }
304
305     if (!hasBehaviorRestriction(RequireUserGestureToControlControlsManager) || ScriptController::processingUserGestureForMedia()) {
306         LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: No user gesture required");
307         return true;
308     }
309
310     if (purpose == PlaybackControlsPurpose::ControlsManager && hasBehaviorRestriction(RequirePlaybackToControlControlsManager) && !m_element.isPlaying()) {
311         LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Needs to be playing");
312         return false;
313     }
314
315     if (!m_element.hasEverNotifiedAboutPlaying()) {
316         LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Hasn't fired playing notification");
317         return false;
318     }
319
320     // Only allow the main content heuristic to forbid videos from showing up if our purpose is the controls manager.
321     if (purpose == PlaybackControlsPurpose::ControlsManager && m_element.isVideo()) {
322         if (!m_element.renderer()) {
323             LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: No renderer");
324             return false;
325         }
326
327         if (!m_element.hasVideo() && !m_element.hasEverHadVideo()) {
328             LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: No video");
329             return false;
330         }
331
332         if (isLargeEnoughForMainContent(MediaSessionMainContentPurpose::MediaControls)) {
333             LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Is main content");
334             return true;
335         }
336     }
337
338     if (purpose == PlaybackControlsPurpose::NowPlaying) {
339         LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Potentially plays audio");
340         return true;
341     }
342
343     LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: No user gesture");
344     return false;
345 }
346
347 bool MediaElementSession::isLargeEnoughForMainContent(MediaSessionMainContentPurpose purpose) const
348 {
349     return isElementLargeEnoughForMainContent(m_element, purpose);
350 }
351
352 double MediaElementSession::mostRecentUserInteractionTime() const
353 {
354     return m_mostRecentUserInteractionTime;
355 }
356
357 bool MediaElementSession::wantsToObserveViewportVisibilityForMediaControls() const
358 {
359     return isLargeEnoughForMainContent(MediaSessionMainContentPurpose::MediaControls);
360 }
361
362 bool MediaElementSession::wantsToObserveViewportVisibilityForAutoplay() const
363 {
364     return hasBehaviorRestriction(InvisibleAutoplayNotPermitted) || hasBehaviorRestriction(OverrideUserGestureRequirementForMainContent);
365 }
366
367 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
368 void MediaElementSession::showPlaybackTargetPicker(const HTMLMediaElement& element)
369 {
370     LOG(Media, "MediaElementSession::showPlaybackTargetPicker");
371
372     if (m_restrictions & RequireUserGestureToShowPlaybackTargetPicker && !ScriptController::processingUserGestureForMedia()) {
373         LOG(Media, "MediaElementSession::showPlaybackTargetPicker - returning early because of permissions");
374         return;
375     }
376
377     if (!element.document().page()) {
378         LOG(Media, "MediaElementSession::showingPlaybackTargetPickerPermitted - returning early because page is NULL");
379         return;
380     }
381
382 #if !PLATFORM(IOS)
383     if (element.readyState() < HTMLMediaElementEnums::HAVE_METADATA) {
384         LOG(Media, "MediaElementSession::showPlaybackTargetPicker - returning early because element is not playable");
385         return;
386     }
387 #endif
388
389     element.document().showPlaybackTargetPicker(*this, is<HTMLVideoElement>(element));
390 }
391
392 bool MediaElementSession::hasWirelessPlaybackTargets(const HTMLMediaElement&) const
393 {
394 #if PLATFORM(IOS)
395     // FIXME: consolidate Mac and iOS implementations
396     m_hasPlaybackTargets = PlatformMediaSessionManager::sharedManager().hasWirelessTargetsAvailable();
397 #endif
398
399     LOG(Media, "MediaElementSession::hasWirelessPlaybackTargets - returning %s", m_hasPlaybackTargets ? "TRUE" : "FALSE");
400
401     return m_hasPlaybackTargets;
402 }
403
404 bool MediaElementSession::wirelessVideoPlaybackDisabled(const HTMLMediaElement& element) const
405 {
406     if (!element.document().settings().allowsAirPlayForMediaPlayback()) {
407         LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of settings");
408         return true;
409     }
410
411     if (element.hasAttributeWithoutSynchronization(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) {
412         LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of attribute");
413         return true;
414     }
415
416 #if PLATFORM(IOS)
417     String legacyAirplayAttributeValue = element.attributeWithoutSynchronization(HTMLNames::webkitairplayAttr);
418     if (equalLettersIgnoringASCIICase(legacyAirplayAttributeValue, "deny")) {
419         LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of legacy attribute");
420         return true;
421     }
422     if (equalLettersIgnoringASCIICase(legacyAirplayAttributeValue, "allow")) {
423         LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning FALSE because of legacy attribute");
424         return false;
425     }
426 #endif
427
428     MediaPlayer* player = element.player();
429     if (!player)
430         return true;
431
432     bool disabled = player->wirelessVideoPlaybackDisabled();
433     LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning %s because media engine says so", disabled ? "TRUE" : "FALSE");
434     
435     return disabled;
436 }
437
438 void MediaElementSession::setWirelessVideoPlaybackDisabled(const HTMLMediaElement& element, bool disabled)
439 {
440     if (disabled)
441         addBehaviorRestriction(WirelessVideoPlaybackDisabled);
442     else
443         removeBehaviorRestriction(WirelessVideoPlaybackDisabled);
444
445     MediaPlayer* player = element.player();
446     if (!player)
447         return;
448
449     LOG(Media, "MediaElementSession::setWirelessVideoPlaybackDisabled - disabled %s", disabled ? "TRUE" : "FALSE");
450     player->setWirelessVideoPlaybackDisabled(disabled);
451 }
452
453 void MediaElementSession::setHasPlaybackTargetAvailabilityListeners(const HTMLMediaElement& element, bool hasListeners)
454 {
455     LOG(Media, "MediaElementSession::setHasPlaybackTargetAvailabilityListeners - hasListeners %s", hasListeners ? "TRUE" : "FALSE");
456
457 #if PLATFORM(IOS)
458     UNUSED_PARAM(element);
459     m_hasPlaybackTargetAvailabilityListeners = hasListeners;
460     PlatformMediaSessionManager::sharedManager().configureWireLessTargetMonitoring();
461 #else
462     UNUSED_PARAM(hasListeners);
463     element.document().playbackTargetPickerClientStateDidChange(*this, element.mediaState());
464 #endif
465 }
466
467 void MediaElementSession::setPlaybackTarget(Ref<MediaPlaybackTarget>&& device)
468 {
469     m_playbackTarget = WTFMove(device);
470     client().setWirelessPlaybackTarget(*m_playbackTarget.copyRef());
471 }
472
473 void MediaElementSession::targetAvailabilityChangedTimerFired()
474 {
475     client().wirelessRoutesAvailableDidChange();
476 }
477
478 void MediaElementSession::externalOutputDeviceAvailableDidChange(bool hasTargets)
479 {
480     if (m_hasPlaybackTargets == hasTargets)
481         return;
482
483     LOG(Media, "MediaElementSession::externalOutputDeviceAvailableDidChange(%p) - hasTargets %s", this, hasTargets ? "TRUE" : "FALSE");
484
485     m_hasPlaybackTargets = hasTargets;
486     m_targetAvailabilityChangedTimer.startOneShot(0);
487 }
488
489 bool MediaElementSession::canPlayToWirelessPlaybackTarget() const
490 {
491 #if !PLATFORM(IOS)
492     if (!m_playbackTarget || !m_playbackTarget->hasActiveRoute())
493         return false;
494 #endif
495
496     return client().canPlayToWirelessPlaybackTarget();
497 }
498
499 bool MediaElementSession::isPlayingToWirelessPlaybackTarget() const
500 {
501 #if !PLATFORM(IOS)
502     if (!m_playbackTarget || !m_playbackTarget->hasActiveRoute())
503         return false;
504 #endif
505
506     return client().isPlayingToWirelessPlaybackTarget();
507 }
508
509 void MediaElementSession::setShouldPlayToPlaybackTarget(bool shouldPlay)
510 {
511     LOG(Media, "MediaElementSession::setShouldPlayToPlaybackTarget - shouldPlay %s", shouldPlay ? "TRUE" : "FALSE");
512     m_shouldPlayToPlaybackTarget = shouldPlay;
513     client().setShouldPlayToPlaybackTarget(shouldPlay);
514 }
515
516 void MediaElementSession::mediaStateDidChange(const HTMLMediaElement& element, MediaProducer::MediaStateFlags state)
517 {
518     element.document().playbackTargetPickerClientStateDidChange(*this, state);
519 }
520 #endif
521
522 MediaPlayer::Preload MediaElementSession::effectivePreloadForElement(const HTMLMediaElement& element) const
523 {
524     MediaPlayer::Preload preload = element.preloadValue();
525
526     if (pageExplicitlyAllowsElementToAutoplayInline(element))
527         return preload;
528
529     if (m_restrictions & MetadataPreloadingNotPermitted)
530         return MediaPlayer::None;
531
532     if (m_restrictions & AutoPreloadingNotPermitted) {
533         if (preload > MediaPlayer::MetaData)
534             return MediaPlayer::MetaData;
535     }
536
537     return preload;
538 }
539
540 bool MediaElementSession::requiresFullscreenForVideoPlayback(const HTMLMediaElement& element) const
541 {
542     if (pageExplicitlyAllowsElementToAutoplayInline(element))
543         return false;
544
545     if (is<HTMLAudioElement>(element))
546         return false;
547
548     if (element.isTemporarilyAllowingInlinePlaybackAfterFullscreen())
549         return false;
550
551     if (!element.document().settings().allowsInlineMediaPlayback())
552         return true;
553
554     if (!element.document().settings().inlineMediaPlaybackRequiresPlaysInlineAttribute())
555         return false;
556
557 #if PLATFORM(IOS)
558     if (IOSApplication::isIBooks())
559         return !element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr) && !element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr);
560     if (dyld_get_program_sdk_version() < DYLD_IOS_VERSION_10_0)
561         return !element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr);
562 #endif
563     return !element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr);
564 }
565
566 bool MediaElementSession::allowsAutomaticMediaDataLoading(const HTMLMediaElement& element) const
567 {
568     if (pageExplicitlyAllowsElementToAutoplayInline(element))
569         return true;
570
571     if (element.document().settings().mediaDataLoadsAutomatically())
572         return true;
573
574     return false;
575 }
576
577 void MediaElementSession::mediaEngineUpdated(const HTMLMediaElement& element)
578 {
579     LOG(Media, "MediaElementSession::mediaEngineUpdated");
580
581 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
582     if (m_restrictions & WirelessVideoPlaybackDisabled)
583         setWirelessVideoPlaybackDisabled(element, true);
584     if (m_playbackTarget)
585         client().setWirelessPlaybackTarget(*m_playbackTarget.copyRef());
586     if (m_shouldPlayToPlaybackTarget)
587         client().setShouldPlayToPlaybackTarget(true);
588 #else
589     UNUSED_PARAM(element);
590 #endif
591     
592 }
593
594 void MediaElementSession::resetPlaybackSessionState()
595 {
596     m_mostRecentUserInteractionTime = 0;
597     addBehaviorRestriction(RequireUserGestureToControlControlsManager | RequirePlaybackToControlControlsManager);
598 }
599
600 bool MediaElementSession::allowsPictureInPicture(const HTMLMediaElement& element) const
601 {
602     return element.document().settings().allowsPictureInPictureMediaPlayback() && !element.webkitCurrentPlaybackTargetIsWireless();
603 }
604
605 #if PLATFORM(IOS)
606 bool MediaElementSession::requiresPlaybackTargetRouteMonitoring() const
607 {
608     return m_hasPlaybackTargetAvailabilityListeners && !client().elementIsHidden();
609 }
610 #endif
611
612 #if ENABLE(MEDIA_SOURCE)
613 size_t MediaElementSession::maximumMediaSourceBufferSize(const SourceBuffer& buffer) const
614 {
615     // A good quality 1080p video uses 8,000 kbps and stereo audio uses 384 kbps, so assume 95% for video and 5% for audio.
616     const float bufferBudgetPercentageForVideo = .95;
617     const float bufferBudgetPercentageForAudio = .05;
618
619     size_t maximum = buffer.document().settings().maximumSourceBufferSize();
620
621     // Allow a SourceBuffer to buffer as though it is audio-only even if it doesn't have any active tracks (yet).
622     size_t bufferSize = static_cast<size_t>(maximum * bufferBudgetPercentageForAudio);
623     if (buffer.hasVideo())
624         bufferSize += static_cast<size_t>(maximum * bufferBudgetPercentageForVideo);
625
626     // FIXME: we might want to modify this algorithm to:
627     // - decrease the maximum size for background tabs
628     // - decrease the maximum size allowed for inactive elements when a process has more than one
629     //   element, eg. so a page with many elements which are played one at a time doesn't keep
630     //   everything buffered after an element has finished playing.
631
632     return bufferSize;
633 }
634 #endif
635
636 static bool isMainContentForPurposesOfAutoplay(const HTMLMediaElement& element)
637 {
638     if (!element.hasAudio() || !element.hasVideo())
639         return false;
640
641     // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content.
642     auto* renderer = element.renderer();
643     if (!renderer)
644         return false;
645
646     if (!isElementLargeEnoughForMainContent(element, MediaSessionMainContentPurpose::Autoplay))
647         return false;
648
649     // Elements which are hidden by style, or have been scrolled out of view, cannot be main content.
650     // But elements which have audio & video and are already playing should not stop playing because
651     // they are scrolled off the page.
652     if (renderer->style().visibility() != VISIBLE)
653         return false;
654     if (renderer->visibleInViewportState() != RenderElement::VisibleInViewport && !element.isPlaying())
655         return false;
656
657     // Main content elements must be in the main frame.
658     Document& document = element.document();
659     if (!document.frame() || !document.frame()->isMainFrame())
660         return false;
661
662     MainFrame& mainFrame = document.frame()->mainFrame();
663     if (!mainFrame.view() || !mainFrame.view()->renderView())
664         return false;
665
666     RenderView& mainRenderView = *mainFrame.view()->renderView();
667
668     // Hit test the area of the main frame where the element appears, to determine if the element is being obscured.
669     IntRect rectRelativeToView = element.clientRect();
670     ScrollPosition scrollPosition = mainFrame.view()->documentScrollPositionRelativeToViewOrigin();
671     IntRect rectRelativeToTopDocument(rectRelativeToView.location() + scrollPosition, rectRelativeToView.size());
672     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::AllowChildFrameContent | HitTestRequest::IgnoreClipping | HitTestRequest::DisallowUserAgentShadowContent);
673     HitTestResult result(rectRelativeToTopDocument.center());
674
675     // Elements which are obscured by other elements cannot be main content.
676     mainRenderView.hitTest(request, result);
677     result.setToNonUserAgentShadowAncestor();
678     Element* hitElement = result.targetElement();
679     if (hitElement != &element)
680         return false;
681
682     return true;
683 }
684
685 static bool isElementRectMostlyInMainFrame(const HTMLMediaElement& element)
686 {
687     if (!element.renderer())
688         return false;
689
690     auto* documentFrame = element.document().frame();
691     if (!documentFrame)
692         return false;
693
694     auto mainFrameView = documentFrame->mainFrame().view();
695     if (!mainFrameView)
696         return false;
697
698     IntRect mainFrameRectAdjustedForScrollPosition = IntRect(-mainFrameView->documentScrollPositionRelativeToViewOrigin(), mainFrameView->contentsSize());
699     IntRect elementRectInMainFrame = element.clientRect();
700     auto totalElementArea = elementRectInMainFrame.area<RecordOverflow>();
701     if (totalElementArea.hasOverflowed())
702         return false;
703
704     elementRectInMainFrame.intersect(mainFrameRectAdjustedForScrollPosition);
705
706     return elementRectInMainFrame.area().unsafeGet() > totalElementArea.unsafeGet() / 2;
707 }
708
709 static bool isElementLargeRelativeToMainFrame(const HTMLMediaElement& element)
710 {
711     static const double minimumPercentageOfMainFrameAreaForMainContent = 0.9;
712     auto* renderer = element.renderer();
713     if (!renderer)
714         return false;
715
716     auto* documentFrame = element.document().frame();
717     if (!documentFrame)
718         return false;
719
720     if (!documentFrame->mainFrame().view())
721         return false;
722
723     auto& mainFrameView = *documentFrame->mainFrame().view();
724     auto maxVisibleClientWidth = std::min(renderer->clientWidth().toInt(), mainFrameView.visibleWidth());
725     auto maxVisibleClientHeight = std::min(renderer->clientHeight().toInt(), mainFrameView.visibleHeight());
726
727     return maxVisibleClientWidth * maxVisibleClientHeight > minimumPercentageOfMainFrameAreaForMainContent * mainFrameView.visibleWidth() * mainFrameView.visibleHeight();
728 }
729
730 static bool isElementLargeEnoughForMainContent(const HTMLMediaElement& element, MediaSessionMainContentPurpose purpose)
731 {
732     static const double elementMainContentAreaMinimum = 400 * 300;
733     static const double maximumAspectRatio = purpose == MediaSessionMainContentPurpose::MediaControls ? 3 : 1.8;
734     static const double minimumAspectRatio = .5; // Slightly smaller than 9:16.
735
736     // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content.
737     auto* renderer = element.renderer();
738     if (!renderer)
739         return false;
740
741     double width = renderer->clientWidth();
742     double height = renderer->clientHeight();
743     double area = width * height;
744     double aspectRatio = width / height;
745
746     if (area < elementMainContentAreaMinimum)
747         return false;
748
749     if (aspectRatio >= minimumAspectRatio && aspectRatio <= maximumAspectRatio)
750         return true;
751
752     return isElementLargeRelativeToMainFrame(element);
753 }
754
755 void MediaElementSession::mainContentCheckTimerFired()
756 {
757     if (!hasBehaviorRestriction(OverrideUserGestureRequirementForMainContent))
758         return;
759
760     updateIsMainContent();
761 }
762
763 bool MediaElementSession::updateIsMainContent() const
764 {
765     bool wasMainContent = m_isMainContent;
766     m_isMainContent = isMainContentForPurposesOfAutoplay(m_element);
767
768     if (m_isMainContent != wasMainContent)
769         m_element.updateShouldPlay();
770
771     return m_isMainContent;
772 }
773
774 bool MediaElementSession::allowsNowPlayingControlsVisibility() const
775 {
776     auto page = m_element.document().page();
777     return page && !page->isVisibleAndActive();
778 }
779
780 bool MediaElementSession::allowsPlaybackControlsForAutoplayingAudio() const
781 {
782     auto page = m_element.document().page();
783     return page && page->allowsPlaybackControlsForAutoplayingAudio();
784 }
785
786 }
787
788 #endif // ENABLE(VIDEO)