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;
}
