f35654e4bee32dceb7ef05dde148bbc691af9152
[WebKit-https.git] / Source / WebCore / html / HTMLMediaSession.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 "HTMLMediaSession.h"
31
32 #include "Chrome.h"
33 #include "ChromeClient.h"
34 #include "Frame.h"
35 #include "HTMLMediaElement.h"
36 #include "HTMLNames.h"
37 #include "Logging.h"
38 #include "MediaSessionManager.h"
39 #include "Page.h"
40 #include "ScriptController.h"
41 #include "SourceBuffer.h"
42
43 #if PLATFORM(IOS)
44 #include "AudioSession.h"
45 #include "RuntimeApplicationChecksIOS.h"
46 #endif
47
48 namespace WebCore {
49
50 #if !LOG_DISABLED
51 static const char* restrictionName(HTMLMediaSession::BehaviorRestrictions restriction)
52 {
53 #define CASE(restriction) case HTMLMediaSession::restriction: return #restriction
54     switch (restriction) {
55     CASE(NoRestrictions);
56     CASE(RequireUserGestureForLoad);
57     CASE(RequireUserGestureForRateChange);
58     CASE(RequireUserGestureForFullscreen);
59     CASE(RequirePageConsentToLoadMedia);
60     CASE(RequirePageConsentToResumeMedia);
61 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
62     CASE(RequireUserGestureToShowPlaybackTargetPicker);
63     CASE(WirelessVideoPlaybackDisabled);
64 #endif
65     }
66
67     ASSERT_NOT_REACHED();
68     return "";
69 }
70 #endif
71
72 HTMLMediaSession::HTMLMediaSession(MediaSessionClient& client)
73     : MediaSession(client)
74     , m_restrictions(NoRestrictions)
75     , m_hasPlaybackTargetAvailabilityListeners(false)
76 {
77 }
78
79 void HTMLMediaSession::addBehaviorRestriction(BehaviorRestrictions restriction)
80 {
81     LOG(Media, "HTMLMediaSession::addBehaviorRestriction - adding %s", restrictionName(restriction));
82     m_restrictions |= restriction;
83 }
84
85 void HTMLMediaSession::removeBehaviorRestriction(BehaviorRestrictions restriction)
86 {
87     LOG(Media, "HTMLMediaSession::removeBehaviorRestriction - removing %s", restrictionName(restriction));
88     m_restrictions &= ~restriction;
89 }
90
91 bool HTMLMediaSession::playbackPermitted(const HTMLMediaElement&) const
92 {
93     if (m_restrictions & RequireUserGestureForRateChange && !ScriptController::processingUserGesture()) {
94         LOG(Media, "HTMLMediaSession::playbackPermitted - returning FALSE");
95         return false;
96     }
97
98     return true;
99 }
100
101 bool HTMLMediaSession::dataLoadingPermitted(const HTMLMediaElement&) const
102 {
103     if (m_restrictions & RequireUserGestureForLoad && !ScriptController::processingUserGesture()) {
104         LOG(Media, "HTMLMediaSession::dataLoadingPermitted - returning FALSE");
105         return false;
106     }
107
108     return true;
109 }
110
111 bool HTMLMediaSession::fullscreenPermitted(const HTMLMediaElement&) const
112 {
113     if (m_restrictions & RequireUserGestureForFullscreen && !ScriptController::processingUserGesture()) {
114         LOG(Media, "HTMLMediaSession::fullscreenPermitted - returning FALSE");
115         return false;
116     }
117
118     return true;
119 }
120
121 bool HTMLMediaSession::pageAllowsDataLoading(const HTMLMediaElement& element) const
122 {
123     Page* page = element.document().page();
124     if (m_restrictions & RequirePageConsentToLoadMedia && page && !page->canStartMedia()) {
125         LOG(Media, "HTMLMediaSession::pageAllowsDataLoading - returning FALSE");
126         return false;
127     }
128
129     return true;
130 }
131
132 bool HTMLMediaSession::pageAllowsPlaybackAfterResuming(const HTMLMediaElement& element) const
133 {
134     Page* page = element.document().page();
135     if (m_restrictions & RequirePageConsentToResumeMedia && page && !page->canStartMedia()) {
136         LOG(Media, "HTMLMediaSession::pageAllowsPlaybackAfterResuming - returning FALSE");
137         return false;
138     }
139
140     return true;
141 }
142
143 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
144 bool HTMLMediaSession::showingPlaybackTargetPickerPermitted(const HTMLMediaElement& element) const
145 {
146     if (m_restrictions & RequireUserGestureToShowPlaybackTargetPicker && !ScriptController::processingUserGesture()) {
147         LOG(Media, "HTMLMediaSession::showingPlaybackTargetPickerPermitted - returning FALSE because of permissions");
148         return false;
149     }
150
151     if (!element.document().page()) {
152         LOG(Media, "HTMLMediaSession::showingPlaybackTargetPickerPermitted - returning FALSE because page is NULL");
153         return false;
154     }
155
156     return !wirelessVideoPlaybackDisabled(element);
157 }
158
159 bool HTMLMediaSession::currentPlaybackTargetIsWireless(const HTMLMediaElement& element) const
160 {
161     MediaPlayer* player = element.player();
162     if (!player) {
163         LOG(Media, "HTMLMediaSession::currentPlaybackTargetIsWireless - returning FALSE because player is NULL");
164         return false;
165     }
166
167     bool isWireless = player->isCurrentPlaybackTargetWireless();
168     LOG(Media, "HTMLMediaSession::currentPlaybackTargetIsWireless - returning %s", isWireless ? "TRUE" : "FALSE");
169
170     return isWireless;
171 }
172
173 void HTMLMediaSession::showPlaybackTargetPicker(const HTMLMediaElement& element)
174 {
175     LOG(Media, "HTMLMediaSession::showPlaybackTargetPicker");
176
177     if (!showingPlaybackTargetPickerPermitted(element))
178         return;
179
180 #if PLATFORM(IOS)
181     element.document().frame()->page()->chrome().client().showPlaybackTargetPicker(element.hasVideo());
182 #endif
183 }
184
185 bool HTMLMediaSession::hasWirelessPlaybackTargets(const HTMLMediaElement& element) const
186 {
187     UNUSED_PARAM(element);
188
189     bool hasTargets = MediaSessionManager::sharedManager().hasWirelessTargetsAvailable();
190     LOG(Media, "HTMLMediaSession::hasWirelessPlaybackTargets - returning %s", hasTargets ? "TRUE" : "FALSE");
191
192     return hasTargets;
193 }
194
195 bool HTMLMediaSession::wirelessVideoPlaybackDisabled(const HTMLMediaElement& element) const
196 {
197     Settings* settings = element.document().settings();
198     if (!settings || !settings->mediaPlaybackAllowsAirPlay()) {
199         LOG(Media, "HTMLMediaSession::wirelessVideoPlaybackDisabled - returning TRUE because of settings");
200         return true;
201     }
202
203     if (element.fastHasAttribute(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) {
204         LOG(Media, "HTMLMediaSession::wirelessVideoPlaybackDisabled - returning TRUE because of attribute");
205         return true;
206     }
207
208 #if PLATFORM(IOS)
209     String legacyAirplayAttributeValue = element.fastGetAttribute(HTMLNames::webkitairplayAttr);
210     if (equalIgnoringCase(legacyAirplayAttributeValue, "deny")) {
211         LOG(Media, "HTMLMediaSession::wirelessVideoPlaybackDisabled - returning TRUE because of legacy attribute");
212         return true;
213     }
214 #endif
215
216     MediaPlayer* player = element.player();
217     if (!player)
218         return false;
219
220     bool disabled = player->wirelessVideoPlaybackDisabled();
221     LOG(Media, "HTMLMediaSession::wirelessVideoPlaybackDisabled - returning %s because media engine says so", disabled ? "TRUE" : "FALSE");
222     
223     return disabled;
224 }
225
226 void HTMLMediaSession::setWirelessVideoPlaybackDisabled(const HTMLMediaElement& element, bool disabled)
227 {
228     if (disabled)
229         addBehaviorRestriction(WirelessVideoPlaybackDisabled);
230     else
231         removeBehaviorRestriction(WirelessVideoPlaybackDisabled);
232
233     MediaPlayer* player = element.player();
234     if (!player)
235         return;
236
237     LOG(Media, "HTMLMediaSession::setWirelessVideoPlaybackDisabled - disabled %s", disabled ? "TRUE" : "FALSE");
238     player->setWirelessVideoPlaybackDisabled(disabled);
239 }
240
241 void HTMLMediaSession::setHasPlaybackTargetAvailabilityListeners(const HTMLMediaElement& element, bool hasListeners)
242 {
243     LOG(Media, "HTMLMediaSession::setHasPlaybackTargetAvailabilityListeners - hasListeners %s", hasListeners ? "TRUE" : "FALSE");
244     UNUSED_PARAM(element);
245
246     m_hasPlaybackTargetAvailabilityListeners = hasListeners;
247     MediaSessionManager::sharedManager().configureWireLessTargetMonitoring();
248 }
249 #endif
250
251 MediaPlayer::Preload HTMLMediaSession::effectivePreloadForElement(const HTMLMediaElement& element) const
252 {
253     MediaSessionManager::SessionRestrictions restrictions = MediaSessionManager::sharedManager().restrictions(mediaType());
254     MediaPlayer::Preload preload = element.preloadValue();
255
256     if ((restrictions & MediaSessionManager::MetadataPreloadingNotPermitted) == MediaSessionManager::MetadataPreloadingNotPermitted)
257         return MediaPlayer::None;
258
259     if ((restrictions & MediaSessionManager::AutoPreloadingNotPermitted) == MediaSessionManager::AutoPreloadingNotPermitted) {
260         if (preload > MediaPlayer::MetaData)
261             return MediaPlayer::MetaData;
262     }
263
264     return preload;
265 }
266
267 bool HTMLMediaSession::requiresFullscreenForVideoPlayback(const HTMLMediaElement& element) const
268 {
269     if (!MediaSessionManager::sharedManager().sessionRestrictsInlineVideoPlayback(*this))
270         return false;
271
272     Settings* settings = element.document().settings();
273     if (!settings || !settings->mediaPlaybackAllowsInline())
274         return true;
275
276     if (element.fastHasAttribute(HTMLNames::webkit_playsinlineAttr))
277         return false;
278
279 #if PLATFORM(IOS)
280     if (applicationIsDumpRenderTree())
281         return false;
282 #endif
283
284     return true;
285 }
286
287 void HTMLMediaSession::applyMediaPlayerRestrictions(const HTMLMediaElement& element)
288 {
289     LOG(Media, "HTMLMediaSession::applyMediaPlayerRestrictions");
290
291 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
292     setWirelessVideoPlaybackDisabled(element, m_restrictions & WirelessVideoPlaybackDisabled);
293 #else
294     UNUSED_PARAM(element);
295 #endif
296     
297 }
298
299 bool HTMLMediaSession::allowsAlternateFullscreen(const HTMLMediaElement& element) const
300 {
301     Settings* settings = element.document().settings();
302     return settings && settings->allowsAlternateFullscreen();
303 }
304
305 #if ENABLE(MEDIA_SOURCE)
306 const unsigned fiveMinutesOf1080PVideo = 290 * 1024 * 1024; // 290 MB is approximately 5 minutes of 8Mbps (1080p) content.
307 const unsigned fiveMinutesStereoAudio = 14 * 1024 * 1024; // 14 MB is approximately 5 minutes of 384kbps content.
308
309 size_t HTMLMediaSession::maximumMediaSourceBufferSize(const SourceBuffer& buffer) const
310 {
311     // A good quality 1080p video uses 8,000 kbps and stereo audio uses 384 kbps, so assume 95% for video and 5% for audio.
312     const float bufferBudgetPercentageForVideo = .95;
313     const float bufferBudgetPercentageForAudio = .05;
314
315     size_t maximum;
316     Settings* settings = buffer.document().settings();
317     if (settings)
318         maximum = settings->maximumSourceBufferSize();
319     else
320         maximum = fiveMinutesOf1080PVideo + fiveMinutesStereoAudio;
321
322     // Allow a SourceBuffer to buffer as though it is audio-only even if it doesn't have any active tracks (yet).
323     size_t bufferSize = static_cast<size_t>(maximum * bufferBudgetPercentageForAudio);
324     if (buffer.hasVideo())
325         bufferSize += static_cast<size_t>(maximum * bufferBudgetPercentageForVideo);
326
327     // FIXME: we might want to modify this algorithm to:
328     // - decrease the maximum size for background tabs
329     // - decrease the maximum size allowed for inactive elements when a process has more than one
330     //   element, eg. so a page with many elements which are played one at a time doesn't keep
331     //   everything buffered after an element has finished playing.
332
333     return bufferSize;
334 }
335 #endif
336
337 }
338
339 #endif // ENABLE(VIDEO)