diff options
Diffstat (limited to 'Source/WebCore/html/MediaElementSession.cpp')
| -rw-r--r-- | Source/WebCore/html/MediaElementSession.cpp | 783 |
1 files changed, 783 insertions, 0 deletions
diff --git a/Source/WebCore/html/MediaElementSession.cpp b/Source/WebCore/html/MediaElementSession.cpp new file mode 100644 index 000000000..10ae65287 --- /dev/null +++ b/Source/WebCore/html/MediaElementSession.cpp @@ -0,0 +1,783 @@ +/* + * Copyright (C) 2014 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#if ENABLE(VIDEO) + +#include "MediaElementSession.h" + +#include "Document.h" +#include "Frame.h" +#include "FrameView.h" +#include "HTMLAudioElement.h" +#include "HTMLMediaElement.h" +#include "HTMLNames.h" +#include "HTMLVideoElement.h" +#include "HitTestResult.h" +#include "Logging.h" +#include "MainFrame.h" +#include "Page.h" +#include "PlatformMediaSessionManager.h" +#include "RenderMedia.h" +#include "RenderView.h" +#include "ScriptController.h" +#include "Settings.h" +#include "SourceBuffer.h" +#include <wtf/CurrentTime.h> +#include <wtf/text/StringBuilder.h> + +#if PLATFORM(IOS) +#include "AudioSession.h" +#include "RuntimeApplicationChecks.h" +#include <wtf/spi/darwin/dyldSPI.h> +#endif + +namespace WebCore { + +static const double elementMainContentCheckInterval = .250; + +static bool isElementRectMostlyInMainFrame(const HTMLMediaElement&); +static bool isElementLargeEnoughForMainContent(const HTMLMediaElement&, MediaSessionMainContentPurpose); + +#if !LOG_DISABLED +static String restrictionName(MediaElementSession::BehaviorRestrictions restriction) +{ + StringBuilder restrictionBuilder; +#define CASE(restrictionType) \ + if (restriction & MediaElementSession::restrictionType) { \ + if (!restrictionBuilder.isEmpty()) \ + restrictionBuilder.appendLiteral(", "); \ + restrictionBuilder.append(#restrictionType); \ + } \ + + CASE(NoRestrictions); + CASE(RequireUserGestureForLoad); + CASE(RequireUserGestureForVideoRateChange); + CASE(RequireUserGestureForAudioRateChange); + CASE(RequireUserGestureForFullscreen); + CASE(RequirePageConsentToLoadMedia); + CASE(RequirePageConsentToResumeMedia); +#if ENABLE(WIRELESS_PLAYBACK_TARGET) + CASE(RequireUserGestureToShowPlaybackTargetPicker); + CASE(WirelessVideoPlaybackDisabled); +#endif + CASE(InvisibleAutoplayNotPermitted); + CASE(OverrideUserGestureRequirementForMainContent); + + return restrictionBuilder.toString(); +} +#endif + +static bool pageExplicitlyAllowsElementToAutoplayInline(const HTMLMediaElement& element) +{ + Document& document = element.document(); + Page* page = document.page(); + return document.isMediaDocument() && !document.ownerElement() && page && page->allowsMediaDocumentInlinePlayback(); +} + +MediaElementSession::MediaElementSession(HTMLMediaElement& element) + : PlatformMediaSession(element) + , m_element(element) + , m_restrictions(NoRestrictions) +#if ENABLE(WIRELESS_PLAYBACK_TARGET) + , m_targetAvailabilityChangedTimer(*this, &MediaElementSession::targetAvailabilityChangedTimerFired) +#endif + , m_mainContentCheckTimer(*this, &MediaElementSession::mainContentCheckTimerFired) +{ +} + +void MediaElementSession::registerWithDocument(Document& document) +{ +#if ENABLE(WIRELESS_PLAYBACK_TARGET) + document.addPlaybackTargetPickerClient(*this); +#else + UNUSED_PARAM(document); +#endif +} + +void MediaElementSession::unregisterWithDocument(Document& document) +{ +#if ENABLE(WIRELESS_PLAYBACK_TARGET) + document.removePlaybackTargetPickerClient(*this); +#else + UNUSED_PARAM(document); +#endif +} + +void MediaElementSession::addBehaviorRestriction(BehaviorRestrictions restriction) +{ + LOG(Media, "MediaElementSession::addBehaviorRestriction - adding %s", restrictionName(restriction).utf8().data()); + m_restrictions |= restriction; + + if (restriction & OverrideUserGestureRequirementForMainContent) + m_mainContentCheckTimer.startRepeating(elementMainContentCheckInterval); +} + +void MediaElementSession::removeBehaviorRestriction(BehaviorRestrictions restriction) +{ + if (restriction & RequireUserGestureToControlControlsManager) { + m_mostRecentUserInteractionTime = monotonicallyIncreasingTime(); + if (auto page = m_element.document().page()) + page->setAllowsPlaybackControlsForAutoplayingAudio(true); + } + + LOG(Media, "MediaElementSession::removeBehaviorRestriction - removing %s", restrictionName(restriction).utf8().data()); + m_restrictions &= ~restriction; +} + +SuccessOr<MediaPlaybackDenialReason> MediaElementSession::playbackPermitted(const HTMLMediaElement& element) const +{ + if (element.document().isMediaDocument() && !element.document().ownerElement()) + return SuccessOr<MediaPlaybackDenialReason>(); + + if (pageExplicitlyAllowsElementToAutoplayInline(element)) + return SuccessOr<MediaPlaybackDenialReason>(); + + if (requiresFullscreenForVideoPlayback(element) && !fullscreenPermitted(element)) { + LOG(Media, "MediaElementSession::playbackPermitted - returning FALSE because of fullscreen restriction"); + return MediaPlaybackDenialReason::FullscreenRequired; + } + + if (m_restrictions & OverrideUserGestureRequirementForMainContent && updateIsMainContent()) + return SuccessOr<MediaPlaybackDenialReason>(); + + if (m_restrictions & RequireUserGestureForVideoRateChange && element.isVideo() && !ScriptController::processingUserGestureForMedia()) { + LOG(Media, "MediaElementSession::playbackPermitted - returning FALSE because of video rate change restriction"); + return MediaPlaybackDenialReason::UserGestureRequired; + } + + if (m_restrictions & RequireUserGestureForAudioRateChange && (!element.isVideo() || element.hasAudio()) && !element.muted() && !ScriptController::processingUserGestureForMedia()) { + LOG(Media, "MediaElementSession::playbackPermitted - returning FALSE because of audio rate change restriction"); + return MediaPlaybackDenialReason::UserGestureRequired; + } + + return SuccessOr<MediaPlaybackDenialReason>(); +} + +bool MediaElementSession::autoplayPermitted() const +{ + const Document& document = m_element.document(); + if (document.pageCacheState() != Document::NotInPageCache) + return false; + if (document.activeDOMObjectsAreSuspended()) + return false; + + if (!hasBehaviorRestriction(MediaElementSession::InvisibleAutoplayNotPermitted)) + return true; + + auto* renderer = m_element.renderer(); + if (!renderer) + return false; + if (renderer->style().visibility() != VISIBLE) + return false; + if (renderer->view().frameView().isOffscreen()) + return false; + if (renderer->visibleInViewportState() != RenderElement::VisibleInViewport) + return false; + return true; +} + +bool MediaElementSession::dataLoadingPermitted(const HTMLMediaElement&) const +{ + if (m_restrictions & OverrideUserGestureRequirementForMainContent && updateIsMainContent()) + return true; + + if (m_restrictions & RequireUserGestureForLoad && !ScriptController::processingUserGestureForMedia()) { + LOG(Media, "MediaElementSession::dataLoadingPermitted - returning FALSE"); + return false; + } + + return true; +} + +bool MediaElementSession::fullscreenPermitted(const HTMLMediaElement&) const +{ + if (m_restrictions & RequireUserGestureForFullscreen && !ScriptController::processingUserGestureForMedia()) { + LOG(Media, "MediaElementSession::fullscreenPermitted - returning FALSE"); + return false; + } + + return true; +} + +bool MediaElementSession::pageAllowsDataLoading(const HTMLMediaElement& element) const +{ + Page* page = element.document().page(); + if (m_restrictions & RequirePageConsentToLoadMedia && page && !page->canStartMedia()) { + LOG(Media, "MediaElementSession::pageAllowsDataLoading - returning FALSE"); + return false; + } + + return true; +} + +bool MediaElementSession::pageAllowsPlaybackAfterResuming(const HTMLMediaElement& element) const +{ + Page* page = element.document().page(); + if (m_restrictions & RequirePageConsentToResumeMedia && page && !page->canStartMedia()) { + LOG(Media, "MediaElementSession::pageAllowsPlaybackAfterResuming - returning FALSE"); + return false; + } + + return true; +} + +bool MediaElementSession::canShowControlsManager(PlaybackControlsPurpose purpose) const +{ + if (m_element.isFullscreen()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Is fullscreen"); + return true; + } + + if (m_element.muted()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Muted"); + return false; + } + + if (m_element.document().isMediaDocument()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Is media document"); + return true; + } + + if (client().presentationType() == Audio) { + if (!hasBehaviorRestriction(RequireUserGestureToControlControlsManager) || ScriptController::processingUserGestureForMedia()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Audio element with user gesture"); + return true; + } + + if (m_element.isPlaying() && allowsPlaybackControlsForAutoplayingAudio()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: User has played media before"); + return true; + } + + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Audio element is not suitable"); + return false; + } + + if (purpose == PlaybackControlsPurpose::ControlsManager && !isElementRectMostlyInMainFrame(m_element)) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Not in main frame"); + return false; + } + + if (!m_element.hasAudio() && !m_element.hasEverHadAudio()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: No audio"); + return false; + } + + if (m_element.document().activeDOMObjectsAreSuspended()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: activeDOMObjectsAreSuspended()"); + return false; + } + + if (!playbackPermitted(m_element)) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Playback not permitted"); + return false; + } + + if (!hasBehaviorRestriction(RequireUserGestureToControlControlsManager) || ScriptController::processingUserGestureForMedia()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: No user gesture required"); + return true; + } + + if (purpose == PlaybackControlsPurpose::ControlsManager && hasBehaviorRestriction(RequirePlaybackToControlControlsManager) && !m_element.isPlaying()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Needs to be playing"); + return false; + } + + if (!m_element.hasEverNotifiedAboutPlaying()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: Hasn't fired playing notification"); + return false; + } + + // Only allow the main content heuristic to forbid videos from showing up if our purpose is the controls manager. + if (purpose == PlaybackControlsPurpose::ControlsManager && m_element.isVideo()) { + if (!m_element.renderer()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: No renderer"); + return false; + } + + if (!m_element.hasVideo() && !m_element.hasEverHadVideo()) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: No video"); + return false; + } + + if (isLargeEnoughForMainContent(MediaSessionMainContentPurpose::MediaControls)) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Is main content"); + return true; + } + } + + if (purpose == PlaybackControlsPurpose::NowPlaying) { + LOG(Media, "MediaElementSession::canShowControlsManager - returning TRUE: Potentially plays audio"); + return true; + } + + LOG(Media, "MediaElementSession::canShowControlsManager - returning FALSE: No user gesture"); + return false; +} + +bool MediaElementSession::isLargeEnoughForMainContent(MediaSessionMainContentPurpose purpose) const +{ + return isElementLargeEnoughForMainContent(m_element, purpose); +} + +double MediaElementSession::mostRecentUserInteractionTime() const +{ + return m_mostRecentUserInteractionTime; +} + +bool MediaElementSession::wantsToObserveViewportVisibilityForMediaControls() const +{ + return isLargeEnoughForMainContent(MediaSessionMainContentPurpose::MediaControls); +} + +bool MediaElementSession::wantsToObserveViewportVisibilityForAutoplay() const +{ + return hasBehaviorRestriction(InvisibleAutoplayNotPermitted) || hasBehaviorRestriction(OverrideUserGestureRequirementForMainContent); +} + +#if ENABLE(WIRELESS_PLAYBACK_TARGET) +void MediaElementSession::showPlaybackTargetPicker(const HTMLMediaElement& element) +{ + LOG(Media, "MediaElementSession::showPlaybackTargetPicker"); + + if (m_restrictions & RequireUserGestureToShowPlaybackTargetPicker && !ScriptController::processingUserGestureForMedia()) { + LOG(Media, "MediaElementSession::showPlaybackTargetPicker - returning early because of permissions"); + return; + } + + if (!element.document().page()) { + LOG(Media, "MediaElementSession::showingPlaybackTargetPickerPermitted - returning early because page is NULL"); + return; + } + +#if !PLATFORM(IOS) + if (element.readyState() < HTMLMediaElementEnums::HAVE_METADATA) { + LOG(Media, "MediaElementSession::showPlaybackTargetPicker - returning early because element is not playable"); + return; + } +#endif + + element.document().showPlaybackTargetPicker(*this, is<HTMLVideoElement>(element)); +} + +bool MediaElementSession::hasWirelessPlaybackTargets(const HTMLMediaElement&) const +{ +#if PLATFORM(IOS) + // FIXME: consolidate Mac and iOS implementations + m_hasPlaybackTargets = PlatformMediaSessionManager::sharedManager().hasWirelessTargetsAvailable(); +#endif + + LOG(Media, "MediaElementSession::hasWirelessPlaybackTargets - returning %s", m_hasPlaybackTargets ? "TRUE" : "FALSE"); + + return m_hasPlaybackTargets; +} + +bool MediaElementSession::wirelessVideoPlaybackDisabled(const HTMLMediaElement& element) const +{ + if (!element.document().settings().allowsAirPlayForMediaPlayback()) { + LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of settings"); + return true; + } + + if (element.hasAttributeWithoutSynchronization(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) { + LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of attribute"); + return true; + } + +#if PLATFORM(IOS) + String legacyAirplayAttributeValue = element.attributeWithoutSynchronization(HTMLNames::webkitairplayAttr); + if (equalLettersIgnoringASCIICase(legacyAirplayAttributeValue, "deny")) { + LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of legacy attribute"); + return true; + } + if (equalLettersIgnoringASCIICase(legacyAirplayAttributeValue, "allow")) { + LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning FALSE because of legacy attribute"); + return false; + } +#endif + + MediaPlayer* player = element.player(); + if (!player) + return true; + + bool disabled = player->wirelessVideoPlaybackDisabled(); + LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning %s because media engine says so", disabled ? "TRUE" : "FALSE"); + + return disabled; +} + +void MediaElementSession::setWirelessVideoPlaybackDisabled(const HTMLMediaElement& element, bool disabled) +{ + if (disabled) + addBehaviorRestriction(WirelessVideoPlaybackDisabled); + else + removeBehaviorRestriction(WirelessVideoPlaybackDisabled); + + MediaPlayer* player = element.player(); + if (!player) + return; + + LOG(Media, "MediaElementSession::setWirelessVideoPlaybackDisabled - disabled %s", disabled ? "TRUE" : "FALSE"); + player->setWirelessVideoPlaybackDisabled(disabled); +} + +void MediaElementSession::setHasPlaybackTargetAvailabilityListeners(const HTMLMediaElement& element, bool hasListeners) +{ + LOG(Media, "MediaElementSession::setHasPlaybackTargetAvailabilityListeners - hasListeners %s", hasListeners ? "TRUE" : "FALSE"); + +#if PLATFORM(IOS) + UNUSED_PARAM(element); + m_hasPlaybackTargetAvailabilityListeners = hasListeners; + PlatformMediaSessionManager::sharedManager().configureWireLessTargetMonitoring(); +#else + UNUSED_PARAM(hasListeners); + element.document().playbackTargetPickerClientStateDidChange(*this, element.mediaState()); +#endif +} + +void MediaElementSession::setPlaybackTarget(Ref<MediaPlaybackTarget>&& device) +{ + m_playbackTarget = WTFMove(device); + client().setWirelessPlaybackTarget(*m_playbackTarget.copyRef()); +} + +void MediaElementSession::targetAvailabilityChangedTimerFired() +{ + client().wirelessRoutesAvailableDidChange(); +} + +void MediaElementSession::externalOutputDeviceAvailableDidChange(bool hasTargets) +{ + if (m_hasPlaybackTargets == hasTargets) + return; + + LOG(Media, "MediaElementSession::externalOutputDeviceAvailableDidChange(%p) - hasTargets %s", this, hasTargets ? "TRUE" : "FALSE"); + + m_hasPlaybackTargets = hasTargets; + m_targetAvailabilityChangedTimer.startOneShot(0); +} + +bool MediaElementSession::canPlayToWirelessPlaybackTarget() const +{ +#if !PLATFORM(IOS) + if (!m_playbackTarget || !m_playbackTarget->hasActiveRoute()) + return false; +#endif + + return client().canPlayToWirelessPlaybackTarget(); +} + +bool MediaElementSession::isPlayingToWirelessPlaybackTarget() const +{ +#if !PLATFORM(IOS) + if (!m_playbackTarget || !m_playbackTarget->hasActiveRoute()) + return false; +#endif + + return client().isPlayingToWirelessPlaybackTarget(); +} + +void MediaElementSession::setShouldPlayToPlaybackTarget(bool shouldPlay) +{ + LOG(Media, "MediaElementSession::setShouldPlayToPlaybackTarget - shouldPlay %s", shouldPlay ? "TRUE" : "FALSE"); + m_shouldPlayToPlaybackTarget = shouldPlay; + client().setShouldPlayToPlaybackTarget(shouldPlay); +} + +void MediaElementSession::mediaStateDidChange(const HTMLMediaElement& element, MediaProducer::MediaStateFlags state) +{ + element.document().playbackTargetPickerClientStateDidChange(*this, state); +} +#endif + +MediaPlayer::Preload MediaElementSession::effectivePreloadForElement(const HTMLMediaElement& element) const +{ + MediaPlayer::Preload preload = element.preloadValue(); + + if (pageExplicitlyAllowsElementToAutoplayInline(element)) + return preload; + + if (m_restrictions & MetadataPreloadingNotPermitted) + return MediaPlayer::None; + + if (m_restrictions & AutoPreloadingNotPermitted) { + if (preload > MediaPlayer::MetaData) + return MediaPlayer::MetaData; + } + + return preload; +} + +bool MediaElementSession::requiresFullscreenForVideoPlayback(const HTMLMediaElement& element) const +{ + if (pageExplicitlyAllowsElementToAutoplayInline(element)) + return false; + + if (is<HTMLAudioElement>(element)) + return false; + + if (element.isTemporarilyAllowingInlinePlaybackAfterFullscreen()) + return false; + + if (!element.document().settings().allowsInlineMediaPlayback()) + return true; + + if (!element.document().settings().inlineMediaPlaybackRequiresPlaysInlineAttribute()) + return false; + +#if PLATFORM(IOS) + if (IOSApplication::isIBooks()) + return !element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr) && !element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr); + if (dyld_get_program_sdk_version() < DYLD_IOS_VERSION_10_0) + return !element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr); +#endif + return !element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr); +} + +bool MediaElementSession::allowsAutomaticMediaDataLoading(const HTMLMediaElement& element) const +{ + if (pageExplicitlyAllowsElementToAutoplayInline(element)) + return true; + + if (element.document().settings().mediaDataLoadsAutomatically()) + return true; + + return false; +} + +void MediaElementSession::mediaEngineUpdated(const HTMLMediaElement& element) +{ + LOG(Media, "MediaElementSession::mediaEngineUpdated"); + +#if ENABLE(WIRELESS_PLAYBACK_TARGET) + if (m_restrictions & WirelessVideoPlaybackDisabled) + setWirelessVideoPlaybackDisabled(element, true); + if (m_playbackTarget) + client().setWirelessPlaybackTarget(*m_playbackTarget.copyRef()); + if (m_shouldPlayToPlaybackTarget) + client().setShouldPlayToPlaybackTarget(true); +#else + UNUSED_PARAM(element); +#endif + +} + +void MediaElementSession::resetPlaybackSessionState() +{ + m_mostRecentUserInteractionTime = 0; + addBehaviorRestriction(RequireUserGestureToControlControlsManager | RequirePlaybackToControlControlsManager); +} + +bool MediaElementSession::allowsPictureInPicture(const HTMLMediaElement& element) const +{ + return element.document().settings().allowsPictureInPictureMediaPlayback() && !element.webkitCurrentPlaybackTargetIsWireless(); +} + +#if PLATFORM(IOS) +bool MediaElementSession::requiresPlaybackTargetRouteMonitoring() const +{ + return m_hasPlaybackTargetAvailabilityListeners && !client().elementIsHidden(); +} +#endif + +#if ENABLE(MEDIA_SOURCE) +size_t MediaElementSession::maximumMediaSourceBufferSize(const SourceBuffer& buffer) const +{ + // A good quality 1080p video uses 8,000 kbps and stereo audio uses 384 kbps, so assume 95% for video and 5% for audio. + const float bufferBudgetPercentageForVideo = .95; + const float bufferBudgetPercentageForAudio = .05; + + size_t maximum = buffer.document().settings().maximumSourceBufferSize(); + + // Allow a SourceBuffer to buffer as though it is audio-only even if it doesn't have any active tracks (yet). + size_t bufferSize = static_cast<size_t>(maximum * bufferBudgetPercentageForAudio); + if (buffer.hasVideo()) + bufferSize += static_cast<size_t>(maximum * bufferBudgetPercentageForVideo); + + // FIXME: we might want to modify this algorithm to: + // - decrease the maximum size for background tabs + // - decrease the maximum size allowed for inactive elements when a process has more than one + // element, eg. so a page with many elements which are played one at a time doesn't keep + // everything buffered after an element has finished playing. + + return bufferSize; +} +#endif + +static bool isMainContentForPurposesOfAutoplay(const HTMLMediaElement& element) +{ + if (!element.hasAudio() || !element.hasVideo()) + return false; + + // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content. + auto* renderer = element.renderer(); + if (!renderer) + return false; + + if (!isElementLargeEnoughForMainContent(element, MediaSessionMainContentPurpose::Autoplay)) + return false; + + // Elements which are hidden by style, or have been scrolled out of view, cannot be main content. + // But elements which have audio & video and are already playing should not stop playing because + // they are scrolled off the page. + if (renderer->style().visibility() != VISIBLE) + return false; + if (renderer->visibleInViewportState() != RenderElement::VisibleInViewport && !element.isPlaying()) + return false; + + // Main content elements must be in the main frame. + Document& document = element.document(); + if (!document.frame() || !document.frame()->isMainFrame()) + return false; + + MainFrame& mainFrame = document.frame()->mainFrame(); + if (!mainFrame.view() || !mainFrame.view()->renderView()) + return false; + + RenderView& mainRenderView = *mainFrame.view()->renderView(); + + // Hit test the area of the main frame where the element appears, to determine if the element is being obscured. + IntRect rectRelativeToView = element.clientRect(); + ScrollPosition scrollPosition = mainFrame.view()->documentScrollPositionRelativeToViewOrigin(); + IntRect rectRelativeToTopDocument(rectRelativeToView.location() + scrollPosition, rectRelativeToView.size()); + HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::AllowChildFrameContent | HitTestRequest::IgnoreClipping | HitTestRequest::DisallowUserAgentShadowContent); + HitTestResult result(rectRelativeToTopDocument.center()); + + // Elements which are obscured by other elements cannot be main content. + mainRenderView.hitTest(request, result); + result.setToNonUserAgentShadowAncestor(); + Element* hitElement = result.targetElement(); + if (hitElement != &element) + return false; + + return true; +} + +static bool isElementRectMostlyInMainFrame(const HTMLMediaElement& element) +{ + if (!element.renderer()) + return false; + + auto* documentFrame = element.document().frame(); + if (!documentFrame) + return false; + + auto mainFrameView = documentFrame->mainFrame().view(); + if (!mainFrameView) + return false; + + IntRect mainFrameRectAdjustedForScrollPosition = IntRect(-mainFrameView->documentScrollPositionRelativeToViewOrigin(), mainFrameView->contentsSize()); + IntRect elementRectInMainFrame = element.clientRect(); + auto totalElementArea = elementRectInMainFrame.area<RecordOverflow>(); + if (totalElementArea.hasOverflowed()) + return false; + + elementRectInMainFrame.intersect(mainFrameRectAdjustedForScrollPosition); + + return elementRectInMainFrame.area().unsafeGet() > totalElementArea.unsafeGet() / 2; +} + +static bool isElementLargeRelativeToMainFrame(const HTMLMediaElement& element) +{ + static const double minimumPercentageOfMainFrameAreaForMainContent = 0.9; + auto* renderer = element.renderer(); + if (!renderer) + return false; + + auto* documentFrame = element.document().frame(); + if (!documentFrame) + return false; + + if (!documentFrame->mainFrame().view()) + return false; + + auto& mainFrameView = *documentFrame->mainFrame().view(); + auto maxVisibleClientWidth = std::min(renderer->clientWidth().toInt(), mainFrameView.visibleWidth()); + auto maxVisibleClientHeight = std::min(renderer->clientHeight().toInt(), mainFrameView.visibleHeight()); + + return maxVisibleClientWidth * maxVisibleClientHeight > minimumPercentageOfMainFrameAreaForMainContent * mainFrameView.visibleWidth() * mainFrameView.visibleHeight(); +} + +static bool isElementLargeEnoughForMainContent(const HTMLMediaElement& element, MediaSessionMainContentPurpose purpose) +{ + static const double elementMainContentAreaMinimum = 400 * 300; + static const double maximumAspectRatio = purpose == MediaSessionMainContentPurpose::MediaControls ? 3 : 1.8; + static const double minimumAspectRatio = .5; // Slightly smaller than 9:16. + + // Elements which have not yet been laid out, or which are not yet in the DOM, cannot be main content. + auto* renderer = element.renderer(); + if (!renderer) + return false; + + double width = renderer->clientWidth(); + double height = renderer->clientHeight(); + double area = width * height; + double aspectRatio = width / height; + + if (area < elementMainContentAreaMinimum) + return false; + + if (aspectRatio >= minimumAspectRatio && aspectRatio <= maximumAspectRatio) + return true; + + return isElementLargeRelativeToMainFrame(element); +} + +void MediaElementSession::mainContentCheckTimerFired() +{ + if (!hasBehaviorRestriction(OverrideUserGestureRequirementForMainContent)) + return; + + updateIsMainContent(); +} + +bool MediaElementSession::updateIsMainContent() const +{ + bool wasMainContent = m_isMainContent; + m_isMainContent = isMainContentForPurposesOfAutoplay(m_element); + + if (m_isMainContent != wasMainContent) + m_element.updateShouldPlay(); + + return m_isMainContent; +} + +bool MediaElementSession::allowsNowPlayingControlsVisibility() const +{ + auto page = m_element.document().page(); + return page && !page->isVisibleAndActive(); +} + +bool MediaElementSession::allowsPlaybackControlsForAutoplayingAudio() const +{ + auto page = m_element.document().page(); + return page && page->allowsPlaybackControlsForAutoplayingAudio(); +} + +} + +#endif // ENABLE(VIDEO) |