#include "config.h"
#if ENABLE(VIDEO)
#include "RenderVideo.h"
#include "Document.h"
#include "Frame.h"
#include "FrameView.h"
#include "GraphicsContext.h"
#include "HTMLNames.h"
#include "HTMLVideoElement.h"
#include "MediaPlayer.h"
#include "Page.h"
#include "PaintInfo.h"
#include "RenderView.h"
#include <wtf/StackStats.h>
#if ENABLE(FULLSCREEN_API)
#include "RenderFullScreen.h"
#endif
namespace WebCore {
using namespace HTMLNames;
RenderVideo::RenderVideo(HTMLVideoElement& element, PassRef<RenderStyle> style)
: RenderMedia(element, WTF::move(style))
{
setIntrinsicSize(calculateIntrinsicSize());
}
RenderVideo::~RenderVideo()
{
if (MediaPlayer* player = videoElement().player()) {
player->setVisible(false);
player->setFrameView(0);
}
}
IntSize RenderVideo::defaultSize()
{
static const int cDefaultWidth = 300;
static const int cDefaultHeight = 150;
return IntSize(cDefaultWidth, cDefaultHeight);
}
void RenderVideo::intrinsicSizeChanged()
{
if (videoElement().shouldDisplayPosterImage())
RenderMedia::intrinsicSizeChanged();
updateIntrinsicSize();
}
void RenderVideo::updateIntrinsicSize()
{
LayoutSize size = calculateIntrinsicSize();
size.scale(style().effectiveZoom());
if (size.isEmpty() && document().isMediaDocument())
return;
if (size == intrinsicSize())
return;
setIntrinsicSize(size);
setPreferredLogicalWidthsDirty(true);
setNeedsLayout();
}
LayoutSize RenderVideo::calculateIntrinsicSize()
{
MediaPlayer* player = videoElement().player();
if (player && videoElement().readyState() >= HTMLVideoElement::HAVE_METADATA) {
LayoutSize size = player->naturalSize();
if (!size.isEmpty())
return size;
}
if (videoElement().shouldDisplayPosterImage() && !m_cachedImageSize.isEmpty() && !imageResource().errorOccurred())
return m_cachedImageSize;
if (videoElement().document().isMediaDocument())
return LayoutSize(defaultSize().width(), 1);
return defaultSize();
}
void RenderVideo::imageChanged(WrappedImagePtr newImage, const IntRect* rect)
{
RenderMedia::imageChanged(newImage, rect);
if (videoElement().shouldDisplayPosterImage())
m_cachedImageSize = intrinsicSize();
updateIntrinsicSize();
}
IntRect RenderVideo::videoBox() const
{
LayoutSize intrinsicSize = this->intrinsicSize();
if (videoElement().shouldDisplayPosterImage())
intrinsicSize = m_cachedImageSize;
return pixelSnappedIntRect(replacedContentRect(intrinsicSize));
}
bool RenderVideo::shouldDisplayVideo() const
{
return !videoElement().shouldDisplayPosterImage();
}
void RenderVideo::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
{
MediaPlayer* mediaPlayer = videoElement().player();
bool displayingPoster = videoElement().shouldDisplayPosterImage();
Page* page = frame().page();
if (!displayingPoster && !mediaPlayer) {
if (page && paintInfo.phase == PaintPhaseForeground)
page->addRelevantUnpaintedObject(this, visualOverflowRect());
return;
}
LayoutRect rect = videoBox();
if (rect.isEmpty()) {
if (page && paintInfo.phase == PaintPhaseForeground)
page->addRelevantUnpaintedObject(this, visualOverflowRect());
return;
}
rect.moveBy(paintOffset);
if (page && paintInfo.phase == PaintPhaseForeground)
page->addRelevantRepaintedObject(this, rect);
LayoutRect contentRect = contentBoxRect();
contentRect.moveBy(paintOffset);
GraphicsContext* context = paintInfo.context;
bool clip = !contentRect.contains(rect);
GraphicsContextStateSaver stateSaver(*context, clip);
if (clip)
context->clip(contentRect);
if (displayingPoster)
paintIntoRect(context, rect);
else if (view().frameView().paintBehavior() & PaintBehaviorFlattenCompositingLayers)
mediaPlayer->paintCurrentFrameInContext(context, pixelSnappedIntRect(rect));
else
mediaPlayer->paint(context, pixelSnappedIntRect(rect));
}
void RenderVideo::layout()
{
StackStats::LayoutCheckPoint layoutCheckPoint;
RenderMedia::layout();
updatePlayer();
}
HTMLVideoElement& RenderVideo::videoElement() const
{
return toHTMLVideoElement(RenderMedia::mediaElement());
}
void RenderVideo::updateFromElement()
{
RenderMedia::updateFromElement();
updatePlayer();
}
void RenderVideo::updatePlayer()
{
if (documentBeingDestroyed())
return;
updateIntrinsicSize();
MediaPlayer* mediaPlayer = videoElement().player();
if (!mediaPlayer)
return;
if (!videoElement().inActiveDocument()) {
mediaPlayer->setVisible(false);
return;
}
contentChanged(VideoChanged);
IntRect videoBounds = videoBox();
mediaPlayer->setFrameView(&view().frameView());
mediaPlayer->setSize(IntSize(videoBounds.width(), videoBounds.height()));
mediaPlayer->setVisible(true);
mediaPlayer->setShouldMaintainAspectRatio(style().objectFit() != ObjectFitFill);
}
LayoutUnit RenderVideo::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
{
return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);
}
LayoutUnit RenderVideo::computeReplacedLogicalHeight() const
{
return RenderReplaced::computeReplacedLogicalHeight();
}
LayoutUnit RenderVideo::minimumReplacedHeight() const
{
return RenderReplaced::minimumReplacedHeight();
}
bool RenderVideo::supportsAcceleratedRendering() const
{
if (MediaPlayer* player = videoElement().player())
return player->supportsAcceleratedRendering();
return false;
}
void RenderVideo::acceleratedRenderingStateChanged()
{
if (MediaPlayer* player = videoElement().player())
player->acceleratedRenderingStateChanged();
}
bool RenderVideo::requiresImmediateCompositing() const
{
MediaPlayer* player = videoElement().player();
return player && player->requiresImmediateCompositing();
}
#if ENABLE(FULLSCREEN_API)
static const RenderBlock* rendererPlaceholder(const RenderObject* renderer)
{
RenderObject* parent = renderer->parent();
if (!parent)
return 0;
RenderFullScreen* fullScreen = parent->isRenderFullScreen() ? toRenderFullScreen(parent) : 0;
if (!fullScreen)
return 0;
return fullScreen->placeholder();
}
LayoutUnit RenderVideo::offsetLeft() const
{
if (const RenderBlock* block = rendererPlaceholder(this))
return block->offsetLeft();
return RenderMedia::offsetLeft();
}
LayoutUnit RenderVideo::offsetTop() const
{
if (const RenderBlock* block = rendererPlaceholder(this))
return block->offsetTop();
return RenderMedia::offsetTop();
}
LayoutUnit RenderVideo::offsetWidth() const
{
if (const RenderBlock* block = rendererPlaceholder(this))
return block->offsetWidth();
return RenderMedia::offsetWidth();
}
LayoutUnit RenderVideo::offsetHeight() const
{
if (const RenderBlock* block = rendererPlaceholder(this))
return block->offsetHeight();
return RenderMedia::offsetHeight();
}
#endif
bool RenderVideo::foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, unsigned maxDepthToTest) const
{
if (videoElement().shouldDisplayPosterImage())
return RenderImage::foregroundIsKnownToBeOpaqueInRect(localRect, maxDepthToTest);
if (!videoBox().contains(enclosingIntRect(localRect)))
return false;
if (MediaPlayer* player = videoElement().player())
return player->hasAvailableVideoFrame();
return false;
}
}
#endif