Add an option to make blink media logging verbose

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 78 matching lines @@
 #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/PtrUtil.h"
 #include "wtf/text/CString.h"
 #include <limits>
 
-#define MEDIA_LOG DVLOG(3)
+#ifndef BLINK_MEDIA_LOG
+#define BLINK_MEDIA_LOG DVLOG(3)
+#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
 
 #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.
@@ skipping 335 matching lines @@
     , m_playPromiseResolveTask(CancellableTaskFactory::create(this, &HTMLMediaElement::resolveScheduledPlayPromises))
     , m_playPromiseRejectTask(CancellableTaskFactory::create(this, &HTMLMediaElement::rejectScheduledPlayPromises))
     , m_audioSourceNode(nullptr)
     , m_autoplayHelperClient(AutoplayHelperClientImpl::create(this))
     , m_autoplayHelper(AutoplayExperimentHelper::create(m_autoplayHelperClient.get()))
     , m_remotePlaybackClient(nullptr)
     , m_autoplayVisibilityObserver(nullptr)
 {
     ThreadState::current()->registerPreFinalizer(this);
 
-    MEDIA_LOG << "HTMLMediaElement(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "HTMLMediaElement(" << (void*)this << ")";
 
     // If any experiment is enabled, then we want to enable a user gesture by
     // default, otherwise the experiment does nothing.
     if ((document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
         || m_autoplayHelper->isExperimentEnabled()) {
         m_lockedPendingUserGesture = true;
     }
 
     setHasCustomStyleCallbacks();
     addElementToDocumentMap(this, &document);
 
     UseCounter::count(document, UseCounter::HTMLMediaElement);
 }
 
 HTMLMediaElement::~HTMLMediaElement()
 {
-    MEDIA_LOG << "~HTMLMediaElement(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "~HTMLMediaElement(" << (void*)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.
     DCHECK(!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)
 {
-    MEDIA_LOG << "didMoveToNewDocument(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "didMoveToNewDocument(" << (void*)this << ")";
 
     // If any experiment is enabled, then we want to enable a user gesture by
     // default, otherwise the experiment does nothing.
     bool oldDocumentRequiresUserGesture = (oldDocument.settings() && oldDocument.settings()->mediaPlaybackRequiresUserGesture())
         || m_autoplayHelper->isExperimentEnabled();
     bool newDocumentRequiresUserGesture = (document().settings() && document().settings()->mediaPlaybackRequiresUserGesture())
         || m_autoplayHelper->isExperimentEnabled();
     if (newDocumentRequiresUserGesture && !oldDocumentRequiresUserGesture) {
         m_lockedPendingUserGesture = true;
     }
@@ skipping 39 matching lines @@
 }
 
 bool HTMLMediaElement::isMouseFocusable() const
 {
     return false;
 }
 
 void HTMLMediaElement::parseAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& value)
 {
     if (name == srcAttr) {
-        MEDIA_LOG << "parseAttribute(" << (void*)this << ", srcAttr, old=" << oldValue << ", new=" << value << ")";
+        BLINK_MEDIA_LOG << "parseAttribute(" << (void*)this << ", srcAttr, old=" << oldValue << ", new=" << value << ")";
         // Trigger a reload, as long as the 'src' attribute is present.
         if (!value.isNull()) {
             m_ignorePreloadNone = false;
             invokeLoadAlgorithm();
         }
     } else if (name == controlsAttr) {
         UseCounter::count(document(), UseCounter::HTMLMediaElementControlsAttribute);
         configureMediaControls();
     } else if (name == preloadAttr) {
         setPlayerPreload();
@@ skipping 17 matching lines @@
     return shouldShowControls() && HTMLElement::layoutObjectIsNeeded(style);
 }
 
 LayoutObject* HTMLMediaElement::createLayoutObject(const ComputedStyle&)
 {
     return new LayoutMedia(this);
 }
 
 Node::InsertionNotificationRequest HTMLMediaElement::insertedInto(ContainerNode* insertionPoint)
 {
-    MEDIA_LOG << "insertedInto(" << (void*)this << ", " << insertionPoint << ")";
+    BLINK_MEDIA_LOG << "insertedInto(" << (void*)this << ", " << 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)
 {
-    MEDIA_LOG << "removedFrom(" << (void*)this << ", " << insertionPoint << ")";
+    BLINK_MEDIA_LOG << "removedFrom(" << (void*)this << ", " << 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()
 {
-    MEDIA_LOG << "scheduleTextTrackResourceLoad(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "scheduleTextTrackResourceLoad(" << (void*)this << ")";
 
     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
-    MEDIA_LOG << "scheduleEvent(" << (void*)this << ")" << " - scheduling '" << event->type() << "'";
+    BLINK_MEDIA_LOG << "scheduleEvent(" << (void*)this << ")" << " - scheduling '" << event->type() << "'";
 #endif
     m_asyncEventQueue->enqueueEvent(event);
 }
 
 void HTMLMediaElement::loadTimerFired(Timer<HTMLMediaElement>*)
 {
     if (m_pendingActionFlags & LoadTextTrackResource)
         honorUserPreferencesForAutomaticTextTrackSelection();
 
     if (m_pendingActionFlags & LoadMediaResource) {
@@ skipping 11 matching lines @@
     return m_error;
 }
 
 void HTMLMediaElement::setSrc(const AtomicString& url)
 {
     setAttribute(srcAttr, url);
 }
 
 void HTMLMediaElement::setSrcObject(MediaStreamDescriptor* srcObject)
 {
-    MEDIA_LOG << "setSrcObject(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "setSrcObject(" << (void*)this << ")";
     m_srcObject = srcObject;
     invokeLoadAlgorithm();
 }
 
 HTMLMediaElement::NetworkState HTMLMediaElement::getNetworkState() const
 {
     return m_networkState;
 }
 
 String HTMLMediaElement::canPlayType(const String& mimeType) const
 {
     WebMimeRegistry::SupportsType support = supportsType(ContentType(mimeType));
     String canPlay;
 
     // 4.8.10.3
     switch (support) {
     case WebMimeRegistry::IsNotSupported:
         canPlay = emptyString();
         break;
     case WebMimeRegistry::MayBeSupported:
         canPlay = "maybe";
         break;
     case WebMimeRegistry::IsSupported:
         canPlay = "probably";
         break;
     }
 
-    MEDIA_LOG << "canPlayType(" << (void*)this << ", " << mimeType << ") -> " << canPlay;
+    BLINK_MEDIA_LOG << "canPlayType(" << (void*)this << ", " << mimeType << ") -> " << canPlay;
 
     return canPlay;
 }
 
 void HTMLMediaElement::load()
 {
-    MEDIA_LOG << "load(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "load(" << (void*)this << ")";
 
     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()
 {
-    MEDIA_LOG << "invokeLoadAlgorithm(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "invokeLoadAlgorithm(" << (void*)this << ")";
 
     // 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_sentStalledEvent = false;
     m_haveFiredLoadedData = false;
     m_displayMode = Unknown;
@@ skipping 66 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()
 {
-    MEDIA_LOG << "invokeResourceSelectionAlgorithm(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "invokeResourceSelectionAlgorithm(" << (void*)this << ")";
     // 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()
 {
-    MEDIA_LOG << "selectMediaResource(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "selectMediaResource(" << (void*)this << ")";
 
     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();
 
-        MEDIA_LOG << "selectMediaResource(" << (void*)this << "), nothing to load";
+        BLINK_MEDIA_LOG << "selectMediaResource(" << (void*)this << "), 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();
-        MEDIA_LOG << "selectMediaResource(" << (void*)this << ", using 'srcObject' attribute";
+        BLINK_MEDIA_LOG << "selectMediaResource(" << (void*)this << ", using 'srcObject' attribute";
         break;
     case Attribute:
         loadSourceFromAttribute();
-        MEDIA_LOG << "selectMediaResource(" << (void*)this << "), using 'src' attribute url";
+        BLINK_MEDIA_LOG << "selectMediaResource(" << (void*)this << "), using 'src' attribute url";
         break;
     case Children:
         loadNextSourceChild();
-        MEDIA_LOG << "selectMediaResource(" << (void*)this << "), using source element";
+        BLINK_MEDIA_LOG << "selectMediaResource(" << (void*)this << "), using source element";
         break;
     default:
         NOTREACHED();
     }
 }
 
 void HTMLMediaElement::loadSourceFromObject()
 {
     DCHECK(m_srcObject);
     m_loadState = LoadingFromSrcObject;
 
     // No type is available when the resource comes from the 'srcObject'
     // attribute.
     loadResource(WebMediaPlayerSource(WebMediaStream(m_srcObject)), ContentType((String())));
 }
 
 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);
-        MEDIA_LOG << "selectMediaResource(" << (void*)this << "), empty 'src'";
+        BLINK_MEDIA_LOG << "selectMediaResource(" << (void*)this << "), 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 17 matching lines @@
     loadResource(WebMediaPlayerSource(WebURL(mediaURL)), contentType);
 }
 
 void HTMLMediaElement::loadResource(const WebMediaPlayerSource& source, const ContentType& contentType)
 {
     DCHECK(isMainThread());
     KURL url;
     if (source.isURL()) {
         url = source.getAsURL();
         DCHECK(isSafeToLoadURL(url, Complain));
-        MEDIA_LOG << "loadResource(" << (void*)this << ", " << urlForLoggingMedia(url) << ", " << contentType.raw() << ")";
+        BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ", " << urlForLoggingMedia(url) << ", " << contentType.raw() << ")";
     }
 
     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);
 
-    MEDIA_LOG << "loadResource(" << (void*)this << ") - m_currentSrc -> " << urlForLoggingMedia(m_currentSrc);
+    BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ") - m_currentSrc -> " << urlForLoggingMedia(m_currentSrc);
 
     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 12 matching lines @@
     }
 
     bool canLoadResource = source.isMediaStream() || canLoadURL(url, contentType);
     if (attemptLoad && canLoadResource) {
         DCHECK(!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 (!source.isMediaStream() && !url.protocolIs("blob") && effectivePreloadType() == WebMediaPlayer::PreloadNone) {
-            MEDIA_LOG << "loadResource(" << (void*)this << ") : Delaying load because preload == 'none'";
+            BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ") : 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()) {
-        MEDIA_LOG << "isSafeToLoadURL(" << (void*)this << ", " << urlForLoggingMedia(url) << ") -> FALSE because url is invalid";
+        BLINK_MEDIA_LOG << "isSafeToLoadURL(" << (void*)this << ", " << urlForLoggingMedia(url) << ") -> 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());
-        MEDIA_LOG << "isSafeToLoadURL(" << (void*)this << ", " << urlForLoggingMedia(url) << ") -> FALSE rejected by SecurityOrigin";
+        BLINK_MEDIA_LOG << "isSafeToLoadURL(" << (void*)this << ", " << urlForLoggingMedia(url) << ") -> FALSE rejected by SecurityOrigin";
         return false;
     }
 
     if (!document().contentSecurityPolicy()->allowMediaFromSource(url)) {
-        MEDIA_LOG << "isSafeToLoadURL(" << (void*)this << ", " << urlForLoggingMedia(url) << ") -> rejected by Content Security Policy";
+        BLINK_MEDIA_LOG << "isSafeToLoadURL(" << (void*)this << ", " << urlForLoggingMedia(url) << ") -> 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()
 {
-    MEDIA_LOG << "waitForSourceChange(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "waitForSourceChange(" << (void*)this << ")";
 
     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()
 {
-    MEDIA_LOG << "noneSupported(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "noneSupported(" << (void*)this << ")";
 
     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)
 {
     DCHECK_GE(m_readyState, HAVE_METADATA);
-    MEDIA_LOG << "mediaEngineError(" << (void*)this << ", " << static_cast<int>(err->code()) << ")";
+    BLINK_MEDIA_LOG << "mediaEngineError(" << (void*)this << ", " << 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()
 {
-    MEDIA_LOG << "cancelPendingEventsAndCallbacks(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "cancelPendingEventsAndCallbacks(" << (void*)this << ")";
     m_asyncEventQueue->cancelAllEvents();
 
     for (HTMLSourceElement* source = Traversal<HTMLSourceElement>::firstChild(*this); source; source = Traversal<HTMLSourceElement>::nextSibling(*source))
         source->cancelPendingErrorEvent();
 
     m_playPromiseResolveTask->cancel();
     m_playPromiseResolveList.clear();
     m_playPromiseRejectTask->cancel();
     m_playPromiseRejectList.clear();
 }
 
 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
-            MEDIA_LOG << "setNetworkState(" << (void*)this << ") - error event not sent, <source> was removed";
+            BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ") - 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()) {
-            MEDIA_LOG << "setNetworkState(" << (void*)this << ") - scheduling next <source>";
+            BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ") - scheduling next <source>";
             scheduleNextSourceChild();
         } else {
-            MEDIA_LOG << "setNetworkState(" << (void*)this << ") - no more <source> elements, waiting";
+            BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ") - 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)
 {
-    MEDIA_LOG << "setNetworkState(" << (void*)this << ", " << static_cast<int>(state) << ") - current state is " << static_cast<int>(m_networkState);
+    BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ", " << 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)
 {
-    MEDIA_LOG << "setReadyState(" << (void*)this << ", " << static_cast<int>(state) << ") - current state is " << static_cast<int>(m_readyState);
+    BLINK_MEDIA_LOG << "setReadyState(" << (void*)this << ", " << 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 156 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)
 {
-    MEDIA_LOG << "addPlayedRange(" << (void*)this << ", " << start << ", " << end << ")";
+    BLINK_MEDIA_LOG << "addPlayedRange(" << (void*)this << ", " << 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()
 {
-    MEDIA_LOG << "setIgnorePreloadNone(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "setIgnorePreloadNone(" << (void*)this << ")";
     m_ignorePreloadNone = true;
     setPlayerPreload();
 }
 
 void HTMLMediaElement::seek(double time)
 {
-    MEDIA_LOG << "seek(" << (void*)this << ", " << time << ")";
+    BLINK_MEDIA_LOG << "seek(" << (void*)this << ", " << time << ")";
 
     // 2 - If the media element's readyState is HAVE_NOTHING, abort these steps.
     // FIXME: remove m_webMediaPlayer check once we figure out how
     // m_webMediaPlayer is going out of sync with readystate.
     // m_webMediaPlayer is cleared but readystate is not set to HAVE_NOTHING.
     if (!m_webMediaPlayer || m_readyState == HAVE_NOTHING)
         return;
 
     // Ignore preload none and start load if necessary.
     setIgnorePreloadNone();
@@ skipping 19 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) {
-        MEDIA_LOG << "seek(" << (void*)this << ", " << time << ") - media timeline equivalent is " << mediaTime;
+        BLINK_MEDIA_LOG << "seek(" << (void*)this << ", " << 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 12 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()
 {
-    MEDIA_LOG << "finishSeek(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "finishSeek(" << (void*)this << ")";
 
     // 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()
 {
-    MEDIA_LOG << "invalidateCachedTime(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "invalidateCachedTime(" << (void*)this << ")";
     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) {
-        MEDIA_LOG << "currentTime(" << (void*)this << ") - seeking, returning " << m_lastSeekTime;
+        BLINK_MEDIA_LOG << "currentTime(" << (void*)this << ") - 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)
-            MEDIA_LOG << "currentTime(" << (void*)this << ") - WARNING, cached time is " << delta << "seconds off of media time when paused";
+            BLINK_MEDIA_LOG << "currentTime(" << (void*)this << ") - 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)
 {
-    MEDIA_LOG << "setPlaybackRate(" << (void*)this << ", " << rate << ")";
+    BLINK_MEDIA_LOG << "setPlaybackRate(" << (void*)this << ", " << 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)
 {
-    MEDIA_LOG << "setPreload(" << (void*)this << ", " << preload << ")";
+    BLINK_MEDIA_LOG << "setPreload(" << (void*)this << ", " << preload << ")";
     setAttribute(preloadAttr, preload);
 }
 
 WebMediaPlayer::Preload HTMLMediaElement::preloadType() const
 {
     // Force preload to none for cellular connections or when data saver is explicitly set.
     if (networkStateNotifier().isCellularConnectionType()
         || (document().settings() && document().settings()->dataSaverEnabled())) {
         UseCounter::count(document(), UseCounter::HTMLMediaElementPreloadForcedNone);
         return WebMediaPlayer::PreloadNone;
@@ skipping 72 matching lines @@
         }
         resolver->reject(DOMException::create(code.get(), message));
         return promise;
     }
 
     return promise;
 }
 
 Nullable<ExceptionCode> HTMLMediaElement::play()
 {
-    MEDIA_LOG << "play(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "play(" << (void*)this << ")";
 
     m_autoplayHelper->playMethodCalled();
 
     if (!UserGestureIndicator::processingUserGesture()) {
         recordAutoplaySourceMetric(AutoplaySourceMethod);
         if (isGestureNeededForPlayback()) {
             // If playback is deferred, then don't start playback but don't
             // fail yet either.
             if (m_autoplayHelper->isPlaybackDeferred())
                 return nullptr;
@@ skipping 21 matching lines @@
     if (m_error && m_error->code() == MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED)
         return NotSupportedError;
 
     playInternal();
 
     return nullptr;
 }
 
 void HTMLMediaElement::playInternal()
 {
-    MEDIA_LOG << "playInternal(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "playInternal(" << (void*)this << ")";
 
     // 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()
 {
-    MEDIA_LOG << "pause(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "pause(" << (void*)this << ")";
 
     // 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()
 {
-    MEDIA_LOG << "pauseInternal(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "pauseInternal(" << (void*)this << ")";
 
     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)
 {
-    MEDIA_LOG << "setLoop(" << (void*)this << ", " << boolString(b) << ")";
+    BLINK_MEDIA_LOG << "setLoop(" << (void*)this << ", " << boolString(b) << ")";
     setBooleanAttribute(loopAttr, b);
 }
 
 bool HTMLMediaElement::shouldShowControls(const RecordMetricsBehavior recordMetrics) const
 {
     if (fastHasAttribute(controlsAttr)) {
         if (recordMetrics == RecordMetricsBehavior::DoRecord)
             showControlsHistogram().count(MediaControlsShowAttribute);
         return true;
     }
@@ skipping 16 matching lines @@
     return false;
 }
 
 double HTMLMediaElement::volume() const
 {
     return m_volume;
 }
 
 void HTMLMediaElement::setVolume(double vol, ExceptionState& exceptionState)
 {
-    MEDIA_LOG << "setVolume(" << (void*)this << ", " << vol << ")";
+    BLINK_MEDIA_LOG << "setVolume(" << (void*)this << ", " << 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)
 {
-    MEDIA_LOG << "setMuted(" << (void*)this << ", " << boolString(muted) << ")";
+    BLINK_MEDIA_LOG << "setMuted(" << (void*)this << ", " << boolString(muted) << ")";
 
     if (m_muted == muted)
         return;
 
     bool wasAutoplayingMuted = !paused() && m_muted && isLockedPendingUserGesture();
 
     if (UserGestureIndicator::processingUserGesture())
         unlockUserGesture();
 
     m_muted = muted;
@@ skipping 100 matching lines @@
 }
 
 AudioTrackList& HTMLMediaElement::audioTracks()
 {
     DCHECK(RuntimeEnabledFeatures::audioVideoTracksEnabled());
     return *m_audioTracks;
 }
 
 void HTMLMediaElement::audioTrackChanged(WebMediaPlayer::TrackId trackId, bool enabled)
 {
-    MEDIA_LOG << "audioTrackChanged(" << (void*)this << ") trackId= " << String(trackId) << " enabled=" << boolString(enabled);
+    BLINK_MEDIA_LOG << "audioTrackChanged(" << (void*)this << ") trackId= " << String(trackId) << " enabled=" << boolString(enabled);
     DCHECK(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->id());
     }
 
     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);
-    MEDIA_LOG << "addAudioTrack(" << (void*)this << ", '" << (String)id << "', ' " << (AtomicString)kindString
+    BLINK_MEDIA_LOG << "addAudioTrack(" << (void*)this << ", '" << (String)id << "', ' " << (AtomicString)kindString
         << "', '" << (String)label << "', '" << (String)language << "', " << boolString(enabled) << ")";
 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return blink::WebMediaPlayer::TrackId();
 
     AudioTrack* audioTrack = AudioTrack::create(id, kindString, label, language, enabled);
     audioTracks().add(audioTrack);
 
     return audioTrack->id();
 }
 
 void HTMLMediaElement::removeAudioTrack(WebMediaPlayer::TrackId trackId)
 {
-    MEDIA_LOG << "removeAudioTrack(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "removeAudioTrack(" << (void*)this << ")";
 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return;
 
     audioTracks().remove(trackId);
 }
 
 VideoTrackList& HTMLMediaElement::videoTracks()
 {
     DCHECK(RuntimeEnabledFeatures::audioVideoTracksEnabled());
     return *m_videoTracks;
 }
 
 void HTMLMediaElement::selectedVideoTrackChanged(WebMediaPlayer::TrackId* selectedTrackId)
 {
-    MEDIA_LOG << "selectedVideoTrackChanged(" << (void*)this << ") selectedTrackId=" << (selectedTrackId ? String(*selectedTrackId) : "none");
+    BLINK_MEDIA_LOG << "selectedVideoTrackChanged(" << (void*)this << ") selectedTrackId=" << (selectedTrackId ? String(*selectedTrackId) : "none");
     DCHECK(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);
-    MEDIA_LOG << "addVideoTrack(" << (void*)this << ", '" << (String)id << "', '" << (AtomicString)kindString
+    BLINK_MEDIA_LOG << "addVideoTrack(" << (void*)this << ", '" << (String)id << "', '" << (AtomicString)kindString
         << "', '" << (String)label << "', '" << (String)language << "', " << boolString(selected) << ")";
 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return blink::WebMediaPlayer::TrackId();
 
     // 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->id();
 }
 
 void HTMLMediaElement::removeVideoTrack(WebMediaPlayer::TrackId trackId)
 {
-    MEDIA_LOG << "removeVideoTrack(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "removeVideoTrack(" << (void*)this << ")";
 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return;
 
     videoTracks().remove(trackId);
 }
 
 void HTMLMediaElement::addTextTrack(WebInbandTextTrack* webTrack)
 {
     // 4.8.10.12.2 Sourcing in-band text tracks
@@ skipping 136 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)
 {
     KURL url = trackElement->getNonEmptyURLAttribute(srcAttr);
-    MEDIA_LOG << "didRemoveTrackElement(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(url);
+    BLINK_MEDIA_LOG << "didRemoveTrackElement(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(url);
 
     TextTrack* textTrack = trackElement->track();
     if (!textTrack)
         return;
 
     textTrack->setHasBeenConfigured(false);
 
     if (!m_textTracks)
         return;
 
@@ skipping 45 matching lines @@
     m_nextChildNodeToConsider = nextNode;
 
     return nextURL.isValid();
 }
 
 KURL HTMLMediaElement::selectNextSourceChild(ContentType* contentType, InvalidURLAction actionIfInvalid)
 {
     // Don't log if this was just called to find out if there are any valid <source> elements.
     bool shouldLog = actionIfInvalid != DoNothing;
     if (shouldLog)
-        MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ")";
+        BLINK_MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ")";
 
     if (!m_nextChildNodeToConsider) {
         if (shouldLog)
-            MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ") -> 0x0000, \"\"";
+            BLINK_MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ") -> 0x0000, \"\"";
         return KURL();
     }
 
     KURL mediaURL;
     Node* node;
     HTMLSourceElement* source = 0;
     String type;
     bool lookingForStartNode = m_nextChildNodeToConsider;
     bool canUseSourceElement = false;
 
@@ skipping 11 matching lines @@
         if (node->parentNode() != this)
             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 (shouldLog)
-            MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(mediaURL);
+            BLINK_MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(mediaURL);
         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 (shouldLog)
-                MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ") - 'type' is '" << type << "'";
+                BLINK_MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ") - 'type' is '" << type << "'";
             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 (shouldLog)
-        MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ") -> " << m_currentSourceNode.get() << ", " << (canUseSourceElement ? urlForLoggingMedia(mediaURL) : "");
+        BLINK_MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ") -> " << m_currentSourceNode.get() << ", " << (canUseSourceElement ? urlForLoggingMedia(mediaURL) : "");
     return canUseSourceElement ? mediaURL : KURL();
 }
 
 void HTMLMediaElement::sourceWasAdded(HTMLSourceElement* source)
 {
-    MEDIA_LOG << "sourceWasAdded(" << (void*)this << ", " << source << ")";
+    BLINK_MEDIA_LOG << "sourceWasAdded(" << (void*)this << ", " << source << ")";
 
     KURL url = source->getNonEmptyURLAttribute(srcAttr);
-    MEDIA_LOG << "sourceWasAdded(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(url);
+    BLINK_MEDIA_LOG << "sourceWasAdded(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(url);
 
     // 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()) {
-        MEDIA_LOG << "sourceWasAdded(" << (void*)this << ") - <source> inserted immediately after current source";
+        BLINK_MEDIA_LOG << "sourceWasAdded(" << (void*)this << ") - <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)
 {
-    MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ", " << source << ")";
+    BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ", " << source << ")";
 
     KURL url = source->getNonEmptyURLAttribute(srcAttr);
-    MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(url);
+    BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(url);
 
     if (source != m_currentSourceNode && source != m_nextChildNodeToConsider)
         return;
 
     if (source == m_nextChildNodeToConsider) {
         if (m_currentSourceNode)
             m_nextChildNodeToConsider = m_currentSourceNode->nextSibling();
-        MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ") - m_nextChildNodeToConsider set to " << m_nextChildNodeToConsider.get();
+        BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ") - 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;
-        MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ") - m_currentSourceNode set to 0";
+        BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ") - m_currentSourceNode set to 0";
     }
 }
 
 void HTMLMediaElement::timeChanged()
 {
-    MEDIA_LOG << "timeChanged(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "timeChanged(" << (void*)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 22 matching lines @@
             // Queue a task to fire a simple event named ended at the media element.
             scheduleEvent(EventTypeNames::ended);
             Platform::current()->recordAction(UserMetricsAction("Media_Playback_Ended"));
         }
     }
     updatePlayState();
 }
 
 void HTMLMediaElement::durationChanged()
 {
-    MEDIA_LOG << "durationChanged(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "durationChanged(" << (void*)this << ")";
     // 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)
 {
-    MEDIA_LOG << "durationChanged(" << (void*)this << ", " << duration << ", " << boolString(requestSeek) << ")";
+    BLINK_MEDIA_LOG << "durationChanged(" << (void*)this << ", " << duration << ", " << boolString(requestSeek) << ")";
 
     // Abort if duration unchanged.
     if (m_duration == duration)
         return;
 
-    MEDIA_LOG << "durationChanged(" << (void*)this << ") : " << m_duration << " -> " << duration;
+    BLINK_MEDIA_LOG << "durationChanged(" << (void*)this << ") : " << m_duration << " -> " << duration;
     m_duration = duration;
     scheduleEvent(EventTypeNames::durationchange);
 
     if (mediaControls())
         mediaControls()->reset();
     if (layoutObject())
         layoutObject()->updateFromElement();
 
     if (requestSeek)
         seek(duration);
 }
 
 void HTMLMediaElement::playbackStateChanged()
 {
-    MEDIA_LOG << "playbackStateChanged(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "playbackStateChanged(" << (void*)this << ")";
 
     if (!webMediaPlayer())
         return;
 
     if (webMediaPlayer()->paused())
         pauseInternal();
     else
         playInternal();
 }
 
@@ skipping 52 matching lines @@
     if (m_webLayer)
         m_webLayer->invalidate();
 
     updateDisplayState();
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::sizeChanged()
 {
-    MEDIA_LOG << "sizeChanged(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "sizeChanged(" << (void*)this << ")";
 
     DCHECK(hasVideo()); // "resize" makes no sense in absence of 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();
 
-    MEDIA_LOG << "updatePlayState(" << (void*)this << ") - shouldBePlaying = "
+    BLINK_MEDIA_LOG << "updatePlayState(" << (void*)this << ") - 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());
@@ skipping 71 matching lines @@
     m_playingRemotely = false;
     if (mediaControls())
         mediaControls()->refreshCastButtonVisibilityWithoutUpdate();
 
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::stop()
 {
-    MEDIA_LOG << "stop(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "stop(" << (void*)this << ")";
 
     // 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()
 {
-    MEDIA_LOG << "enterFullscreen(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "enterFullscreen(" << (void*)this << ")";
 
     Fullscreen::from(document()).requestFullscreen(*this, Fullscreen::PrefixedRequest);
 }
 
 void HTMLMediaElement::exitFullscreen()
 {
-    MEDIA_LOG << "exitFullscreen(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "exitFullscreen(" << (void*)this << ")";
 
     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 70 matching lines @@
     // so that they are rendered behind them.
     shadowRoot.insertBefore(textTrackContainer, firstChild);
 
     assertShadowRootChildren(shadowRoot);
 
     return *textTrackContainer;
 }
 
 void HTMLMediaElement::updateTextTrackDisplay()
 {
-    MEDIA_LOG << "updateTextTrackDisplay(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "updateTextTrackDisplay(" << (void*)this << ")";
 
     ensureTextTrackContainer().updateDisplay(*this, TextTrackContainer::DidNotStartExposingControls);
 }
 
 void HTMLMediaElement::mediaControlsDidBecomeVisible()
 {
-    MEDIA_LOG << "mediaControlsDidBecomeVisible(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "mediaControlsDidBecomeVisible(" << (void*)this << ")";
 
     // 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 58 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;
 
-    MEDIA_LOG << "setShouldDelayLoadEvent(" << (void*)this << ", " << boolString(shouldDelay) << ")";
+    BLINK_MEDIA_LOG << "setShouldDelayLoadEvent(" << (void*)this << ", " << 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()
 {
     DCHECK(m_textTracks);
-    MEDIA_LOG << "configureTextTrackDisplay(" << (void*)this << ")";
+    BLINK_MEDIA_LOG << "configureTextTrackDisplay(" << (void*)this << ")";
 
     if (m_processingPreferenceChange)
         return;
 
     bool haveVisibleTextTrack = m_textTracks->hasShowingTracks();
     m_textTracksVisible = haveVisibleTextTrack;
 
     if (!haveVisibleTextTrack && !mediaControls())
         return;
 
@@ skipping 484 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect() const
 {
     IntRect result;
     if (LayoutObject* object = m_element->layoutObject())
         result = object->absoluteBoundingBoxRect();
     return result;
 }
 
 } // namespace blink