HTMLMediaElement* HTMLTrackElement::mediaElement() const
{
Element* parent = parentElement();
if (isHTMLMediaElement(parent))
return toHTMLMediaElement(parent);
return nullptr;
}
void FullscreenController::didEnterFullScreen()
{
if (!m_fullScreenFrame)
return;
if (Document* doc = m_fullScreenFrame->document()) {
if (FullscreenElementStack::isFullScreen(*doc)) {
if (!m_exitFullscreenPageScaleFactor) {
m_exitFullscreenPageScaleFactor = m_webViewImpl->pageScaleFactor();
m_exitFullscreenScrollOffset = m_webViewImpl->mainFrame()->scrollOffset();
m_exitFullscreenPinchViewportOffset = m_webViewImpl->pinchViewportOffset();
m_webViewImpl->setPageScaleFactor(1.0f);
m_webViewImpl->setMainFrameScrollOffset(IntPoint());
m_webViewImpl->setPinchViewportOffset(FloatPoint());
}
FullscreenElementStack::from(*doc).webkitDidEnterFullScreenForElement(0);
if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled()) {
Element* element = FullscreenElementStack::currentFullScreenElementFrom(*doc);
ASSERT(element);
if (isHTMLMediaElement(*element)) {
HTMLMediaElement* mediaElement = toHTMLMediaElement(element);
if (mediaElement->webMediaPlayer() && mediaElement->webMediaPlayer()->canEnterFullscreen()
// FIXME: There is no embedder-side handling in layout test mode.
&& !isRunningLayoutTest()) {
mediaElement->webMediaPlayer()->enterFullscreen();
}
if (m_webViewImpl->layerTreeView())
m_webViewImpl->layerTreeView()->setHasTransparentBackground(true);
}
}
}
}
}
void WebVideoFullscreenManager::enterFullscreenForNode(Node* node)
{
ASSERT(node);
m_node = node;
setMediaElement(toHTMLMediaElement(node));
enterFullscreen();
}
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;
}
}
static bool shouldAppendLayer(const RenderLayer& layer)
{
if (!RuntimeEnabledFeatures::overlayFullscreenVideoEnabled())
return true;
Node* node = layer.renderer()->node();
if (node && isHTMLMediaElement(*node) && toHTMLMediaElement(node)->isFullscreen())
return false;
return true;
}
Node::InsertionNotificationRequest HTMLSourceElement::insertedInto(ContainerNode* insertionPoint)
{
HTMLElement::insertedInto(insertionPoint);
Element* parent = parentElement();
if (isHTMLMediaElement(parent))
toHTMLMediaElement(parent)->sourceWasAdded(this);
if (isHTMLPictureElement(parent))
toHTMLPictureElement(parent)->sourceOrMediaChanged();
return InsertionDone;
}
static HTMLMediaElement* getMediaElementFromRenderObject(const RenderObject& o)
{
Node* node = o.node();
Node* mediaNode = node ? node->shadowHost() : 0;
if (!mediaNode)
mediaNode = node;
if (!mediaNode || !mediaNode->isElementNode() || !toElement(mediaNode)->isMediaElement())
return 0;
return toHTMLMediaElement(mediaNode);
}
void HTMLSourceElement::removedFrom(ContainerNode* removalRoot)
{
Element* parent = parentElement();
if (!parent && removalRoot->isElementNode())
parent = toElement(removalRoot);
if (isHTMLMediaElement(parent))
toHTMLMediaElement(parent)->sourceWasRemoved(this);
if (isHTMLPictureElement(parent))
toHTMLPictureElement(parent)->sourceOrMediaChanged();
HTMLElement::removedFrom(removalRoot);
}
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 (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();
}
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();
}
HTMLMediaElement* LayoutMedia::mediaElement() const {
return toHTMLMediaElement(node());
}
void HTMLTrackElement::removedFrom(ContainerNode* insertionPoint)
{
if (!parentNode() && isHTMLMediaElement(*insertionPoint))
toHTMLMediaElement(insertionPoint)->didRemoveTrackElement(this);
HTMLElement::removedFrom(insertionPoint);
}
HTMLMediaElement* RenderMedia::mediaElement() const
{
return toHTMLMediaElement(node());
}
void ContextMenuClientImpl::showContextMenu(const WebCore::ContextMenu* defaultMenu)
{
// Displaying the context menu in this function is a big hack as we don't
// have context, i.e. whether this is being invoked via a script or in
// response to user input (Mouse event WM_RBUTTONDOWN,
// Keyboard events KeyVK_APPS, Shift+F10). Check if this is being invoked
// in response to the above input events before popping up the context menu.
if (!m_webView->contextMenuAllowed())
return;
HitTestResult r = m_webView->page()->contextMenuController().hitTestResult();
LocalFrame* selectedFrame = r.innerNodeFrame();
WebContextMenuData data;
IntPoint mousePoint = selectedFrame->view()->contentsToWindow(r.roundedPointInInnerNodeFrame());
// FIXME(bokan): crbug.com/371902 - We shouldn't be making these scale
// related coordinate transformatios in an ad hoc way.
PinchViewport& pinchViewport = selectedFrame->host()->pinchViewport();
mousePoint -= flooredIntSize(pinchViewport.visibleRect().location());
mousePoint.scale(m_webView->pageScaleFactor(), m_webView->pageScaleFactor());
data.mousePosition = mousePoint;
// Compute edit flags.
data.editFlags = WebContextMenuData::CanDoNone;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canUndo())
data.editFlags |= WebContextMenuData::CanUndo;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canRedo())
data.editFlags |= WebContextMenuData::CanRedo;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canCut())
data.editFlags |= WebContextMenuData::CanCut;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canCopy())
data.editFlags |= WebContextMenuData::CanCopy;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canPaste())
data.editFlags |= WebContextMenuData::CanPaste;
if (toLocalFrame(m_webView->focusedWebCoreFrame())->editor().canDelete())
data.editFlags |= WebContextMenuData::CanDelete;
// We can always select all...
data.editFlags |= WebContextMenuData::CanSelectAll;
data.editFlags |= WebContextMenuData::CanTranslate;
// Links, Images, Media tags, and Image/Media-Links take preference over
// all else.
data.linkURL = r.absoluteLinkURL();
if (isHTMLCanvasElement(r.innerNonSharedNode())) {
data.mediaType = WebContextMenuData::MediaTypeCanvas;
} else if (!r.absoluteImageURL().isEmpty()) {
data.srcURL = r.absoluteImageURL();
data.mediaType = WebContextMenuData::MediaTypeImage;
data.mediaFlags |= WebContextMenuData::MediaCanPrint;
} else if (!r.absoluteMediaURL().isEmpty()) {
data.srcURL = r.absoluteMediaURL();
// We know that if absoluteMediaURL() is not empty, then this
// is a media element.
HTMLMediaElement* mediaElement = toHTMLMediaElement(r.innerNonSharedNode());
if (isHTMLVideoElement(*mediaElement))
data.mediaType = WebContextMenuData::MediaTypeVideo;
else if (isHTMLAudioElement(*mediaElement))
data.mediaType = WebContextMenuData::MediaTypeAudio;
if (mediaElement->error())
data.mediaFlags |= WebContextMenuData::MediaInError;
if (mediaElement->paused())
data.mediaFlags |= WebContextMenuData::MediaPaused;
if (mediaElement->muted())
data.mediaFlags |= WebContextMenuData::MediaMuted;
if (mediaElement->loop())
data.mediaFlags |= WebContextMenuData::MediaLoop;
if (mediaElement->supportsSave())
data.mediaFlags |= WebContextMenuData::MediaCanSave;
if (mediaElement->hasAudio())
data.mediaFlags |= WebContextMenuData::MediaHasAudio;
// Media controls can be toggled only for video player. If we toggle
// controls for audio then the player disappears, and there is no way to
// return it back. Don't set this bit for fullscreen video, since
// toggling is ignored in that case.
if (mediaElement->hasVideo() && !mediaElement->isFullscreen())
data.mediaFlags |= WebContextMenuData::MediaCanToggleControls;
if (mediaElement->controls())
data.mediaFlags |= WebContextMenuData::MediaControls;
} else if (isHTMLObjectElement(*r.innerNonSharedNode()) || isHTMLEmbedElement(*r.innerNonSharedNode())) {
RenderObject* object = r.innerNonSharedNode()->renderer();
if (object && object->isWidget()) {
Widget* widget = toRenderWidget(object)->widget();
if (widget && widget->isPluginContainer()) {
data.mediaType = WebContextMenuData::MediaTypePlugin;
WebPluginContainerImpl* plugin = toWebPluginContainerImpl(widget);
WebString text = plugin->plugin()->selectionAsText();
if (!text.isEmpty()) {
data.selectedText = text;
data.editFlags |= WebContextMenuData::CanCopy;
}
data.editFlags &= ~WebContextMenuData::CanTranslate;
data.linkURL = plugin->plugin()->linkAtPosition(data.mousePosition);
if (plugin->plugin()->supportsPaginatedPrint())
data.mediaFlags |= WebContextMenuData::MediaCanPrint;
HTMLPlugInElement* pluginElement = toHTMLPlugInElement(r.innerNonSharedNode());
data.srcURL = pluginElement->document().completeURL(pluginElement->url());
data.mediaFlags |= WebContextMenuData::MediaCanSave;
// Add context menu commands that are supported by the plugin.
if (plugin->plugin()->canRotateView())
data.mediaFlags |= WebContextMenuData::MediaCanRotate;
}
}
}
// An image can to be null for many reasons, like being blocked, no image
// data received from server yet.
data.hasImageContents =
(data.mediaType == WebContextMenuData::MediaTypeImage)
&& r.image() && !(r.image()->isNull());
// If it's not a link, an image, a media element, or an image/media link,
// show a selection menu or a more generic page menu.
if (selectedFrame->document()->loader())
data.frameEncoding = selectedFrame->document()->encodingName();
// Send the frame and page URLs in any case.
data.pageURL = urlFromFrame(m_webView->mainFrameImpl()->frame());
if (selectedFrame != m_webView->mainFrameImpl()->frame()) {
data.frameURL = urlFromFrame(selectedFrame);
RefPtr<HistoryItem> historyItem = selectedFrame->loader().currentItem();
if (historyItem)
data.frameHistoryItem = WebHistoryItem(historyItem);
}
if (r.isSelected()) {
if (!isHTMLInputElement(*r.innerNonSharedNode()) || !toHTMLInputElement(r.innerNonSharedNode())->isPasswordField())
data.selectedText = selectedFrame->selectedText().stripWhiteSpace();
}
if (r.isContentEditable()) {
data.isEditable = true;
// When Chrome enables asynchronous spellchecking, its spellchecker adds spelling markers to misspelled
// words and attaches suggestions to these markers in the background. Therefore, when a user right-clicks
// a mouse on a word, Chrome just needs to find a spelling marker on the word instead of spellchecking it.
if (selectedFrame->settings() && selectedFrame->settings()->asynchronousSpellCheckingEnabled()) {
DocumentMarker marker;
data.misspelledWord = selectMisspellingAsync(selectedFrame, marker);
data.misspellingHash = marker.hash();
if (marker.description().length()) {
Vector<String> suggestions;
marker.description().split('\n', suggestions);
data.dictionarySuggestions = suggestions;
} else if (m_webView->spellCheckClient()) {
int misspelledOffset, misspelledLength;
m_webView->spellCheckClient()->spellCheck(data.misspelledWord, misspelledOffset, misspelledLength, &data.dictionarySuggestions);
}
} else {
data.isSpellCheckingEnabled =
toLocalFrame(m_webView->focusedWebCoreFrame())->spellChecker().isContinuousSpellCheckingEnabled();
// Spellchecking might be enabled for the field, but could be disabled on the node.
if (toLocalFrame(m_webView->focusedWebCoreFrame())->spellChecker().isSpellCheckingEnabledInFocusedNode()) {
data.misspelledWord = selectMisspelledWord(selectedFrame);
if (m_webView->spellCheckClient()) {
int misspelledOffset, misspelledLength;
m_webView->spellCheckClient()->spellCheck(
data.misspelledWord, misspelledOffset, misspelledLength,
&data.dictionarySuggestions);
if (!misspelledLength)
data.misspelledWord.reset();
}
}
}
HTMLFormElement* form = selectedFrame->selection().currentForm();
if (form && isHTMLInputElement(*r.innerNonSharedNode())) {
HTMLInputElement& selectedElement = toHTMLInputElement(*r.innerNonSharedNode());
WebSearchableFormData ws = WebSearchableFormData(WebFormElement(form), WebInputElement(&selectedElement));
if (ws.url().isValid())
data.keywordURL = ws.url();
}
}
if (selectedFrame->editor().selectionHasStyle(CSSPropertyDirection, "ltr") != FalseTriState)
data.writingDirectionLeftToRight |= WebContextMenuData::CheckableMenuItemChecked;
if (selectedFrame->editor().selectionHasStyle(CSSPropertyDirection, "rtl") != FalseTriState)
data.writingDirectionRightToLeft |= WebContextMenuData::CheckableMenuItemChecked;
// Now retrieve the security info.
DocumentLoader* dl = selectedFrame->loader().documentLoader();
WebDataSource* ds = WebDataSourceImpl::fromDocumentLoader(dl);
if (ds)
data.securityInfo = ds->response().securityInfo();
data.referrerPolicy = static_cast<WebReferrerPolicy>(selectedFrame->document()->referrerPolicy());
// Filter out custom menu elements and add them into the data.
populateCustomMenuItems(defaultMenu, &data);
// Extract suggested filename for saving file.
if (isHTMLAnchorElement(r.URLElement())) {
HTMLAnchorElement* anchor = toHTMLAnchorElement(r.URLElement());
data.suggestedFilename = anchor->fastGetAttribute(HTMLNames::downloadAttr);
}
data.node = r.innerNonSharedNode();
WebLocalFrameImpl* selectedWebFrame = WebLocalFrameImpl::fromFrame(selectedFrame);
if (selectedWebFrame->client())
selectedWebFrame->client()->showContextMenu(data);
}
