976621d5f991fb9d1b09749275e747f29ce2cf11
[WebKit-https.git] / Source / WebCore / rendering / RenderVideo.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
28 #if ENABLE(VIDEO)
29 #include "RenderVideo.h"
30
31 #include "Document.h"
32 #include "Frame.h"
33 #include "FrameView.h"
34 #include "GraphicsContext.h"
35 #include "HTMLNames.h"
36 #include "HTMLVideoElement.h"
37 #include "MediaPlayer.h"
38 #include "Page.h"
39 #include "PaintInfo.h"
40 #include "RenderView.h"
41 #include <wtf/StackStats.h>
42
43 #if ENABLE(FULLSCREEN_API)
44 #include "RenderFullScreen.h"
45 #endif
46
47 namespace WebCore {
48
49 using namespace HTMLNames;
50
51 RenderVideo::RenderVideo(HTMLVideoElement& element, Ref<RenderStyle>&& style)
52     : RenderMedia(element, WTFMove(style))
53 {
54     setIntrinsicSize(calculateIntrinsicSize());
55 }
56
57 RenderVideo::~RenderVideo()
58 {
59     if (MediaPlayer* player = videoElement().player())
60         player->setVisible(false);
61 }
62
63 IntSize RenderVideo::defaultSize()
64 {
65     // These values are specified in the spec.
66     static const int cDefaultWidth = 300;
67     static const int cDefaultHeight = 150;
68
69     return IntSize(cDefaultWidth, cDefaultHeight);
70 }
71
72 void RenderVideo::intrinsicSizeChanged()
73 {
74     if (videoElement().shouldDisplayPosterImage())
75         RenderMedia::intrinsicSizeChanged();
76     updateIntrinsicSize(); 
77 }
78
79 void RenderVideo::updateIntrinsicSize()
80 {
81     LayoutSize size = calculateIntrinsicSize();
82     size.scale(style().effectiveZoom());
83
84     // Never set the element size to zero when in a media document.
85     if (size.isEmpty() && document().isMediaDocument())
86         return;
87
88     if (size == intrinsicSize())
89         return;
90
91     setIntrinsicSize(size);
92     setPreferredLogicalWidthsDirty(true);
93     setNeedsLayout();
94 }
95     
96 LayoutSize RenderVideo::calculateIntrinsicSize()
97 {
98     // Spec text from 4.8.6
99     //
100     // The intrinsic width of a video element's playback area is the intrinsic width 
101     // of the video resource, if that is available; otherwise it is the intrinsic 
102     // width of the poster frame, if that is available; otherwise it is 300 CSS pixels.
103     //
104     // The intrinsic height of a video element's playback area is the intrinsic height 
105     // of the video resource, if that is available; otherwise it is the intrinsic 
106     // height of the poster frame, if that is available; otherwise it is 150 CSS pixels.
107     MediaPlayer* player = videoElement().player();
108     if (player && videoElement().readyState() >= HTMLVideoElement::HAVE_METADATA) {
109         LayoutSize size(player->naturalSize());
110         if (!size.isEmpty())
111             return size;
112     }
113
114     if (videoElement().shouldDisplayPosterImage() && !m_cachedImageSize.isEmpty() && !imageResource().errorOccurred())
115         return m_cachedImageSize;
116
117     // <video> in standalone media documents should not use the default 300x150
118     // size since they also have audio-only files. By setting the intrinsic
119     // size to 300x1 the video will resize itself in these cases, and audio will
120     // have the correct height (it needs to be > 0 for controls to render properly).
121     if (videoElement().document().isMediaDocument())
122         return LayoutSize(defaultSize().width(), 1);
123
124     return defaultSize();
125 }
126
127 void RenderVideo::imageChanged(WrappedImagePtr newImage, const IntRect* rect)
128 {
129     RenderMedia::imageChanged(newImage, rect);
130
131     // Cache the image intrinsic size so we can continue to use it to draw the image correctly
132     // even if we know the video intrinsic size but aren't able to draw video frames yet
133     // (we don't want to scale the poster to the video size without keeping aspect ratio).
134     if (videoElement().shouldDisplayPosterImage())
135         m_cachedImageSize = intrinsicSize();
136
137     // The intrinsic size is now that of the image, but in case we already had the
138     // intrinsic size of the video we call this here to restore the video size.
139     updateIntrinsicSize();
140 }
141
142 IntRect RenderVideo::videoBox() const
143 {
144     LayoutSize intrinsicSize = this->intrinsicSize();
145
146     if (videoElement().shouldDisplayPosterImage())
147         intrinsicSize = m_cachedImageSize;
148
149     return snappedIntRect(replacedContentRect(intrinsicSize));
150 }
151
152 bool RenderVideo::shouldDisplayVideo() const
153 {
154     return !videoElement().shouldDisplayPosterImage();
155 }
156
157 void RenderVideo::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
158 {
159     MediaPlayer* mediaPlayer = videoElement().player();
160     bool displayingPoster = videoElement().shouldDisplayPosterImage();
161
162     Page* page = frame().page();
163
164     if (!displayingPoster && !mediaPlayer) {
165         if (page && paintInfo.phase == PaintPhaseForeground)
166             page->addRelevantUnpaintedObject(this, visualOverflowRect());
167         return;
168     }
169
170     LayoutRect rect = videoBox();
171     if (rect.isEmpty()) {
172         if (page && paintInfo.phase == PaintPhaseForeground)
173             page->addRelevantUnpaintedObject(this, visualOverflowRect());
174         return;
175     }
176     rect.moveBy(paintOffset);
177
178     if (page && paintInfo.phase == PaintPhaseForeground)
179         page->addRelevantRepaintedObject(this, rect);
180
181     LayoutRect contentRect = contentBoxRect();
182     contentRect.moveBy(paintOffset);
183     GraphicsContext& context = paintInfo.context();
184     bool clip = !contentRect.contains(rect);
185     GraphicsContextStateSaver stateSaver(context, clip);
186     if (clip)
187         context.clip(contentRect);
188
189     if (displayingPoster)
190         paintIntoRect(context, rect);
191     else if (!videoElement().isFullscreen() || !mediaPlayer->supportsAcceleratedRendering()) {
192         if (view().frameView().paintBehavior() & PaintBehaviorFlattenCompositingLayers)
193             mediaPlayer->paintCurrentFrameInContext(context, rect);
194         else
195             mediaPlayer->paint(context, rect);
196     }
197 }
198
199 void RenderVideo::layout()
200 {
201     StackStats::LayoutCheckPoint layoutCheckPoint;
202     RenderMedia::layout();
203     updatePlayer();
204 }
205     
206 HTMLVideoElement& RenderVideo::videoElement() const
207 {
208     return downcast<HTMLVideoElement>(RenderMedia::mediaElement());
209 }
210
211 void RenderVideo::updateFromElement()
212 {
213     RenderMedia::updateFromElement();
214     updatePlayer();
215 }
216
217 void RenderVideo::updatePlayer()
218 {
219     if (documentBeingDestroyed())
220         return;
221
222     updateIntrinsicSize();
223
224     MediaPlayer* mediaPlayer = videoElement().player();
225     if (!mediaPlayer)
226         return;
227
228     if (!videoElement().inActiveDocument()) {
229         mediaPlayer->setVisible(false);
230         return;
231     }
232
233     contentChanged(VideoChanged);
234     
235     IntRect videoBounds = videoBox(); 
236     mediaPlayer->setSize(IntSize(videoBounds.width(), videoBounds.height()));
237     mediaPlayer->setVisible(true);
238     mediaPlayer->setShouldMaintainAspectRatio(style().objectFit() != ObjectFitFill);
239 }
240
241 LayoutUnit RenderVideo::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
242 {
243     return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
244 }
245
246 LayoutUnit RenderVideo::computeReplacedLogicalHeight() const
247 {
248     return RenderReplaced::computeReplacedLogicalHeight();
249 }
250
251 LayoutUnit RenderVideo::minimumReplacedHeight() const 
252 {
253     return RenderReplaced::minimumReplacedHeight(); 
254 }
255
256 bool RenderVideo::supportsAcceleratedRendering() const
257 {
258     if (MediaPlayer* player = videoElement().player())
259         return player->supportsAcceleratedRendering();
260     return false;
261 }
262
263 void RenderVideo::acceleratedRenderingStateChanged()
264 {
265     if (MediaPlayer* player = videoElement().player())
266         player->acceleratedRenderingStateChanged();
267 }
268
269 bool RenderVideo::requiresImmediateCompositing() const
270 {
271     MediaPlayer* player = videoElement().player();
272     return player && player->requiresImmediateCompositing();
273 }
274
275 #if ENABLE(FULLSCREEN_API)
276 static const RenderBlock* rendererPlaceholder(const RenderObject* renderer)
277 {
278     RenderObject* parent = renderer->parent();
279     return is<RenderFullScreen>(parent) ? downcast<RenderFullScreen>(*parent).placeholder() : nullptr;
280 }
281
282 LayoutUnit RenderVideo::offsetLeft() const
283 {
284     if (const RenderBlock* block = rendererPlaceholder(this))
285         return block->offsetLeft();
286     return RenderMedia::offsetLeft();
287 }
288
289 LayoutUnit RenderVideo::offsetTop() const
290 {
291     if (const RenderBlock* block = rendererPlaceholder(this))
292         return block->offsetTop();
293     return RenderMedia::offsetTop();
294 }
295
296 LayoutUnit RenderVideo::offsetWidth() const
297 {
298     if (const RenderBlock* block = rendererPlaceholder(this))
299         return block->offsetWidth();
300     return RenderMedia::offsetWidth();
301 }
302
303 LayoutUnit RenderVideo::offsetHeight() const
304 {
305     if (const RenderBlock* block = rendererPlaceholder(this))
306         return block->offsetHeight();
307     return RenderMedia::offsetHeight();
308 }
309 #endif
310
311 bool RenderVideo::foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const
312 {
313     if (videoElement().shouldDisplayPosterImage())
314         return RenderImage::foregroundIsKnownToBeOpaqueInRect(localRect, maxDepthToTest);
315
316     if (!videoBox().contains(enclosingIntRect(localRect)))
317         return false;
318
319     if (MediaPlayer* player = videoElement().player())
320         return player->hasAvailableVideoFrame();
321
322     return false;
323 }
324
325 } // namespace WebCore
326
327 #endif