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 148 matching lines @@
     } else {
         set = it->value;
     }
     set->add(element);
 }
 
 void removeElementFromDocumentMap(HTMLMediaElement* element, Document* document)
 {
     DocumentElementSetMap& map = documentToElementSetMap();
     auto it = map.find(document);
-    ASSERT(it != map.end());
+    DCHECK(it != map.end());
     WeakMediaElementSet* set = it->value;
     set->remove(element);
     if (set->isEmpty())
         map.remove(it);
 }
 
 class AudioSourceProviderClientLockScope {
     STACK_ALLOCATED();
 public:
     AudioSourceProviderClientLockScope(HTMLMediaElement& element)
@@ skipping 24 matching lines @@
     case WebMediaPlayerClient::AudioTrackKindMain:
         return AudioTrack::mainKeyword();
     case WebMediaPlayerClient::AudioTrackKindMainDescriptions:
         return AudioTrack::mainDescriptionsKeyword();
     case WebMediaPlayerClient::AudioTrackKindTranslation:
         return AudioTrack::translationKeyword();
     case WebMediaPlayerClient::AudioTrackKindCommentary:
         return AudioTrack::commentaryKeyword();
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return emptyAtom;
 }
 
 const AtomicString& VideoKindToString(WebMediaPlayerClient::VideoTrackKind kind)
 {
     switch (kind) {
     case WebMediaPlayerClient::VideoTrackKindNone:
         return emptyAtom;
     case WebMediaPlayerClient::VideoTrackKindAlternative:
         return VideoTrack::alternativeKeyword();
     case WebMediaPlayerClient::VideoTrackKindCaptions:
         return VideoTrack::captionsKeyword();
     case WebMediaPlayerClient::VideoTrackKindMain:
         return VideoTrack::mainKeyword();
     case WebMediaPlayerClient::VideoTrackKindSign:
         return VideoTrack::signKeyword();
     case WebMediaPlayerClient::VideoTrackKindSubtitles:
         return VideoTrack::subtitlesKeyword();
     case WebMediaPlayerClient::VideoTrackKindCommentary:
         return VideoTrack::commentaryKeyword();
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return emptyAtom;
 }
 
 bool canLoadURL(const KURL& url, const ContentType& contentType)
 {
     DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
     String contentMIMEType = contentType.type().lower();
     String contentTypeCodecs = contentType.parameter(codecs);
 
@@ skipping 22 matching lines @@
 {
     switch (preloadType) {
     case WebMediaPlayer::PreloadNone:
         return "none";
     case WebMediaPlayer::PreloadMetaData:
         return "metadata";
     case WebMediaPlayer::PreloadAuto:
         return "auto";
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return String();
 }
 
 } // anonymous namespace
 
 class HTMLMediaElement::AutoplayHelperClientImpl :
     public AutoplayExperimentHelper::Client {
 
 public:
     static AutoplayHelperClientImpl* create(HTMLMediaElement* element)
@@ skipping 77 matching lines @@
     if (type == "application/octet-stream")
         return WebMimeRegistry::IsNotSupported;
 
     return Platform::current()->mimeRegistry()->supportsMediaMIMEType(type, typeCodecs);
 }
 
 URLRegistry* HTMLMediaElement::s_mediaStreamRegistry = 0;
 
 void HTMLMediaElement::setMediaStreamRegistry(URLRegistry* registry)
 {
-    ASSERT(!s_mediaStreamRegistry);
+    DCHECK(!s_mediaStreamRegistry);
     s_mediaStreamRegistry = registry;
 }
 
 bool HTMLMediaElement::isMediaStreamURL(const String& url)
 {
     return s_mediaStreamRegistry ? s_mediaStreamRegistry->contains(url) : false;
 }
 
 HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName, Document& document)
     : HTMLElement(tagName, document)
@@ skipping 70 matching lines @@
 }
 
 HTMLMediaElement::~HTMLMediaElement()
 {
     DVLOG(MEDIA_LOG_LEVEL) << "~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.
-    ASSERT(!m_audioSourceNode);
+    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
@@ skipping 424 matching lines @@
         break;
     case Attribute:
         loadSourceFromAttribute();
         DVLOG(MEDIA_LOG_LEVEL) << "selectMediaResource(" << (void*)this << "), using 'src' attribute url";
         break;
     case Children:
         loadNextSourceChild();
         DVLOG(MEDIA_LOG_LEVEL) << "selectMediaResource(" << (void*)this << "), using source element";
         break;
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
 }
 
 void HTMLMediaElement::loadSourceFromObject()
 {
-    ASSERT(m_srcObject);
+    DCHECK(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()
 {
@@ skipping 30 matching lines @@
 
     // Reset the MediaPlayer and MediaSource if any
     resetMediaPlayerAndMediaSource();
 
     m_loadState = LoadingFromSourceElement;
     loadResource(WebMediaPlayerSource(WebURL(mediaURL)), contentType);
 }
 
 void HTMLMediaElement::loadResource(const WebMediaPlayerSource& source, ContentType& contentType)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     KURL url;
     if (source.isURL()) {
         url = source.getAsURL();
-        ASSERT(isSafeToLoadURL(url, Complain));
+        DCHECK(isSafeToLoadURL(url, Complain));
         DVLOG(MEDIA_LOG_LEVEL) << "loadResource(" << (void*)this << ", " << urlForLoggingMedia(url) << ", " << contentType.raw() << ")";
     }
 
     LocalFrame* frame = document().frame();
     if (!frame) {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
         return;
     }
 
     // The resource fetch algorithm
@@ skipping 14 matching lines @@
 
     // 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;
     updateVolume();
 
-    ASSERT(!m_mediaSource);
+    DCHECK(!m_mediaSource);
 
     bool attemptLoad = true;
 
     bool isStreamOrBlobUrl = source.isMediaStream() || url.protocolIs(mediaSourceBlobProtocol);
     if (isStreamOrBlobUrl) {
         bool isMediaStream = source.isMediaStream() || (source.isURL() && isMediaStreamURL(url.getString()));
         if (isMediaStream) {
             m_autoplayHelper->unlockUserGesture(GesturelessPlaybackEnabledByStream);
         } else {
             m_mediaSource = HTMLMediaSource::lookup(url.getString());
 
             if (m_mediaSource) {
                 if (!m_mediaSource->attachToElement(this)) {
                     // Forget our reference to the MediaSource, so we leave it alone
                     // while processing remainder of load failure.
                     m_mediaSource = nullptr;
                     attemptLoad = false;
                 }
             }
         }
     }
 
     bool canLoadResource = source.isMediaStream() || canLoadURL(url, contentType);
     if (attemptLoad && canLoadResource) {
-        ASSERT(!webMediaPlayer());
+        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 (!isStreamOrBlobUrl && effectivePreloadType() == WebMediaPlayer::PreloadNone) {
             DVLOG(MEDIA_LOG_LEVEL) << "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.
     updateDisplayState();
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::startPlayerLoad()
 {
-    ASSERT(!m_webMediaPlayer);
+    DCHECK(!m_webMediaPlayer);
 
     WebMediaPlayerSource source;
     if (m_srcObject) {
         source = WebMediaPlayerSource(WebMediaStream(m_srcObject));
     } else {
         // Filter out user:pass as those two URL components aren't
         // considered for media resource fetches (including for the CORS
         // use-credentials mode.) That behavior aligns with Gecko, with IE
         // being more restrictive and not allowing fetches to such URLs.
         //
@@ skipping 57 matching lines @@
 }
 
 bool HTMLMediaElement::loadIsDeferred() const
 {
     return m_deferredLoadState != NotDeferred;
 }
 
 void HTMLMediaElement::deferLoad()
 {
     // This implements the "optional" step 3 from the resource fetch algorithm.
-    ASSERT(!m_deferredLoadTimer.isActive());
-    ASSERT(m_deferredLoadState == NotDeferred);
+    DCHECK(!m_deferredLoadTimer.isActive());
+    DCHECK_EQ(m_deferredLoadState, NotDeferred);
     // 1. Set the networkState to NETWORK_IDLE.
     // 2. Queue a task to fire a simple event named suspend at the element.
     changeNetworkStateFromLoadingToIdle();
     // 3. Queue a task to set the element's delaying-the-load-event
     // flag to false. This stops delaying the load event.
     m_deferredLoadTimer.startOneShot(0, BLINK_FROM_HERE);
     // 4. Wait for the task to be run.
     m_deferredLoadState = WaitingForStopDelayingLoadEventTask;
     // Continued in executeDeferredLoad().
 }
 
 void HTMLMediaElement::cancelDeferredLoad()
 {
     m_deferredLoadTimer.stop();
     m_deferredLoadState = NotDeferred;
 }
 
 void HTMLMediaElement::executeDeferredLoad()
 {
-    ASSERT(m_deferredLoadState >= WaitingForTrigger);
+    DCHECK_GE(m_deferredLoadState, WaitingForTrigger);
 
     // resource fetch algorithm step 3 - continued from deferLoad().
 
     // 5. Wait for an implementation-defined event (e.g. the user requesting that the media element begin playback).
     // This is assumed to be whatever 'event' ended up calling this method.
     cancelDeferredLoad();
     // 6. 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);
     // 7. Set the networkState to NETWORK_LOADING.
     setNetworkState(NETWORK_LOADING);
 
     startProgressEventTimer();
 
     startPlayerLoad();
 }
 
 void HTMLMediaElement::startDeferredLoad()
 {
     if (m_deferredLoadState == WaitingForTrigger) {
         executeDeferredLoad();
         return;
     }
     if (m_deferredLoadState == ExecuteOnStopDelayingLoadEventTask)
         return;
-    ASSERT(m_deferredLoadState == WaitingForStopDelayingLoadEventTask);
+    DCHECK_EQ(m_deferredLoadState, WaitingForStopDelayingLoadEventTask);
     m_deferredLoadState = ExecuteOnStopDelayingLoadEventTask;
 }
 
 void HTMLMediaElement::deferredLoadTimerFired(Timer<HTMLMediaElement>*)
 {
     setShouldDelayLoadEvent(false);
 
     if (m_deferredLoadState == ExecuteOnStopDelayingLoadEventTask) {
         executeDeferredLoad();
         return;
     }
-    ASSERT(m_deferredLoadState == WaitingForStopDelayingLoadEventTask);
+    DCHECK_EQ(m_deferredLoadState, WaitingForStopDelayingLoadEventTask);
     m_deferredLoadState = WaitingForTrigger;
 }
 
 WebMediaPlayer::LoadType HTMLMediaElement::loadType() const
 {
     if (m_mediaSource)
         return WebMediaPlayer::LoadTypeMediaSource;
 
     if (m_srcObject || isMediaStreamURL(m_currentSrc.getString()))
         return WebMediaPlayer::LoadTypeMediaStream;
@@ skipping 32 matching lines @@
 }
 
 void HTMLMediaElement::textTrackModeChanged(TextTrack* track)
 {
     // Mark this track as "configured" so configureTextTracks won't change the mode again.
     if (track->trackType() == TextTrack::TrackElement)
         track->setHasBeenConfigured(true);
 
     configureTextTrackDisplay();
 
-    ASSERT(textTracks()->contains(track));
+    DCHECK(textTracks()->contains(track));
     textTracks()->scheduleChangeEvent();
 }
 
 void HTMLMediaElement::disableAutomaticTextTrackSelection()
 {
     m_shouldPerformAutomaticTrackSelection = false;
 }
 
 bool HTMLMediaElement::isSafeToLoadURL(const KURL& url, InvalidURLAction actionIfInvalid)
 {
@@ skipping 93 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);
+    DCHECK_GE(m_readyState, HAVE_METADATA);
     DVLOG(MEDIA_LOG_LEVEL) << "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;
 
@@ skipping 647 matching lines @@
     if (!code.isNull()) {
         String message;
         switch (code.get()) {
         case NotAllowedError:
             message = "play() can only be initiated by a user gesture.";
             break;
         case NotSupportedError:
             message = "The element has no supported sources.";
             break;
         default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
         }
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(code.get(), message));
     }
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     m_playResolvers.append(resolver);
     return promise;
 }
@@ skipping 106 matching lines @@
         scheduleTimeupdateEvent(false);
         scheduleEvent(EventTypeNames::pause);
         scheduleRejectPlayPromises(AbortError);
     }
 
     updatePlayState();
 }
 
 void HTMLMediaElement::requestRemotePlayback()
 {
-    ASSERT(m_remoteRoutesAvailable);
+    DCHECK(m_remoteRoutesAvailable);
     webMediaPlayer()->requestRemotePlayback();
     Platform::current()->recordAction(UserMetricsAction("Media_RequestRemotePlayback"));
 }
 
 void HTMLMediaElement::requestRemotePlaybackControl()
 {
-    ASSERT(m_remoteRoutesAvailable);
+    DCHECK(m_remoteRoutesAvailable);
     webMediaPlayer()->requestRemotePlaybackControl();
     Platform::current()->recordAction(UserMetricsAction("Media_RequestRemotePlayback_Control"));
 }
 
 void HTMLMediaElement::closeMediaSource()
 {
     if (!m_mediaSource)
         return;
 
     m_mediaSource->close();
@@ skipping 162 matching lines @@
 void HTMLMediaElement::togglePlayState()
 {
     if (paused())
         play();
     else
         pause();
 }
 
 AudioTrackList& HTMLMediaElement::audioTracks()
 {
-    ASSERT(RuntimeEnabledFeatures::audioVideoTracksEnabled());
+    DCHECK(RuntimeEnabledFeatures::audioVideoTracksEnabled());
     return *m_audioTracks;
 }
 
 void HTMLMediaElement::audioTrackChanged(WebMediaPlayer::TrackId trackId, bool enabled)
 {
     DVLOG(MEDIA_LOG_LEVEL) << "audioTrackChanged(" << (void*)this << ") trackId= " << trackId << " enabled=" << boolString(enabled);
-    ASSERT(RuntimeEnabledFeatures::audioVideoTracksEnabled());
+    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>*)
@@ skipping 28 matching lines @@
     DVLOG(MEDIA_LOG_LEVEL) << "removeAudioTrack(" << (void*)this << ")";
 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return;
 
     audioTracks().remove(trackId);
 }
 
 VideoTrackList& HTMLMediaElement::videoTracks()
 {
-    ASSERT(RuntimeEnabledFeatures::audioVideoTracksEnabled());
+    DCHECK(RuntimeEnabledFeatures::audioVideoTracksEnabled());
     return *m_videoTracks;
 }
 
 void HTMLMediaElement::selectedVideoTrackChanged(WebMediaPlayer::TrackId* selectedTrackId)
 {
     DVLOG(MEDIA_LOG_LEVEL) << "selectedVideoTrackChanged(" << (void*)this << ") selectedTrackId=" << (selectedTrackId ? String::format("%u", *selectedTrackId) : "none");
-    ASSERT(RuntimeEnabledFeatures::audioVideoTracksEnabled());
+    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)
@@ skipping 534 matching lines @@
 
     updateDisplayState();
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::sizeChanged()
 {
     DVLOG(MEDIA_LOG_LEVEL) << "sizeChanged(" << (void*)this << ")";
 
-    ASSERT(hasVideo()); // "resize" makes no sense absent video.
+    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
 {
     if (m_mediaSource)
@@ skipping 58 matching lines @@
         return false;
 
     // and the current playback position is the end of the media resource and the direction
     // of playback is forwards, Either the media element does not have a loop attribute specified,
     double now = currentTime();
     if (getDirectionOfPlayback() == Forward)
         return dur > 0 && now >= dur && (loopCondition == LoopCondition::Ignored || !loop());
 
     // or the current playback position is the earliest possible position and the direction
     // of playback is backwards
-    ASSERT(getDirectionOfPlayback() == Backward);
+    DCHECK_EQ(getDirectionOfPlayback(), Backward);
     return now <= 0;
 }
 
 bool HTMLMediaElement::stoppedDueToErrors() const
 {
     if (m_readyState >= HAVE_METADATA && m_error) {
         TimeRanges* seekableRanges = seekable();
         if (!seekableRanges->contain(currentTime()))
             return true;
     }
@@ skipping 117 matching lines @@
     m_paused = true;
     m_seeking = false;
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 
     stopPeriodicTimers();
 
     // Ensure that hasPendingActivity() is not preventing garbage collection, since otherwise this
     // media element will simply leak.
-    ASSERT(!hasPendingActivity());
+    DCHECK(!hasPendingActivity());
 }
 
 bool HTMLMediaElement::hasPendingActivity() const
 {
     // The delaying-the-load-event flag is set by resource selection algorithm when looking for a
     // resource to load, before networkState has reached to NETWORK_LOADING.
     if (m_shouldDelayLoadEvent)
         return true;
 
     // When networkState is NETWORK_LOADING, progress and stalled events may be fired.
@@ skipping 79 matching lines @@
     return false;
 }
 
 bool HTMLMediaElement::textTracksVisible() const
 {
     return m_textTracksVisible;
 }
 
 static void assertShadowRootChildren(ShadowRoot& shadowRoot)
 {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     // There can be up to two children, either or both of the text
     // track container and media controls. If both are present, the
     // text track container must be the first child.
     unsigned numberOfChildren = shadowRoot.countChildren();
-    ASSERT(numberOfChildren <= 2);
+    DCHECK_LE(numberOfChildren, 2u);
     Node* firstChild = shadowRoot.firstChild();
     Node* lastChild = shadowRoot.lastChild();
     if (numberOfChildren == 1) {
-        ASSERT(firstChild->isTextTrackContainer() || firstChild->isMediaControls());
+        DCHECK(firstChild->isTextTrackContainer() || firstChild->isMediaControls());
     } else if (numberOfChildren == 2) {
-        ASSERT(firstChild->isTextTrackContainer());
-        ASSERT(lastChild->isMediaControls());
+        DCHECK(firstChild->isTextTrackContainer());
+        DCHECK(lastChild->isMediaControls());
     }
 #endif
 }
 
 TextTrackContainer& HTMLMediaElement::ensureTextTrackContainer()
 {
     ShadowRoot& shadowRoot = ensureUserAgentShadowRoot();
     assertShadowRootChildren(shadowRoot);
 
     Node* firstChild = shadowRoot.firstChild();
@@ skipping 27 matching lines @@
     // 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)
 {
     auto it = documentToElementSetMap().find(document);
     if (it == documentToElementSetMap().end())
         return;
-    ASSERT(it->value);
+    DCHECK(it->value);
     WeakMediaElementSet& elements = *it->value;
     for (const auto& element : elements)
         element->automaticTrackSelectionForUpdatedUserPreference();
 }
 
 void HTMLMediaElement::automaticTrackSelectionForUpdatedUserPreference()
 {
     if (!m_textTracks || !m_textTracks->length())
         return;
 
@@ skipping 114 matching lines @@
 
 CueTimeline& HTMLMediaElement::cueTimeline()
 {
     if (!m_cueTimeline)
         m_cueTimeline = new CueTimeline(*this);
     return *m_cueTimeline;
 }
 
 void HTMLMediaElement::configureTextTrackDisplay()
 {
-    ASSERT(m_textTracks);
+    DCHECK(m_textTracks);
     DVLOG(MEDIA_LOG_LEVEL) << "configureTextTrackDisplay(" << (void*)this << ")";
 
     if (m_processingPreferenceChange)
         return;
 
     bool haveVisibleTextTrack = m_textTracks->hasShowingTracks();
     m_textTracksVisible = haveVisibleTextTrack;
 
     if (!haveVisibleTextTrack && !mediaControls())
         return;
@@ skipping 33 matching lines @@
     // We haven't yet found out if any remote routes are available.
     m_remoteRoutesAvailable = false;
     m_playingRemotely = false;
 
     if (m_audioSourceNode)
         getAudioSourceProvider().setClient(m_audioSourceNode);
 }
 
 void HTMLMediaElement::setAudioSourceNode(AudioSourceProviderClient* sourceNode)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     m_audioSourceNode = sourceNode;
 
     AudioSourceProviderClientLockScope scope(*this);
     getAudioSourceProvider().setClient(m_audioSourceNode);
 }
 
 void HTMLMediaElement::setAllowHiddenVolumeControls(bool allow)
 {
     ensureMediaControls();
     mediaControls()->setAllowHiddenVolumeControls(allow);
@@ skipping 191 matching lines @@
         resolver->resolve();
 
     m_playResolvers.clear();
 }
 
 void HTMLMediaElement::rejectPlayPromises()
 {
     // TODO(mlamouri): the message is generated based on the code because
     // arguments can't be passed to a cancellable task. In order to save space
     // used by the object, the string isn't saved.
-    ASSERT(m_playPromiseErrorCode == AbortError || m_playPromiseErrorCode == NotSupportedError);
+    DCHECK(m_playPromiseErrorCode == AbortError || m_playPromiseErrorCode == NotSupportedError);
     if (m_playPromiseErrorCode == AbortError)
         rejectPlayPromises(AbortError, "The play() request was interrupted by a call to pause().");
     else
         rejectPlayPromises(NotSupportedError, "Failed to load because no supported source was found.");
 }
 
 void HTMLMediaElement::rejectPlayPromises(ExceptionCode code, const String& message)
 {
-    ASSERT(code == AbortError || code == NotSupportedError);
+    DCHECK(code == AbortError || code == NotSupportedError);
 
     for (auto& resolver: m_playResolvers)
         resolver->reject(DOMException::create(code, message));
 
     m_playResolvers.clear();
 }
 
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor)
 {
     if (!ThreadHeap::isHeapObjectAlive(m_audioSourceNode)) {
@@ skipping 22 matching lines @@
         m_client = new HTMLMediaElement::AudioClientImpl(client);
     else
         m_client.clear();
 
     if (m_webAudioSourceProvider)
         m_webAudioSourceProvider->setClient(m_client.get());
 }
 
 void HTMLMediaElement::AudioSourceProviderImpl::provideInput(AudioBus* bus, size_t framesToProcess)
 {
-    ASSERT(bus);
+    DCHECK(bus);
 
     MutexTryLocker tryLocker(provideInputLock);
     if (!tryLocker.locked() || !m_webAudioSourceProvider || !m_client.get()) {
         bus->zero();
         return;
     }
 
     // Wrap the AudioBus channel data using WebVector.
     size_t n = bus->numberOfChannels();
     WebVector<float*> webAudioData(n);
@@ skipping 61 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect() const
 {
     IntRect result;
     if (LayoutObject* object = m_element->layoutObject())
         result = object->absoluteBoundingBoxRect();
     return result;
 }
 
 } // namespace blink