void ChromeClient::enterFullScreenForElement(WebCore::Element* element)
{
gboolean returnValue;
GRefPtr<WebKitDOMHTMLElement> kitElement(adoptGRef(kit(reinterpret_cast<HTMLElement*>(element))));
g_signal_emit_by_name(m_webView, "entering-fullscreen", kitElement.get(), &returnValue);
if (returnValue)
return;
#if ENABLE(VIDEO) && USE(NATIVE_FULLSCREEN_VIDEO)
if (element && element->isMediaElement()) {
HTMLMediaElement* mediaElement = toHTMLMediaElement(element);
if (mediaElement->player() && mediaElement->player()->canEnterFullscreen()) {
element->document()->webkitWillEnterFullScreenForElement(element);
mediaElement->player()->enterFullscreen();
m_fullScreenElement = element;
element->document()->webkitDidEnterFullScreenForElement(element);
}
return;
}
#endif
GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
if (!widgetIsOnscreenToplevelWindow(window))
return;
g_signal_connect(window, "key-press-event", G_CALLBACK(onFullscreenGtkKeyPressEvent), this);
m_fullScreenElement = element;
element->document()->webkitWillEnterFullScreenForElement(element);
m_adjustmentWatcher.disableAllScrollbars();
gtk_window_fullscreen(GTK_WINDOW(window));
element->document()->webkitDidEnterFullScreenForElement(element);
}
void FullscreenController::enterFullScreenForElement(WebCore::Element* element)
{
// We are already transitioning to fullscreen for a different element.
if (m_provisionalFullScreenElement) {
m_provisionalFullScreenElement = element;
return;
}
// We are already in fullscreen mode.
if (m_fullScreenFrame) {
m_provisionalFullScreenElement = element;
willEnterFullScreen();
didEnterFullScreen();
return;
}
if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled()
&& element && element->isMediaElement()
// FIXME: There is no embedder-side handling in layout test mode.
&& !isRunningLayoutTest()) {
HTMLMediaElement* mediaElement = toHTMLMediaElement(element);
if (mediaElement->player() && mediaElement->player()->canShowFullscreenOverlay()) {
mediaElement->player()->showFullscreenOverlay();
m_provisionalFullScreenElement = element;
return;
}
}
// We need to transition to fullscreen mode.
if (WebViewClient* client = m_webViewImpl->client()) {
if (client->enterFullScreen())
m_provisionalFullScreenElement = element;
}
}
void FullscreenController::enterFullScreenForElement(WebCore::Element* element)
{
// We are already transitioning to fullscreen for a different element.
if (m_provisionalFullScreenElement) {
m_provisionalFullScreenElement = element;
return;
}
// We are already in fullscreen mode.
if (m_fullScreenFrame) {
m_provisionalFullScreenElement = element;
willEnterFullScreen();
didEnterFullScreen();
return;
}
#if USE(NATIVE_FULLSCREEN_VIDEO)
if (element && element->isMediaElement()) {
HTMLMediaElement* mediaElement = toMediaElement(element);
if (mediaElement->player() && mediaElement->player()->canEnterFullscreen()) {
mediaElement->player()->enterFullscreen();
m_provisionalFullScreenElement = element;
}
return;
}
#endif
// We need to transition to fullscreen mode.
if (WebViewClient* client = m_webViewImpl->client()) {
if (client->enterFullScreen())
m_provisionalFullScreenElement = element;
}
}
void ChromeClient::exitFullscreenForNode(Node* node)
{
if (!node)
return;
HTMLElement* element = static_cast<HTMLElement*>(node);
if (element && element->isMediaElement()) {
HTMLMediaElement* mediaElement = toHTMLMediaElement(element);
if (mediaElement->player())
mediaElement->player()->exitFullscreen();
}
}
void FullscreenController::exitFullScreenForElement(WebCore::Element* element)
{
// The client is exiting full screen, so don't send a notification.
if (m_isCancelingFullScreen)
return;
#if USE(NATIVE_FULLSCREEN_VIDEO)
if (element && element->isMediaElement()) {
HTMLMediaElement* mediaElement = static_cast<HTMLMediaElement*>(element);
if (mediaElement->player())
mediaElement->player()->exitFullscreen();
return;
}
#endif
if (WebViewClient* client = m_webViewImpl->client())
client->exitFullScreen();
}
bool MediaElementSession::wirelessVideoPlaybackDisabled(const HTMLMediaElement& element) const
{
Settings* settings = element.document().settings();
if (!settings || !settings->allowsAirPlayForMediaPlayback()) {
LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of settings");
return true;
}
if (element.fastHasAttribute(HTMLNames::webkitwirelessvideoplaybackdisabledAttr)) {
LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of attribute");
return true;
}
#if PLATFORM(IOS)
String legacyAirplayAttributeValue = element.fastGetAttribute(HTMLNames::webkitairplayAttr);
if (equalLettersIgnoringASCIICase(legacyAirplayAttributeValue, "deny")) {
LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning TRUE because of legacy attribute");
return true;
}
if (equalLettersIgnoringASCIICase(legacyAirplayAttributeValue, "allow")) {
LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning FALSE because of legacy attribute");
return false;
}
#endif
MediaPlayer* player = element.player();
if (!player)
return true;
bool disabled = player->wirelessVideoPlaybackDisabled();
LOG(Media, "MediaElementSession::wirelessVideoPlaybackDisabled - returning %s because media engine says so", disabled ? "TRUE" : "FALSE");
return disabled;
}
bool RenderThemeQt::paintMediaSliderTrack(RenderObject* o, const PaintInfo& paintInfo, const IntRect& r)
{
HTMLMediaElement* mediaElement = toParentMediaElement(o);
if (!mediaElement)
return false;
QSharedPointer<StylePainter> p = getStylePainter(paintInfo);
if (p.isNull() || !p->isValid())
return true;
p->painter->setRenderHint(QPainter::Antialiasing, true);
paintMediaBackground(p->painter, r);
if (MediaPlayer* player = mediaElement->player()) {
// Get the buffered parts of the media
RefPtr<TimeRanges> buffered = player->buffered();
if (buffered->length() > 0 && player->duration() < std::numeric_limits<float>::infinity()) {
// Set the transform and brush
WorldMatrixTransformer transformer(p->painter, o, r);
p->painter->setBrush(getMediaControlForegroundColor());
// Paint each buffered section
for (int i = 0; i < buffered->length(); i++) {
float startX = (buffered->start(i, IGNORE_EXCEPTION) / player->duration()) * 100;
float width = ((buffered->end(i, IGNORE_EXCEPTION) / player->duration()) * 100) - startX;
p->painter->drawRect(startX, 37, width, 26);
}
}
}
return false;
}
void FullscreenVideoController::LayerClient::platformCALayerLayoutSublayersOfLayer(PlatformCALayer* layer)
{
ASSERT_ARG(layer, layer == m_parent->m_rootChild);
HTMLMediaElement* mediaElement = m_parent->m_mediaElement.get();
if (!mediaElement)
return;
PlatformCALayer* videoLayer = PlatformCALayer::platformCALayer(mediaElement->platformLayer());
if (!videoLayer || videoLayer->superlayer() != layer)
return;
FloatRect layerBounds = layer->bounds();
FloatSize videoSize = mediaElement->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->setFrame(FloatRect(videoOrigin, videoSize));
}
bool RenderThemeQt::paintMediaSliderTrack(RenderObject* o, const RenderObject::PaintInfo& paintInfo, const IntRect& r)
{
HTMLMediaElement* mediaElement = getMediaElementFromRenderObject(o);
if (!mediaElement)
return false;
StylePainter p(this, paintInfo);
if (!p.isValid())
return true;
p.painter->setRenderHint(QPainter::Antialiasing, true);
paintMediaBackground(p.painter, r);
if (MediaPlayer* player = mediaElement->player()) {
if (player->totalBytesKnown()) {
float percentLoaded = static_cast<float>(player->bytesLoaded()) / player->totalBytes();
WorldMatrixTransformer transformer(p.painter, o, r);
p.painter->setBrush(getMediaControlForegroundColor());
p.painter->drawRect(0, 37, 100 * percentLoaded, 26);
}
}
return false;
}
void FullscreenController::exitFullScreenForElement(WebCore::Element* element)
{
// The client is exiting full screen, so don't send a notification.
if (m_isCancelingFullScreen)
return;
if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled()
&& element && element->isMediaElement()
// FIXME: There is no embedder-side handling in layout test mode.
&& !isRunningLayoutTest()) {
HTMLMediaElement* mediaElement = toHTMLMediaElement(element);
if (mediaElement->player())
mediaElement->player()->hideFullscreenOverlay();
return;
}
if (WebViewClient* client = m_webViewImpl->client())
client->exitFullScreen();
}
bool RenderMediaControls::paintMediaControlsPart(MediaControlElementType part, RenderObject* o, const RenderObject::PaintInfo& paintInfo, const IntRect& r)
{
ASSERT(SafariThemeLibrary());
switch (part) {
case MediaFullscreenButton:
paintThemePart(SafariTheme::MediaFullscreenButtonPart, paintInfo.context->platformContext(), r, NSRegularControlSize, determineState(o));
break;
case MediaMuteButton:
case MediaUnMuteButton:
if (HTMLMediaElement* mediaElement = parentMediaElement(o))
paintThemePart(mediaElement->muted() ? SafariTheme::MediaUnMuteButtonPart : SafariTheme::MediaMuteButtonPart, paintInfo.context->platformContext(), r, NSRegularControlSize, determineState(o));
break;
case MediaPauseButton:
case MediaPlayButton:
if (HTMLMediaElement* mediaElement = parentMediaElement(o))
paintThemePart(mediaElement->canPlay() ? SafariTheme::MediaPlayButtonPart : SafariTheme::MediaPauseButtonPart, paintInfo.context->platformContext(), r, NSRegularControlSize, determineState(o));
break;
case MediaSeekBackButton:
paintThemePart(SafariTheme::MediaSeekBackButtonPart, paintInfo.context->platformContext(), r, NSRegularControlSize, determineState(o));
break;
case MediaSeekForwardButton:
paintThemePart(SafariTheme::MediaSeekForwardButtonPart, paintInfo.context->platformContext(), r, NSRegularControlSize, determineState(o));
break;
case MediaSlider: {
HTMLMediaElement* mediaElement = parentMediaElement(o);
if (!mediaElement)
break;
MediaPlayer* player = mediaElement->player();
float duration = player ? player->duration() : 0;
float percentLoaded = duration ? player->maxTimeBuffered() /duration : 0;
STPaintProgressIndicator(SafariTheme::MediaType, paintInfo.context->platformContext(), r, NSRegularControlSize, 0, percentLoaded);
break;
}
case MediaSliderThumb:
paintThemePart(SafariTheme::MediaSliderThumbPart, paintInfo.context->platformContext(), r, NSRegularControlSize, determineState(o));
break;
case MediaTimelineContainer:
ASSERT_NOT_REACHED();
break;
case MediaCurrentTimeDisplay:
ASSERT_NOT_REACHED();
break;
case MediaTimeRemainingDisplay:
ASSERT_NOT_REACHED();
break;
case MediaControlsPanel:
ASSERT_NOT_REACHED();
break;
}
return false;
}
bool HTMLMediaSession::currentPlaybackTargetIsSupported(const HTMLMediaElement& element) const
{
MediaPlayer* player = element.player();
if (!player) {
LOG(Media, "HTMLMediaSession::currentPlaybackTargetIsSupported - returning FALSE because player is NULL");
return false;
}
bool isSupported = player->isCurrentPlaybackTargetSupported();
LOG(Media, "HTMLMediaSession::currentPlaybackTargetIsSupported - returning %s", isSupported ? "TRUE" : "FALSE");
return isSupported;
}
void MediaElementSession::setWirelessVideoPlaybackDisabled(const HTMLMediaElement& element, bool disabled)
{
if (disabled)
addBehaviorRestriction(WirelessVideoPlaybackDisabled);
else
removeBehaviorRestriction(WirelessVideoPlaybackDisabled);
MediaPlayer* player = element.player();
if (!player)
return;
LOG(Media, "MediaElementSession::setWirelessVideoPlaybackDisabled - disabled %s", disabled ? "TRUE" : "FALSE");
player->setWirelessVideoPlaybackDisabled(disabled);
}
void ChromeClient::exitFullScreenForElement(WebCore::Element*)
{
// The element passed into this function is not reliable, i.e. it could
// be null. In addition the parameter may be disappearing in the future.
// So we use the reference to the element we saved above.
ASSERT(m_fullScreenElement);
gboolean returnValue;
GRefPtr<WebKitDOMHTMLElement> kitElement(adoptGRef(kit(reinterpret_cast<HTMLElement*>(m_fullScreenElement.get()))));
g_signal_emit_by_name(m_webView, "leaving-fullscreen", kitElement.get(), &returnValue);
if (returnValue)
return;
#if ENABLE(VIDEO) && USE(NATIVE_FULLSCREEN_VIDEO)
if (m_fullScreenElement && m_fullScreenElement->isMediaElement()) {
m_fullScreenElement->document()->webkitWillExitFullScreenForElement(m_fullScreenElement.get());
HTMLMediaElement* mediaElement = toHTMLMediaElement(m_fullScreenElement.get());
if (mediaElement->player()) {
mediaElement->player()->exitFullscreen();
m_fullScreenElement->document()->webkitDidExitFullScreenForElement(m_fullScreenElement.get());
m_fullScreenElement.clear();
}
return;
}
#endif
GtkWidget* window = gtk_widget_get_toplevel(GTK_WIDGET(m_webView));
ASSERT(widgetIsOnscreenToplevelWindow(window));
g_signal_handlers_disconnect_by_func(window, reinterpret_cast<void*>(onFullscreenGtkKeyPressEvent), this);
m_fullScreenElement->document()->webkitWillExitFullScreenForElement(m_fullScreenElement.get());
gtk_window_unfullscreen(GTK_WINDOW(window));
m_adjustmentWatcher.enableAllScrollbars();
m_fullScreenElement->document()->webkitDidExitFullScreenForElement(m_fullScreenElement.get());
m_fullScreenElement.clear();
}
bool HTMLMediaSession::hasWirelessPlaybackTargets(const HTMLMediaElement& element) const
{
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
if (element.shouldUseVideoPluginProxy()) {
MediaPlayer* player = element.player();
if (!player)
return false;
return player->hasWirelessPlaybackTargets();
}
#else
UNUSED_PARAM(element);
#endif
bool hasTargets = MediaSessionManager::sharedManager().hasWirelessTargetsAvailable();
LOG(Media, "HTMLMediaSession::hasWirelessPlaybackTargets - returning %s", hasTargets ? "TRUE" : "FALSE");
return hasTargets;
}
bool RenderThemeSafari::paintMediaSliderTrack(RenderObject* o, const RenderObject::PaintInfo& paintInfo, const IntRect& r)
{
Node* node = o->element();
Node* mediaNode = node ? node->shadowAncestorNode() : 0;
if (!mediaNode || (!mediaNode->hasTagName(videoTag) && !mediaNode->hasTagName(audioTag)))
return false;
HTMLMediaElement* mediaElement = static_cast<HTMLMediaElement*>(mediaNode);
if (!mediaElement)
return false;
float percentLoaded = 0;
if (MediaPlayer* player = mediaElement->player())
if (player->duration())
percentLoaded = player->maxTimeBuffered() / player->duration();
#if defined(SAFARI_THEME_VERSION) && SAFARI_THEME_VERSION >= 2
ASSERT(SafariThemeLibrary());
STPaintProgressIndicator(SafariTheme::MediaType, paintInfo.context->platformContext(), r, NSRegularControlSize, 0, percentLoaded);
#endif
return false;
}
void HTMLMediaSession::setHasPlaybackTargetAvailabilityListeners(const HTMLMediaElement& element, bool hasListeners)
{
LOG(Media, "HTMLMediaSession::setHasPlaybackTargetAvailabilityListeners - hasListeners %s", hasListeners ? "TRUE" : "FALSE");
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
if (element.shouldUseVideoPluginProxy()) {
MediaPlayer* player = element.player();
if (!player)
return;
player->setHasPlaybackTargetAvailabilityListeners(hasListeners);
return;
}
#else
UNUSED_PARAM(element);
#endif
if (hasListeners)
MediaSessionManager::sharedManager().startMonitoringAirPlayRoutes();
else
MediaSessionManager::sharedManager().stopMonitoringAirPlayRoutes();
}
void HTMLMediaSession::showPlaybackTargetPicker(const HTMLMediaElement& element)
{
LOG(Media, "HTMLMediaSession::showPlaybackTargetPicker");
if (!showingPlaybackTargetPickerPermitted(element))
return;
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
if (element.shouldUseVideoPluginProxy()) {
MediaPlayer* player = element.player();
if (!player)
return;
player->showPlaybackTargetPicker();
return;
}
#endif
#if PLATFORM(IOS)
element.document().frame()->page()->chrome().client().showPlaybackTargetPicker(element.hasVideo());
#endif
}
