[SCM] WebKit Debian packaging branch, debian/experimental, updated. upstream/1.3.3-9427-gc2be6fc
eric.carlson at apple.com
eric.carlson at apple.com
Wed Dec 22 13:15:01 UTC 2010
The following commit has been merged in the debian/experimental branch:
commit 574f0c594a2ee778afafaabdd0407f966d2e27eb
Author: eric.carlson at apple.com <eric.carlson at apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Thu Sep 9 21:07:12 2010 +0000
2010-09-09 Eric Carlson <eric.carlson at apple.com>
Reviewed by Chris Marrin.
Add media element logging
https://bugs.webkit.org/show_bug.cgi?id=45469
Add logging at interesting points in a media element's lifecycle.
* html/HTMLMediaElement.cpp:
(WebCore::urlForLogging):
(WebCore::boolString):
(WebCore::HTMLMediaElement::scheduleEvent):
(WebCore::HTMLMediaElement::asyncEventTimerFired):
(WebCore::HTMLMediaElement::canPlayType):
(WebCore::HTMLMediaElement::load):
(WebCore::HTMLMediaElement::prepareForLoad):
(WebCore::HTMLMediaElement::selectMediaResource):
(WebCore::HTMLMediaElement::loadResource):
(WebCore::HTMLMediaElement::isSafeToLoadURL):
(WebCore::HTMLMediaElement::waitForSourceChange):
(WebCore::HTMLMediaElement::noneSupported):
(WebCore::HTMLMediaElement::mediaEngineError):
(WebCore::HTMLMediaElement::cancelPendingEventsAndCallbacks):
(WebCore::HTMLMediaElement::setNetworkState):
(WebCore::HTMLMediaElement::setReadyState):
(WebCore::HTMLMediaElement::rewind):
(WebCore::HTMLMediaElement::returnToRealtime):
(WebCore::HTMLMediaElement::addPlayedRange):
(WebCore::HTMLMediaElement::seek):
(WebCore::HTMLMediaElement::finishSeek):
(WebCore::HTMLMediaElement::setPlaybackRate):
(WebCore::HTMLMediaElement::setWebkitPreservesPitch):
(WebCore::HTMLMediaElement::setAutoplay):
(WebCore::HTMLMediaElement::setPreload):
(WebCore::HTMLMediaElement::play):
(WebCore::HTMLMediaElement::playInternal):
(WebCore::HTMLMediaElement::pause):
(WebCore::HTMLMediaElement::pauseInternal):
(WebCore::HTMLMediaElement::setLoop):
(WebCore::HTMLMediaElement::setControls):
(WebCore::HTMLMediaElement::setVolume):
(WebCore::HTMLMediaElement::setMuted):
(WebCore::HTMLMediaElement::togglePlayState):
(WebCore::HTMLMediaElement::beginScrubbing):
(WebCore::HTMLMediaElement::endScrubbing):
(WebCore::HTMLMediaElement::selectNextSourceChild):
(WebCore::HTMLMediaElement::mediaPlayerTimeChanged):
(WebCore::HTMLMediaElement::mediaPlayerVolumeChanged):
(WebCore::HTMLMediaElement::mediaPlayerMuteChanged):
(WebCore::HTMLMediaElement::mediaPlayerDurationChanged):
(WebCore::HTMLMediaElement::mediaPlayerRateChanged):
(WebCore::HTMLMediaElement::mediaPlayerPlaybackStateChanged):
(WebCore::HTMLMediaElement::mediaPlayerSawUnsupportedTracks):
(WebCore::HTMLMediaElement::mediaPlayerSizeChanged):
(WebCore::HTMLMediaElement::mediaPlayerRenderingModeChanged):
(WebCore::HTMLMediaElement::updatePlayState):
(WebCore::HTMLMediaElement::userCancelledLoad):
(WebCore::HTMLMediaElement::stop):
(WebCore::HTMLMediaElement::suspend):
(WebCore::HTMLMediaElement::resume):
(WebCore::HTMLMediaElement::hasPendingActivity):
(WebCore::HTMLMediaElement::mediaVolumeDidChange):
(WebCore::HTMLMediaElement::createMediaPlayerProxy):
(WebCore::HTMLMediaElement::enterFullscreen):
(WebCore::HTMLMediaElement::exitFullscreen):
(WebCore::HTMLMediaElement::setClosedCaptionsVisible):
(WebCore::HTMLMediaElement::mediaCanStart):
(WebCore::HTMLMediaElement::setShouldDelayLoadEvent):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@67114 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index 663dd14..546344f 100644
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,73 @@
+2010-09-09 Eric Carlson <eric.carlson at apple.com>
+
+ Reviewed by Chris Marrin.
+
+ Add media element logging
+ https://bugs.webkit.org/show_bug.cgi?id=45469
+
+ Add logging at interesting points in a media element's lifecycle.
+
+ * html/HTMLMediaElement.cpp:
+ (WebCore::urlForLogging):
+ (WebCore::boolString):
+ (WebCore::HTMLMediaElement::scheduleEvent):
+ (WebCore::HTMLMediaElement::asyncEventTimerFired):
+ (WebCore::HTMLMediaElement::canPlayType):
+ (WebCore::HTMLMediaElement::load):
+ (WebCore::HTMLMediaElement::prepareForLoad):
+ (WebCore::HTMLMediaElement::selectMediaResource):
+ (WebCore::HTMLMediaElement::loadResource):
+ (WebCore::HTMLMediaElement::isSafeToLoadURL):
+ (WebCore::HTMLMediaElement::waitForSourceChange):
+ (WebCore::HTMLMediaElement::noneSupported):
+ (WebCore::HTMLMediaElement::mediaEngineError):
+ (WebCore::HTMLMediaElement::cancelPendingEventsAndCallbacks):
+ (WebCore::HTMLMediaElement::setNetworkState):
+ (WebCore::HTMLMediaElement::setReadyState):
+ (WebCore::HTMLMediaElement::rewind):
+ (WebCore::HTMLMediaElement::returnToRealtime):
+ (WebCore::HTMLMediaElement::addPlayedRange):
+ (WebCore::HTMLMediaElement::seek):
+ (WebCore::HTMLMediaElement::finishSeek):
+ (WebCore::HTMLMediaElement::setPlaybackRate):
+ (WebCore::HTMLMediaElement::setWebkitPreservesPitch):
+ (WebCore::HTMLMediaElement::setAutoplay):
+ (WebCore::HTMLMediaElement::setPreload):
+ (WebCore::HTMLMediaElement::play):
+ (WebCore::HTMLMediaElement::playInternal):
+ (WebCore::HTMLMediaElement::pause):
+ (WebCore::HTMLMediaElement::pauseInternal):
+ (WebCore::HTMLMediaElement::setLoop):
+ (WebCore::HTMLMediaElement::setControls):
+ (WebCore::HTMLMediaElement::setVolume):
+ (WebCore::HTMLMediaElement::setMuted):
+ (WebCore::HTMLMediaElement::togglePlayState):
+ (WebCore::HTMLMediaElement::beginScrubbing):
+ (WebCore::HTMLMediaElement::endScrubbing):
+ (WebCore::HTMLMediaElement::selectNextSourceChild):
+ (WebCore::HTMLMediaElement::mediaPlayerTimeChanged):
+ (WebCore::HTMLMediaElement::mediaPlayerVolumeChanged):
+ (WebCore::HTMLMediaElement::mediaPlayerMuteChanged):
+ (WebCore::HTMLMediaElement::mediaPlayerDurationChanged):
+ (WebCore::HTMLMediaElement::mediaPlayerRateChanged):
+ (WebCore::HTMLMediaElement::mediaPlayerPlaybackStateChanged):
+ (WebCore::HTMLMediaElement::mediaPlayerSawUnsupportedTracks):
+ (WebCore::HTMLMediaElement::mediaPlayerSizeChanged):
+ (WebCore::HTMLMediaElement::mediaPlayerRenderingModeChanged):
+ (WebCore::HTMLMediaElement::updatePlayState):
+ (WebCore::HTMLMediaElement::userCancelledLoad):
+ (WebCore::HTMLMediaElement::stop):
+ (WebCore::HTMLMediaElement::suspend):
+ (WebCore::HTMLMediaElement::resume):
+ (WebCore::HTMLMediaElement::hasPendingActivity):
+ (WebCore::HTMLMediaElement::mediaVolumeDidChange):
+ (WebCore::HTMLMediaElement::createMediaPlayerProxy):
+ (WebCore::HTMLMediaElement::enterFullscreen):
+ (WebCore::HTMLMediaElement::exitFullscreen):
+ (WebCore::HTMLMediaElement::setClosedCaptionsVisible):
+ (WebCore::HTMLMediaElement::mediaCanStart):
+ (WebCore::HTMLMediaElement::setShouldDelayLoadEvent):
+
2010-09-09 Anton Muhin <antonm at chromium.org>
Reviewed by Adam Barth.
diff --git a/WebCore/html/HTMLMediaElement.cpp b/WebCore/html/HTMLMediaElement.cpp
index 9c2c15c..1d4a1bd 100644
--- a/WebCore/html/HTMLMediaElement.cpp
+++ b/WebCore/html/HTMLMediaElement.cpp
@@ -48,6 +48,7 @@
#include "HTMLNames.h"
#include "HTMLSourceElement.h"
#include "HTMLVideoElement.h"
+#include "Logging.h"
#include "MediaDocument.h"
#include "MediaError.h"
#include "MediaList.h"
@@ -78,6 +79,28 @@ using namespace std;
namespace WebCore {
+#if !LOG_DISABLED
+static String urlForLogging(const String& url)
+{
+ static unsigned maximumURLLengthForLogging = 128;
+
+ if (url.length() < maximumURLLengthForLogging)
+ return url;
+ return url.substring(0, maximumURLLengthForLogging) + "...";
+}
+
+static const char *boolString(bool val)
+{
+ return val ? "true" : "false";
+}
+#endif
+
+#ifndef LOG_MEDIA_EVENTS
+// Default to not logging events because so many are generated they can overwhelm the rest of
+// the logging.
+#define LOG_MEDIA_EVENTS 0
+#endif
+
using namespace HTMLNames;
HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName, Document* document)
@@ -366,6 +389,9 @@ void HTMLMediaElement::scheduleNextSourceChild()
void HTMLMediaElement::scheduleEvent(const AtomicString& eventName)
{
+#if LOG_MEDIA_EVENTS
+ LOG(Media, "HTMLMediaElement::scheduleEvent - scheduling '%s'", eventName.string().ascii().data());
+#endif
m_pendingEvents.append(Event::create(eventName, false, true));
if (!m_asyncEventTimer.isActive())
m_asyncEventTimer.startOneShot(0);
@@ -388,6 +414,9 @@ void HTMLMediaElement::asyncEventTimerFired(Timer<HTMLMediaElement>*)
m_pendingEvents.swap(pendingEvents);
unsigned count = pendingEvents.size();
for (unsigned ndx = 0; ndx < count; ++ndx) {
+#if LOG_MEDIA_EVENTS
+ LOG(Media, "HTMLMediaElement::asyncEventTimerFired - dispatching '%s'", pendingEvents[ndx]->type().string().ascii().data());
+#endif
if (pendingEvents[ndx]->type() == eventNames().canplayEvent) {
m_dispatchingCanPlayEvent = true;
dispatchEvent(pendingEvents[ndx].release(), ec);
@@ -480,11 +509,15 @@ String HTMLMediaElement::canPlayType(const String& mimeType) const
break;
}
+ LOG(Media, "HTMLMediaElement::canPlayType(%s) -> %s", mimeType.utf8().data(), canPlay.utf8().data());
+
return canPlay;
}
void HTMLMediaElement::load(bool isUserGesture, ExceptionCode& ec)
{
+ LOG(Media, "HTMLMediaElement::load(isUserGesture : %s)", boolString(isUserGesture));
+
if (m_restrictions & RequireUserGestureForLoadRestriction && !isUserGesture)
ec = INVALID_STATE_ERR;
else {
@@ -496,6 +529,8 @@ void HTMLMediaElement::load(bool isUserGesture, ExceptionCode& ec)
void HTMLMediaElement::prepareForLoad()
{
+ LOG(Media, "HTMLMediaElement::prepareForLoad");
+
// Perform the cleanup required for the resource load algorithm to run.
stopPeriodicTimers();
m_loadTimer.stop();
@@ -579,6 +614,8 @@ void HTMLMediaElement::loadInternal()
void HTMLMediaElement::selectMediaResource()
{
+ LOG(Media, "HTMLMediaElement::selectMediaResource");
+
enum Mode { attribute, children };
Mode mode = attribute;
@@ -597,6 +634,8 @@ void HTMLMediaElement::selectMediaResource()
// ... set the networkState to NETWORK_EMPTY, and abort these steps
m_networkState = NETWORK_EMPTY;
+
+ LOG(Media, "HTMLMediaElement::selectMediaResource, nothing to load");
return;
}
@@ -617,6 +656,7 @@ void HTMLMediaElement::selectMediaResource()
KURL mediaURL = getNonEmptyURLAttribute(srcAttr);
if (mediaURL.isEmpty()) {
noneSupported();
+ LOG(Media, "HTMLMediaElement::selectMediaResource, empty 'src'");
return;
}
@@ -627,6 +667,7 @@ void HTMLMediaElement::selectMediaResource()
} else
noneSupported();
+ LOG(Media, "HTMLMediaElement::selectMediaResource, 'src' not used");
return;
}
@@ -657,6 +698,8 @@ void HTMLMediaElement::loadResource(const KURL& initialURL, ContentType& content
{
ASSERT(isSafeToLoadURL(initialURL, Complain));
+ LOG(Media, "HTMLMediaElement::loadResource(%s, %s)", urlForLogging(initialURL.string()).utf8().data(), contentType.raw().utf8().data());
+
Frame* frame = document()->frame();
if (!frame)
return;
@@ -673,6 +716,8 @@ void HTMLMediaElement::loadResource(const KURL& initialURL, ContentType& content
m_currentSrc = url;
+ LOG(Media, "HTMLMediaElement::loadResource - m_currentSrc -> %s", urlForLogging(m_currentSrc).utf8().data());
+
if (m_sendProgressEvents)
startProgressEventTimer();
@@ -693,8 +738,10 @@ void HTMLMediaElement::loadResource(const KURL& initialURL, ContentType& content
bool HTMLMediaElement::isSafeToLoadURL(const KURL& url, InvalidSourceAction actionIfInvalid)
{
- if (!url.isValid())
+ if (!url.isValid()) {
+ LOG(Media, "HTMLMediaElement::isSafeToLoadURL(%s) -> FALSE because url is invalid", urlForLogging(url.string()).utf8().data());
return false;
+ }
Frame* frame = document()->frame();
FrameLoader* loader = frame ? frame->loader() : 0;
@@ -703,6 +750,7 @@ bool HTMLMediaElement::isSafeToLoadURL(const KURL& url, InvalidSourceAction acti
if (!loader || !SecurityOrigin::canDisplay(url, String(), document())) {
if (actionIfInvalid == Complain)
FrameLoader::reportLocalLoadFailed(frame, url.string());
+ LOG(Media, "HTMLMediaElement::isSafeToLoadURL(%s) -> FALSE rejected by SecurityOrigin", urlForLogging(url.string()).utf8().data());
return false;
}
@@ -722,6 +770,8 @@ void HTMLMediaElement::startProgressEventTimer()
void HTMLMediaElement::waitForSourceChange()
{
+ LOG(Media, "HTMLMediaElement::waitForSourceChange");
+
stopPeriodicTimers();
m_loadState = WaitingForSource;
@@ -734,6 +784,8 @@ void HTMLMediaElement::waitForSourceChange()
void HTMLMediaElement::noneSupported()
{
+ LOG(Media, "HTMLMediaElement::noneSupported");
+
stopPeriodicTimers();
m_loadState = WaitingForSource;
m_currentSourceNode = 0;
@@ -764,6 +816,8 @@ void HTMLMediaElement::noneSupported()
void HTMLMediaElement::mediaEngineError(PassRefPtr<MediaError> err)
{
+ LOG(Media, "HTMLMediaElement::mediaEngineError(%d)", static_cast<int>(err->code()));
+
// 1 - The user agent should cancel the fetching process.
stopPeriodicTimers();
m_loadState = WaitingForSource;
@@ -789,6 +843,8 @@ void HTMLMediaElement::mediaEngineError(PassRefPtr<MediaError> err)
void HTMLMediaElement::cancelPendingEventsAndCallbacks()
{
+ LOG(Media, "HTMLMediaElement::cancelPendingEventsAndCallbacks");
+
m_pendingEvents.clear();
for (Node* node = firstChild(); node; node = node->nextSibling()) {
@@ -816,6 +872,8 @@ void HTMLMediaElement::mediaPlayerNetworkStateChanged(MediaPlayer*)
void HTMLMediaElement::setNetworkState(MediaPlayer::NetworkState state)
{
+ LOG(Media, "HTMLMediaElement::setNetworkState(%d) - current state is %d", static_cast<int>(state), static_cast<int>(m_networkState));
+
if (state == MediaPlayer::Empty) {
// just update the cached state and leave, we can't do anything
m_networkState = NETWORK_EMPTY;
@@ -829,10 +887,13 @@ void HTMLMediaElement::setNetworkState(MediaPlayer::NetworkState state)
// <source> children, schedule the next one
if (m_readyState < HAVE_METADATA && m_loadState == LoadingFromSourceElement) {
m_currentSourceNode->scheduleErrorEvent();
- if (havePotentialSourceChild())
+ if (havePotentialSourceChild()) {
+ LOG(Media, "HTMLMediaElement::setNetworkState scheduling next <source>");
scheduleNextSourceChild();
- else
+ } else {
+ LOG(Media, "HTMLMediaElement::setNetworkState no more <source> elements, waiting");
waitForSourceChange();
+ }
return;
}
@@ -886,6 +947,8 @@ void HTMLMediaElement::mediaPlayerReadyStateChanged(MediaPlayer*)
void HTMLMediaElement::setReadyState(MediaPlayer::ReadyState state)
{
+ LOG(Media, "HTMLMediaElement::setReadyState(%d) - current state is %d,", static_cast<int>(state), static_cast<int>(m_readyState));
+
// Set "wasPotentiallyPlaying" BEFORE updating m_readyState, potentiallyPlaying() uses it
bool wasPotentiallyPlaying = potentiallyPlaying();
@@ -999,18 +1062,22 @@ void HTMLMediaElement::progressEventTimerFired(Timer<HTMLMediaElement>*)
void HTMLMediaElement::rewind(float timeDelta)
{
+ LOG(Media, "HTMLMediaElement::rewind(%f)", timeDelta);
+
ExceptionCode e;
setCurrentTime(max(currentTime() - timeDelta, minTimeSeekable()), e);
}
void HTMLMediaElement::returnToRealtime()
{
+ LOG(Media, "HTMLMediaElement::returnToRealtime");
ExceptionCode e;
setCurrentTime(maxTimeSeekable(), e);
}
void HTMLMediaElement::addPlayedRange(float start, float end)
{
+ LOG(Media, "HTMLMediaElement::addPlayedRange(%f, %f)", start, end);
if (!m_playedTimeRanges)
m_playedTimeRanges = TimeRanges::create();
m_playedTimeRanges->add(start, end);
@@ -1023,6 +1090,8 @@ bool HTMLMediaElement::supportsSave() const
void HTMLMediaElement::seek(float time, ExceptionCode& ec)
{
+ LOG(Media, "HTMLMediaElement::seek(%f)", time);
+
// 4.8.9.9 Seeking
// 1 - If the media element's readyState is HAVE_NOTHING, then raise an INVALID_STATE_ERR exception.
@@ -1075,6 +1144,8 @@ void HTMLMediaElement::seek(float time, ExceptionCode& ec)
void HTMLMediaElement::finishSeek()
{
+ LOG(Media, "HTMLMediaElement::finishSeek");
+
// 4.8.10.10 Seeking step 12
m_seeking = false;
@@ -1159,6 +1230,8 @@ float HTMLMediaElement::playbackRate() const
void HTMLMediaElement::setPlaybackRate(float rate)
{
+ LOG(Media, "HTMLMediaElement::setPlaybackRate(%f)", rate);
+
if (m_playbackRate != rate) {
m_playbackRate = rate;
scheduleEvent(eventNames().ratechangeEvent);
@@ -1174,6 +1247,8 @@ bool HTMLMediaElement::webkitPreservesPitch() const
void HTMLMediaElement::setWebkitPreservesPitch(bool preservesPitch)
{
+ LOG(Media, "HTMLMediaElement::setWebkitPreservesPitch(%s)", boolString(preservesPitch));
+
m_webkitPreservesPitch = preservesPitch;
if (!m_player)
@@ -1197,6 +1272,7 @@ bool HTMLMediaElement::autoplay() const
void HTMLMediaElement::setAutoplay(bool b)
{
+ LOG(Media, "HTMLMediaElement::setAutoplay(%s)", boolString(b));
setBooleanAttribute(autoplayAttr, b);
}
@@ -1220,11 +1296,14 @@ String HTMLMediaElement::preload() const
void HTMLMediaElement::setPreload(const String& preload)
{
+ LOG(Media, "HTMLMediaElement::setPreload(%s)", preload.utf8().data());
setAttribute(preloadAttr, preload);
}
void HTMLMediaElement::play(bool isUserGesture)
{
+ LOG(Media, "HTMLMediaElement::play(isUserGesture : %s)", boolString(isUserGesture));
+
if (m_restrictions & RequireUserGestureForRateChangeRestriction && !isUserGesture)
return;
@@ -1244,6 +1323,8 @@ void HTMLMediaElement::play(bool isUserGesture)
void HTMLMediaElement::playInternal()
{
+ LOG(Media, "HTMLMediaElement::playInternal");
+
// 4.8.10.9. Playing the media resource
if (!m_player || m_networkState == NETWORK_EMPTY)
scheduleLoad();
@@ -1271,6 +1352,8 @@ void HTMLMediaElement::playInternal()
void HTMLMediaElement::pause(bool isUserGesture)
{
+ LOG(Media, "HTMLMediaElement::pause(isUserGesture : %s)", boolString(isUserGesture));
+
if (m_restrictions & RequireUserGestureForRateChangeRestriction && !isUserGesture)
return;
@@ -1280,6 +1363,8 @@ void HTMLMediaElement::pause(bool isUserGesture)
void HTMLMediaElement::pauseInternal()
{
+ LOG(Media, "HTMLMediaElement::pauseInternal");
+
// 4.8.10.9. Playing the media resource
if (!m_player || m_networkState == NETWORK_EMPTY)
scheduleLoad();
@@ -1302,6 +1387,7 @@ bool HTMLMediaElement::loop() const
void HTMLMediaElement::setLoop(bool b)
{
+ LOG(Media, "HTMLMediaElement::setLoop(%s)", boolString(b));
setBooleanAttribute(loopAttr, b);
}
@@ -1318,6 +1404,7 @@ bool HTMLMediaElement::controls() const
void HTMLMediaElement::setControls(bool b)
{
+ LOG(Media, "HTMLMediaElement::setControls(%s)", boolString(b));
setBooleanAttribute(controlsAttr, b);
}
@@ -1328,6 +1415,8 @@ float HTMLMediaElement::volume() const
void HTMLMediaElement::setVolume(float vol, ExceptionCode& ec)
{
+ LOG(Media, "HTMLMediaElement::setControls(%f)", vol);
+
if (vol < 0.0f || vol > 1.0f) {
ec = INDEX_SIZE_ERR;
return;
@@ -1347,6 +1436,8 @@ bool HTMLMediaElement::muted() const
void HTMLMediaElement::setMuted(bool muted)
{
+ LOG(Media, "HTMLMediaElement::setMuted(%s)", boolString(muted));
+
if (m_muted != muted) {
m_muted = muted;
// Avoid recursion when the player reports volume changes.
@@ -1364,6 +1455,8 @@ void HTMLMediaElement::setMuted(bool muted)
void HTMLMediaElement::togglePlayState()
{
+ LOG(Media, "HTMLMediaElement::togglePlayState - canPlay() is %s", boolString(canPlay()));
+
// We can safely call the internal play/pause methods, which don't check restrictions, because
// this method is only called from the built-in media controller
if (canPlay())
@@ -1374,6 +1467,8 @@ void HTMLMediaElement::togglePlayState()
void HTMLMediaElement::beginScrubbing()
{
+ LOG(Media, "HTMLMediaElement::beginScrubbing - paused() is %s", boolString(paused()));
+
if (!paused()) {
if (ended()) {
// Because a media element stays in non-paused state when it reaches end, playback resumes
@@ -1391,6 +1486,8 @@ void HTMLMediaElement::beginScrubbing()
void HTMLMediaElement::endScrubbing()
{
+ LOG(Media, "HTMLMediaElement::beginScrubbing - m_pausedInternal is %s", boolString(m_pausedInternal));
+
if (m_pausedInternal)
setPausedInternal(false);
}
@@ -1477,6 +1574,13 @@ bool HTMLMediaElement::havePotentialSourceChild()
KURL HTMLMediaElement::selectNextSourceChild(ContentType *contentType, InvalidSourceAction actionIfInvalid)
{
+#if !LOG_DISABLED
+ // Don't log if this was just called to find out if there are any valid <source> elements.
+ bool shouldLog = actionIfInvalid != DoNothing;
+ if (shouldLog)
+ LOG(Media, "HTMLMediaElement::selectNextSourceChild(contentType : \"%s\")", contentType ? contentType->raw().utf8().data() : "");
+#endif
+
KURL mediaURL;
Node* node;
bool lookingForPreviousNode = m_currentSourceNode;
@@ -1496,17 +1600,29 @@ KURL HTMLMediaElement::selectNextSourceChild(ContentType *contentType, InvalidSo
// If candidate does not have a src attribute, or if its src attribute's value is the empty string ... jump down to the failed step below
mediaURL = source->getNonEmptyURLAttribute(srcAttr);
+#if !LOG_DISABLED
+ if (shouldLog)
+ LOG(Media, "HTMLMediaElement::selectNextSourceChild - 'src' is %s", urlForLogging(mediaURL).utf8().data());
+#endif
if (mediaURL.isEmpty())
goto check_again;
if (source->hasAttribute(mediaAttr)) {
MediaQueryEvaluator screenEval("screen", document()->frame(), renderer() ? renderer()->style() : 0);
RefPtr<MediaList> media = MediaList::createAllowingDescriptionSyntax(source->media());
+#if !LOG_DISABLED
+ if (shouldLog)
+ LOG(Media, "HTMLMediaElement::selectNextSourceChild - 'media' is %s", source->media().utf8().data());
+#endif
if (!screenEval.eval(media.get()))
goto check_again;
}
if (source->hasAttribute(typeAttr)) {
+#if !LOG_DISABLED
+ if (shouldLog)
+ LOG(Media, "HTMLMediaElement::selectNextSourceChild - 'type' is %s", source->type().utf8().data());
+#endif
if (!MediaPlayer::supportsType(ContentType(source->type())))
goto check_again;
}
@@ -1528,11 +1644,17 @@ check_again:
if (!canUse)
m_currentSourceNode = 0;
+#if !LOG_DISABLED
+ if (shouldLog)
+ LOG(Media, "HTMLMediaElement::selectNextSourceChild -> %s", canUse ? urlForLogging(mediaURL.string()).utf8().data() : "");
+#endif
return canUse ? mediaURL : KURL();
}
void HTMLMediaElement::mediaPlayerTimeChanged(MediaPlayer*)
{
+ LOG(Media, "HTMLMediaElement::mediaPlayerTimeChanged");
+
beginProcessingMediaPlayerCallback();
// Always call scheduleTimeupdateEvent when the media engine reports a time discontinuity,
@@ -1567,6 +1689,8 @@ void HTMLMediaElement::mediaPlayerTimeChanged(MediaPlayer*)
void HTMLMediaElement::mediaPlayerVolumeChanged(MediaPlayer*)
{
+ LOG(Media, "HTMLMediaElement::mediaPlayerVolumeChanged");
+
beginProcessingMediaPlayerCallback();
if (m_player)
m_volume = m_player->volume();
@@ -1576,6 +1700,8 @@ void HTMLMediaElement::mediaPlayerVolumeChanged(MediaPlayer*)
void HTMLMediaElement::mediaPlayerMuteChanged(MediaPlayer*)
{
+ LOG(Media, "HTMLMediaElement::mediaPlayerMuteChanged");
+
beginProcessingMediaPlayerCallback();
if (m_player)
setMuted(m_player->muted());
@@ -1584,6 +1710,8 @@ void HTMLMediaElement::mediaPlayerMuteChanged(MediaPlayer*)
void HTMLMediaElement::mediaPlayerDurationChanged(MediaPlayer*)
{
+ LOG(Media, "HTMLMediaElement::mediaPlayerDurationChanged");
+
beginProcessingMediaPlayerCallback();
scheduleEvent(eventNames().durationchangeEvent);
if (renderer())
@@ -1593,6 +1721,8 @@ void HTMLMediaElement::mediaPlayerDurationChanged(MediaPlayer*)
void HTMLMediaElement::mediaPlayerRateChanged(MediaPlayer*)
{
+ LOG(Media, "HTMLMediaElement::mediaPlayerRateChanged");
+
beginProcessingMediaPlayerCallback();
// Stash the rate in case the one we tried to set isn't what the engine is
// using (eg. it can't handle the rate we set)
@@ -1602,6 +1732,8 @@ void HTMLMediaElement::mediaPlayerRateChanged(MediaPlayer*)
void HTMLMediaElement::mediaPlayerPlaybackStateChanged(MediaPlayer*)
{
+ LOG(Media, "HTMLMediaElement::mediaPlayerPlaybackStateChanged");
+
if (!m_player)
return;
@@ -1615,6 +1747,8 @@ void HTMLMediaElement::mediaPlayerPlaybackStateChanged(MediaPlayer*)
void HTMLMediaElement::mediaPlayerSawUnsupportedTracks(MediaPlayer*)
{
+ LOG(Media, "HTMLMediaElement::mediaPlayerSawUnsupportedTracks");
+
// The MediaPlayer came across content it cannot completely handle.
// This is normally acceptable except when we are in a standalone
// MediaDocument. If so, tell the document what has happened.
@@ -1636,6 +1770,8 @@ void HTMLMediaElement::mediaPlayerRepaint(MediaPlayer*)
void HTMLMediaElement::mediaPlayerSizeChanged(MediaPlayer*)
{
+ LOG(Media, "HTMLMediaElement::mediaPlayerSizeChanged");
+
beginProcessingMediaPlayerCallback();
if (renderer())
renderer()->updateFromElement();
@@ -1654,6 +1790,8 @@ bool HTMLMediaElement::mediaPlayerRenderingCanBeAccelerated(MediaPlayer*)
void HTMLMediaElement::mediaPlayerRenderingModeChanged(MediaPlayer*)
{
+ LOG(Media, "HTMLMediaElement::mediaPlayerRenderingModeChanged");
+
// Kick off a fake recalcStyle that will update the compositing tree.
setNeedsStyleRecalc(SyntheticStyleChange);
}
@@ -1789,6 +1927,9 @@ void HTMLMediaElement::updatePlayState()
bool shouldBePlaying = potentiallyPlaying();
bool playerPaused = m_player->paused();
+ LOG(Media, "HTMLMediaElement::updatePlayState - shouldBePlaying = %s, playerPaused = %s",
+ boolString(shouldBePlaying), boolString(playerPaused));
+
if (shouldBePlaying) {
setDisplayMode(Video);
@@ -1834,6 +1975,8 @@ void HTMLMediaElement::stopPeriodicTimers()
void HTMLMediaElement::userCancelledLoad()
{
+ LOG(Media, "HTMLMediaElement::userCancelledLoad");
+
if (m_networkState == NETWORK_EMPTY || m_completelyLoaded)
return;
@@ -1879,11 +2022,14 @@ bool HTMLMediaElement::canSuspend() const
void HTMLMediaElement::stop()
{
+ LOG(Media, "HTMLMediaElement::stop");
suspend();
}
void HTMLMediaElement::suspend()
{
+ LOG(Media, "HTMLMediaElement::suspend");
+
if (m_isFullscreen)
exitFullscreen();
@@ -1902,6 +2048,8 @@ void HTMLMediaElement::suspend()
void HTMLMediaElement::resume()
{
+ LOG(Media, "HTMLMediaElement::resume");
+
m_inActiveDocument = true;
setPausedInternal(false);
@@ -1922,11 +2070,14 @@ bool HTMLMediaElement::hasPendingActivity() const
{
// Return true when we have pending events so we can't fire events after the JS
// object gets collected.
- return m_pendingEvents.size();
+ bool pending = m_pendingEvents.size();
+ LOG(Media, "HTMLMediaElement::hasPendingActivity -> %s", boolString(pending));
+ return pending;
}
void HTMLMediaElement::mediaVolumeDidChange()
{
+ LOG(Media, "HTMLMediaElement::mediaVolumeDidChange");
updateVolume();
}
@@ -2038,6 +2189,8 @@ void HTMLMediaElement::createMediaPlayerProxy()
if (!loader)
return;
+ LOG(Media, "HTMLMediaElement::createMediaPlayerProxy");
+
KURL url;
Vector<String> paramNames;
Vector<String> paramValues;
@@ -2068,6 +2221,8 @@ void HTMLMediaElement::updateWidget(bool)
void HTMLMediaElement::enterFullscreen()
{
+ LOG(Media, "HTMLMediaElement::enterFullscreen");
+
ASSERT(!m_isFullscreen);
m_isFullscreen = true;
if (document() && document()->page()) {
@@ -2078,6 +2233,8 @@ void HTMLMediaElement::enterFullscreen()
void HTMLMediaElement::exitFullscreen()
{
+ LOG(Media, "HTMLMediaElement::exitFullscreen");
+
ASSERT(m_isFullscreen);
m_isFullscreen = false;
if (document() && document()->page()) {
@@ -2110,6 +2267,8 @@ bool HTMLMediaElement::closedCaptionsVisible() const
void HTMLMediaElement::setClosedCaptionsVisible(bool closedCaptionVisible)
{
+ LOG(Media, "HTMLMediaElement::setClosedCaptionsVisible(%s)", boolString(closedCaptionVisible));
+
if (!m_player ||!hasClosedCaptions())
return;
@@ -2137,6 +2296,8 @@ bool HTMLMediaElement::webkitHasClosedCaptions() const
void HTMLMediaElement::mediaCanStart()
{
+ LOG(Media, "HTMLMediaElement::mediaCanStart");
+
ASSERT(m_isWaitingUntilMediaCanStart);
m_isWaitingUntilMediaCanStart = false;
loadInternal();
@@ -2166,6 +2327,8 @@ void HTMLMediaElement::setShouldDelayLoadEvent(bool shouldDelay)
return;
}
+ LOG(Media, "HTMLMediaElement::setShouldDelayLoadEvent(%s)", boolString(shouldDelay));
+
m_shouldDelayLoadEvent = shouldDelay;
m_isWaitingToDecrementLoadEventDelayCount = false;
if (shouldDelay)
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list