void MediaDocument::replaceMediaElementTimerFired(Timer<MediaDocument>*)
{
HTMLElement* htmlBody = body();
if (!htmlBody)
return;
// Set body margin width and height to 0 as that is what a PluginDocument uses.
htmlBody->setAttribute(marginwidthAttr, "0");
htmlBody->setAttribute(marginheightAttr, "0");
RefPtr<NodeList> nodeList = htmlBody->getElementsByTagName("video");
if (nodeList.get()->length() > 0) {
HTMLVideoElement* videoElement = static_cast<HTMLVideoElement*>(nodeList.get()->item(0));
RefPtr<Element> element = Document::createElement(embedTag, false);
HTMLEmbedElement* embedElement = static_cast<HTMLEmbedElement*>(element.get());
embedElement->setAttribute(widthAttr, "100%");
embedElement->setAttribute(heightAttr, "100%");
embedElement->setAttribute(nameAttr, "plugin");
embedElement->setAttribute(srcAttr, url().string());
embedElement->setAttribute(typeAttr, frame()->loader()->writer()->mimeType());
ExceptionCode ec;
videoElement->parent()->replaceChild(embedElement, videoElement, ec);
}
}
void FullScreenVideoQt::exitFullScreenForNode(Node* node)
{
Q_ASSERT(node);
#if USE(QT_MULTIMEDIA)
HTMLVideoElement* videoElement = static_cast<HTMLVideoElement*>(node);
PlatformMedia platformMedia = videoElement->platformMedia();
ASSERT(platformMedia.type == PlatformMedia::QtMediaPlayerType);
if (platformMedia.type != PlatformMedia::QtMediaPlayerType)
return;
Q_ASSERT(m_FullScreenVideoHandler);
if (!m_FullScreenVideoHandler)
return;
m_FullScreenVideoHandler->exitFullScreen();
MediaPlayerPrivateQt* mediaPlayerQt = mediaPlayer();
mediaPlayerQt->restoreVideoItem();
#endif
#if USE(GSTREAMER)
m_FullScreenVideoHandlerGStreamer->exitFullScreen();
#endif
#if USE(QTKIT)
m_FullScreenVideoHandlerQTKit->exitFullScreen();
#endif
}
JSValue jsHTMLVideoElementPoster(ExecState* exec, const Identifier&, const PropertySlot& slot)
{
JSHTMLVideoElement* castedThis = static_cast<JSHTMLVideoElement*>(asObject(slot.slotBase()));
UNUSED_PARAM(exec);
HTMLVideoElement* imp = static_cast<HTMLVideoElement*>(castedThis->impl());
return jsString(exec, imp->poster());
}
static void heightAttrSetter(v8::Local<v8::String> name, v8::Local<v8::Value> value, const v8::AccessorInfo& info)
{
HTMLVideoElement* imp = V8HTMLVideoElement::toNative(info.Holder());
unsigned v = toUInt32(value);
imp->setUnsignedIntegralAttribute(WebCore::HTMLNames::heightAttr, v);
return;
}
HTMLVideoElement* HTMLVideoElement::create(Document& document)
{
HTMLVideoElement* video = new HTMLVideoElement(document);
video->ensureUserAgentShadowRoot();
video->suspendIfNeeded();
return video;
}
QUrl DumpRenderTreeSupportQt::mediaContentUrlByElementId(QWebFrameAdapter* adapter, const QString& elementId)
{
QUrl res;
#if ENABLE(VIDEO) && USE(QT_MULTIMEDIA)
Frame* coreFrame = adapter->frame;
if (!coreFrame)
return res;
Document* doc = coreFrame->document();
if (!doc)
return res;
Node* coreNode = doc->getElementById(elementId);
if (!coreNode)
return res;
HTMLVideoElement* videoElement = static_cast<HTMLVideoElement*>(coreNode);
PlatformMedia platformMedia = videoElement->platformMedia();
if (platformMedia.type != PlatformMedia::QtMediaPlayerType)
return res;
MediaPlayerPrivateQt* mediaPlayerQt = static_cast<MediaPlayerPrivateQt*>(platformMedia.media.qtMediaPlayer);
if (mediaPlayerQt && mediaPlayerQt->mediaPlayer())
res = mediaPlayerQt->mediaPlayer()->media().canonicalUrl();
#endif
return res;
}
LayoutSize RenderVideo::calculateIntrinsicSize()
{
HTMLVideoElement* video = videoElement();
// Spec text from 4.8.6
//
// The intrinsic width of a video element's playback area is the intrinsic width
// of the video resource, if that is available; otherwise it is the intrinsic
// width of the poster frame, if that is available; otherwise it is 300 CSS pixels.
//
// The intrinsic height of a video element's playback area is the intrinsic height
// of the video resource, if that is available; otherwise it is the intrinsic
// height of the poster frame, if that is available; otherwise it is 150 CSS pixels.
MediaPlayer* player = mediaElement()->player();
if (player && video->readyState() >= HTMLVideoElement::HAVE_METADATA) {
LayoutSize size = player->naturalSize();
if (!size.isEmpty())
return size;
}
if (video->shouldDisplayPosterImage() && !m_cachedImageSize.isEmpty() && !imageResource()->errorOccurred())
return m_cachedImageSize;
// <video> in standalone media documents should not use the default 300x150
// size since they also have audio-only files. By setting the intrinsic
// size to 300x1 the video will resize itself in these cases, and audio will
// have the correct height (it needs to be > 0 for controls to render properly).
if (video->ownerDocument() && video->ownerDocument()->isMediaDocument())
return LayoutSize(defaultSize().width(), 1);
return defaultSize();
}
void FullscreenVideoController::LayerClient::platformCALayerLayoutSublayersOfLayer(PlatformCALayer* layer)
{
ASSERT_ARG(layer, layer == m_parent->m_rootChild);
HTMLVideoElement* videoElement = m_parent->m_videoElement.get();
if (!videoElement)
return;
PlatformCALayer* videoLayer = PlatformCALayer::platformCALayer(videoElement->platformLayer());
if (!videoLayer || videoLayer->superlayer() != layer)
return;
FloatRect layerBounds = layer->bounds();
FloatSize videoSize = videoElement->player()->naturalSize();
float scaleFactor;
if (videoSize.aspectRatio() > layerBounds.size().aspectRatio())
scaleFactor = layerBounds.width() / videoSize.width();
else
scaleFactor = layerBounds.height() / videoSize.height();
videoSize.scale(scaleFactor);
// Calculate the centered position based on the videoBounds and layerBounds:
FloatPoint videoPosition;
FloatPoint videoOrigin;
videoOrigin.setX((layerBounds.width() - videoSize.width()) * 0.5);
videoOrigin.setY((layerBounds.height() - videoSize.height()) * 0.5);
videoLayer->setPosition(videoOrigin);
videoLayer->setBounds(FloatRect(FloatPoint(), videoSize));
}
static bool shouldAppendLayer(const PaintLayer& layer)
{
Node* node = layer.layoutObject()->node();
if (node && isHTMLVideoElement(*node)) {
HTMLVideoElement* element = toHTMLVideoElement(node);
if (element->isFullscreen() && element->usesOverlayFullscreenVideo())
return false;
}
return true;
}
void MediaDocument::defaultEventHandler(Event* event)
{
// Match the default Quicktime plugin behavior to allow
// clicking and double-clicking to pause and play the media.
Node* targetNode = event->target()->toNode();
if (!targetNode)
return;
HTMLVideoElement* video = descendentVideoElement(targetNode);
if (!video)
return;
if (event->type() == eventNames().clickEvent) {
if (!video->canPlay()) {
video->pause(event->fromUserGesture());
event->setDefaultHandled();
}
} else if (event->type() == eventNames().dblclickEvent) {
if (video->canPlay()) {
video->play(event->fromUserGesture());
event->setDefaultHandled();
}
} else if (event->type() == eventNames().keydownEvent && event->isKeyboardEvent()) {
KeyboardEvent* keyboardEvent = static_cast<KeyboardEvent*>(event);
if (keyboardEvent->keyIdentifier() == "U+0020") { // space
if (video->paused()) {
if (video->canPlay())
video->play(event->fromUserGesture());
} else
video->pause(event->fromUserGesture());
event->setDefaultHandled();
}
}
}
void HitTestResult::enterFullscreenForVideo() const
{
#if ENABLE(VIDEO)
HTMLMediaElement* mediaElt(mediaElement());
if (mediaElt && mediaElt->hasTagName(HTMLNames::videoTag)) {
HTMLVideoElement* videoElt = static_cast<HTMLVideoElement*>(mediaElt);
if (!videoElt->isFullscreen() && mediaElt->supportsFullscreen())
videoElt->enterFullscreen();
}
#endif
}
void HitTestResult::enterFullscreenForVideo() const
{
#if ENABLE(VIDEO)
HTMLMediaElement* mediaElt(mediaElement());
if (mediaElt && isHTMLVideoElement(mediaElt)) {
HTMLVideoElement* videoElt = toHTMLVideoElement(mediaElt);
if (!videoElt->isFullscreen() && mediaElt->supportsFullscreen()) {
UserGestureIndicator indicator(DefinitelyProcessingUserGesture);
videoElt->enterFullscreen();
}
}
#endif
}
void HitTestResult::enterFullscreenForVideo() const
{
#if ENABLE(VIDEO)
HTMLMediaElement* mediaElt(mediaElement());
if (mediaElt && mediaElt->hasTagName(HTMLNames::videoTag)) {
HTMLVideoElement* videoElt = static_cast<HTMLVideoElement*>(mediaElt);
if (!videoElt->isFullscreen() && mediaElt->supportsFullscreen()) {
UserGestureIndicator indicator(DefinitelyProcessingUserGesture);
videoElt->enterFullscreen();
}
}
#endif
}
static v8::Handle<v8::Value> webkitEnterFullScreenCallback(const v8::Arguments& args)
{
HTMLVideoElement* imp = V8HTMLVideoElement::toNative(args.Holder());
ExceptionCode ec = 0;
{
imp->webkitEnterFullScreen(ec);
if (UNLIKELY(ec))
goto fail;
return v8Undefined();
}
fail:
return setDOMException(ec, args.GetIsolate());
}
void MediaDocument::defaultEventHandler(Event* event)
{
#if !(PLATFORM(BLACKBERRY) && OS(QNX))
// Match the default Quicktime plugin behavior to allow
// clicking and double-clicking to pause and play the media.
Node* targetNode = event->target()->toNode();
if (targetNode && targetNode->hasTagName(videoTag)) {
HTMLVideoElement* video = static_cast<HTMLVideoElement*>(targetNode);
if (event->type() == eventNames().clickEvent) {
if (!video->canPlay()) {
video->pause(event->fromUserGesture());
event->setDefaultHandled();
}
} else if (event->type() == eventNames().dblclickEvent) {
if (video->canPlay()) {
video->play(event->fromUserGesture());
event->setDefaultHandled();
}
}
}
if (event->type() == eventNames().keydownEvent && event->isKeyboardEvent()) {
HTMLVideoElement* video = 0;
if (targetNode) {
if (targetNode->hasTagName(videoTag))
video = static_cast<HTMLVideoElement*>(targetNode);
else {
RefPtr<NodeList> nodeList = targetNode->getElementsByTagName("video");
if (nodeList.get()->length() > 0)
video = static_cast<HTMLVideoElement*>(nodeList.get()->item(0));
}
}
if (video) {
KeyboardEvent* keyboardEvent = static_cast<KeyboardEvent*>(event);
if (keyboardEvent->keyIdentifier() == "U+0020") { // space
if (video->paused()) {
if (video->canPlay())
video->play(event->fromUserGesture());
} else
video->pause(event->fromUserGesture());
event->setDefaultHandled();
}
}
}
#endif
}
/* static */ already_AddRefed<ImageBitmap>
ImageBitmap::CreateInternal(nsIGlobalObject* aGlobal, HTMLVideoElement& aVideoEl,
const Maybe<IntRect>& aCropRect, ErrorResult& aRv)
{
// Check network state.
if (aVideoEl.NetworkState() == HTMLMediaElement::NETWORK_EMPTY) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return nullptr;
}
// Check ready state.
// Cannot be HTMLMediaElement::HAVE_NOTHING or HTMLMediaElement::HAVE_METADATA.
if (aVideoEl.ReadyState() <= HTMLMediaElement::HAVE_METADATA) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return nullptr;
}
// Check security.
nsCOMPtr<nsIPrincipal> principal = aVideoEl.GetCurrentPrincipal();
bool CORSUsed = aVideoEl.GetCORSMode() != CORS_NONE;
if (!CheckSecurityForHTMLElements(false, CORSUsed, principal)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return nullptr;
}
// Create ImageBitmap.
ImageContainer *container = aVideoEl.GetImageContainer();
if (!container) {
aRv.Throw(NS_ERROR_NOT_AVAILABLE);
return nullptr;
}
AutoLockImage lockImage(container);
layers::Image* data = lockImage.GetImage();
RefPtr<ImageBitmap> ret = new ImageBitmap(aGlobal, data);
// Set the picture rectangle.
if (ret && aCropRect.isSome()) {
ret->SetPictureRect(aCropRect.ref(), aRv);
}
return ret.forget();
}
void MediaDocument::defaultEventHandler(Event* event)
{
Node* targetNode = event->target()->toNode();
if (!targetNode)
return;
if (event->type() == EventTypeNames::keydown && event->isKeyboardEvent()) {
HTMLVideoElement* video = Traversal<HTMLVideoElement>::firstWithin(*targetNode);
if (!video)
return;
KeyboardEvent* keyboardEvent = toKeyboardEvent(event);
if (keyboardEvent->key() == " " || keyboardEvent->keyCode() == VKEY_MEDIA_PLAY_PAUSE) {
// space or media key (play/pause)
video->togglePlayState();
event->setDefaultHandled();
}
}
}
void HTMLVideoElement::CloneElementVisually(HTMLVideoElement& aTargetVideo,
ErrorResult& rv) {
MOZ_ASSERT(!mUnboundFromTree,
"Can't clone a video that's not bound to a DOM tree.");
MOZ_ASSERT(!aTargetVideo.mUnboundFromTree,
"Can't clone to a video that's not bound to a DOM tree.");
if (mUnboundFromTree || aTargetVideo.mUnboundFromTree) {
rv.Throw(NS_ERROR_UNEXPECTED);
return;
}
// Do we already have a visual clone target? If so, shut it down.
if (mVisualCloneTarget) {
EndCloningVisually();
}
// If there's a poster set on the target video, clear it, otherwise
// it'll display over top of the cloned frames.
aTargetVideo.UnsetHTMLAttr(nsGkAtoms::poster, rv);
if (rv.Failed()) {
return;
}
if (!SetVisualCloneTarget(&aTargetVideo)) {
rv.Throw(NS_ERROR_FAILURE);
return;
}
if (!aTargetVideo.SetVisualCloneSource(this)) {
mVisualCloneTarget = nullptr;
rv.Throw(NS_ERROR_FAILURE);
return;
}
aTargetVideo.SetMediaInfo(mMediaInfo);
if (IsInComposedDoc() && !sCloneElementVisuallyTesting) {
NotifyUAWidgetSetupOrChange();
}
MaybeBeginCloningVisually();
}
void MediaDocument::defaultEventHandler(Event* event)
{
// Match the default Quicktime plugin behavior to allow
// clicking and double-clicking to pause and play the media.
Node* targetNode = event->target()->toNode();
if (!targetNode)
return;
if (HTMLVideoElement* video = ancestorVideoElement(targetNode)) {
if (event->type() == eventNames().clickEvent) {
if (!video->canPlay()) {
video->pause();
event->setDefaultHandled();
}
} else if (event->type() == eventNames().dblclickEvent) {
if (video->canPlay()) {
video->play();
event->setDefaultHandled();
}
}
}
if (!is<ContainerNode>(*targetNode))
return;
ContainerNode& targetContainer = downcast<ContainerNode>(*targetNode);
if (event->type() == eventNames().keydownEvent && is<KeyboardEvent>(*event)) {
HTMLVideoElement* video = descendantVideoElement(targetContainer);
if (!video)
return;
KeyboardEvent& keyboardEvent = downcast<KeyboardEvent>(*event);
if (keyboardEvent.keyIdentifier() == "U+0020") { // space
if (video->paused()) {
if (video->canPlay())
video->play();
} else
video->pause();
keyboardEvent.setDefaultHandled();
}
}
}
void FullscreenController::didEnterFullScreen()
{
if (!m_provisionalFullScreenElement)
return;
RefPtrWillBeRawPtr<Element> element = m_provisionalFullScreenElement.release();
Document& document = element->document();
m_fullScreenFrame = document.frame();
if (!m_fullScreenFrame)
return;
if (!m_exitFullscreenPageScaleFactor) {
m_exitFullscreenPageScaleFactor = m_webViewImpl->pageScaleFactor();
m_exitFullscreenScrollOffset = m_webViewImpl->mainFrame()->scrollOffset();
m_exitFullscreenPinchViewportOffset = m_webViewImpl->pinchViewportOffset();
updatePageScaleConstraints(false);
m_webViewImpl->setPageScaleFactor(1.0f);
m_webViewImpl->setMainFrameScrollOffset(IntPoint());
m_webViewImpl->setPinchViewportOffset(FloatPoint());
}
Fullscreen::from(document).didEnterFullScreenForElement(element.get());
ASSERT(Fullscreen::currentFullScreenElementFrom(document) == element);
if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled()) {
if (isHTMLVideoElement(element)) {
HTMLVideoElement* videoElement = toHTMLVideoElement(element);
if (HTMLMediaElement::isMediaStreamURL(videoElement->sourceURL().string()))
return;
if (videoElement->webMediaPlayer()
// FIXME: There is no embedder-side handling in layout test mode.
&& !LayoutTestSupport::isRunningLayoutTest()) {
videoElement->webMediaPlayer()->enterFullscreen();
}
if (m_webViewImpl->layerTreeView())
m_webViewImpl->layerTreeView()->setHasTransparentBackground(true);
}
}
}