9ed6117e0d0401697c5222112823c4e2935120ad
[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 static const AtomicString& presentationModeFullscreen()
385 {
386     static NeverDestroyed<AtomicString> fullscreen("fullscreen", AtomicString::ConstructFromLiteral);
387     return fullscreen;
388 }
389
390 static const AtomicString& presentationModePictureInPicture()
391 {
392     static NeverDestroyed<AtomicString> pictureInPicture("picture-in-picture", AtomicString::ConstructFromLiteral);
393     return pictureInPicture;
394 }
395
396 static const AtomicString& presentationModeInline()
397 {
398     static NeverDestroyed<AtomicString> inlineMode("inline", AtomicString::ConstructFromLiteral);
399     return inlineMode;
400 }
401
402 bool HTMLVideoElement::webkitSupportsPresentationMode(const String& mode) const
403 {
404     if (mode == presentationModeFullscreen())
405         return mediaSession().fullscreenPermitted(*this) && supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenModeStandard);
406
407     if (mode == presentationModePictureInPicture()) {
408 #if PLATFORM(COCOA)
409         if (!supportsPictureInPicture())
410             return false;
411 #endif
412
413         return mediaSession().allowsPictureInPicture(*this) && supportsFullscreen(HTMLMediaElementEnums::VideoFullscreenModePictureInPicture);
414     }
415
416     if (mode == presentationModeInline())
417         return !mediaSession().requiresFullscreenForVideoPlayback(*this);
418
419     return false;
420 }
421
422 static bool presentationModeToFullscreenMode(const String& presentationMode, HTMLMediaElementEnums::VideoFullscreenMode& fullscreenMode)
423 {
424     if (presentationMode == presentationModeFullscreen()) {
425         fullscreenMode = HTMLMediaElementEnums::VideoFullscreenModeStandard;
426         return true;
427     }
428
429     if (presentationMode == presentationModePictureInPicture()) {
430         fullscreenMode = HTMLMediaElementEnums::VideoFullscreenModePictureInPicture;
431         return true;
432     }
433
434     if (presentationMode == presentationModeInline()) {
435         fullscreenMode = HTMLMediaElementEnums::VideoFullscreenModeNone;
436         return true;
437     }
438     return false;
439 }
440
441 void HTMLVideoElement::webkitSetPresentationMode(const String& mode)
442 {
443     VideoFullscreenMode fullscreenMode = VideoFullscreenModeNone;
444     if (!presentationModeToFullscreenMode(mode, fullscreenMode))
445         return;
446
447     LOG_WITH_STREAM(Media, stream << "HTMLVideoElement::webkitSetPresentationMode(" << this << ") - setting to \"" << mode << "\"");
448     setFullscreenMode(fullscreenMode);
449 }
450
451 void HTMLVideoElement::setFullscreenMode(HTMLMediaElementEnums::VideoFullscreenMode mode)
452 {
453     if (mode == VideoFullscreenModeNone && isFullscreen()) {
454         exitFullscreen();
455         return;
456     }
457
458     if (!mediaSession().fullscreenPermitted(*this) || !supportsFullscreen(mode))
459         return;
460
461     enterFullscreen(mode);
462 }
463
464 String HTMLVideoElement::webkitPresentationMode() const
465 {
466     HTMLMediaElement::VideoFullscreenMode mode = fullscreenMode();
467
468     if (mode == VideoFullscreenModeStandard)
469         return presentationModeFullscreen();
470
471     if (mode & VideoFullscreenModePictureInPicture)
472         return presentationModePictureInPicture();
473
474     if (mode == VideoFullscreenModeNone)
475         return presentationModeInline();
476
477     ASSERT_NOT_REACHED();
478     return presentationModeInline();
479 }
480
481 void HTMLVideoElement::fullscreenModeChanged(VideoFullscreenMode mode)
482 {
483     if (mode != fullscreenMode()) {
484         LOG(Media, "HTMLVideoElement::fullscreenModeChanged(%p) - mode changed from %i to %i", this, fullscreenMode(), mode);
485         scheduleEvent(eventNames().webkitpresentationmodechangedEvent);
486     }
487
488     if (player())
489         player()->setVideoFullscreenMode(mode);
490
491     HTMLMediaElement::fullscreenModeChanged(mode);
492 }
493
494 #endif
495
496 #if PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE)
497 void HTMLVideoElement::exitToFullscreenModeWithoutAnimationIfPossible(HTMLMediaElementEnums::VideoFullscreenMode fromMode, HTMLMediaElementEnums::VideoFullscreenMode toMode)
498 {
499     if (document().page()->chrome().client().supportsVideoFullscreen(fromMode))
500         document().page()->chrome().client().exitVideoFullscreenToModeWithoutAnimation(*this, toMode);
501 }
502 #endif
503
504 }
505
506 #endif