Next batch of conversions to use C++ enum class instead of strings for enumerations
[WebKit-https.git] / Source / WebCore / html / HTMLVideoElement.cpp
1 /*
2  * Copyright (C) 2007, 2008, 2009, 2010 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. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #if ENABLE(VIDEO)
28 #include "HTMLVideoElement.h"
29
30 #include "CSSPropertyNames.h"
31 #include "Chrome.h"
32 #include "ChromeClient.h"
33 #include "Document.h"
34 #include "Frame.h"
35 #include "HTMLImageLoader.h"
36 #include "HTMLNames.h"
37 #include "HTMLParserIdioms.h"
38 #include "Logging.h"
39 #include "Page.h"
40 #include "RenderImage.h"
41 #include "RenderVideo.h"
42 #include "ScriptController.h"
43 #include "Settings.h"
44 #include "TextStream.h"
45 #include <wtf/NeverDestroyed.h>
46
47 #if ENABLE(VIDEO_PRESENTATION_MODE)
48 #include "WebVideoFullscreenInterface.h"
49 #endif
50
51 namespace WebCore {
52
53 using namespace HTMLNames;
54
55 inline HTMLVideoElement::HTMLVideoElement(const QualifiedName& tagName, Document& document, bool createdByParser)
56     : HTMLMediaElement(tagName, document, createdByParser)
57 {
58     ASSERT(hasTagName(videoTag));
59     setHasCustomStyleResolveCallbacks();
60     if (document.settings())
61         m_defaultPosterURL = document.settings()->defaultVideoPosterURL();
62 }
63
64 Ref<HTMLVideoElement> HTMLVideoElement::create(const QualifiedName& tagName, Document& document, bool createdByParser)
65 {
66     Ref<HTMLVideoElement> videoElement = adoptRef(*new HTMLVideoElement(tagName, document, createdByParser));
67     videoElement->suspendIfNeeded();
68     return videoElement;
69 }
70
71 bool HTMLVideoElement::rendererIsNeeded(const RenderStyle& style) 
72 {
73     return HTMLElement::rendererIsNeeded(style); 
74 }
75
76 RenderPtr<RenderElement> HTMLVideoElement::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
77 {
78     return createRenderer<RenderVideo>(*this, WTFMove(style));
79 }
80
81 void HTMLVideoElement::didAttachRenderers()
82 {
83     HTMLMediaElement::didAttachRenderers();
84
85     updateDisplayState();
86     if (shouldDisplayPosterImage()) {
87         if (!m_imageLoader)
88             m_imageLoader = std::make_unique<HTMLImageLoader>(*this);
89         m_imageLoader->updateFromElement();
90         if (renderer())
91             downcast<RenderImage>(*renderer()).imageResource().setCachedImage(m_imageLoader->image());
92     }
93 }
94
95 void HTMLVideoElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
96 {
97     if (name == widthAttr)
98         addHTMLLengthToStyle(style, CSSPropertyWidth, value);
99     else if (name == heightAttr)
100         addHTMLLengthToStyle(style, CSSPropertyHeight, value);
101     else
102         HTMLMediaElement::collectStyleForPresentationAttribute(name, value, style);
103 }
104
105 bool HTMLVideoElement::isPresentationAttribute(const QualifiedName& name) const
106 {
107     if (name == widthAttr || name == heightAttr)
108         return true;
109     return HTMLMediaElement::isPresentationAttribute(name);
110 }
111
112 void HTMLVideoElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
113 {
114     if (name == posterAttr) {
115         // Force a poster recalc by setting m_displayMode to Unknown directly before calling updateDisplayState.
116         HTMLMediaElement::setDisplayMode(Unknown);
117         updateDisplayState();
118
119         if (shouldDisplayPosterImage()) {
120             if (!m_imageLoader)
121                 m_imageLoader = std::make_unique<HTMLImageLoader>(*this);
122             m_imageLoader->updateFromElementIgnoringPreviousError();
123         } else {
124             if (renderer())
125                 downcast<RenderImage>(*renderer()).imageResource().setCachedImage(nullptr);
126         }
127     }
128 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
129     else if (name == webkitwirelessvideoplaybackdisabledAttr)
130         mediaSession().setWirelessVideoPlaybackDisabled(*this, true);
131 #endif
132     else {
133         HTMLMediaElement::parseAttribute(name, value);    
134
135 #if PLATFORM(IOS) && ENABLE(WIRELESS_PLAYBACK_TARGET)
136         if (name == webkitairplayAttr) {
137             bool disabled = false;
138             if (equalLettersIgnoringASCIICase(fastGetAttribute(HTMLNames::webkitairplayAttr), "deny"))
139                 disabled = true;
140             mediaSession().setWirelessVideoPlaybackDisabled(*this, disabled);
141         }
142 #endif
143     }
144
145 }
146
147 bool HTMLVideoElement::supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenMode videoFullscreenMode) const
148 {
149 #if USE(APPLE_INTERNAL_SDK)
150 #include <WebKitAdditions/HTMLVideoElementSupportsFullscreenAdditions.cpp>
151 #endif
152
153     Page* page = document().page();
154     if (!page) 
155         return false;
156
157     if (!player() || !player()->supportsFullscreen())
158         return false;
159
160 #if PLATFORM(IOS)
161     UNUSED_PARAM(videoFullscreenMode);
162     // Fullscreen implemented by player.
163     return true;
164 #else
165 #if ENABLE(FULLSCREEN_API)
166     // If the full screen API is enabled and is supported for the current element
167     // do not require that the player has a video track to enter full screen.
168     if (videoFullscreenMode == HTMLMediaElementEnums::VideoFullscreenModeStandard && page->chrome().client().supportsFullScreenForElement(this, false))
169         return true;
170 #endif
171
172     if (!player()->hasVideo())
173         return false;
174
175     return page->chrome().client().supportsVideoFullscreen(videoFullscreenMode);
176 #endif // PLATFORM(IOS)
177 }
178
179 unsigned HTMLVideoElement::videoWidth() const
180 {
181     if (!player())
182         return 0;
183     return clampToUnsigned(player()->naturalSize().width());
184 }
185
186 unsigned HTMLVideoElement::videoHeight() const
187 {
188     if (!player())
189         return 0;
190     return clampToUnsigned(player()->naturalSize().height());
191 }
192
193 void HTMLVideoElement::scheduleResizeEvent()
194 {
195     m_lastReportedVideoWidth = videoWidth();
196     m_lastReportedVideoHeight = videoHeight();
197     scheduleEvent(eventNames().resizeEvent);
198 }
199
200 void HTMLVideoElement::scheduleResizeEventIfSizeChanged()
201 {
202     if (m_lastReportedVideoWidth == videoWidth() && m_lastReportedVideoHeight == videoHeight())
203         return;
204     scheduleResizeEvent();
205 }
206
207 bool HTMLVideoElement::isURLAttribute(const Attribute& attribute) const
208 {
209     return attribute.name() == posterAttr || HTMLMediaElement::isURLAttribute(attribute);
210 }
211
212 const AtomicString& HTMLVideoElement::imageSourceURL() const
213 {
214     const AtomicString& url = getAttribute(posterAttr);
215     if (!stripLeadingAndTrailingHTMLSpaces(url).isEmpty())
216         return url;
217     return m_defaultPosterURL;
218 }
219
220 void HTMLVideoElement::setDisplayMode(DisplayMode mode)
221 {
222     DisplayMode oldMode = displayMode();
223     URL poster = posterImageURL();
224
225     if (!poster.isEmpty()) {
226         // We have a poster path, but only show it until the user triggers display by playing or seeking and the
227         // media engine has something to display.
228         if (mode == Video) {
229             if (oldMode != Video && player())
230                 player()->prepareForRendering();
231             if (!hasAvailableVideoFrame())
232                 mode = PosterWaitingForVideo;
233         }
234     } else if (oldMode != Video && player())
235         player()->prepareForRendering();
236
237     HTMLMediaElement::setDisplayMode(mode);
238
239     if (player() && player()->canLoadPoster()) {
240         bool canLoad = true;
241         if (!poster.isEmpty()) {
242             if (Frame* frame = document().frame())
243                 canLoad = frame->loader().willLoadMediaElementURL(poster);
244         }
245         if (canLoad)
246             player()->setPoster(poster);
247     }
248
249     if (renderer() && displayMode() != oldMode)
250         renderer()->updateFromElement();
251 }
252
253 void HTMLVideoElement::updateDisplayState()
254 {
255     if (posterImageURL().isEmpty())
256         setDisplayMode(Video);
257     else if (displayMode() < Poster)
258         setDisplayMode(Poster);
259 }
260
261 void HTMLVideoElement::paintCurrentFrameInContext(GraphicsContext& context, const FloatRect& destRect)
262 {
263     MediaPlayer* player = HTMLMediaElement::player();
264     if (!player)
265         return;
266     
267     player->setVisible(true); // Make player visible or it won't draw.
268     player->paintCurrentFrameInContext(context, destRect);
269 }
270
271 bool HTMLVideoElement::copyVideoTextureToPlatformTexture(GraphicsContext3D* context, Platform3DObject texture, GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Denum format, GC3Denum type, bool premultiplyAlpha, bool flipY)
272 {
273     if (!player())
274         return false;
275     return player()->copyVideoTextureToPlatformTexture(context, texture, target, level, internalFormat, format, type, premultiplyAlpha, flipY);
276 }
277
278 bool HTMLVideoElement::hasAvailableVideoFrame() const
279 {
280     if (!player())
281         return false;
282     
283     return player()->hasVideo() && player()->hasAvailableVideoFrame();
284 }
285
286 NativeImagePtr HTMLVideoElement::nativeImageForCurrentTime()
287 {
288     if (!player())
289         return nullptr;
290
291     return player()->nativeImageForCurrentTime();
292 }
293
294 void HTMLVideoElement::webkitEnterFullscreen(ExceptionCode& ec)
295 {
296     if (isFullscreen())
297         return;
298
299     // Generate an exception if this isn't called in response to a user gesture, or if the 
300     // element does not support fullscreen.
301     if (!mediaSession().fullscreenPermitted(*this) || !supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenModeStandard)) {
302         ec = INVALID_STATE_ERR;
303         return;
304     }
305
306     enterFullscreen();
307 }
308
309 void HTMLVideoElement::webkitExitFullscreen()
310 {
311     if (isFullscreen())
312         exitFullscreen();
313 }
314
315 bool HTMLVideoElement::webkitSupportsFullscreen()
316 {
317     return supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenModeStandard);
318 }
319
320 bool HTMLVideoElement::webkitDisplayingFullscreen()
321 {
322     return isFullscreen();
323 }
324
325 void HTMLVideoElement::ancestorWillEnterFullscreen()
326 {
327 #if PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE)
328     if (fullscreenMode() == VideoFullscreenModeNone)
329         return;
330
331     // If this video element's presentation mode is not inline, but its ancestor
332     // is entering fullscreen, exit its current fullscreen mode.
333     exitToFullscreenModeWithoutAnimationIfPossible(fullscreenMode(), VideoFullscreenModeNone);
334 #endif
335 }
336
337 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
338 bool HTMLVideoElement::webkitWirelessVideoPlaybackDisabled() const
339 {
340     return mediaSession().wirelessVideoPlaybackDisabled(*this);
341 }
342
343 void HTMLVideoElement::setWebkitWirelessVideoPlaybackDisabled(bool disabled)
344 {
345     setBooleanAttribute(webkitwirelessvideoplaybackdisabledAttr, disabled);
346 }
347 #endif
348
349 void HTMLVideoElement::didMoveToNewDocument(Document* oldDocument)
350 {
351     if (m_imageLoader)
352         m_imageLoader->elementDidMoveToNewDocument();
353     HTMLMediaElement::didMoveToNewDocument(oldDocument);
354 }
355
356 #if ENABLE(MEDIA_STATISTICS)
357 unsigned HTMLVideoElement::webkitDecodedFrameCount() const
358 {
359     if (!player())
360         return 0;
361
362     return player()->decodedFrameCount();
363 }
364
365 unsigned HTMLVideoElement::webkitDroppedFrameCount() const
366 {
367     if (!player())
368         return 0;
369
370     return player()->droppedFrameCount();
371 }
372 #endif
373
374 URL HTMLVideoElement::posterImageURL() const
375 {
376     String url = stripLeadingAndTrailingHTMLSpaces(imageSourceURL());
377     if (url.isEmpty())
378         return URL();
379     return document().completeURL(url);
380 }
381
382 #if ENABLE(VIDEO_PRESENTATION_MODE)
383
384 bool HTMLVideoElement::webkitSupportsPresentationMode(VideoPresentationMode mode) const
385 {
386     if (mode == VideoPresentationMode::Fullscreen)
387         return mediaSession().fullscreenPermitted(*this) && supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenModeStandard);
388
389     if (mode == VideoPresentationMode::PictureInPicture) {
390 #if PLATFORM(COCOA)
391         if (!supportsPictureInPicture())
392             return false;
393 #endif
394
395         return mediaSession().allowsPictureInPicture(*this) && supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenModePictureInPicture);
396     }
397
398     if (mode == VideoPresentationMode::Inline)
399         return !mediaSession().requiresFullscreenForVideoPlayback(*this);
400
401     return false;
402 }
403
404 static inline HTMLMediaElementEnums::VideoFullscreenMode toFullscreenMode(VideoPresentationMode mode)
405 {
406     switch (mode) {
407     case VideoPresentationMode::Fullscreen:
408         return HTMLMediaElementEnums::VideoFullscreenModeStandard;
409     case VideoPresentationMode::PictureInPicture:
410         return HTMLMediaElementEnums::VideoFullscreenModePictureInPicture;
411     case VideoPresentationMode::Inline:
412         return HTMLMediaElementEnums::VideoFullscreenModeNone;
413     }
414     ASSERT_NOT_REACHED();
415     return HTMLMediaElementEnums::VideoFullscreenModeNone;
416 }
417
418 void HTMLVideoElement::webkitSetPresentationMode(VideoPresentationMode mode)
419 {
420     setFullscreenMode(toFullscreenMode(mode));
421 }
422
423 void HTMLVideoElement::setFullscreenMode(HTMLMediaElementEnums::VideoFullscreenMode mode)
424 {
425     if (mode == VideoFullscreenModeNone && isFullscreen()) {
426         exitFullscreen();
427         return;
428     }
429
430     if (!mediaSession().fullscreenPermitted(*this) || !supportsFullscreen(mode))
431         return;
432
433     enterFullscreen(mode);
434 }
435
436 static VideoPresentationMode toPresentationMode(HTMLMediaElement::VideoFullscreenMode mode)
437 {
438     if (mode == HTMLMediaElementEnums::VideoFullscreenModeStandard)
439         return VideoPresentationMode::Fullscreen;
440
441     if (mode & HTMLMediaElementEnums::VideoFullscreenModePictureInPicture)
442         return VideoPresentationMode::PictureInPicture;
443
444     if (mode == HTMLMediaElementEnums::VideoFullscreenModeNone)
445         return VideoPresentationMode::Inline;
446
447     ASSERT_NOT_REACHED();
448     return VideoPresentationMode::Inline;
449 }
450
451 VideoPresentationMode HTMLVideoElement::webkitPresentationMode() const
452 {
453     return toPresentationMode(fullscreenMode());
454 }
455
456 void HTMLVideoElement::fullscreenModeChanged(VideoFullscreenMode mode)
457 {
458     if (mode != fullscreenMode()) {
459         LOG(Media, "HTMLVideoElement::fullscreenModeChanged(%p) - mode changed from %i to %i", this, fullscreenMode(), mode);
460         scheduleEvent(eventNames().webkitpresentationmodechangedEvent);
461     }
462
463     if (player())
464         player()->setVideoFullscreenMode(mode);
465
466     HTMLMediaElement::fullscreenModeChanged(mode);
467 }
468
469 #endif
470
471 #if PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE)
472 void HTMLVideoElement::exitToFullscreenModeWithoutAnimationIfPossible(HTMLMediaElementEnums::VideoFullscreenMode fromMode, HTMLMediaElementEnums::VideoFullscreenMode toMode)
473 {
474     if (document().page()->chrome().client().supportsVideoFullscreen(fromMode))
475         document().page()->chrome().client().exitVideoFullscreenToModeWithoutAnimation(*this, toMode);
476 }
477 #endif
478
479 }
480
481 #endif