#if ENABLE(WEB_AUDIO)
#include "platform/audio/AudioSourceProvider.h"
-#include "modules/webaudio/MediaElementAudioSourceNode.h"
+#include "platform/audio/AudioSourceProviderClient.h"
#endif
using namespace std;
using namespace HTMLNames;
using namespace std;
-typedef HashMap<Document*, HashSet<HTMLMediaElement*> > DocumentElementSetMap;
+typedef WillBeHeapHashSet<RawPtrWillBeWeakMember<HTMLMediaElement> > WeakMediaElementSet;
+typedef WillBeHeapHashMap<RawPtrWillBeWeakMember<Document>, WeakMediaElementSet> DocumentElementSetMap;
static DocumentElementSetMap& documentToElementSetMap()
{
+#if ENABLE(OILPAN)
+ DEFINE_STATIC_LOCAL(Persistent<DocumentElementSetMap>, map, (new DocumentElementSetMap()));
+ return *map;
+#else
DEFINE_STATIC_LOCAL(DocumentElementSetMap, map, ());
return map;
+#endif
}
static void addElementToDocumentMap(HTMLMediaElement* element, Document* document)
{
DocumentElementSetMap& map = documentToElementSetMap();
- HashSet<HTMLMediaElement*> set = map.take(document);
+ WeakMediaElementSet set = map.take(document);
set.add(element);
map.add(document, set);
}
static void removeElementFromDocumentMap(HTMLMediaElement* element, Document* document)
{
DocumentElementSetMap& map = documentToElementSetMap();
- HashSet<HTMLMediaElement*> set = map.take(document);
+ WeakMediaElementSet set = map.take(document);
set.remove(element);
if (!set.isEmpty())
map.add(document, set);
, m_lastTimeUpdateEventMovieTime(numeric_limits<double>::max())
, m_loadState(WaitingForSource)
, m_webLayer(0)
- , m_opaque(false)
, m_preload(MediaPlayer::Auto)
, m_displayMode(Unknown)
, m_cachedTime(MediaPlayer::invalidTime())
setShouldDelayLoadEvent(false);
+#if !ENABLE(OILPAN)
if (m_textTracks)
m_textTracks->clearOwner();
+#endif
if (m_mediaController) {
m_mediaController->removeMediaElement(this);
closeMediaSource();
+#if !ENABLE(OILPAN)
removeElementFromDocumentMap(this, &document());
+#endif
// Destroying the player may cause a resource load to be canceled,
// which could result in userCancelledLoad() being called back.
// See http://crbug.com/233654 for more details.
m_completelyLoaded = true;
+ // With Oilpan load events on the Document are always delayed during
+ // sweeping so we don't need to explicitly increment and decrement
+ // load event delay counts.
+#if !ENABLE(OILPAN)
// Destroying the player may cause a resource load to be canceled,
// which could result in Document::dispatchWindowLoadEvent() being
// called via ResourceFetch::didLoadResource() then
// object destruction, we use Document::incrementLoadEventDelayCount().
// See http://crbug.com/275223 for more details.
document().incrementLoadEventDelayCount();
+#endif
clearMediaPlayerAndAudioSourceProviderClient();
+#if !ENABLE(OILPAN)
document().decrementLoadEventDelayCount();
+#endif
}
void HTMLMediaElement::didMoveToNewDocument(Document& oldDocument)
if (!autoplay() && m_player)
setPlayerPreload();
- } else if (name == mediagroupAttr) {
+ } else if (name == mediagroupAttr && RuntimeEnabledFeatures::mediaControllerEnabled()) {
setMediaGroup(value);
} else {
HTMLElement::parseAttribute(name, value);
{
HTMLElement::finishParsingChildren();
- if (!RuntimeEnabledFeatures::videoTrackEnabled())
- return;
-
if (Traversal<HTMLTrackElement>::firstChild(*this))
scheduleDelayedAction(LoadTextTrackResource);
}
scheduleDelayedAction(LoadMediaResource);
}
+ return InsertionShouldCallDidNotifySubtreeInsertions;
+}
+
+void HTMLMediaElement::didNotifySubtreeInsertionsToDocument()
+{
configureMediaControls();
- return InsertionDone;
}
void HTMLMediaElement::removedFrom(ContainerNode* insertionPoint)
m_pendingActionFlags |= LoadMediaResource;
}
- if (RuntimeEnabledFeatures::videoTrackEnabled() && (actionType & LoadTextTrackResource))
+ if (actionType & LoadTextTrackResource)
m_pendingActionFlags |= LoadTextTrackResource;
if (!m_loadTimer.isActive())
scheduleEvent(Event::createCancelable(eventName));
}
-void HTMLMediaElement::scheduleEvent(PassRefPtr<Event> event)
+void HTMLMediaElement::scheduleEvent(PassRefPtrWillBeRawPtr<Event> event)
{
#if LOG_MEDIA_EVENTS
WTF_LOG(Media, "HTMLMediaElement::scheduleEvent - scheduling '%s'", event->type().ascii().data());
void HTMLMediaElement::loadTimerFired(Timer<HTMLMediaElement>*)
{
- if (RuntimeEnabledFeatures::videoTrackEnabled() && (m_pendingActionFlags & LoadTextTrackResource))
+ if (m_pendingActionFlags & LoadTextTrackResource)
configureTextTracks();
if (m_pendingActionFlags & LoadMediaResource) {
updateMediaController();
- if (RuntimeEnabledFeatures::videoTrackEnabled())
- updateActiveTextTrackCues(0);
+ updateActiveTextTrackCues(0);
}
// 5 - Set the playbackRate attribute to the value of the defaultPlaybackRate attribute.
- setPlaybackRate(defaultPlaybackRate(), IGNORE_EXCEPTION);
+ setPlaybackRate(defaultPlaybackRate());
// 6 - Set the error attribute to null and the autoplaying flag to true.
m_error = nullptr;
{
// HTMLMediaElement::textTracksAreReady will need "... the text tracks whose mode was not in the
// disabled state when the element's resource selection algorithm last started".
- if (RuntimeEnabledFeatures::videoTrackEnabled()) {
- m_textTracksWhenResourceSelectionBegan.clear();
- if (m_textTracks) {
- for (unsigned i = 0; i < m_textTracks->length(); ++i) {
- TextTrack* track = m_textTracks->item(i);
- if (track->mode() != TextTrack::disabledKeyword())
- m_textTracksWhenResourceSelectionBegan.append(track);
- }
+ m_textTracksWhenResourceSelectionBegan.clear();
+ if (m_textTracks) {
+ for (unsigned i = 0; i < m_textTracks->length(); ++i) {
+ TextTrack* track = m_textTracks->item(i);
+ if (track->mode() != TextTrack::disabledKeyword())
+ m_textTracksWhenResourceSelectionBegan.append(track);
}
}
affectedTracks.append(eventTasks[i].second->track());
// 13 - Queue each task in events, in list order.
- RefPtr<Event> event;
+ RefPtrWillBeRawPtr<Event> event = nullptr;
// Each event in eventTasks may be either an enterEvent or an exitEvent,
// depending on the time that is associated with the event. This
// 15 - For each text track in affected tracks, in the list order, queue a
// task to fire a simple event named cuechange at the TextTrack object, and, ...
for (size_t i = 0; i < affectedTracks.size(); ++i) {
- RefPtr<Event> event = Event::create(EventTypeNames::cuechange);
+ RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::cuechange);
event->setTarget(affectedTracks[i]);
m_asyncEventQueue->enqueueEvent(event.release());
// ... if the text track has a corresponding track element, to then fire a
// simple event named cuechange at the track element as well.
if (affectedTracks[i]->trackType() == TextTrack::TrackElement) {
- RefPtr<Event> event = Event::create(EventTypeNames::cuechange);
+ RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::cuechange);
HTMLTrackElement* trackElement = static_cast<LoadableTextTrack*>(affectedTracks[i])->trackElement();
ASSERT(trackElement);
event->setTarget(trackElement);
textTrackRemoveCue(cues->item(i)->track(), cues->item(i));
}
-void HTMLMediaElement::textTrackAddCue(TextTrack* track, PassRefPtr<TextTrackCue> cue)
+void HTMLMediaElement::textTrackAddCue(TextTrack* track, PassRefPtrWillBeRawPtr<TextTrackCue> cue)
{
if (track->mode() == TextTrack::disabledKeyword())
return;
updateActiveTextTrackCues(currentTime());
}
-void HTMLMediaElement::textTrackRemoveCue(TextTrack*, PassRefPtr<TextTrackCue> cue)
+void HTMLMediaElement::textTrackRemoveCue(TextTrack*, PassRefPtrWillBeRawPtr<TextTrackCue> cue)
{
// Negative duration cues need to be treated in the interval tree as
// zero-length cues.
ReadyState oldState = m_readyState;
ReadyState newState = static_cast<ReadyState>(state);
- bool tracksAreReady = !RuntimeEnabledFeatures::videoTrackEnabled() || textTracksAreReady();
+ bool tracksAreReady = textTracksAreReady();
if (newState == oldState && m_tracksAreReady == tracksAreReady)
return;
updatePlayState();
updateMediaController();
- if (RuntimeEnabledFeatures::videoTrackEnabled())
- updateActiveTextTrackCues(currentTime());
+ updateActiveTextTrackCues(currentTime());
}
void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)
// 3 - Set the seeking IDL attribute to true.
// The flag will be cleared when the engine tells us the time has actually changed.
+ bool previousSeekStillPending = m_seeking;
m_seeking = true;
// 5 - If the new playback position is later than the end of the media resource, then let it be the end
if (noSeekRequired) {
if (time == now) {
scheduleEvent(EventTypeNames::seeking);
+ if (previousSeekStillPending)
+ return;
// FIXME: There must be a stable state before timeupdate+seeked are dispatched and seeking
// is reset to false. See http://crbug.com/266631
scheduleTimeupdateEvent(false);
void HTMLMediaElement::setCurrentTime(double time, ExceptionState& exceptionState)
{
- // FIXME: generated bindings should check isfinite: http://crbug.com/354298
- if (!std::isfinite(time)) {
- exceptionState.throwTypeError(ExceptionMessages::notAFiniteNumber(time));
- return;
- }
if (m_mediaController) {
exceptionState.throwDOMException(InvalidStateError, "The element is slaved to a MediaController.");
return;
return m_defaultPlaybackRate;
}
-void HTMLMediaElement::setDefaultPlaybackRate(double rate, ExceptionState& exceptionState)
+void HTMLMediaElement::setDefaultPlaybackRate(double rate)
{
- // FIXME: generated bindings should check isfinite: http://crbug.com/354298
- if (!std::isfinite(rate)) {
- exceptionState.throwTypeError(ExceptionMessages::notAFiniteNumber(rate));
+ if (m_defaultPlaybackRate == rate)
return;
- }
- if (m_defaultPlaybackRate != rate) {
- m_defaultPlaybackRate = rate;
- scheduleEvent(EventTypeNames::ratechange);
- }
+
+ m_defaultPlaybackRate = rate;
+ scheduleEvent(EventTypeNames::ratechange);
}
double HTMLMediaElement::playbackRate() const
return m_playbackRate;
}
-void HTMLMediaElement::setPlaybackRate(double rate, ExceptionState& exceptionState)
+void HTMLMediaElement::setPlaybackRate(double rate)
{
WTF_LOG(Media, "HTMLMediaElement::setPlaybackRate(%f)", rate);
- // FIXME: generated bindings should check isfinite: http://crbug.com/354298
- if (!std::isfinite(rate)) {
- exceptionState.throwTypeError(ExceptionMessages::notAFiniteNumber(rate));
- return;
- }
-
if (m_playbackRate != rate) {
m_playbackRate = rate;
invalidateCachedTime();
{
WTF_LOG(Media, "HTMLMediaElement::setVolume(%f)", vol);
- // FIXME: generated bindings should check isfinite: http://crbug.com/354298
- if (!std::isfinite(vol)) {
- exceptionState.throwTypeError(ExceptionMessages::notAFiniteNumber(vol));
+ if (m_volume == vol)
return;
- }
if (vol < 0.0f || vol > 1.0f) {
exceptionState.throwDOMException(IndexSizeError, ExceptionMessages::indexOutsideRange("volume", vol, 0.0, ExceptionMessages::InclusiveBound, 1.0, ExceptionMessages::InclusiveBound));
return;
}
- if (m_volume != vol) {
- m_volume = vol;
- updateVolume();
- scheduleEvent(EventTypeNames::volumechange);
- }
+ m_volume = vol;
+ updateVolume();
+ scheduleEvent(EventTypeNames::volumechange);
}
bool HTMLMediaElement::muted() const
updateVolume();
- if (hasMediaControls())
- mediaControls()->changedMute();
-
scheduleEvent(EventTypeNames::volumechange);
}
if (!m_paused && hasMediaControls())
mediaControls()->playbackProgressed();
- if (RuntimeEnabledFeatures::videoTrackEnabled())
- updateActiveTextTrackCues(currentTime());
+ updateActiveTextTrackCues(currentTime());
}
void HTMLMediaElement::scheduleTimeupdateEvent(bool periodicEvent)
void HTMLMediaElement::mediaPlayerDidAddTextTrack(WebInbandTextTrack* webTrack)
{
- if (!RuntimeEnabledFeatures::videoTrackEnabled())
- return;
-
// 4.8.10.12.2 Sourcing in-band text tracks
// 1. Associate the relevant data with a new text track and its corresponding new TextTrack object.
- RefPtr<InbandTextTrack> textTrack = InbandTextTrack::create(document(), webTrack);
+ RefPtrWillBeRawPtr<InbandTextTrack> textTrack = InbandTextTrack::create(document(), webTrack);
// 2. Set the new text track's kind, label, and language based on the semantics of the relevant data,
// as defined by the relevant specification. If there is no label in that data, then the label must
void HTMLMediaElement::mediaPlayerDidRemoveTextTrack(WebInbandTextTrack* webTrack)
{
- if (!RuntimeEnabledFeatures::videoTrackEnabled())
- return;
-
if (!m_textTracks)
return;
// This cast is safe because we created the InbandTextTrack with the WebInbandTextTrack
// passed to mediaPlayerDidAddTextTrack.
- RefPtr<InbandTextTrack> textTrack = static_cast<InbandTextTrack*>(webTrack->client());
+ RefPtrWillBeRawPtr<InbandTextTrack> textTrack = static_cast<InbandTextTrack*>(webTrack->client());
if (!textTrack)
return;
}
}
-PassRefPtr<TextTrack> HTMLMediaElement::addTextTrack(const AtomicString& kind, const AtomicString& label, const AtomicString& language, ExceptionState& exceptionState)
+PassRefPtrWillBeRawPtr<TextTrack> HTMLMediaElement::addTextTrack(const AtomicString& kind, const AtomicString& label, const AtomicString& language, ExceptionState& exceptionState)
{
- ASSERT(RuntimeEnabledFeatures::videoTrackEnabled());
-
// 4.8.10.12.4 Text track API
// The addTextTrack(kind, label, language) method of media elements, when invoked, must run the following steps:
// 5. Create a new text track corresponding to the new object, and set its text track kind to kind, its text
// track label to label, its text track language to language...
- RefPtr<TextTrack> textTrack = TextTrack::create(document(), kind, label, language);
+ RefPtrWillBeRawPtr<TextTrack> textTrack = TextTrack::create(document(), kind, label, language);
// Note, due to side effects when changing track parameters, we have to
// first append the track to the text track list.
TextTrackList* HTMLMediaElement::textTracks()
{
- ASSERT(RuntimeEnabledFeatures::videoTrackEnabled());
-
if (!m_textTracks)
m_textTracks = TextTrackList::create(this);
void HTMLMediaElement::didAddTrackElement(HTMLTrackElement* trackElement)
{
- if (!RuntimeEnabledFeatures::videoTrackEnabled())
- return;
-
// 4.8.10.12.3 Sourcing out-of-band text tracks
// When a track element's parent element changes and the new parent is a media element,
// then the user agent must add the track element's corresponding text track to the
// media element's list of text tracks ... [continues in TextTrackList::append]
- RefPtr<TextTrack> textTrack = trackElement->track();
+ RefPtrWillBeRawPtr<TextTrack> textTrack = trackElement->track();
if (!textTrack)
return;
void HTMLMediaElement::didRemoveTrackElement(HTMLTrackElement* trackElement)
{
- if (!RuntimeEnabledFeatures::videoTrackEnabled())
- return;
-
#if !LOG_DISABLED
KURL url = trackElement->getNonEmptyURLAttribute(srcAttr);
WTF_LOG(Media, "HTMLMediaElement::didRemoveTrackElement - 'src' is %s", urlForLoggingMedia(url).utf8().data());
#endif
- RefPtr<TextTrack> textTrack = trackElement->track();
+ RefPtrWillBeRawPtr<TextTrack> textTrack = trackElement->track();
if (!textTrack)
return;
if (languageMatchIndex >= languages.size())
return 0;
- // Matching a track language is more important than matching track type, so this multiplier must be
- // greater than the maximum value returned by textTrackSelectionScore.
- return (languages.size() - languageMatchIndex) * 10;
+ return languages.size() - languageMatchIndex;
}
-static int textTrackSelectionScore(const TextTrack& track, Settings* settings)
+static int textTrackSelectionScore(const TextTrack& track)
{
- int trackScore = 0;
-
- if (!settings)
- return trackScore;
-
if (track.kind() != TextTrack::captionsKeyword() && track.kind() != TextTrack::subtitlesKeyword())
- return trackScore;
-
- if (track.kind() == TextTrack::subtitlesKeyword() && settings->shouldDisplaySubtitles())
- trackScore = 1;
- else if (track.kind() == TextTrack::captionsKeyword() && settings->shouldDisplayCaptions())
- trackScore = 1;
+ return 0;
- return trackScore + textTrackLanguageSelectionScore(track);
+ return textTrackLanguageSelectionScore(track);
}
void HTMLMediaElement::configureTextTrackGroup(const TrackGroup& group)
WTF_LOG(Media, "HTMLMediaElement::configureTextTrackGroup(%d)", group.kind);
- Settings* settings = document().settings();
-
// First, find the track in the group that should be enabled (if any).
- Vector<RefPtr<TextTrack> > currentlyEnabledTracks;
- RefPtr<TextTrack> trackToEnable;
- RefPtr<TextTrack> defaultTrack;
- RefPtr<TextTrack> fallbackTrack;
+ WillBeHeapVector<RefPtrWillBeMember<TextTrack> > currentlyEnabledTracks;
+ RefPtrWillBeRawPtr<TextTrack> trackToEnable = nullptr;
+ RefPtrWillBeRawPtr<TextTrack> defaultTrack = nullptr;
+ RefPtrWillBeRawPtr<TextTrack> fallbackTrack = nullptr;
int highestTrackScore = 0;
for (size_t i = 0; i < group.tracks.size(); ++i) {
- RefPtr<TextTrack> textTrack = group.tracks[i];
+ RefPtrWillBeRawPtr<TextTrack> textTrack = group.tracks[i];
if (m_processingPreferenceChange && textTrack->mode() == TextTrack::showingKeyword())
currentlyEnabledTracks.append(textTrack);
- int trackScore = textTrackSelectionScore(*textTrack, settings);
+ int trackScore = textTrackSelectionScore(*textTrack);
if (trackScore) {
// * If the text track kind is { [subtitles or captions] [descriptions] } and the user has indicated an interest in having a
// track with this text track kind, text track language, and text track label enabled, and there is no
if (currentlyEnabledTracks.size()) {
for (size_t i = 0; i < currentlyEnabledTracks.size(); ++i) {
- RefPtr<TextTrack> textTrack = currentlyEnabledTracks[i];
+ RefPtrWillBeRawPtr<TextTrack> textTrack = currentlyEnabledTracks[i];
if (textTrack != trackToEnable)
textTrack->setMode(TextTrack::disabledKeyword());
}
return;
for (size_t i = 0; i < m_textTracks->length(); ++i) {
- RefPtr<TextTrack> textTrack = m_textTracks->item(i);
+ RefPtrWillBeRawPtr<TextTrack> textTrack = m_textTracks->item(i);
if (!textTrack)
continue;
{
// Stash the current <source> node and next nodes so we can restore them after checking
// to see there is another potential.
- RefPtr<HTMLSourceElement> currentSourceNode = m_currentSourceNode;
- RefPtr<Node> nextNode = m_nextChildNodeToConsider;
+ RefPtrWillBeRawPtr<HTMLSourceElement> currentSourceNode = m_currentSourceNode;
+ RefPtrWillBeRawPtr<Node> nextNode = m_nextChildNodeToConsider;
KURL nextURL = selectNextSourceChild(0, 0, DoNothing);
{
WTF_LOG(Media, "HTMLMediaElement::mediaPlayerTimeChanged");
- if (RuntimeEnabledFeatures::videoTrackEnabled())
- updateActiveTextTrackCues(currentTime());
+ updateActiveTextTrackCues(currentTime());
invalidateCachedTime();
webMediaPlayer()->setVolume(playerVolume());
if (hasMediaControls())
- mediaControls()->changedVolume();
+ mediaControls()->updateVolume();
}
double HTMLMediaElement::playerVolume() const
// Reset m_readyState since m_player is gone.
m_readyState = HAVE_NOTHING;
updateMediaController();
- if (RuntimeEnabledFeatures::videoTrackEnabled())
- updateActiveTextTrackCues(0);
+ updateActiveTextTrackCues(0);
}
void HTMLMediaElement::clearMediaPlayerAndAudioSourceProviderClient()
{
WTF_LOG(Media, "HTMLMediaElement::enterFullscreen");
- if (document().settings() && document().settings()->fullScreenEnabled())
- FullscreenElementStack::from(document()).requestFullScreenForElement(this, 0, FullscreenElementStack::ExemptIFrameAllowFullScreenRequirement);
+ FullscreenElementStack::from(document()).requestFullScreenForElement(this, 0, FullscreenElementStack::ExemptIFrameAllowFullScreenRequirement);
}
void HTMLMediaElement::exitFullscreen()
{
WTF_LOG(Media, "HTMLMediaElement::exitFullscreen");
- if (document().settings() && document().settings()->fullScreenEnabled() && isFullscreen())
- FullscreenElementStack::from(document()).webkitCancelFullScreen();
+ FullscreenElementStack::from(document()).webkitCancelFullScreen();
}
void HTMLMediaElement::didBecomeFullscreenElement()
bool HTMLMediaElement::hasClosedCaptions() const
{
- if (RuntimeEnabledFeatures::videoTrackEnabled() && m_textTracks) {
+ if (m_textTracks) {
for (unsigned i = 0; i < m_textTracks->length(); ++i) {
if (m_textTracks->item(i)->readinessState() == TextTrack::FailedToLoad)
continue;
m_closedCaptionsVisible = closedCaptionVisible;
- if (RuntimeEnabledFeatures::videoTrackEnabled()) {
- m_processingPreferenceChange = true;
- markCaptionAndSubtitleTracksAsUnconfigured();
- m_processingPreferenceChange = false;
+ m_processingPreferenceChange = true;
+ markCaptionAndSubtitleTracksAsUnconfigured();
+ m_processingPreferenceChange = false;
- updateTextTrackDisplay();
- }
+ updateTextTrackDisplay();
}
unsigned HTMLMediaElement::webkitAudioDecodedByteCount() const
mediaControls()->changedClosedCaptionsVisibility();
- if (RuntimeEnabledFeatures::videoTrackEnabled()) {
- updateActiveTextTrackCues(currentTime());
- updateTextTrackDisplay();
- }
+ updateActiveTextTrackCues(currentTime());
+ updateTextTrackDisplay();
}
void HTMLMediaElement::markCaptionAndSubtitleTracksAsUnconfigured()
// captions and non-default tracks should be displayed based on language
// preferences if the user has turned captions on).
for (unsigned i = 0; i < m_textTracks->length(); ++i) {
- RefPtr<TextTrack> textTrack = m_textTracks->item(i);
+ RefPtrWillBeRawPtr<TextTrack> textTrack = m_textTracks->item(i);
String kind = textTrack->kind();
if (kind == TextTrack::subtitlesKeyword() || kind == TextTrack::captionsKeyword())
#if ENABLE(WEB_AUDIO)
if (m_audioSourceNode) {
- // When creating the player, make sure its AudioSourceProvider knows about the MediaElementAudioSourceNode.
+ // When creating the player, make sure its AudioSourceProvider knows about the client.
if (audioSourceProvider())
audioSourceProvider()->setClient(m_audioSourceNode);
}
#if ENABLE(WEB_AUDIO)
-void HTMLMediaElement::setAudioSourceNode(MediaElementAudioSourceNode* sourceNode)
+void HTMLMediaElement::setAudioSourceNode(AudioSourceProviderClient* sourceNode)
{
m_audioSourceNode = sourceNode;
// 4. If there is another media element whose Document is the same as m's Document (even if one or both
// of these elements are not actually in the Document),
- HashSet<HTMLMediaElement*> elements = documentToElementSetMap().get(&document());
- for (HashSet<HTMLMediaElement*>::iterator i = elements.begin(); i != elements.end(); ++i) {
+ WeakMediaElementSet elements = documentToElementSetMap().get(&document());
+ for (WeakMediaElementSet::iterator i = elements.begin(); i != elements.end(); ++i) {
if (*i == this)
continue;
m_mediaController = controller;
- if (m_mediaController) {
- UseCounter::count(document(), UseCounter::HTMLMediaElementControllerNotNull);
+ if (m_mediaController)
m_mediaController->addMediaElement(this);
- }
}
void HTMLMediaElement::updateMediaController()
// If either of the layers is null we need to enable or disable compositing. This is done by triggering a style recalc.
if (!m_webLayer || !webLayer)
- scheduleLayerUpdate();
+ setNeedsCompositingUpdate();
if (m_webLayer)
GraphicsLayer::unregisterContentsLayer(m_webLayer);
m_webLayer = webLayer;
if (m_webLayer) {
- m_webLayer->setOpaque(m_opaque);
GraphicsLayer::registerContentsLayer(m_webLayer);
}
}
-void HTMLMediaElement::mediaPlayerSetOpaque(bool opaque)
-{
- m_opaque = opaque;
- if (m_webLayer)
- m_webLayer->setOpaque(m_opaque);
-}
-
void HTMLMediaElement::mediaPlayerMediaSourceOpened(blink::WebMediaSource* webMediaSource)
{
m_mediaSource->setWebMediaSourceAndOpen(adoptPtr(webMediaSource));
return fastHasAttribute(controlsAttr);
}
+void HTMLMediaElement::trace(Visitor* visitor)
+{
+ visitor->trace(m_currentSourceNode);
+ visitor->trace(m_nextChildNodeToConsider);
+ visitor->trace(m_textTracks);
+ visitor->trace(m_textTracksWhenResourceSelectionBegan);
+ WillBeHeapSupplementable<HTMLMediaElement>::trace(visitor);
+ HTMLElement::trace(visitor);
+}
+
}
projects / platform / framework / web / crosswalk.git / blobdiff