bool HTMLMediaSession::requiresFullscreenForVideoPlayback(const HTMLMediaElement& element) const { if (!MediaSessionManager::sharedManager().sessionRestrictsInlineVideoPlayback(*this)) return false; Settings* settings = element.document().settings(); if (!settings || !settings->mediaPlaybackAllowsInline()) return true; if (element.fastHasAttribute(HTMLNames::webkit_playsinlineAttr)) return false; #if PLATFORM(IOS) if (applicationIsDumpRenderTree()) return false; #endif return true; }
bool RenderThemeWinCE::paintSliderThumb(RenderObject* o, const PaintInfo& i, const IntRect& r) { bool rc = RenderTheme::paintSliderThumb(o, i, r); i.context->save(); i.context->setStrokeColor(Color::black, ColorSpaceDeviceRGB); i.context->setFillColor(Color::black, ColorSpaceDeviceRGB); #if ENABLE(VIDEO) HTMLMediaElement* mediaElement = mediaElementParent(o->node()); if (mediaElement) { float pt = (mediaElement->currentTime() - mediaElement->startTime()) / mediaElement->duration(); FloatRect intRect = r; intRect.setX(intRect.x() + intRect.width() * pt - 2); intRect.setWidth(5); i.context->fillRect(intRect); } #endif i.context->restore(); return rc; }
void MediaControlClosedCaptionsTrackListElement::updateDisplay() { #if ENABLE(VIDEO_TRACK) DEFINE_STATIC_LOCAL(AtomicString, selectedClassValue, ("selected", AtomicString::ConstructFromLiteral)); if (!mediaController()->hasClosedCaptions()) return; HTMLMediaElement* mediaElement = toParentMediaElement(this); if (!mediaElement) return; TextTrackList* trackList = mediaElement->textTracks(); if (!trackList || !trackList->length()) return; if (m_trackListHasChanged) rebuildTrackListMenu(); bool captionsVisible = mediaElement->closedCaptionsVisible(); for (unsigned i = 0, length = m_menuItems.size(); i < length; ++i) { RefPtr<Element> trackItem = m_menuItems[i]; int trackIndex = trackListIndexForElement(trackItem.get()); if (trackIndex != HTMLMediaElement::textTracksIndexNotFound()) { if (trackIndex == HTMLMediaElement::textTracksOffIndex()) { if (captionsVisible) trackItem->classList()->remove(selectedClassValue, ASSERT_NO_EXCEPTION); else trackItem->classList()->add(selectedClassValue, ASSERT_NO_EXCEPTION); } else { TextTrack* track = trackList->item(trackIndex); if (!track) continue; if (track->mode() == TextTrack::showingKeyword()) trackItem->classList()->add(selectedClassValue, ASSERT_NO_EXCEPTION); else trackItem->classList()->remove(selectedClassValue, ASSERT_NO_EXCEPTION); } } } #endif }
bool MediaElementSession::pageAllowsPlaybackAfterResuming(const HTMLMediaElement& element) const { Page* page = element.document().page(); if (m_restrictions & RequirePageConsentToResumeMedia && page && !page->canStartMedia()) { LOG(Media, "MediaElementSession::pageAllowsPlaybackAfterResuming - returning FALSE"); return false; } return true; }
bool HTMLMediaSession::pageAllowsDataLoading(const HTMLMediaElement& element) const { Page* page = element.document().page(); if (m_restrictions & RequirePageConsentToLoadMedia && page && !page->canStartMedia()) { LOG(Media, "HTMLMediaSession::pageAllowsDataLoading - returning FALSE"); return false; } return true; }
void MediaControlClosedCaptionsTrackListElement::rebuildTrackListMenu() { #if ENABLE(VIDEO_TRACK) // Remove any existing content. removeChildren(); m_menuItems.clear(); m_menuToTrackMap.clear(); if (!mediaController()->hasClosedCaptions()) return; HTMLMediaElement* mediaElement = toParentMediaElement(this); if (!mediaElement) return; TextTrackList* trackList = mediaElement->textTracks(); if (!trackList || !trackList->length()) return; Document* doc = document(); if (!document()->page()) return; CaptionUserPreferences* captionPreferences = document()->page()->group().captionPreferences(); Vector<RefPtr<TextTrack> > tracksForMenu = captionPreferences->sortedTrackListForMenu(trackList); RefPtr<Element> captionsHeader = doc->createElement(h3Tag, ASSERT_NO_EXCEPTION); captionsHeader->appendChild(doc->createTextNode(textTrackSubtitlesText())); appendChild(captionsHeader); RefPtr<Element> captionsMenuList = doc->createElement(ulTag, ASSERT_NO_EXCEPTION); for (unsigned i = 0, length = tracksForMenu.size(); i < length; ++i) { RefPtr<TextTrack> textTrack = tracksForMenu[i]; RefPtr<Element> menuItem = doc->createElement(liTag, ASSERT_NO_EXCEPTION); menuItem->appendChild(doc->createTextNode(captionPreferences->displayNameForTrack(textTrack.get()))); captionsMenuList->appendChild(menuItem); m_menuItems.append(menuItem); m_menuToTrackMap.add(menuItem, textTrack); } appendChild(captionsMenuList); #endif }
int MediaPlayerPrivate::showErrorDialog(MMRPlayer::Error type) { using namespace BlackBerry::WebKit; WebPageClient::AlertType atype; switch (type) { case MMRPlayer::MediaOK: atype = WebPageClient::MediaOK; break; case MMRPlayer::MediaDecodeError: atype = WebPageClient::MediaDecodeError; break; case MMRPlayer::MediaMetaDataError: atype = WebPageClient::MediaMetaDataError; break; case MMRPlayer::MediaMetaDataTimeoutError: atype = WebPageClient::MediaMetaDataTimeoutError; break; case MMRPlayer::MediaNoMetaDataError: atype = WebPageClient::MediaNoMetaDataError; break; case MMRPlayer::MediaVideoReceiveError: atype = WebPageClient::MediaVideoReceiveError; break; case MMRPlayer::MediaAudioReceiveError: atype = WebPageClient::MediaAudioReceiveError; break; case MMRPlayer::MediaInvalidError: atype = WebPageClient::MediaInvalidError; break; default: LOG(Media, "Alert type does not exist."); return -1; } int rc = 0; HTMLMediaElement* element = static_cast<HTMLMediaElement*>(m_webCorePlayer->mediaPlayerClient()); Document* topdoc = element->document()->topDocument(); if (topdoc->view() && topdoc->view()->hostWindow()) rc = topdoc->view()->hostWindow()->platformPageClient()->showAlertDialog(atype); return rc; }
nsresult HTMLSourceElement::BindToTree(nsIDocument *aDocument, nsIContent *aParent, nsIContent *aBindingParent, bool aCompileEventHandlers) { nsresult rv = nsGenericHTMLElement::BindToTree(aDocument, aParent, aBindingParent, aCompileEventHandlers); NS_ENSURE_SUCCESS(rv, rv); if (!aParent || !aParent->IsNodeOfType(nsINode::eMEDIA)) return NS_OK; HTMLMediaElement* media = static_cast<HTMLMediaElement*>(aParent); media->NotifyAddedSource(); return NS_OK; }
bool MediaElementSession::canControlControlsManager(const HTMLMediaElement& element) const { if (!element.hasAudio()) return false; if (!playbackPermitted(element)) return false; RenderBox* renderer = downcast<RenderBox>(element.renderer()); if (!renderer) return false; if (isElementLargeEnoughForMainContent(element)) return true; if (ScriptController::processingUserGestureForMedia()) return true; return false; }
static bool shouldShowFullscreenButton(const HTMLMediaElement& mediaElement) { // Unconditionally allow the user to exit fullscreen if we are in it // now. Especially on android, when we might not yet know if // fullscreen is supported, we sometimes guess incorrectly and show // the button earlier, and we don't want to remove it here if the // user chose to enter fullscreen. crbug.com/500732 . if (mediaElement.isFullscreen()) return true; if (!mediaElement.isHTMLVideoElement()) return false; if (!mediaElement.hasVideo()) return false; if (!Fullscreen::fullscreenEnabled(mediaElement.document())) return false; return true; }
MediaElementAudioSourceHandler::MediaElementAudioSourceHandler( AudioNode& node, HTMLMediaElement& mediaElement) : AudioHandler(NodeTypeMediaElementAudioSource, node, node.context()->sampleRate()), m_mediaElement(mediaElement), m_sourceNumberOfChannels(0), m_sourceSampleRate(0), m_passesCurrentSrcCORSAccessCheck( passesCurrentSrcCORSAccessCheck(mediaElement.currentSrc())), m_maybePrintCORSMessage(!m_passesCurrentSrcCORSAccessCheck), m_currentSrcString(mediaElement.currentSrc().getString()) { DCHECK(isMainThread()); // Default to stereo. This could change depending on what the media element // .src is set to. addOutput(2); initialize(); }
bool MediaElementSession::allowsAutomaticMediaDataLoading(const HTMLMediaElement& element) const { if (pageExplicitlyAllowsElementToAutoplayInline(element)) return true; Settings* settings = element.document().settings(); if (settings && settings->mediaDataLoadsAutomatically()) return true; return false; }
static bool isElementLargeRelativeToMainFrame(const HTMLMediaElement& element) { static const double minimumPercentageOfMainFrameAreaForMainContent = 0.9; auto* renderer = element.renderer(); if (!renderer) return false; auto* documentFrame = element.document().frame(); if (!documentFrame) return false; if (!documentFrame->mainFrame().view()) return false; auto& mainFrameView = *documentFrame->mainFrame().view(); auto maxVisibleClientWidth = std::min(renderer->clientWidth().toInt(), mainFrameView.visibleWidth()); auto maxVisibleClientHeight = std::min(renderer->clientHeight().toInt(), mainFrameView.visibleHeight()); return maxVisibleClientWidth * maxVisibleClientHeight > minimumPercentageOfMainFrameAreaForMainContent * mainFrameView.visibleWidth() * mainFrameView.visibleHeight(); }
KURL HitTestResult::absoluteMediaURL() const { #if ENABLE(VIDEO) if (!(m_innerNonSharedNode && m_innerNonSharedNode->document())) return KURL(); if (!(m_innerNonSharedNode->renderer() && m_innerNonSharedNode->renderer()->isMedia())) return KURL(); AtomicString urlString; if (m_innerNonSharedNode->hasTagName(HTMLNames::videoTag) || m_innerNonSharedNode->hasTagName(HTMLNames::audioTag)) { HTMLMediaElement* mediaElement = static_cast<HTMLMediaElement*>(m_innerNonSharedNode.get()); urlString = mediaElement->currentSrc(); } else return KURL(); return m_innerNonSharedNode->document()->completeURL(deprecatedParseURL(urlString)); #else return KURL(); #endif }
void HTMLMediaElementEncryptedMedia::keyAdded(HTMLMediaElement& element, const String& keySystem, const String& sessionId) { WTF_LOG(Media, "HTMLMediaElementEncryptedMedia::mediaPlayerKeyAdded"); MediaKeyEventInit initializer; initializer.setKeySystem(keySystem); initializer.setSessionId(sessionId); RefPtrWillBeRawPtr<Event> event = MediaKeyEvent::create(EventTypeNames::webkitkeyadded, initializer); event->setTarget(&element); element.scheduleEvent(event.release()); }
bool RenderThemeAndroid::shouldRenderMediaControlPart(ControlPart part, Element* e) { HTMLMediaElement* mediaElement = static_cast<HTMLMediaElement*>(e); switch (part) { case MediaMuteButtonPart: return false; case MediaSeekBackButtonPart: case MediaSeekForwardButtonPart: return false; case MediaRewindButtonPart: return mediaElement->movieLoadType() != MediaPlayer::LiveStream; case MediaReturnToRealtimeButtonPart: return mediaElement->movieLoadType() == MediaPlayer::LiveStream; case MediaFullscreenButtonPart: return mediaElement->supportsFullscreen(); case MediaToggleClosedCaptionsButtonPart: return mediaElement->hasClosedCaptions(); default: return true; } }
// static void HTMLMediaElementRemotePlayback::setBooleanAttribute( const QualifiedName& name, HTMLMediaElement& element, bool value) { ASSERT(name == HTMLNames::disableremoteplaybackAttr); element.setBooleanAttribute(name, value); HTMLMediaElementRemotePlayback& self = HTMLMediaElementRemotePlayback::from(element); if (self.m_remote && value) self.m_remote->remotePlaybackDisabled(); }
bool MediaElementSession::requiresFullscreenForVideoPlayback(const HTMLMediaElement& element) const { if (pageExplicitlyAllowsElementToAutoplayInline(element)) return false; if (is<HTMLAudioElement>(element)) return false; Settings* settings = element.document().settings(); if (!settings || !settings->allowsInlineMediaPlayback()) return true; if (!settings->inlineMediaPlaybackRequiresPlaysInlineAttribute()) return false; #if PLATFORM(IOS) if (dyld_get_program_sdk_version() < DYLD_IOS_VERSION_10_0) return !element.hasAttributeWithoutSynchronization(HTMLNames::webkit_playsinlineAttr); #endif return !element.hasAttributeWithoutSynchronization(HTMLNames::playsinlineAttr); }
PassRefPtr<Widget> SubframeLoader::loadMediaPlayerProxyPlugin(Node* node, const URL& url, const Vector<String>& paramNames, const Vector<String>& paramValues) { ASSERT(node->hasTagName(videoTag) || isHTMLAudioElement(node)); URL completedURL; if (!url.isEmpty()) completedURL = completeURL(url); if (!m_frame.document()->securityOrigin()->canDisplay(completedURL)) { FrameLoader::reportLocalLoadFailed(m_frame, completedURL.string()); return 0; } if (!m_frame.document()->contentSecurityPolicy()->allowMediaFromSource(completedURL)) return 0; HTMLMediaElement* mediaElement = toHTMLMediaElement(node); RenderWidget* renderer = toRenderWidget(node->renderer()); IntSize size; if (renderer) size = roundedIntSize(LayoutSize(renderer->contentWidth(), renderer->contentHeight())); else if (mediaElement->isVideo()) size = RenderVideo::defaultSize(); if (!m_frame.loader().mixedContentChecker().canRunInsecureContent(m_frame.document()->securityOrigin(), completedURL)) return 0; RefPtr<Widget> widget = m_frame.loader().client().createMediaPlayerProxyPlugin(size, mediaElement, completedURL, paramNames, paramValues, "application/x-media-element-proxy-plugin"); if (widget && renderer) { renderer->setWidget(widget); renderer->node()->setNeedsStyleRecalc(SyntheticStyleChange); } m_containsPlugins = true; return widget ? widget.release() : 0; }
static bool paintMediaMuteButton(RenderObject* object, const PaintInfo& paintInfo, const IntRect& rect) { HTMLMediaElement* mediaElement = toParentMediaElement(object); if (!mediaElement) return false; static Image* soundLevel3 = platformResource("mediaplayerSoundLevel3"); static Image* soundLevel2 = platformResource("mediaplayerSoundLevel2"); static Image* soundLevel1 = platformResource("mediaplayerSoundLevel1"); static Image* soundLevel0 = platformResource("mediaplayerSoundLevel0"); static Image* soundDisabled = platformResource("mediaplayerSoundDisabled"); if (!hasSource(mediaElement) || !mediaElement->hasAudio()) return paintMediaButton(paintInfo.context, rect, soundDisabled); if (mediaElement->muted() || mediaElement->volume() <= 0) return paintMediaButton(paintInfo.context, rect, soundLevel0); if (mediaElement->volume() <= 0.33) return paintMediaButton(paintInfo.context, rect, soundLevel1); if (mediaElement->volume() <= 0.66) return paintMediaButton(paintInfo.context, rect, soundLevel2); return paintMediaButton(paintInfo.context, rect, soundLevel3); }
void TextTrack::UpdateActiveCueList() { if (!mTextTrackList) { return; } HTMLMediaElement* mediaElement = mTextTrackList->GetMediaElement(); if (!mediaElement) { return; } // If we are dirty, i.e. an event happened that may cause the sorted mCueList // to have changed like a seek or an insert for a cue, than we need to rebuild // the active cue list from scratch. if (mDirty) { mCuePos = 0; mDirty = false; mActiveCueList->RemoveAll(); } double playbackTime = mediaElement->CurrentTime(); // Remove all the cues from the active cue list whose end times now occur // earlier then the current playback time. for (uint32_t i = mActiveCueList->Length(); i > 0; i--) { if ((*mActiveCueList)[i - 1]->EndTime() < playbackTime) { mActiveCueList->RemoveCueAt(i - 1); } } // Add all the cues, starting from the position of the last cue that was // added, that have valid start and end times for the current playback time. // We can stop iterating safely once we encounter a cue that does not have // a valid start time as the cue list is sorted. for (; mCuePos < mCueList->Length() && (*mCueList)[mCuePos]->StartTime() <= playbackTime; mCuePos++) { if ((*mCueList)[mCuePos]->EndTime() >= playbackTime) { mActiveCueList->AddCue(*(*mCueList)[mCuePos]); } } }
void MediaDecoder::ResourceCallback::NotifyDataEnded(nsresult aStatus) { RefPtr<ResourceCallback> self = this; nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () { if (!self->mDecoder) { return; } self->mDecoder->NotifyDownloadEnded(aStatus); if (NS_SUCCEEDED(aStatus)) { HTMLMediaElement* element = self->GetMediaOwner()->GetMediaElement(); if (element) { element->DownloadSuspended(); } // NotifySuspendedStatusChanged will tell the element that download // has been suspended "by the cache", which is true since we never // download anything. The element can then transition to HAVE_ENOUGH_DATA. self->mDecoder->NotifySuspendedStatusChanged(); } }); AbstractThread::MainThread()->Dispatch(r.forget()); }
void MediaPlayerPrivate::resizeSourceDimensions() { if (!m_webCorePlayer) return; HTMLMediaElement* client = static_cast<HTMLMediaElement*>(m_webCorePlayer->mediaPlayerClient()); if (!client || !client->isVideo()) return; RenderObject* o = client->renderer(); if (!o) return; // If we have an HTMLVideoElement but the source has no video, then we need to resize the media element. if (!hasVideo()) { IntRect rect = o->enclosingBox()->contentBoxRect(); static const int playbookMinAudioElementWidth = 300; static const int playbookMinAudioElementHeight = 32; // If the rect dimensions are less than the allowed minimum, use the minimum instead. int newWidth = max(rect.width(), playbookMinAudioElementWidth); int newHeight = max(rect.height(), playbookMinAudioElementHeight); char attrString[12]; sprintf(attrString, "%d", newWidth); client->setAttribute(HTMLNames::widthAttr, attrString); sprintf(attrString, "%d", newHeight); client->setAttribute(HTMLNames::heightAttr, attrString); } // If we don't know what the width and height of the video source is, then we need to set it to something sane. if (m_platformPlayer->sourceWidth() && m_platformPlayer->sourceHeight()) return; IntRect rect = o->enclosingBox()->contentBoxRect(); m_platformPlayer->setSourceDimension(rect.width(), rect.height()); }
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(); }
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; }
already_AddRefed<MediaElementAudioSourceNode> AudioContext::CreateMediaElementSource(HTMLMediaElement& aMediaElement, ErrorResult& aRv) { if (mIsOffline) { aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); return nullptr; } #ifdef MOZ_EME if (aMediaElement.ContainsRestrictedContent()) { aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR); return nullptr; } #endif nsRefPtr<DOMMediaStream> stream = aMediaElement.MozCaptureStream(aRv); if (aRv.Failed()) { return nullptr; } nsRefPtr<MediaElementAudioSourceNode> mediaElementAudioSourceNode = new MediaElementAudioSourceNode(this, stream); return mediaElementAudioSourceNode.forget(); }
bool RenderThemeWinCE::paintSliderTrack(RenderObject* o, const PaintInfo& i, const IntRect& r) { bool rc = RenderTheme::paintSliderTrack(o, i, r); IntPoint left = IntPoint(r.x() + 2, (r.y() + r.maxY()) / 2); i.context->save(); i.context->setStrokeColor(Color::gray, ColorSpaceDeviceRGB); i.context->setFillColor(Color::gray, ColorSpaceDeviceRGB); i.context->fillRect(r); #if ENABLE(VIDEO) HTMLMediaElement* mediaElement = mediaElementParent(o->node()); if (mediaElement) { i.context->setStrokeColor(Color(0, 0xff, 0)); IntPoint right = IntPoint(left.x() + mediaElement->percentLoaded() * (r.maxX() - r.x() - 4), (r.y() + r.maxY()) / 2); i.context->drawLine(left, right); left = right; } #endif i.context->setStrokeColor(Color::black, ColorSpaceDeviceRGB); i.context->drawLine(left, IntPoint(r.maxX() - 2, left.y())); i.context->restore(); return rc; }
void MediaDecoder::ConstructMediaTracks() { MOZ_ASSERT(NS_IsMainThread()); if (mMediaTracksConstructed) { return; } if (!mOwner || !mInfo) { return; } HTMLMediaElement* element = mOwner->GetMediaElement(); if (!element) { return; } mMediaTracksConstructed = true; AudioTrackList* audioList = element->AudioTracks(); if (audioList && mInfo->HasAudio()) { const TrackInfo& info = mInfo->mAudio; nsRefPtr<AudioTrack> track = MediaTrackList::CreateAudioTrack( info.mId, info.mKind, info.mLabel, info.mLanguage, info.mEnabled); audioList->AddTrack(track); } VideoTrackList* videoList = element->VideoTracks(); if (videoList && mInfo->HasVideo()) { const TrackInfo& info = mInfo->mVideo; nsRefPtr<VideoTrack> track = MediaTrackList::CreateVideoTrack( info.mId, info.mKind, info.mLabel, info.mLanguage); videoList->AddTrack(track); track->SetEnabledInternal(info.mEnabled, MediaTrack::FIRE_NO_EVENTS); } }
PassRefPtr<Widget> SubframeLoader::loadMediaPlayerProxyPlugin(Node* node, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues) { ASSERT(node->hasTagName(videoTag) || node->hasTagName(audioTag)); if (!m_frame->script()->xssAuditor()->canLoadObject(url.string())) return 0; KURL completedURL; if (!url.isEmpty()) completedURL = completeURL(url); if (!m_frame->document()->securityOrigin()->canDisplay(completedURL)) { FrameLoader::reportLocalLoadFailed(m_frame, completedURL.string()); return 0; } HTMLMediaElement* mediaElement = static_cast<HTMLMediaElement*>(node); RenderPart* renderer = toRenderPart(node->renderer()); IntSize size; if (renderer) size = IntSize(renderer->contentWidth(), renderer->contentHeight()); else if (mediaElement->isVideo()) size = RenderVideo::defaultSize(); m_frame->loader()->checkIfRunInsecureContent(m_frame->document()->securityOrigin(), completedURL); RefPtr<Widget> widget = m_frame->loader()->client()->createMediaPlayerProxyPlugin(size, mediaElement, completedURL, paramNames, paramValues, "application/x-media-element-proxy-plugin"); if (widget && renderer) { renderer->setWidget(widget); renderer->node()->setNeedsStyleRecalc(SyntheticStyleChange); } m_containsPlugins = true; return widget ? widget.release() : 0; }
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; }