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

third_party/WebKit/Source/modules/mediasource/MediaSource.cpp

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 33 matching lines @@
 #include "platform/MIMETypeRegistry.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/WebMediaSource.h"
 #include "public/platform/WebSourceBuffer.h"
 #include "wtf/text/CString.h"
 
 using blink::WebMediaSource;
 using blink::WebSourceBuffer;
 
+#define MEDIA_SOURCE_LOG_LEVEL 3
+
 namespace blink {
 
 static bool throwExceptionIfClosedOrUpdating(bool isOpen, bool isUpdating, ExceptionState& exceptionState)
 {
     if (!isOpen) {
         MediaSource::logAndThrowDOMException(exceptionState, InvalidStateError, "The MediaSource's readyState is not 'open'.");
         return true;
     }
     if (isUpdating) {
         MediaSource::logAndThrowDOMException(exceptionState, InvalidStateError, "The 'updating' attribute is true on one or more of this MediaSource's SourceBuffers.");
@@ skipping 31 matching lines @@
 MediaSource::MediaSource(ExecutionContext* context)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(context)
     , m_readyState(closedKeyword())
     , m_asyncEventQueue(GenericEventQueue::create(this))
     , m_attachedElement(nullptr)
     , m_sourceBuffers(SourceBufferList::create(getExecutionContext(), m_asyncEventQueue.get()))
     , m_activeSourceBuffers(SourceBufferList::create(getExecutionContext(), m_asyncEventQueue.get()))
     , m_isAddedToRegistry(false)
 {
-    WTF_LOG(Media, "MediaSource::MediaSource %p", this);
+    DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(" << this << ")";
 }
 
 MediaSource::~MediaSource()
 {
-    WTF_LOG(Media, "MediaSource::~MediaSource %p", this);
-    ASSERT(isClosed());
+    DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(" << this << ")";
+    DCHECK(isClosed());
 }
 
 void MediaSource::logAndThrowDOMException(ExceptionState& exceptionState, const ExceptionCode& error, const String& message)
 {
-    WTF_LOG(Media, "throwDOMException: error=%d msg=%s", error, message.utf8().data());
+    DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(error=" << error << ", message=" << message << ")";
     exceptionState.throwDOMException(error, message);
 }
 
 SourceBuffer* MediaSource::addSourceBuffer(const String& type, ExceptionState& exceptionState)
 {
-    WTF_LOG(Media, "MediaSource::addSourceBuffer(%s) %p", type.ascii().data(), this);
+    DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(" << type << ") " << this;
 
     // 2.2 https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-MediaSource-addSourceBuffer-SourceBuffer-DOMString-type
     // 1. If type is an empty string then throw an InvalidAccessError exception
     // and abort these steps.
     if (type.isEmpty()) {
         logAndThrowDOMException(exceptionState, InvalidAccessError, "The type provided is empty.");
         return 0;
     }
 
     // 2. If type contains a MIME type that is not supported ..., then throw a
     // NotSupportedError exception and abort these steps.
     if (!isTypeSupported(type)) {
         logAndThrowDOMException(exceptionState, NotSupportedError, "The type provided ('" + type + "') is unsupported.");
         return 0;
     }
 
     // 4. If the readyState attribute is not in the "open" state then throw an
     // InvalidStateError exception and abort these steps.
     if (!isOpen()) {
         logAndThrowDOMException(exceptionState, InvalidStateError, "The MediaSource's readyState is not 'open'.");
         return 0;
     }
 
     // 5. Create a new SourceBuffer object and associated resources.
     ContentType contentType(type);
     String codecs = contentType.parameter("codecs");
     OwnPtr<WebSourceBuffer> webSourceBuffer = createWebSourceBuffer(contentType.type(), codecs, exceptionState);
 
     if (!webSourceBuffer) {
-        ASSERT(exceptionState.code() == NotSupportedError || exceptionState.code() == QuotaExceededError);
+        DCHECK(exceptionState.code() == NotSupportedError || exceptionState.code() == QuotaExceededError);
         // 2. If type contains a MIME type that is not supported ..., then throw a NotSupportedError exception and abort these steps.
         // 3. If the user agent can't handle any more SourceBuffer objects then throw a QuotaExceededError exception and abort these steps
         return 0;
     }
 
     SourceBuffer* buffer = SourceBuffer::create(std::move(webSourceBuffer), this, m_asyncEventQueue.get());
     // 6. Add the new object to sourceBuffers and fire a addsourcebuffer on that object.
     m_sourceBuffers->add(buffer);
 
     // 7. Return the new object to the caller.
-    WTF_LOG(Media, "MediaSource::addSourceBuffer(%s) %p -> %p", type.ascii().data(), this, buffer);
+    DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(" << type << ") " << buffer << " -> " << this;
     return buffer;
 }
 
 void MediaSource::removeSourceBuffer(SourceBuffer* buffer, ExceptionState& exceptionState)
 {
-    WTF_LOG(Media, "MediaSource::removeSourceBuffer() %p", this);
+    DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(" << buffer << ") -> " << this;
 
     // 2.2 https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-MediaSource-removeSourceBuffer-void-SourceBuffer-sourceBuffer
 
     // 1. If sourceBuffer specifies an object that is not in sourceBuffers then
     // throw a NotFoundError exception and abort these steps.
     if (!m_sourceBuffers->length() || !m_sourceBuffers->contains(buffer)) {
         logAndThrowDOMException(exceptionState, NotFoundError, "The SourceBuffer provided is not contained in this MediaSource.");
         return;
     }
 
@@ skipping 16 matching lines @@
     if (isOpen()) {
         scheduleEvent(EventTypeNames::sourceopen);
         return;
     }
 
     if (oldState == openKeyword() && newState == endedKeyword()) {
         scheduleEvent(EventTypeNames::sourceended);
         return;
     }
 
-    ASSERT(isClosed());
+    DCHECK(isClosed());
 
     m_activeSourceBuffers->clear();
 
     // Clear SourceBuffer references to this object.
     for (unsigned long i = 0; i < m_sourceBuffers->length(); ++i)
         m_sourceBuffers->item(i)->removedFromMediaSource();
     m_sourceBuffers->clear();
 
     m_attachedElement.clear();
 
@@ skipping 10 matching lines @@
 
     return false;
 }
 
 bool MediaSource::isTypeSupported(const String& type)
 {
     // Section 2.2 isTypeSupported() method steps.
     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#widl-MediaSource-isTypeSupported-boolean-DOMString-type
     // 1. If type is an empty string, then return false.
     if (type.isEmpty()) {
-        WTF_LOG(Media, "MediaSource::isTypeSupported(%s) -> false (empty input)", type.ascii().data());
+        DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(" << type << ") -> false (empty input)";
         return false;
     }
 
     ContentType contentType(type);
     String codecs = contentType.parameter("codecs");
 
     // 2. If type does not contain a valid MIME type string, then return false.
     if (contentType.type().isEmpty()) {
-        WTF_LOG(Media, "MediaSource::isTypeSupported(%s) -> false (invalid mime type)", type.ascii().data());
+        DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(" << type << ") -> false (invalid mime type)";
         return false;
     }
 
     // Note: MediaSource.isTypeSupported() returning true implies that HTMLMediaElement.canPlayType() will return "maybe" or "probably"
     // since it does not make sense for a MediaSource to support a type the HTMLMediaElement knows it cannot play.
     if (HTMLMediaElement::supportsType(contentType) == WebMimeRegistry::IsNotSupported) {
-        WTF_LOG(Media, "MediaSource::isTypeSupported(%s) -> false (not supported by HTMLMediaElement)", type.ascii().data());
+        DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(" << type << ") -> false (not supported by HTMLMediaElement)";
         return false;
     }
 
     // 3. If type contains a media type or media subtype that the MediaSource does not support, then return false.
     // 4. If type contains at a codec that the MediaSource does not support, then return false.
     // 5. If the MediaSource does not support the specified combination of media type, media subtype, and codecs then return false.
     // 6. Return true.
     bool result = MIMETypeRegistry::isSupportedMediaSourceMIMEType(contentType.type(), codecs);
-    WTF_LOG(Media, "MediaSource::isTypeSupported(%s) -> %s", type.ascii().data(), result ? "true" : "false");
+    DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << "(" << type << ") -> " << (result ? "true" : "false");
     return result;
 }
 
 const AtomicString& MediaSource::interfaceName() const
 {
     return EventTargetNames::MediaSource;
 }
 
 ExecutionContext* MediaSource::getExecutionContext() const
 {
     return ActiveDOMObject::getExecutionContext();
 }
 
 DEFINE_TRACE(MediaSource)
 {
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_attachedElement);
     visitor->trace(m_sourceBuffers);
     visitor->trace(m_activeSourceBuffers);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 void MediaSource::setWebMediaSourceAndOpen(PassOwnPtr<WebMediaSource> webMediaSource)
 {
     TRACE_EVENT_ASYNC_END0("media", "MediaSource::attachToElement", this);
-    ASSERT(webMediaSource);
-    ASSERT(!m_webMediaSource);
-    ASSERT(m_attachedElement);
+    DCHECK(webMediaSource);
+    DCHECK(!m_webMediaSource);
+    DCHECK(m_attachedElement);
     m_webMediaSource = std::move(webMediaSource);
     setReadyState(openKeyword());
 }
 
 void MediaSource::addedToRegistry()
 {
-    ASSERT(!m_isAddedToRegistry);
+    DCHECK(!m_isAddedToRegistry);
     m_isAddedToRegistry = true;
 }
 
 void MediaSource::removedFromRegistry()
 {
-    ASSERT(m_isAddedToRegistry);
+    DCHECK(m_isAddedToRegistry);
     m_isAddedToRegistry = false;
 }
 
 double MediaSource::duration() const
 {
     return isClosed() ? std::numeric_limits<float>::quiet_NaN() : m_webMediaSource->duration();
 }
 
 TimeRanges* MediaSource::buffered() const
 {
@@ skipping 120 matching lines @@
     // 5. If a user agent is unable to partially render audio frames or text cues that start before and end after the duration, then run the following steps:
     // NOTE: Currently we assume that the media engine is able to render partial frames/cues. If a media
     // engine gets added that doesn't support this, then we'll need to add logic to handle the substeps.
 
     // 6. Update the media controller duration to new duration and run the HTMLMediaElement duration change algorithm.
     m_attachedElement->durationChanged(newDuration, requestSeek);
 }
 
 void MediaSource::setReadyState(const AtomicString& state)
 {
-    ASSERT(state == openKeyword() || state == closedKeyword() || state == endedKeyword());
+    DCHECK(state == openKeyword() || state == closedKeyword() || state == endedKeyword());
 
     AtomicString oldState = readyState();
-    WTF_LOG(Media, "MediaSource::setReadyState() %p : %s -> %s", this, oldState.ascii().data(), state.ascii().data());
+    DVLOG(MEDIA_SOURCE_LOG_LEVEL) << __FUNCTION__ << " : " << oldState << " -> " << state << " " << this;
 
     if (state == closedKeyword()) {
         m_webMediaSource.clear();
     }
 
     if (oldState == state)
         return;
 
     m_readyState = state;
 
     onReadyStateChange(oldState, state);
 }
 
 void MediaSource::endOfStream(const AtomicString& error, ExceptionState& exceptionState)
 {
     DEFINE_STATIC_LOCAL(const AtomicString, network, ("network"));
     DEFINE_STATIC_LOCAL(const AtomicString, decode, ("decode"));
 
     if (error == network) {
         endOfStreamInternal(WebMediaSource::EndOfStreamStatusNetworkError, exceptionState);
     } else if (error == decode) {
         endOfStreamInternal(WebMediaSource::EndOfStreamStatusDecodeError, exceptionState);
     } else {
-        ASSERT_NOT_REACHED(); // IDL enforcement should prevent this case.
+        NOTREACHED(); // IDL enforcement should prevent this case.
     }
 }
 
 void MediaSource::endOfStream(ExceptionState& exceptionState)
 {
     endOfStreamInternal(WebMediaSource::EndOfStreamStatusNoError, exceptionState);
 }
 
 void MediaSource::endOfStreamInternal(const WebMediaSource::EndOfStreamStatus eosStatus, ExceptionState& exceptionState)
 {
@@ skipping 14 matching lines @@
     m_webMediaSource->markEndOfStream(eosStatus);
 }
 
 bool MediaSource::isOpen() const
 {
     return readyState() == openKeyword();
 }
 
 void MediaSource::setSourceBufferActive(SourceBuffer* sourceBuffer)
 {
-    ASSERT(!m_activeSourceBuffers->contains(sourceBuffer));
+    DCHECK(!m_activeSourceBuffers->contains(sourceBuffer));
 
     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#widl-MediaSource-activeSourceBuffers
     // SourceBuffer objects in SourceBuffer.activeSourceBuffers must appear in
     // the same order as they appear in SourceBuffer.sourceBuffers.
     // SourceBuffer transitions to active are not guaranteed to occur in the
     // same order as buffers in |m_sourceBuffers|, so this method needs to
     // insert |sourceBuffer| into |m_activeSourceBuffers|.
     size_t indexInSourceBuffers = m_sourceBuffers->find(sourceBuffer);
-    ASSERT(indexInSourceBuffers != kNotFound);
+    DCHECK(indexInSourceBuffers != kNotFound);
 
     size_t insertPosition = 0;
     while (insertPosition < m_activeSourceBuffers->length()
         && m_sourceBuffers->find(m_activeSourceBuffers->item(insertPosition)) < indexInSourceBuffers) {
         ++insertPosition;
     }
 
     m_activeSourceBuffers->insert(insertPosition, sourceBuffer);
 }
 
@@ skipping 10 matching lines @@
 void MediaSource::close()
 {
     setReadyState(closedKeyword());
 }
 
 bool MediaSource::attachToElement(HTMLMediaElement* element)
 {
     if (m_attachedElement)
         return false;
 
-    ASSERT(isClosed());
+    DCHECK(isClosed());
 
     TRACE_EVENT_ASYNC_BEGIN0("media", "MediaSource::attachToElement", this);
     m_attachedElement = element;
     return true;
 }
 
 void MediaSource::openIfInEndedState()
 {
     if (m_readyState != endedKeyword())
         return;
@@ skipping 18 matching lines @@
 }
 
 PassOwnPtr<WebSourceBuffer> MediaSource::createWebSourceBuffer(const String& type, const String& codecs, ExceptionState& exceptionState)
 {
     WebSourceBuffer* webSourceBuffer = 0;
 
     switch (m_webMediaSource->addSourceBuffer(type, codecs, &webSourceBuffer)) {
     case WebMediaSource::AddStatusOk:
         return adoptPtr(webSourceBuffer);
     case WebMediaSource::AddStatusNotSupported:
-        ASSERT(!webSourceBuffer);
+        DCHECK(!webSourceBuffer);
         // 2.2 https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-MediaSource-addSourceBuffer-SourceBuffer-DOMString-type
         // Step 2: If type contains a MIME type ... that is not supported with the types
         // specified for the other SourceBuffer objects in sourceBuffers, then throw
         // a NotSupportedError exception and abort these steps.
         logAndThrowDOMException(exceptionState, NotSupportedError, "The type provided ('" + type + "') is not supported.");
         return nullptr;
     case WebMediaSource::AddStatusReachedIdLimit:
-        ASSERT(!webSourceBuffer);
+        DCHECK(!webSourceBuffer);
         // 2.2 https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-MediaSource-addSourceBuffer-SourceBuffer-DOMString-type
         // Step 3: If the user agent can't handle any more SourceBuffer objects then throw
         // a QuotaExceededError exception and abort these steps.
         logAndThrowDOMException(exceptionState, QuotaExceededError, "This MediaSource has reached the limit of SourceBuffer objects it can handle. No additional SourceBuffer objects may be added.");
         return nullptr;
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return nullptr;
 }
 
 void MediaSource::scheduleEvent(const AtomicString& eventName)
 {
-    ASSERT(m_asyncEventQueue);
+    DCHECK(m_asyncEventQueue);
 
     Event* event = Event::create(eventName);
     event->setTarget(this);
 
     m_asyncEventQueue->enqueueEvent(event);
 }
 
 URLRegistry& MediaSource::registry() const
 {
     return MediaSourceRegistry::registry();
 }
 
 } // namespace blink