media: Replace wtf/Assertions.h macros in favor of base/logging.h macros

third_party/WebKit/Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 76 matching lines @@
 #include "public/platform/WebInbandTextTrack.h"
 #include "public/platform/WebMediaPlayerSource.h"
 #include "public/platform/WebMediaStream.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackClient.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackState.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/CString.h"
 #include <limits>
 
+#define LOG_LEVEL 3

[fs, 2016/05/18 13:24:36]

LOG_LEVEL is a pretty generic name, so clashes doesn't seem unlikely. Maybe
qualify/prefix with something that reduces the risk (MEDIA_LOG_LEVEL?)

[Srirama, 2016/05/18 13:55:01]

Done.

+
 #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
 
 #ifndef LOG_CACHED_TIME_WARNINGS
 // Default to not logging warnings about excessive drift in the cached media time because it adds a
 // fair amount of overhead and logging.
 #define LOG_CACHED_TIME_WARNINGS 0
@@ skipping 319 matching lines @@
     , m_textTracks(nullptr)
     , m_playPromiseResolveTask(CancellableTaskFactory::create(this, &HTMLMediaElement::resolvePlayPromises))
     , m_playPromiseRejectTask(CancellableTaskFactory::create(this, &HTMLMediaElement::rejectPlayPromises))
     , m_audioSourceNode(nullptr)
     , m_autoplayHelperClient(AutoplayHelperClientImpl::create(this))
     , m_autoplayHelper(AutoplayExperimentHelper::create(m_autoplayHelperClient.get()))
     , m_remotePlaybackClient(nullptr)
 {
     ThreadState::current()->registerPreFinalizer(this);
 
-    WTF_LOG(Media, "HTMLMediaElement::HTMLMediaElement(%p)", this);
+    DVLOG(LOG_LEVEL) << "HTMLMediaElement(" << this << ")";
 
     if (document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
         m_userGestureRequiredForPlay = true;
 
     setHasCustomStyleCallbacks();
     addElementToDocumentMap(this, &document);
 
     UseCounter::count(document, UseCounter::HTMLMediaElement);
 }
 
 HTMLMediaElement::~HTMLMediaElement()
 {
-    WTF_LOG(Media, "HTMLMediaElement::~HTMLMediaElement(%p)", this);
+    DVLOG(LOG_LEVEL) << "~HTMLMediaElement(" << this << ")";
 
     // m_audioSourceNode is explicitly cleared by AudioNode::dispose().
     // Since AudioNode::dispose() is guaranteed to be always called before
     // the AudioNode is destructed, m_audioSourceNode is explicitly cleared
     // even if the AudioNode and the HTMLMediaElement die together.
     ASSERT(!m_audioSourceNode);
 }
 
 void HTMLMediaElement::dispose()
 {
     closeMediaSource();
 
     // Destroying the player may cause a resource load to be canceled,
     // which could result in LocalDOMWindow::dispatchWindowLoadEvent() being
     // called via ResourceFetch::didLoadResource(), then
     // FrameLoader::checkCompleted(). But it's guaranteed that the load event
     // doesn't get dispatched during the object destruction.
     // See Document::isDelayingLoadEvent().
     // Also see http://crbug.com/275223 for more details.
     clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
 }
 
 void HTMLMediaElement::didMoveToNewDocument(Document& oldDocument)
 {
-    WTF_LOG(Media, "HTMLMediaElement::didMoveToNewDocument(%p)", this);
+    DVLOG(LOG_LEVEL) << "didMoveToNewDocument";
 
     if (m_shouldDelayLoadEvent) {
         document().incrementLoadEventDelayCount();
         // Note: Keeping the load event delay count increment on oldDocument that was added
         // when m_shouldDelayLoadEvent was set so that destruction of m_webMediaPlayer can not
         // cause load event dispatching in oldDocument.
     } else {
         // Incrementing the load event delay count so that destruction of m_webMediaPlayer can not
         // cause load event dispatching in oldDocument.
         oldDocument.incrementLoadEventDelayCount();
@@ skipping 66 matching lines @@
     return shouldShowControls() && HTMLElement::layoutObjectIsNeeded(style);
 }
 
 LayoutObject* HTMLMediaElement::createLayoutObject(const ComputedStyle&)
 {
     return new LayoutMedia(this);
 }
 
 Node::InsertionNotificationRequest HTMLMediaElement::insertedInto(ContainerNode* insertionPoint)
 {
-    WTF_LOG(Media, "HTMLMediaElement::insertedInto(%p, %p)", this, insertionPoint);
+    DVLOG(LOG_LEVEL) << "insertedInto(" << insertionPoint << ")";
 
     HTMLElement::insertedInto(insertionPoint);
     if (insertionPoint->inShadowIncludingDocument()) {
         UseCounter::count(document(), UseCounter::HTMLMediaElementInDocument);
         if ((!getAttribute(srcAttr).isEmpty() || m_srcObject) && m_networkState == NETWORK_EMPTY) {
             m_ignorePreloadNone = false;
             invokeLoadAlgorithm();
         }
     }
 
     return InsertionShouldCallDidNotifySubtreeInsertions;
 }
 
 void HTMLMediaElement::didNotifySubtreeInsertionsToDocument()
 {
     configureMediaControls();
 }
 
 void HTMLMediaElement::removedFrom(ContainerNode* insertionPoint)
 {
-    WTF_LOG(Media, "HTMLMediaElement::removedFrom(%p, %p)", this, insertionPoint);
+    DVLOG(LOG_LEVEL) << "removedFrom(" << insertionPoint << ")";
 
     HTMLElement::removedFrom(insertionPoint);
     if (insertionPoint->inActiveDocument()) {
         configureMediaControls();
         if (m_networkState > NETWORK_EMPTY)
             pauseInternal();
     }
 }
 
 void HTMLMediaElement::attach(const AttachContext& context)
 {
     HTMLElement::attach(context);
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::didRecalcStyle(StyleRecalcChange)
 {
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::scheduleTextTrackResourceLoad()
 {
-    WTF_LOG(Media, "HTMLMediaElement::scheduleTextTrackResourceLoad(%p)", this);
+    DVLOG(LOG_LEVEL) << "scheduleTextTrackResourceLoad";
 
     m_pendingActionFlags |= LoadTextTrackResource;
 
     if (!m_loadTimer.isActive())
         m_loadTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::scheduleNextSourceChild()
 {
     // Schedule the timer to try the next <source> element WITHOUT resetting state ala invokeLoadAlgorithm.
     m_pendingActionFlags |= LoadMediaResource;
     m_loadTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::scheduleEvent(const AtomicString& eventName)
 {
     scheduleEvent(Event::createCancelable(eventName));
 }
 
 void HTMLMediaElement::scheduleEvent(Event* event)
 {
 #if LOG_MEDIA_EVENTS
-    WTF_LOG(Media, "HTMLMediaElement::scheduleEvent(%p) - scheduling '%s'", this, event->type().ascii().data());
+    DVLOG(LOG_LEVEL) << "scheduleEvent - scheduling '" << event->type().ascii().data() << "'";
 #endif
     m_asyncEventQueue->enqueueEvent(event);
 }
 
 void HTMLMediaElement::loadTimerFired(Timer<HTMLMediaElement>*)
 {
     if (m_pendingActionFlags & LoadTextTrackResource)
         honorUserPreferencesForAutomaticTextTrackSelection();
 
     if (m_pendingActionFlags & LoadMediaResource) {
@@ skipping 38 matching lines @@
         canPlay = emptyString();
         break;
     case WebMimeRegistry::MayBeSupported:
         canPlay = "maybe";
         break;
     case WebMimeRegistry::IsSupported:
         canPlay = "probably";
         break;
     }
 
-    WTF_LOG(Media, "HTMLMediaElement::canPlayType(%p, %s) -> %s", this, mimeType.utf8().data(), canPlay.utf8().data());
+    DVLOG(LOG_LEVEL) << "canPlayType(" << this << ", " << mimeType.utf8().data() << ") -> " << canPlay.utf8().data();
 
     return canPlay;
 }
 
 void HTMLMediaElement::load()
 {
-    WTF_LOG(Media, "HTMLMediaElement::load(%p)", this);
+    DVLOG(LOG_LEVEL) << "load";
 
     m_autoplayHelper->loadMethodCalled();
 
     m_ignorePreloadNone = true;
     invokeLoadAlgorithm();
 }
 
 // TODO(srirama.m): Currently m_ignorePreloadNone is reset before calling
 // invokeLoadAlgorithm() in all places except load(). Move it inside here
 // once microtask is implemented for "Await a stable state" step
 // in resource selection algorithm.
 void HTMLMediaElement::invokeLoadAlgorithm()
 {
-    WTF_LOG(Media, "HTMLMediaElement::invokeLoadAlgorithm(%p)", this);
+    DVLOG(LOG_LEVEL) << "invokeLoadAlgorithm";
 
     // Perform the cleanup required for the resource load algorithm to run.
     stopPeriodicTimers();
     m_loadTimer.stop();
     cancelDeferredLoad();
     // FIXME: Figure out appropriate place to reset LoadTextTrackResource if necessary and set m_pendingActionFlags to 0 here.
     m_pendingActionFlags &= ~LoadMediaResource;
     m_sentEndEvent = false;
     m_sentStalledEvent = false;
     m_haveFiredLoadedData = false;
@@ skipping 67 matching lines @@
     m_autoplaying = true;
 
     // 7 - Invoke the media element's resource selection algorithm.
     invokeResourceSelectionAlgorithm();
 
     // 8 - Note: Playback of any previously playing media resource for this element stops.
 }
 
 void HTMLMediaElement::invokeResourceSelectionAlgorithm()
 {
-    WTF_LOG(Media, "HTMLMediaElement::invokeResourceSelectionAlgorithm(%p)", this);
+    DVLOG(LOG_LEVEL) << "invokeResourceSelectionAlgorithm";
     // The resource selection algorithm
     // 1 - Set the networkState to NETWORK_NO_SOURCE
     setNetworkState(NETWORK_NO_SOURCE);
 
     // 2 - Set the element's show poster flag to true
     // TODO(srirama.m): Introduce show poster flag and update it as per spec
 
     m_playedTimeRanges = TimeRanges::create();
 
     // FIXME: Investigate whether these can be moved into m_networkState != NETWORK_EMPTY block above
@@ skipping 23 matching lines @@
             if (track->mode() != TextTrack::disabledKeyword())
                 m_textTracksWhenResourceSelectionBegan.append(track);
         }
     }
 
     selectMediaResource();
 }
 
 void HTMLMediaElement::selectMediaResource()
 {
-    WTF_LOG(Media, "HTMLMediaElement::selectMediaResource(%p)", this);
+    DVLOG(LOG_LEVEL) << "selectMediaResource";
 
     enum Mode { Object, Attribute, Children, Nothing };
     Mode mode = Nothing;
 
     // 6 - If the media element has an assigned media provider object, then let
     //     mode be object.
     if (m_srcObject) {
         mode = Object;
     } else if (fastHasAttribute(srcAttr)) {
         // Otherwise, if the media element has no assigned media provider object
@@ skipping 10 matching lines @@
     } else {
         // Otherwise the media element has no assigned media provider object and
         // has neither a src attribute nor a source element child: set the
         // networkState to NETWORK_EMPTY, and abort these steps; the synchronous
         // section ends.
         m_loadState = WaitingForSource;
         setShouldDelayLoadEvent(false);
         setNetworkState(NETWORK_EMPTY);
         updateDisplayState();
 
-        WTF_LOG(Media, "HTMLMediaElement::selectMediaResource(%p), nothing to load", this);
+        DVLOG(LOG_LEVEL) << "selectMediaResource, nothing to load";
         return;
     }
 
     // 7 - Set the media element's networkState to NETWORK_LOADING.
     setNetworkState(NETWORK_LOADING);
 
     // 8 - Queue a task to fire a simple event named loadstart at the media element.
     scheduleEvent(EventTypeNames::loadstart);
 
     // 9 - Run the appropriate steps...
     switch (mode) {
     case Object:
         loadSourceFromObject();
-        WTF_LOG(Media, "HTMLMediaElement::selectMediaResource(%p), using 'srcObject' attribute", this);
+        DVLOG(LOG_LEVEL) << "selectMediaResource, using 'srcObject' attribute";
         break;
     case Attribute:
         loadSourceFromAttribute();
-        WTF_LOG(Media, "HTMLMediaElement::selectMediaResource(%p), using 'src' attribute url", this);
+        DVLOG(LOG_LEVEL) << "selectMediaResource, using 'src' attribute url";
         break;
     case Children:
         loadNextSourceChild();
-        WTF_LOG(Media, "HTMLMediaElement::selectMediaResource(%p), using source element", this);
+        DVLOG(LOG_LEVEL) << "selectMediaResource, using source element";
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 void HTMLMediaElement::loadSourceFromObject()
 {
     ASSERT(m_srcObject);
     m_loadState = LoadingFromSrcObject;
 
     // No type is available when the resource comes from the 'srcObject'
     // attribute.
     ContentType contentType((String()));
     loadResource(WebMediaPlayerSource(WebMediaStream(m_srcObject)), contentType);
 }
 
 void HTMLMediaElement::loadSourceFromAttribute()
 {
     m_loadState = LoadingFromSrcAttr;
     const AtomicString& srcValue = fastGetAttribute(srcAttr);
 
     // If the src attribute's value is the empty string ... jump down to the failed step below
     if (srcValue.isEmpty()) {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
-        WTF_LOG(Media, "HTMLMediaElement::selectMediaResource(%p), empty 'src'", this);
+        DVLOG(LOG_LEVEL) << "selectMediaResource, empty 'src'";
         return;
     }
 
     KURL mediaURL = document().completeURL(srcValue);
     if (!isSafeToLoadURL(mediaURL, Complain)) {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
         return;
     }
 
     // No type is available when the url comes from the 'src' attribute so
@@ skipping 18 matching lines @@
     loadResource(WebMediaPlayerSource(WebURL(mediaURL)), contentType);
 }
 
 void HTMLMediaElement::loadResource(const WebMediaPlayerSource& source, ContentType& contentType)
 {
     ASSERT(isMainThread());
     KURL url;
     if (source.isURL()) {
         url = source.getAsURL();
         ASSERT(isSafeToLoadURL(url, Complain));
-        WTF_LOG(Media, "HTMLMediaElement::loadResource(%p, %s, %s)", this, urlForLoggingMedia(url).utf8().data(), contentType.raw().utf8().data());
+        DVLOG(LOG_LEVEL) << "loadResource(" << urlForLoggingMedia(url).utf8().data() << ", " << contentType.raw().utf8().data() << ")";
     }
 
     LocalFrame* frame = document().frame();
     if (!frame) {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
         return;
     }
 
     // The resource fetch algorithm
     setNetworkState(NETWORK_LOADING);
 
     m_autoplayHelper->loadingStarted();
 
     // Set m_currentSrc *before* changing to the cache url, the fact that we are loading from the app
     // cache is an internal detail not exposed through the media element API.
     m_currentSrc = url;
 
     if (m_audioSourceNode)
         m_audioSourceNode->onCurrentSrcChanged(m_currentSrc);
 
-    WTF_LOG(Media, "HTMLMediaElement::loadResource(%p) - m_currentSrc -> %s", this, urlForLoggingMedia(m_currentSrc).utf8().data());
+    DVLOG(LOG_LEVEL) << "loadResource - m_currentSrc -> " << urlForLoggingMedia(m_currentSrc).utf8().data();
 
     startProgressEventTimer();
 
     // Reset display mode to force a recalculation of what to show because we are resetting the player.
     setDisplayMode(Unknown);
 
     setPlayerPreload();
 
     if (fastHasAttribute(mutedAttr))
         m_muted = true;
@@ skipping 23 matching lines @@
     }
 
     bool canLoadResource = source.isMediaStream() || canLoadURL(url, contentType);
     if (attemptLoad && canLoadResource) {
         ASSERT(!webMediaPlayer());
 
         // Conditionally defer the load if effective preload is 'none'.
         // Skip this optional deferral for MediaStream sources or any blob URL,
         // including MediaSource blob URLs.
         if (!isStreamOrBlobUrl && effectivePreloadType() == WebMediaPlayer::PreloadNone) {
-            WTF_LOG(Media, "HTMLMediaElement::loadResource(%p) : Delaying load because preload == 'none'", this);
+            DVLOG(LOG_LEVEL) << "loadResource : Delaying load because preload == 'none'";
             deferLoad();
         } else {
             startPlayerLoad();
         }
     } else {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
     }
 
     // If there is no poster to display, allow the media engine to render video frames as soon as
     // they are available.
@@ skipping 200 matching lines @@
 }
 
 void HTMLMediaElement::disableAutomaticTextTrackSelection()
 {
     m_shouldPerformAutomaticTrackSelection = false;
 }
 
 bool HTMLMediaElement::isSafeToLoadURL(const KURL& url, InvalidURLAction actionIfInvalid)
 {
     if (!url.isValid()) {
-        WTF_LOG(Media, "HTMLMediaElement::isSafeToLoadURL(%p, %s) -> FALSE because url is invalid", this, urlForLoggingMedia(url).utf8().data());
+        DVLOG(LOG_LEVEL) << "isSafeToLoadURL(" << urlForLoggingMedia(url).utf8().data() << ") -> FALSE because url is invalid";
         return false;
     }
 
     LocalFrame* frame = document().frame();
     if (!frame || !document().getSecurityOrigin()->canDisplay(url)) {
         if (actionIfInvalid == Complain)
             FrameLoader::reportLocalLoadFailed(frame, url.elidedString());
-        WTF_LOG(Media, "HTMLMediaElement::isSafeToLoadURL(%p, %s) -> FALSE rejected by SecurityOrigin", this, urlForLoggingMedia(url).utf8().data());
+        DVLOG(LOG_LEVEL) << "isSafeToLoadURL(" << urlForLoggingMedia(url).utf8().data() << ") -> FALSE rejected by SecurityOrigin";
         return false;
     }
 
     if (!document().contentSecurityPolicy()->allowMediaFromSource(url)) {
-        WTF_LOG(Media, "HTMLMediaElement::isSafeToLoadURL(%p, %s) -> rejected by Content Security Policy", this, urlForLoggingMedia(url).utf8().data());
+        DVLOG(LOG_LEVEL) << "isSafeToLoadURL(" << urlForLoggingMedia(url).utf8().data() << ") -> rejected by Content Security Policy";
         return false;
     }
 
     return true;
 }
 
 bool HTMLMediaElement::isMediaDataCORSSameOrigin(SecurityOrigin* origin) const
 {
     // hasSingleSecurityOrigin() tells us whether the origin in the src is
     // the same as the actual request (i.e. after redirect).
@@ skipping 10 matching lines @@
     if (m_progressEventTimer.isActive())
         return;
 
     m_previousProgressTime = WTF::currentTime();
     // 350ms is not magic, it is in the spec!
     m_progressEventTimer.startRepeating(0.350, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::waitForSourceChange()
 {
-    WTF_LOG(Media, "HTMLMediaElement::waitForSourceChange(%p)", this);
+    DVLOG(LOG_LEVEL) << "waitForSourceChange";
 
     stopPeriodicTimers();
     m_loadState = WaitingForSource;
 
     // 6.17 - Waiting: Set the element's networkState attribute to the NETWORK_NO_SOURCE value
     setNetworkState(NETWORK_NO_SOURCE);
 
     // 6.18 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     updateDisplayState();
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::noneSupported()
 {
-    WTF_LOG(Media, "HTMLMediaElement::noneSupported(%p)", this);
+    DVLOG(LOG_LEVEL) << "noneSupported";
 
     stopPeriodicTimers();
     m_loadState = WaitingForSource;
     m_currentSourceNode = nullptr;
 
     // 4.8.13.5
     // The dedicated media source failure steps are the following steps:
 
     // 1 - Set the error attribute to a new MediaError object whose code attribute is set to
     // MEDIA_ERR_SRC_NOT_SUPPORTED.
@@ skipping 19 matching lines @@
     // 7 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::mediaEngineError(MediaError* err)
 {
     ASSERT(m_readyState >= HAVE_METADATA);
-    WTF_LOG(Media, "HTMLMediaElement::mediaEngineError(%p, %d)", this, static_cast<int>(err->code()));
+    DVLOG(LOG_LEVEL) << "mediaEngineError(" << static_cast<int>(err->code()) << ")";
 
     // 1 - The user agent should cancel the fetching process.
     stopPeriodicTimers();
     m_loadState = WaitingForSource;
 
     // 2 - Set the error attribute to a new MediaError object whose code attribute is
     // set to MEDIA_ERR_NETWORK/MEDIA_ERR_DECODE.
     m_error = err;
 
     // 3 - Queue a task to fire a simple event named error at the media element.
     scheduleEvent(EventTypeNames::error);
 
     // 4 - Set the element's networkState attribute to the NETWORK_IDLE value.
     setNetworkState(NETWORK_IDLE);
 
     // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     // 6 - Abort the overall resource selection algorithm.
     m_currentSourceNode = nullptr;
 }
 
 void HTMLMediaElement::cancelPendingEventsAndCallbacks()
 {
-    WTF_LOG(Media, "HTMLMediaElement::cancelPendingEventsAndCallbacks(%p)", this);
+    DVLOG(LOG_LEVEL) << "cancelPendingEventsAndCallbacks";
     m_asyncEventQueue->cancelAllEvents();
 
     for (HTMLSourceElement* source = Traversal<HTMLSourceElement>::firstChild(*this); source; source = Traversal<HTMLSourceElement>::nextSibling(*source))
         source->cancelPendingErrorEvent();
 
     m_playPromiseResolveTask->cancel();
     m_playPromiseRejectTask->cancel();
 }
 
 void HTMLMediaElement::networkStateChanged()
 {
     setNetworkState(webMediaPlayer()->getNetworkState());
 }
 
 void HTMLMediaElement::mediaLoadingFailed(WebMediaPlayer::NetworkState error)
 {
     stopPeriodicTimers();
 
     // If we failed while trying to load a <source> element, the movie was never parsed, and there are more
     // <source> children, schedule the next one
     if (m_readyState < HAVE_METADATA && m_loadState == LoadingFromSourceElement) {
 
         // resource selection algorithm
         // Step 9.Otherwise.9 - Failed with elements: Queue a task, using the DOM manipulation task source, to fire a simple event named error at the candidate element.
         if (m_currentSourceNode)
             m_currentSourceNode->scheduleErrorEvent();
         else
-            WTF_LOG(Media, "HTMLMediaElement::setNetworkState(%p) - error event not sent, <source> was removed", this);
+            DVLOG(LOG_LEVEL) << "setNetworkState - error event not sent, <source> was removed";
 
         // 9.Otherwise.10 - Asynchronously await a stable state. The synchronous section consists of all the remaining steps of this algorithm until the algorithm says the synchronous section has ended.
 
         // 9.Otherwise.11 - Forget the media element's media-resource-specific tracks.
         forgetResourceSpecificTracks();
 
         if (havePotentialSourceChild()) {
-            WTF_LOG(Media, "HTMLMediaElement::setNetworkState(%p) - scheduling next <source>", this);
+            DVLOG(LOG_LEVEL) << "setNetworkState - scheduling next <source>";
             scheduleNextSourceChild();
         } else {
-            WTF_LOG(Media, "HTMLMediaElement::setNetworkState(%p) - no more <source> elements, waiting", this);
+            DVLOG(LOG_LEVEL) << "setNetworkState - no more <source> elements, waiting";
             waitForSourceChange();
         }
 
         return;
     }
 
     if (error == WebMediaPlayer::NetworkStateNetworkError && m_readyState >= HAVE_METADATA)
         mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_NETWORK));
     else if (error == WebMediaPlayer::NetworkStateDecodeError)
         mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_DECODE));
     else if ((error == WebMediaPlayer::NetworkStateFormatError
         || error == WebMediaPlayer::NetworkStateNetworkError)
         && m_loadState == LoadingFromSrcAttr)
         noneSupported();
 
     updateDisplayState();
     if (mediaControls())
         mediaControls()->reset();
 }
 
 void HTMLMediaElement::setNetworkState(WebMediaPlayer::NetworkState state)
 {
-    WTF_LOG(Media, "HTMLMediaElement::setNetworkState(%p, %d) - current state is %d", this, static_cast<int>(state), static_cast<int>(m_networkState));
+    DVLOG(LOG_LEVEL) << "setNetworkState(" << static_cast<int>(state) << ") - current state is " << static_cast<int>(m_networkState);
 
     if (state == WebMediaPlayer::NetworkStateEmpty) {
         // Just update the cached state and leave, we can't do anything.
         setNetworkState(NETWORK_EMPTY);
         return;
     }
 
     if (state == WebMediaPlayer::NetworkStateFormatError
         || state == WebMediaPlayer::NetworkStateNetworkError
         || state == WebMediaPlayer::NetworkStateDecodeError) {
@@ skipping 34 matching lines @@
     setNetworkState(NETWORK_IDLE);
 }
 
 void HTMLMediaElement::readyStateChanged()
 {
     setReadyState(static_cast<ReadyState>(webMediaPlayer()->getReadyState()));
 }
 
 void HTMLMediaElement::setReadyState(ReadyState state)
 {
-    WTF_LOG(Media, "HTMLMediaElement::setReadyState(%p, %d) - current state is %d,", this, static_cast<int>(state), static_cast<int>(m_readyState));
+    DVLOG(LOG_LEVEL) << "setReadyState(" << static_cast<int>(state) << ") - current state is " << static_cast<int>(m_readyState);
 
     // Set "wasPotentiallyPlaying" BEFORE updating m_readyState, potentiallyPlaying() uses it
     bool wasPotentiallyPlaying = potentiallyPlaying();
 
     ReadyState oldState = m_readyState;
     ReadyState newState = state;
 
     bool tracksAreReady = textTracksAreReady();
 
     if (newState == oldState && m_tracksAreReady == tracksAreReady)
@@ skipping 145 matching lines @@
             layoutObject()->updateFromElement();
     } else if (timedelta > 3.0 && !m_sentStalledEvent) {
         scheduleEvent(EventTypeNames::stalled);
         m_sentStalledEvent = true;
         setShouldDelayLoadEvent(false);
     }
 }
 
 void HTMLMediaElement::addPlayedRange(double start, double end)
 {
-    WTF_LOG(Media, "HTMLMediaElement::addPlayedRange(%p, %f, %f)", this, start, end);
+    DVLOG(LOG_LEVEL) << "addPlayedRange(" << start << ", " << end << ")";
     if (!m_playedTimeRanges)
         m_playedTimeRanges = TimeRanges::create();
     m_playedTimeRanges->add(start, end);
 }
 
 bool HTMLMediaElement::supportsSave() const
 {
     return webMediaPlayer() && webMediaPlayer()->supportsSave();
 }
 
 void HTMLMediaElement::setIgnorePreloadNone()
 {
-    WTF_LOG(Media, "HTMLMediaElement::setIgnorePreloadNone(%p)", this);
+    DVLOG(LOG_LEVEL) << "setIgnorePreloadNone";
     m_ignorePreloadNone = true;
     setPlayerPreload();
 }
 
 void HTMLMediaElement::seek(double time)
 {
-    WTF_LOG(Media, "HTMLMediaElement::seek(%p, %f)", this, time);
+    DVLOG(LOG_LEVEL) << "seek(" << time << ")";
 
     // 2 - If the media element's readyState is HAVE_NOTHING, abort these steps.
     if (m_readyState == HAVE_NOTHING)
         return;
 
     // Ignore preload none and start load if necessary.
     setIgnorePreloadNone();
 
     // Get the current time before setting m_seeking, m_lastSeekTime is returned once it is set.
     refreshCachedTime();
@@ skipping 16 matching lines @@
     // 7 - If the new playback position is less than the earliest possible position, let it be that position instead.
     time = std::max(time, 0.0);
 
     // Ask the media engine for the time value in the movie's time scale before comparing with current time. This
     // is necessary because if the seek time is not equal to currentTime but the delta is less than the movie's
     // time scale, we will ask the media engine to "seek" to the current movie time, which may be a noop and
     // not generate a timechanged callback. This means m_seeking will never be cleared and we will never
     // fire a 'seeked' event.
     double mediaTime = webMediaPlayer()->mediaTimeForTimeValue(time);
     if (time != mediaTime) {
-        WTF_LOG(Media, "HTMLMediaElement::seek(%p, %f) - media timeline equivalent is %f", this, time, mediaTime);
+        DVLOG(LOG_LEVEL) << "seek(" << time << ") - media timeline equivalent is " << mediaTime;
         time = mediaTime;
     }
 
     // 8 - If the (possibly now changed) new playback position is not in one of the ranges given in the
     // seekable attribute, then let it be the position in one of the ranges given in the seekable attribute
     // that is the nearest to the new playback position. ... If there are no ranges given in the seekable
     // attribute then set the seeking IDL attribute to false and abort these steps.
     TimeRanges* seekableRanges = seekable();
 
     if (!seekableRanges->length()) {
@@ skipping 13 matching lines @@
 
     // 11 - Set the current playback position to the given new playback position.
     webMediaPlayer()->seek(time);
 
     // 14-17 are handled, if necessary, when the engine signals a readystate change or otherwise
     // satisfies seek completion and signals a time change.
 }
 
 void HTMLMediaElement::finishSeek()
 {
-    WTF_LOG(Media, "HTMLMediaElement::finishSeek(%p)", this);
+    DVLOG(LOG_LEVEL) << "finishSeek";
 
     // 14 - Set the seeking IDL attribute to false.
     m_seeking = false;
 
     // 16 - Queue a task to fire a simple event named timeupdate at the element.
     scheduleTimeupdateEvent(false);
 
     // 17 - Queue a task to fire a simple event named seeked at the element.
     scheduleEvent(EventTypeNames::seeked);
 
@@ skipping 25 matching lines @@
 void HTMLMediaElement::refreshCachedTime() const
 {
     if (!webMediaPlayer() || m_readyState < HAVE_METADATA)
         return;
 
     m_cachedTime = webMediaPlayer()->currentTime();
 }
 
 void HTMLMediaElement::invalidateCachedTime()
 {
-    WTF_LOG(Media, "HTMLMediaElement::invalidateCachedTime(%p)", this);
+    DVLOG(LOG_LEVEL) << "invalidateCachedTime";
     m_cachedTime = std::numeric_limits<double>::quiet_NaN();
 }
 
 // playback state
 double HTMLMediaElement::currentTime() const
 {
     if (m_defaultPlaybackStartPosition)
         return m_defaultPlaybackStartPosition;
 
     if (m_readyState == HAVE_NOTHING)
         return 0;
 
     if (m_seeking) {
-        WTF_LOG(Media, "HTMLMediaElement::currentTime(%p) - seeking, returning %f", this, m_lastSeekTime);
+        DVLOG(LOG_LEVEL) << "currentTime - seeking, returning " << m_lastSeekTime;
         return m_lastSeekTime;
     }
 
     if (!std::isnan(m_cachedTime) && m_paused) {
 #if LOG_CACHED_TIME_WARNINGS
         static const double minCachedDeltaForWarning = 0.01;
         double delta = m_cachedTime - webMediaPlayer()->currentTime();
         if (delta > minCachedDeltaForWarning)
-            WTF_LOG(Media, "HTMLMediaElement::currentTime(%p) - WARNING, cached time is %f seconds off of media time when paused", this, delta);
+            DVLOG(LOG_LEVEL) << "currentTime - WARNING, cached time is " << delta << "seconds off of media time when paused";
 #endif
         return m_cachedTime;
     }
 
     refreshCachedTime();
 
     return m_cachedTime;
 }
 
 void HTMLMediaElement::setCurrentTime(double time)
@@ skipping 51 matching lines @@
     scheduleEvent(EventTypeNames::ratechange);
 }
 
 double HTMLMediaElement::playbackRate() const
 {
     return m_playbackRate;
 }
 
 void HTMLMediaElement::setPlaybackRate(double rate)
 {
-    WTF_LOG(Media, "HTMLMediaElement::setPlaybackRate(%p, %f)", this, rate);
+    DVLOG(LOG_LEVEL) << "setPlaybackRate(" << rate << ")";
 
     if (m_playbackRate != rate) {
         m_playbackRate = rate;
         invalidateCachedTime();
         scheduleEvent(EventTypeNames::ratechange);
     }
 
     updatePlaybackRate();
 }
 
@@ skipping 39 matching lines @@
     return false;
 }
 
 String HTMLMediaElement::preload() const
 {
     return preloadTypeToString(preloadType());
 }
 
 void HTMLMediaElement::setPreload(const AtomicString& preload)
 {
-    WTF_LOG(Media, "HTMLMediaElement::setPreload(%p, %s)", this, preload.utf8().data());
+    DVLOG(LOG_LEVEL) << "setPreload(" << preload.utf8().data() << ")";
     setAttribute(preloadAttr, preload);
 }
 
 WebMediaPlayer::Preload HTMLMediaElement::preloadType() const
 {
     // Force preload to none for cellular connections.
     if (networkStateNotifier().isCellularConnectionType()) {
         UseCounter::count(document(), UseCounter::HTMLMediaElementPreloadForcedNone);
         return WebMediaPlayer::PreloadNone;
     }
@@ skipping 62 matching lines @@
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     m_playResolvers.append(resolver);
     return promise;
 }
 
 Nullable<ExceptionCode> HTMLMediaElement::play()
 {
-    WTF_LOG(Media, "HTMLMediaElement::play(%p)", this);
+    DVLOG(LOG_LEVEL) << "play";
 
     m_autoplayHelper->playMethodCalled();
 
     if (!UserGestureIndicator::processingUserGesture()) {
         if (m_userGestureRequiredForPlay) {
             recordAutoplayMetric(PlayMethodFailed);
             String message = ExceptionMessages::failedToExecute("play", "HTMLMediaElement", "API can only be initiated by a user gesture.");
             document().addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, message));
             return NotAllowedError;
         }
     } else {
         UserGestureIndicator::utilizeUserGesture();
         // We ask the helper to remove the gesture requirement for us, so that
         // it can record the reason.
         Platform::current()->recordAction(UserMetricsAction("Media_Play_WithGesture"));
         m_autoplayHelper->removeUserGestureRequirement(GesturelessPlaybackEnabledByPlayMethod);
     }
 
     if (m_error && m_error->code() == MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED)
         return NotSupportedError;
 
     playInternal();
 
     return nullptr;
 }
 
 void HTMLMediaElement::playInternal()
 {
-    WTF_LOG(Media, "HTMLMediaElement::playInternal(%p)", this);
+    DVLOG(LOG_LEVEL) << "playInternal";
 
     // Always return the buffering strategy to normal when not paused,
     // regardless of the cause. (In contrast with aggressive buffering which is
     // only enabled by pause(), not pauseInternal().)
     if (webMediaPlayer())
         webMediaPlayer()->setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Normal);
 
     // 4.8.10.9. Playing the media resource
     if (m_networkState == NETWORK_EMPTY)
         invokeResourceSelectionAlgorithm();
@@ skipping 18 matching lines @@
     }
 
     m_autoplaying = false;
 
     setIgnorePreloadNone();
     updatePlayState();
 }
 
 void HTMLMediaElement::pause()
 {
-    WTF_LOG(Media, "HTMLMediaElement::pause(%p)", this);
+    DVLOG(LOG_LEVEL) << "pause";
 
     // Only buffer aggressively on a user-initiated pause. Other types of pauses
     // (which go directly to pauseInternal()) should not cause this behavior.
     if (webMediaPlayer() && UserGestureIndicator::utilizeUserGesture())
         webMediaPlayer()->setBufferingStrategy(WebMediaPlayer::BufferingStrategy::Aggressive);
 
     pauseInternal();
 }
 
 void HTMLMediaElement::pauseInternal()
 {
-    WTF_LOG(Media, "HTMLMediaElement::pauseInternal(%p)", this);
+    DVLOG(LOG_LEVEL) << "pauseInternal";
 
     if (m_networkState == NETWORK_EMPTY)
         invokeResourceSelectionAlgorithm();
 
     m_autoplayHelper->pauseMethodCalled();
 
     m_autoplaying = false;
 
     if (!m_paused) {
         m_paused = true;
@@ skipping 28 matching lines @@
     m_mediaSource = nullptr;
 }
 
 bool HTMLMediaElement::loop() const
 {
     return fastHasAttribute(loopAttr);
 }
 
 void HTMLMediaElement::setLoop(bool b)
 {
-    WTF_LOG(Media, "HTMLMediaElement::setLoop(%p, %s)", this, boolString(b));
+    DVLOG(LOG_LEVEL) << "setLoop(" << boolString(b) << ")";
     setBooleanAttribute(loopAttr, b);
 }
 
 bool HTMLMediaElement::shouldShowControls(const RecordMetricsBehavior recordMetrics) const
 {
     DEFINE_STATIC_LOCAL(EnumerationHistogram, showControlsHistogram, ("Media.Controls.Show", MediaControlsShowMax));
 
     if (fastHasAttribute(controlsAttr)) {
         if (recordMetrics == RecordMetricsBehavior::DoRecord)
             showControlsHistogram.count(MediaControlsShowAttribute);
@@ skipping 18 matching lines @@
     return false;
 }
 
 double HTMLMediaElement::volume() const
 {
     return m_volume;
 }
 
 void HTMLMediaElement::setVolume(double vol, ExceptionState& exceptionState)
 {
-    WTF_LOG(Media, "HTMLMediaElement::setVolume(%p, %f)", this, vol);
+    DVLOG(LOG_LEVEL) << "setVolume(" << 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;
     }
 
     Platform::current()->recordAction(UserMetricsAction("Media_SetVolume"));
 
     m_volume = vol;
     updateVolume();
     scheduleEvent(EventTypeNames::volumechange);
 }
 
 bool HTMLMediaElement::muted() const
 {
     return m_muted;
 }
 
 void HTMLMediaElement::setMuted(bool muted)
 {
-    WTF_LOG(Media, "HTMLMediaElement::setMuted(%p, %s)", this, boolString(muted));
+    DVLOG(LOG_LEVEL) << "setMuted(" << boolString(muted) << ")";
 
     if (m_muted == muted)
         return;
 
     m_muted = muted;
 
     m_autoplayHelper->mutedChanged();
 
     updateVolume();
 
@@ skipping 85 matching lines @@
 }
 
 AudioTrackList& HTMLMediaElement::audioTracks()
 {
     ASSERT(RuntimeEnabledFeatures::audioVideoTracksEnabled());
     return *m_audioTracks;
 }
 
 void HTMLMediaElement::audioTrackChanged(WebMediaPlayer::TrackId trackId, bool enabled)
 {
-    WTF_LOG(Media, "HTMLMediaElement::audioTrackChanged(%p) trackId=%u enabled=%d", this, trackId, enabled);
+    DVLOG(LOG_LEVEL) << "audioTrackChanged trackId= " << trackId << " enabled=" << enabled;

[fs, 2016/05/18 13:24:36]

boolString(enabled)?

[Srirama, 2016/05/18 13:55:01]

Done.

     ASSERT(RuntimeEnabledFeatures::audioVideoTracksEnabled());
 
     audioTracks().scheduleChangeEvent();
 
     // FIXME: Add call on m_mediaSource to notify it of track changes once the SourceBuffer.audioTracks attribute is added.
 
     if (!m_audioTracksTimer.isActive())
         m_audioTracksTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::audioTracksTimerFired(Timer<HTMLMediaElement>*)
 {
     Vector<WebMediaPlayer::TrackId> enabledTrackIds;
     for (unsigned i = 0; i < audioTracks().length(); ++i) {
         AudioTrack* track = audioTracks().anonymousIndexedGetter(i);
         if (track->enabled())
             enabledTrackIds.append(track->trackId());
     }
 
     webMediaPlayer()->enabledAudioTracksChanged(enabledTrackIds);
 }
 
 WebMediaPlayer::TrackId HTMLMediaElement::addAudioTrack(const WebString& id, WebMediaPlayerClient::AudioTrackKind kind, const WebString& label, const WebString& language, bool enabled)
 {
     AtomicString kindString = AudioKindToString(kind);
-    WTF_LOG(Media, "HTMLMediaElement::addAudioTrack(%p, '%s', '%s', '%s', '%s', %d)",
-        this, id.utf8().data(), kindString.ascii().data(), label.utf8().data(), language.utf8().data(), enabled);
+    DVLOG(LOG_LEVEL) << "addAudioTrack('" << id.utf8().data() << "', ' " << kindString.ascii().data()
+        << "', '" << label.utf8().data() << "', '" << language.utf8().data() << "', " << enabled << ")";

[fs, 2016/05/18 13:24:36]

Ditto.

[Srirama, 2016/05/18 13:55:00]

Done.

 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return 0;
 
     AudioTrack* audioTrack = AudioTrack::create(id, kindString, label, language, enabled);
     audioTracks().add(audioTrack);
 
     return audioTrack->trackId();
 }
 
 void HTMLMediaElement::removeAudioTrack(WebMediaPlayer::TrackId trackId)
 {
-    WTF_LOG(Media, "HTMLMediaElement::removeAudioTrack(%p)", this);
+    DVLOG(LOG_LEVEL) << "removeAudioTrack";
 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return;
 
     audioTracks().remove(trackId);
 }
 
 VideoTrackList& HTMLMediaElement::videoTracks()
 {
     ASSERT(RuntimeEnabledFeatures::audioVideoTracksEnabled());
     return *m_videoTracks;
 }
 
 void HTMLMediaElement::selectedVideoTrackChanged(WebMediaPlayer::TrackId* selectedTrackId)
 {
-    WTF_LOG(Media, "HTMLMediaElement::selectedVideoTrackChanged(%p) selectedTrackId=%s", this, selectedTrackId ? String::format("%u", *selectedTrackId).ascii().data() : "none");
+    DVLOG(LOG_LEVEL) << "selectedVideoTrackChanged selectedTrackId=" << (selectedTrackId ? String::format("%u", *selectedTrackId).ascii().data() : "none");
     ASSERT(RuntimeEnabledFeatures::audioVideoTracksEnabled());
 
     if (selectedTrackId)
         videoTracks().trackSelected(*selectedTrackId);
 
     // FIXME: Add call on m_mediaSource to notify it of track changes once the SourceBuffer.videoTracks attribute is added.
 
     webMediaPlayer()->selectedVideoTrackChanged(selectedTrackId);
 }
 
 WebMediaPlayer::TrackId HTMLMediaElement::addVideoTrack(const WebString& id, WebMediaPlayerClient::VideoTrackKind kind, const WebString& label, const WebString& language, bool selected)
 {
     AtomicString kindString = VideoKindToString(kind);
-    WTF_LOG(Media, "HTMLMediaElement::addVideoTrack(%p, '%s', '%s', '%s', '%s', %d)",
-        this, id.utf8().data(), kindString.ascii().data(), label.utf8().data(), language.utf8().data(), selected);
+    DVLOG(LOG_LEVEL) << "addVideoTrack('" << id.utf8().data() << "', '" << kindString.ascii().data()
+        << "', '" << label.utf8().data() << "', '" << language.utf8().data() << "', " << selected << ")";

[fs, 2016/05/18 13:24:36]

boolString(selected)

[Srirama, 2016/05/18 13:55:01]

Done.

 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return 0;
 
     // If another track was selected (potentially by the user), leave it selected.
     if (selected && videoTracks().selectedIndex() != -1)
         selected = false;
 
     VideoTrack* videoTrack = VideoTrack::create(id, kindString, label, language, selected);
     videoTracks().add(videoTrack);
 
     return videoTrack->trackId();
 }
 
 void HTMLMediaElement::removeVideoTrack(WebMediaPlayer::TrackId trackId)
 {
-    WTF_LOG(Media, "HTMLMediaElement::removeVideoTrack(%p)", this);
+    DVLOG(LOG_LEVEL) << "removeVideoTrack";
 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return;
 
     videoTracks().remove(trackId);
 }
 
 void HTMLMediaElement::addTextTrack(WebInbandTextTrack* webTrack)
 {
     // 4.8.10.12.2 Sourcing in-band text tracks
@@ skipping 137 matching lines @@
     // Do not schedule the track loading until parsing finishes so we don't start before all tracks
     // in the markup have been added.
     if (isFinishedParsingChildren())
         scheduleTextTrackResourceLoad();
 }
 
 void HTMLMediaElement::didRemoveTrackElement(HTMLTrackElement* trackElement)
 {
 #if !LOG_DISABLED
     KURL url = trackElement->getNonEmptyURLAttribute(srcAttr);
-    WTF_LOG(Media, "HTMLMediaElement::didRemoveTrackElement(%p) - 'src' is %s", this, urlForLoggingMedia(url).utf8().data());
+    DVLOG(LOG_LEVEL) << "didRemoveTrackElement - 'src' is " << urlForLoggingMedia(url).utf8().data();
 #endif
 
     TextTrack* textTrack = trackElement->track();
     if (!textTrack)
         return;
 
     textTrack->setHasBeenConfigured(false);
 
     if (!m_textTracks)
         return;
@@ skipping 43 matching lines @@
     KURL nextURL = selectNextSourceChild(0, DoNothing);
 
     m_currentSourceNode = currentSourceNode;
     m_nextChildNodeToConsider = nextNode;
 
     return nextURL.isValid();
 }
 
 KURL HTMLMediaElement::selectNextSourceChild(ContentType* contentType, InvalidURLAction actionIfInvalid)
 {
 #if !LOG_DISABLED

[fs, 2016/05/18 13:24:36]

Not sure how useful this is now, but that can be cleaned up separately.

[Srirama, 2016/05/18 13:55:01]

Acknowledged.

     // Don't log if this was just called to find out if there are any valid <source> elements.
     bool shouldLog = actionIfInvalid != DoNothing;
     if (shouldLog)
-        WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p)", this);
+        DVLOG(LOG_LEVEL) << "selectNextSourceChild";
 #endif
 
     if (!m_nextChildNodeToConsider) {
 #if !LOG_DISABLED
         if (shouldLog)
-            WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) -> 0x0000, \"\"", this);
+            DVLOG(LOG_LEVEL) << "selectNextSourceChild -> 0x0000, \"\"";
 #endif
         return KURL();
     }
 
     KURL mediaURL;
     Node* node;
     HTMLSourceElement* source = 0;
     String type;
     bool lookingForStartNode = m_nextChildNodeToConsider;
     bool canUseSourceElement = false;
@@ skipping 13 matching lines @@
             continue;
 
         source = toHTMLSourceElement(node);
 
         // 2. 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
         const AtomicString& srcValue = source->fastGetAttribute(srcAttr);
 #if !LOG_DISABLED
         if (shouldLog)
-            WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) - 'src' is %s", this, urlForLoggingMedia(mediaURL).utf8().data());
+            DVLOG(LOG_LEVEL) << "selectNextSourceChild - 'src' is " << urlForLoggingMedia(mediaURL).utf8().data();
 #endif
         if (srcValue.isEmpty())
             goto checkAgain;
 
         // 3. Let urlString be the resulting URL string that would have resulted
         // from parsing the URL specified by candidate's src attribute's value
         // relative to the candidate's node document when the src attribute was
         // last changed.
         mediaURL = source->document().completeURL(srcValue);
 
         // 4. If urlString was not obtained successfully, then end the
         // synchronous section, and jump down to the failed with elements step
         // below.
         if (!isSafeToLoadURL(mediaURL, actionIfInvalid))
             goto checkAgain;
 
         // 5. If candidate has a type attribute whose value, when parsed as a
         // MIME type ...
         type = source->type();
         if (type.isEmpty() && mediaURL.protocolIsData())
             type = mimeTypeFromDataURL(mediaURL);
         if (!type.isEmpty()) {
 #if !LOG_DISABLED
             if (shouldLog)
-                WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) - 'type' is '%s'", this, type.utf8().data());
+                DVLOG(LOG_LEVEL) << "selectNextSourceChild - 'type' is '" << type.utf8().data() << "'";
 #endif
             if (!supportsType(ContentType(type)))
                 goto checkAgain;
         }
 
         // Making it this far means the <source> looks reasonable.
         canUseSourceElement = true;
 
 checkAgain:
         if (!canUseSourceElement && actionIfInvalid == Complain && source)
             source->scheduleErrorEvent();
     }
 
     if (canUseSourceElement) {
         if (contentType)
             *contentType = ContentType(type);
         m_currentSourceNode = source;
         m_nextChildNodeToConsider = source->nextSibling();
     } else {
         m_currentSourceNode = nullptr;
         m_nextChildNodeToConsider = nullptr;
     }
 
 #if !LOG_DISABLED
     if (shouldLog)
-        WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild(%p) -> %p, %s", this, m_currentSourceNode.get(), canUseSourceElement ? urlForLoggingMedia(mediaURL).utf8().data() : "");
+        DVLOG(LOG_LEVEL) << "selectNextSourceChild -> " << m_currentSourceNode.get() << ", " << (canUseSourceElement ? urlForLoggingMedia(mediaURL).utf8().data() : "");
 #endif
     return canUseSourceElement ? mediaURL : KURL();
 }
 
 void HTMLMediaElement::sourceWasAdded(HTMLSourceElement* source)
 {
-    WTF_LOG(Media, "HTMLMediaElement::sourceWasAdded(%p, %p)", this, source);
+    DVLOG(LOG_LEVEL) << "sourceWasAdded(" << source << ")";
 
 #if !LOG_DISABLED
     KURL url = source->getNonEmptyURLAttribute(srcAttr);
-    WTF_LOG(Media, "HTMLMediaElement::sourceWasAdded(%p) - 'src' is %s", this, urlForLoggingMedia(url).utf8().data());
+    DVLOG(LOG_LEVEL) << "sourceWasAdded - 'src' is " << urlForLoggingMedia(url).utf8().data();
 #endif
 
     // We should only consider a <source> element when there is not src attribute at all.
     if (fastHasAttribute(srcAttr))
         return;
 
     // 4.8.8 - If a source element is inserted as a child of a media element that has no src
     // attribute and whose networkState has the value NETWORK_EMPTY, the user agent must invoke
     // the media element's resource selection algorithm.
     if (getNetworkState() == HTMLMediaElement::NETWORK_EMPTY) {
         invokeResourceSelectionAlgorithm();
         // Ignore current |m_nextChildNodeToConsider| and consider |source|.
         m_nextChildNodeToConsider = source;
         return;
     }
 
     if (m_currentSourceNode && source == m_currentSourceNode->nextSibling()) {
-        WTF_LOG(Media, "HTMLMediaElement::sourceWasAdded(%p) - <source> inserted immediately after current source", this);
+        DVLOG(LOG_LEVEL) << "sourceWasAdded - <source> inserted immediately after current source";
         // Ignore current |m_nextChildNodeToConsider| and consider |source|.
         m_nextChildNodeToConsider = source;
         return;
     }
 
     // Consider current |m_nextChildNodeToConsider| as it is already in the middle of processing.
     if (m_nextChildNodeToConsider)
         return;
 
     if (m_loadState != WaitingForSource)
         return;
 
     // 4.8.9.5, resource selection algorithm, source elements section:
     // 21. Wait until the node after pointer is a node other than the end of the list. (This step might wait forever.)
     // 22. Asynchronously await a stable state...
     // 23. Set the element's delaying-the-load-event flag back to true (this delays the load event again, in case
     // it hasn't been fired yet).
     setShouldDelayLoadEvent(true);
 
     // 24. Set the networkState back to NETWORK_LOADING.
     setNetworkState(NETWORK_LOADING);
 
     // 25. Jump back to the find next candidate step above.
     m_nextChildNodeToConsider = source;
     scheduleNextSourceChild();
 }
 
 void HTMLMediaElement::sourceWasRemoved(HTMLSourceElement* source)
 {
-    WTF_LOG(Media, "HTMLMediaElement::sourceWasRemoved(%p, %p)", this, source);
+    DVLOG(LOG_LEVEL) << "sourceWasRemoved(" << source << ")";
 
 #if !LOG_DISABLED
     KURL url = source->getNonEmptyURLAttribute(srcAttr);
-    WTF_LOG(Media, "HTMLMediaElement::sourceWasRemoved(%p) - 'src' is %s", this, urlForLoggingMedia(url).utf8().data());
+    DVLOG(LOG_LEVEL) << "sourceWasRemoved - 'src' is " << urlForLoggingMedia(url).utf8().data();
 #endif
 
     if (source != m_currentSourceNode && source != m_nextChildNodeToConsider)
         return;
 
     if (source == m_nextChildNodeToConsider) {
         if (m_currentSourceNode)
             m_nextChildNodeToConsider = m_currentSourceNode->nextSibling();
-        WTF_LOG(Media, "HTMLMediaElement::sourceRemoved(%p) - m_nextChildNodeToConsider set to %p", this, m_nextChildNodeToConsider.get());
+        DVLOG(LOG_LEVEL) << "sourceWasRemoved - m_nextChildNodeToConsider set to " << m_nextChildNodeToConsider.get();
     } else if (source == m_currentSourceNode) {
         // Clear the current source node pointer, but don't change the movie as the spec says:
         // 4.8.8 - Dynamically modifying a source element and its attribute when the element is already
         // inserted in a video or audio element will have no effect.
         m_currentSourceNode = nullptr;
-        WTF_LOG(Media, "HTMLMediaElement::sourceRemoved(%p) - m_currentSourceNode set to 0", this);
+        DVLOG(LOG_LEVEL) << "sourceWasRemoved - m_currentSourceNode set to 0";
     }
 }
 
 void HTMLMediaElement::timeChanged()
 {
-    WTF_LOG(Media, "HTMLMediaElement::timeChanged(%p)", this);
+    DVLOG(LOG_LEVEL) << "timeChanged(" << this << ")";
 
     cueTimeline().updateActiveCues(currentTime());
 
     invalidateCachedTime();
 
     // 4.8.10.9 steps 12-14. Needed if no ReadyState change is associated with the seek.
     if (m_seeking && m_readyState >= HAVE_CURRENT_DATA && !webMediaPlayer()->seeking())
         finishSeek();
 
     // Always call scheduleTimeupdateEvent when the media engine reports a time discontinuity,
@@ skipping 29 matching lines @@
         }
     } else {
         m_sentEndEvent = false;
     }
 
     updatePlayState();
 }
 
 void HTMLMediaElement::durationChanged()
 {
-    WTF_LOG(Media, "HTMLMediaElement::durationChanged(%p)", this);
+    DVLOG(LOG_LEVEL) << "durationChanged";
     // FIXME: Change WebMediaPlayer to convey the currentTime
     // when the duration change occured. The current WebMediaPlayer
     // implementations always clamp currentTime() to duration()
     // so the requestSeek condition here is always false.
     durationChanged(duration(), currentTime() > duration());
 }
 
 void HTMLMediaElement::durationChanged(double duration, bool requestSeek)
 {
-    WTF_LOG(Media, "HTMLMediaElement::durationChanged(%p, %f, %d)", this, duration, requestSeek);
+    DVLOG(LOG_LEVEL) << "durationChanged(" << duration << ", " << requestSeek << ")";

[fs, 2016/05/18 13:24:36]

boolString?

[Srirama, 2016/05/18 13:55:01]

Done.

 
     // Abort if duration unchanged.
     if (m_duration == duration)
         return;
 
-    WTF_LOG(Media, "HTMLMediaElement::durationChanged(%p) : %f -> %f", this, m_duration, duration);
+    DVLOG(LOG_LEVEL) << "durationChanged : " << m_duration << " -> " << duration;
     m_duration = duration;
     scheduleEvent(EventTypeNames::durationchange);
 
     if (mediaControls())
         mediaControls()->reset();
     if (layoutObject())
         layoutObject()->updateFromElement();
 
     if (requestSeek)
         seek(duration);
 }
 
 void HTMLMediaElement::playbackStateChanged()
 {
-    WTF_LOG(Media, "HTMLMediaElement::playbackStateChanged(%p)", this);
+    DVLOG(LOG_LEVEL) << "playbackStateChanged";
 
     if (!webMediaPlayer())
         return;
 
     if (webMediaPlayer()->paused())
         pauseInternal();
     else
         playInternal();
 }
 
@@ skipping 42 matching lines @@
     if (m_webLayer)
         m_webLayer->invalidate();
 
     updateDisplayState();
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::sizeChanged()
 {
-    WTF_LOG(Media, "HTMLMediaElement::sizeChanged(%p)", this);
+    DVLOG(LOG_LEVEL) << "sizeChanged";
 
     ASSERT(hasVideo()); // "resize" makes no sense absent video.
     if (m_readyState > HAVE_NOTHING && isHTMLVideoElement())
         scheduleEvent(EventTypeNames::resize);
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 TimeRanges* HTMLMediaElement::buffered() const
@@ skipping 80 matching lines @@
     }
 
     return false;
 }
 
 void HTMLMediaElement::updatePlayState()
 {
     bool isPlaying = webMediaPlayer() && !webMediaPlayer()->paused();
     bool shouldBePlaying = potentiallyPlaying();
 
-    WTF_LOG(Media, "HTMLMediaElement::updatePlayState(%p) - shouldBePlaying = %s, isPlaying = %s",
-        this, boolString(shouldBePlaying), boolString(isPlaying));
+    DVLOG(LOG_LEVEL) << "updatePlayState - shouldBePlaying = "
+        << boolString(shouldBePlaying) << ", isPlaying = " << boolString(isPlaying);
 
     if (shouldBePlaying) {
         setDisplayMode(Video);
         invalidateCachedTime();
 
         if (!isPlaying) {
             // Set rate, muted before calling play in case they were set before the media engine was setup.
             // The media engine should just stash the rate and muted values since it isn't already playing.
             webMediaPlayer()->setRate(playbackRate());
             updateVolume();
@@ skipping 70 matching lines @@
     m_playingRemotely = false;
     if (mediaControls())
         mediaControls()->refreshCastButtonVisibilityWithoutUpdate();
 
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::stop()
 {
-    WTF_LOG(Media, "HTMLMediaElement::stop(%p)", this);
+    DVLOG(LOG_LEVEL) << "stop";
 
     // Close the async event queue so that no events are enqueued.
     cancelPendingEventsAndCallbacks();
     m_asyncEventQueue->close();
 
     // Clear everything in the Media Element
     clearMediaPlayer();
     m_readyState = HAVE_NOTHING;
     m_readyStateMaximum = HAVE_NOTHING;
     setNetworkState(NETWORK_EMPTY);
@@ skipping 46 matching lines @@
     return false;
 }
 
 bool HTMLMediaElement::isFullscreen() const
 {
     return Fullscreen::isActiveFullScreenElement(*this);
 }
 
 void HTMLMediaElement::enterFullscreen()
 {
-    WTF_LOG(Media, "HTMLMediaElement::enterFullscreen(%p)", this);
+    DVLOG(LOG_LEVEL) << "enterFullscreen";
 
     Fullscreen::from(document()).requestFullscreen(*this, Fullscreen::PrefixedRequest);
 }
 
 void HTMLMediaElement::exitFullscreen()
 {
-    WTF_LOG(Media, "HTMLMediaElement::exitFullscreen(%p)", this);
+    DVLOG(LOG_LEVEL) << "exitFullscreen";
 
     Fullscreen::from(document()).exitFullscreen();
 }
 
 void HTMLMediaElement::didBecomeFullscreenElement()
 {
     if (mediaControls())
         mediaControls()->enteredFullscreen();
     // FIXME: There is no embedder-side handling in layout test mode.
     if (webMediaPlayer() && !LayoutTestSupport::isRunningLayoutTest())
@@ skipping 75 matching lines @@
     // so that they are rendered behind them.
     shadowRoot.insertBefore(textTrackContainer, firstChild);
 
     assertShadowRootChildren(shadowRoot);
 
     return *textTrackContainer;
 }
 
 void HTMLMediaElement::updateTextTrackDisplay()
 {
-    WTF_LOG(Media, "HTMLMediaElement::updateTextTrackDisplay(%p)", this);
+    DVLOG(LOG_LEVEL) << "updateTextTrackDisplay";
 
     ensureTextTrackContainer().updateDisplay(*this, TextTrackContainer::DidNotStartExposingControls);
 }
 
 void HTMLMediaElement::mediaControlsDidBecomeVisible()
 {
-    WTF_LOG(Media, "HTMLMediaElement::mediaControlsDidBecomeVisible(%p)", this);
+    DVLOG(LOG_LEVEL) << "mediaControlsDidBecomeVisible";
 
     // When the user agent starts exposing a user interface for a video element,
     // the user agent should run the rules for updating the text track rendering
     // of each of the text tracks in the video element's list of text tracks ...
     if (isHTMLVideoElement() && textTracksVisible())
         ensureTextTrackContainer().updateDisplay(*this, TextTrackContainer::DidStartExposingControls);
 }
 
 void HTMLMediaElement::setTextTrackKindUserPreferenceForAllMediaElements(Document* document)
 {
@@ skipping 60 matching lines @@
 bool HTMLMediaElement::isURLAttribute(const Attribute& attribute) const
 {
     return attribute.name() == srcAttr || HTMLElement::isURLAttribute(attribute);
 }
 
 void HTMLMediaElement::setShouldDelayLoadEvent(bool shouldDelay)
 {
     if (m_shouldDelayLoadEvent == shouldDelay)
         return;
 
-    WTF_LOG(Media, "HTMLMediaElement::setShouldDelayLoadEvent(%p, %s)", this, boolString(shouldDelay));
+    DVLOG(LOG_LEVEL) << "setShouldDelayLoadEvent(" << boolString(shouldDelay) << ")";
 
     m_shouldDelayLoadEvent = shouldDelay;
     if (shouldDelay)
         document().incrementLoadEventDelayCount();
     else
         document().decrementLoadEventDelayCount();
 }
 
 MediaControls* HTMLMediaElement::mediaControls() const
 {
@@ skipping 50 matching lines @@
 CueTimeline& HTMLMediaElement::cueTimeline()
 {
     if (!m_cueTimeline)
         m_cueTimeline = new CueTimeline(*this);
     return *m_cueTimeline;
 }
 
 void HTMLMediaElement::configureTextTrackDisplay()
 {
     ASSERT(m_textTracks);
-    WTF_LOG(Media, "HTMLMediaElement::configureTextTrackDisplay(%p)", this);
+    DVLOG(LOG_LEVEL) << "configureTextTrackDisplay";
 
     if (m_processingPreferenceChange)
         return;
 
     bool haveVisibleTextTrack = m_textTracks->hasShowingTracks();
     m_textTracksVisible = haveVisibleTextTrack;
 
     if (!haveVisibleTextTrack && !mediaControls())
         return;
 
@@ skipping 353 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect() const
 {
     IntRect result;
     if (LayoutObject* object = m_element->layoutObject())
         result = object->absoluteBoundingBoxRect();
     return result;
 }
 
 } // namespace blink