Add an option to make blink media logging verbose

third_party/WebKit/Source/modules/mediasource/SourceBuffer.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 42 matching lines @@
 #include "modules/mediasource/SourceBufferTrackBaseSupplement.h"
 #include "platform/Logging.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/WebSourceBuffer.h"
 #include "wtf/MathExtras.h"
 #include <limits>
 #include <memory>
 #include <sstream>
 
+#ifndef BLINK_SBLOG
+#define BLINK_SBLOG DVLOG(3)
+#endif
+
 using blink::WebSourceBuffer;
 
-#define SBLOG DVLOG(3)
-
 namespace blink {
 
 namespace {
 
 static bool throwExceptionIfRemovedOrUpdating(bool isRemoved, bool isUpdating, ExceptionState& exceptionState)
 {
     if (isRemoved) {
         MediaSource::logAndThrowDOMException(exceptionState, InvalidStateError, "This SourceBuffer has been removed from the parent media source.");
         return true;
     }
@@ skipping 44 matching lines @@
     , m_firstInitializationSegmentReceived(false)
     , m_pendingAppendDataOffset(0)
     , m_appendBufferAsyncPartRunner(AsyncMethodRunner<SourceBuffer>::create(this, &SourceBuffer::appendBufferAsyncPart))
     , m_pendingRemoveStart(-1)
     , m_pendingRemoveEnd(-1)
     , m_removeAsyncPartRunner(AsyncMethodRunner<SourceBuffer>::create(this, &SourceBuffer::removeAsyncPart))
     , m_streamMaxSizeValid(false)
     , m_streamMaxSize(0)
     , m_appendStreamAsyncPartRunner(AsyncMethodRunner<SourceBuffer>::create(this, &SourceBuffer::appendStreamAsyncPart))
 {
-    SBLOG << __FUNCTION__ << " this=" << this;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this;
 
     DCHECK(m_webSourceBuffer);
     DCHECK(m_source);
     DCHECK(m_source->mediaElement());
     ThreadState::current()->registerPreFinalizer(this);
     m_audioTracks = AudioTrackList::create(*m_source->mediaElement());
     m_videoTracks = VideoTrackList::create(*m_source->mediaElement());
     m_webSourceBuffer->setClient(this);
 }
 
 SourceBuffer::~SourceBuffer()
 {
-    SBLOG << __FUNCTION__ << " this=" << this;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this;
 }
 
 void SourceBuffer::dispose()
 {
     // Promptly clears a raw reference from content/ to an on-heap object
     // so that content/ doesn't access it in a lazy sweeping phase.
     m_webSourceBuffer.reset();
 }
 
 const AtomicString& SourceBuffer::segmentsKeyword()
 {
     DEFINE_STATIC_LOCAL(const AtomicString, segments, ("segments"));
     return segments;
 }
 
 const AtomicString& SourceBuffer::sequenceKeyword()
 {
     DEFINE_STATIC_LOCAL(const AtomicString, sequence, ("sequence"));
     return sequence;
 }
 
 void SourceBuffer::setMode(const AtomicString& newMode, ExceptionState& exceptionState)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " newMode=" << newMode;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " newMode=" << newMode;
     // Section 3.1 On setting mode attribute steps.
     // 1. Let new mode equal the new value being assigned to this attribute.
     // 2. If this object has been removed from the sourceBuffers attribute of the parent media source, then throw
     //    an INVALID_STATE_ERR exception and abort these steps.
     // 3. If the updating attribute equals true, then throw an INVALID_STATE_ERR exception and abort these steps.
     if (throwExceptionIfRemovedOrUpdating(isRemoved(), m_updating, exceptionState))
         return;
 
     // 4. If the readyState attribute of the parent media source is in the "ended" state then run the following steps:
     // 4.1 Set the readyState attribute of the parent media source to "open"
@@ skipping 28 matching lines @@
     return TimeRanges::create(m_webSourceBuffer->buffered());
 }
 
 double SourceBuffer::timestampOffset() const
 {
     return m_timestampOffset;
 }
 
 void SourceBuffer::setTimestampOffset(double offset, ExceptionState& exceptionState)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " offset=" << offset;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " offset=" << offset;
     // Section 3.1 timestampOffset attribute setter steps.
     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#widl-SourceBuffer-timestampOffset
     // 1. Let new timestamp offset equal the new value being assigned to this attribute.
     // 2. If this object has been removed from the sourceBuffers attribute of the parent media source, then throw an
     //    InvalidStateError exception and abort these steps.
     // 3. If the updating attribute equals true, then throw an InvalidStateError exception and abort these steps.
     if (throwExceptionIfRemovedOrUpdating(isRemoved(), m_updating, exceptionState))
         return;
 
     // 4. If the readyState attribute of the parent media source is in the "ended" state then run the following steps:
@@ skipping 24 matching lines @@
     return *m_videoTracks;
 }
 
 double SourceBuffer::appendWindowStart() const
 {
     return m_appendWindowStart;
 }
 
 void SourceBuffer::setAppendWindowStart(double start, ExceptionState& exceptionState)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " start=" << start;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " start=" << start;
     // Section 3.1 appendWindowStart attribute setter steps.
     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#widl-SourceBuffer-appendWindowStart
     // 1. If this object has been removed from the sourceBuffers attribute of the parent media source then throw an
     //    InvalidStateError exception and abort these steps.
     // 2. If the updating attribute equals true, then throw an InvalidStateError exception and abort these steps.
     if (throwExceptionIfRemovedOrUpdating(isRemoved(), m_updating, exceptionState))
         return;
 
     // 3. If the new value is less than 0 or greater than or equal to appendWindowEnd then throw an InvalidAccessError
     //    exception and abort these steps.
     if (start < 0 || start >= m_appendWindowEnd) {
         MediaSource::logAndThrowDOMException(exceptionState, InvalidAccessError, ExceptionMessages::indexOutsideRange("value", start, 0.0, ExceptionMessages::ExclusiveBound, m_appendWindowEnd, ExceptionMessages::InclusiveBound));
         return;
     }
 
     m_webSourceBuffer->setAppendWindowStart(start);
 
     // 4. Update the attribute to the new value.
     m_appendWindowStart = start;
 }
 
 double SourceBuffer::appendWindowEnd() const
 {
     return m_appendWindowEnd;
 }
 
 void SourceBuffer::setAppendWindowEnd(double end, ExceptionState& exceptionState)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " end=" << end;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " end=" << end;
     // Section 3.1 appendWindowEnd attribute setter steps.
     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#widl-SourceBuffer-appendWindowEnd
     // 1. If this object has been removed from the sourceBuffers attribute of the parent media source then throw an
     //    InvalidStateError exception and abort these steps.
     // 2. If the updating attribute equals true, then throw an InvalidStateError exception and abort these steps.
     if (throwExceptionIfRemovedOrUpdating(isRemoved(), m_updating, exceptionState))
         return;
 
     // 3. If the new value equals NaN, then throw an InvalidAccessError and abort these steps.
     if (std::isnan(end)) {
         MediaSource::logAndThrowDOMException(exceptionState, InvalidAccessError, ExceptionMessages::notAFiniteNumber(end));
         return;
     }
     // 4. If the new value is less than or equal to appendWindowStart then throw an InvalidAccessError
     //    exception and abort these steps.
     if (end <= m_appendWindowStart) {
         MediaSource::logAndThrowDOMException(exceptionState, InvalidAccessError, ExceptionMessages::indexExceedsMinimumBound("value", end, m_appendWindowStart));
         return;
     }
 
     m_webSourceBuffer->setAppendWindowEnd(end);
 
     // 5. Update the attribute to the new value.
     m_appendWindowEnd = end;
 }
 
 void SourceBuffer::appendBuffer(DOMArrayBuffer* data, ExceptionState& exceptionState)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " size=" << data->byteLength();
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " size=" << data->byteLength();
     // Section 3.2 appendBuffer()
     // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-SourceBuffer-appendBuffer-void-ArrayBufferView-data
     appendBufferInternal(static_cast<const unsigned char*>(data->data()), data->byteLength(), exceptionState);
 }
 
 void SourceBuffer::appendBuffer(DOMArrayBufferView* data, ExceptionState& exceptionState)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " size=" << data->byteLength();
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " size=" << data->byteLength();
     // Section 3.2 appendBuffer()
     // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-SourceBuffer-appendBuffer-void-ArrayBufferView-data
     appendBufferInternal(static_cast<const unsigned char*>(data->baseAddress()), data->byteLength(), exceptionState);
 }
 
 void SourceBuffer::appendStream(Stream* stream, ExceptionState& exceptionState)
 {
     m_streamMaxSizeValid = false;
     appendStreamInternal(stream, exceptionState);
 }
 
 void SourceBuffer::appendStream(Stream* stream, unsigned long long maxSize, ExceptionState& exceptionState)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " maxSize=" << maxSize;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " maxSize=" << maxSize;
     m_streamMaxSizeValid = maxSize > 0;
     if (m_streamMaxSizeValid)
         m_streamMaxSize = maxSize;
     appendStreamInternal(stream, exceptionState);
 }
 
 void SourceBuffer::abort(ExceptionState& exceptionState)
 {
-    SBLOG << __FUNCTION__ << " this=" << this;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this;
     // http://w3c.github.io/media-source/#widl-SourceBuffer-abort-void
     // 1. If this object has been removed from the sourceBuffers attribute of the parent media source
     //    then throw an InvalidStateError exception and abort these steps.
     // 2. If the readyState attribute of the parent media source is not in the "open" state
     //    then throw an InvalidStateError exception and abort these steps.
     if (isRemoved()) {
         MediaSource::logAndThrowDOMException(exceptionState, InvalidStateError, "This SourceBuffer has been removed from the parent media source.");
         return;
     }
     if (!m_source->isOpen()) {
@@ skipping 25 matching lines @@
 
     // 6. Set appendWindowStart to 0.
     setAppendWindowStart(0, exceptionState);
 
     // 7. Set appendWindowEnd to positive Infinity.
     setAppendWindowEnd(std::numeric_limits<double>::infinity(), exceptionState);
 }
 
 void SourceBuffer::remove(double start, double end, ExceptionState& exceptionState)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " start=" << start << " end=" << end;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " start=" << start << " end=" << end;
 
     // Section 3.2 remove() method steps.
     // 1. If duration equals NaN, then throw an InvalidAccessError exception and abort these steps.
     // 2. If start is negative or greater than duration, then throw an InvalidAccessError exception and abort these steps.
 
     if (start < 0 || (m_source && (std::isnan(m_source->duration()) || start > m_source->duration()))) {
         MediaSource::logAndThrowDOMException(exceptionState, InvalidAccessError, ExceptionMessages::indexOutsideRange("start", start, 0.0, ExceptionMessages::ExclusiveBound, !m_source || std::isnan(m_source->duration()) ? 0 : m_source->duration(), ExceptionMessages::ExclusiveBound));
         return;
     }
 
@@ skipping 99 matching lines @@
     scheduleEvent(EventTypeNames::updateend);
 
     TRACE_EVENT_ASYNC_END0("media", traceEventName, this);
 }
 
 void SourceBuffer::removedFromMediaSource()
 {
     if (isRemoved())
         return;
 
-    SBLOG << __FUNCTION__ << " this=" << this;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this;
     if (m_pendingRemoveStart != -1) {
         cancelRemove();
     } else {
         abortIfUpdating();
     }
 
     if (RuntimeEnabledFeatures::audioVideoTracksEnabled()) {
         DCHECK(m_source);
         if (m_source->mediaElement()->audioTracks().length() > 0
             || m_source->mediaElement()->videoTracks().length() > 0) {
             removeMediaTracks();
         }
     }
 
     m_webSourceBuffer->removedFromMediaSource();
     m_webSourceBuffer.reset();
     m_source = nullptr;
     m_asyncEventQueue = nullptr;
 }
 
 double SourceBuffer::highestPresentationTimestamp()
 {
     DCHECK(!isRemoved());
 
     double pts = m_webSourceBuffer->highestPresentationTimestamp();
-    SBLOG << __FUNCTION__ << " this=" << this << ", pts=" << pts;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << ", pts=" << pts;
     return pts;
 }
 
 void SourceBuffer::removeMediaTracks()
 {
     DCHECK(RuntimeEnabledFeatures::audioVideoTracksEnabled());
     // Spec: http://w3c.github.io/media-source/#widl-MediaSource-removeSourceBuffer-void-SourceBuffer-sourceBuffer
     DCHECK(m_source);
 
     HTMLMediaElement* mediaElement = m_source->mediaElement();
@@ skipping 100 matching lines @@
 
 AtomicString SourceBuffer::defaultTrackLanguage(const AtomicString& trackType, const AtomicString& byteStreamTrackID) const
 {
     // Spec: https://w3c.github.io/media-source/#sourcebuffer-default-track-language
     const TrackDefault* trackDefault = getTrackDefault(trackType, byteStreamTrackID);
     return trackDefault ? AtomicString(trackDefault->language()) : "";
 }
 
 bool SourceBuffer::initializationSegmentReceived(const WebVector<MediaTrackInfo>& newTracks)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " tracks=" << newTracks.size();
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " tracks=" << newTracks.size();
     DCHECK(m_source);
     DCHECK(m_source->mediaElement());
     DCHECK(m_updating);
 
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled()) {
         if (!m_firstInitializationSegmentReceived) {
             m_source->setSourceBufferActive(this);
             m_firstInitializationSegmentReceived = true;
         }
         return true;
@@ skipping 10 matching lines @@
         const TrackBase* track = nullptr;
         if (trackInfo.trackType == WebMediaPlayer::AudioTrack) {
             newAudioTracks.append(trackInfo);
             if (m_firstInitializationSegmentReceived)
                 track = findExistingTrackById(audioTracks(), trackInfo.id);
         } else if (trackInfo.trackType == WebMediaPlayer::VideoTrack) {
             newVideoTracks.append(trackInfo);
             if (m_firstInitializationSegmentReceived)
                 track = findExistingTrackById(videoTracks(), trackInfo.id);
         } else {
-            SBLOG << __FUNCTION__ << " this=" << this << " failed: unsupported track type " << trackInfo.trackType;
+            BLINK_SBLOG << __FUNCTION__ << " this=" << this << " failed: unsupported track type " << trackInfo.trackType;
             // TODO(servolk): Add handling of text tracks.
             NOTREACHED();
         }
         if (m_firstInitializationSegmentReceived && !track) {
-            SBLOG << __FUNCTION__ << " this=" << this << " failed: tracks mismatch the first init segment.";
+            BLINK_SBLOG << __FUNCTION__ << " this=" << this << " failed: tracks mismatch the first init segment.";
             return false;
         }
 #if !LOG_DISABLED
         const char* logTrackTypeStr = (trackInfo.trackType == WebMediaPlayer::AudioTrack) ? "audio" : "video";
-        SBLOG << __FUNCTION__ << " this=" << this << " : " << logTrackTypeStr << " track "
+        BLINK_SBLOG << __FUNCTION__ << " this=" << this << " : " << logTrackTypeStr << " track "
             << " id=" << String(trackInfo.id) << " byteStreamTrackID=" << String(trackInfo.byteStreamTrackID)
             << " kind=" << String(trackInfo.kind) << " label=" << String(trackInfo.label) << " language=" << String(trackInfo.language);
 #endif
     }
 
     // 1. Update the duration attribute if it currently equals NaN:
     // TODO(servolk): Pass also stream duration into initSegmentReceived.
 
     // 2. If the initialization segment has no audio, video, or text tracks, then run the append error algorithm with the decode error parameter set to true and abort these steps.
     if (newTracks.size() == 0) {
-        SBLOG << __FUNCTION__ << " this=" << this << " failed: no tracks found in the init segment.";
+        BLINK_SBLOG << __FUNCTION__ << " this=" << this << " failed: no tracks found in the init segment.";
         // The append error algorithm will be called at the top level after we return false here to indicate failure.
         return false;
     }
 
     // 3. If the first initialization segment received flag is true, then run the following steps:
     if (m_firstInitializationSegmentReceived) {
         // 3.1 Verify the following properties. If any of the checks fail then run the append error algorithm with the decode error parameter set to true and abort these steps.
         bool tracksMatchFirstInitSegment = true;
         // - The number of audio, video, and text tracks match what was in the first initialization segment.
         if (newAudioTracks.size() != audioTracks().length() || newVideoTracks.size() != videoTracks().length()) {
@@ skipping 16 matching lines @@
             for (size_t i = 0; i < newVideoTracks.size(); ++i) {
                 const String& newTrackId = newVideoTracks[i].id;
                 if (newTrackId != String(videoTracks().anonymousIndexedGetter(i)->id())) {
                     tracksMatchFirstInitSegment = false;
                     break;
                 }
             }
         }
 
         if (!tracksMatchFirstInitSegment) {
-            SBLOG << __FUNCTION__ << " this=" << this << " failed: tracks mismatch the first init segment.";
+            BLINK_SBLOG << __FUNCTION__ << " this=" << this << " failed: tracks mismatch the first init segment.";
             // The append error algorithm will be called at the top level after we return false here to indicate failure.
             return false;
         }
 
         // 3.2 Add the appropriate track descriptions from this initialization segment to each of the track buffers.
         // This is done in Chromium code in stream parsers and demuxer implementations.
 
         // 3.3 Set the need random access point flag on all track buffers to true.
         // This is done in Chromium code, see MediaSourceState::OnNewConfigs.
     }
@@ skipping 170 matching lines @@
     }
 
     // 4. If the readyState attribute of the parent media source is in the "ended" state then run the following steps:
     //    1. Set the readyState attribute of the parent media source to "open"
     //    2. Queue a task to fire a simple event named sourceopen at the parent media source.
     m_source->openIfInEndedState();
 
     // 5. Run the coded frame eviction algorithm.
     if (!evictCodedFrames(newDataSize)) {
         // 6. If the buffer full flag equals true, then throw a QUOTA_EXCEEDED_ERR exception and abort these steps.
-        SBLOG << __FUNCTION__ << " this=" << this << " -> throw QuotaExceededError";
+        BLINK_SBLOG << __FUNCTION__ << " this=" << this << " -> throw QuotaExceededError";
         MediaSource::logAndThrowDOMException(exceptionState, QuotaExceededError, "The SourceBuffer is full, and cannot free space to append additional buffers.");
         TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::prepareAppend", this);
         return false;
     }
 
     TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::prepareAppend", this);
     return true;
 }
 
 bool SourceBuffer::evictCodedFrames(size_t newDataSize)
 {
     DCHECK(m_source);
     DCHECK(m_source->mediaElement());
     double currentTime = m_source->mediaElement()->currentTime();
     bool result = m_webSourceBuffer->evictCodedFrames(currentTime, newDataSize);
     if (!result) {
-        SBLOG << __FUNCTION__ << " this=" << this << " failed. newDataSize=" << newDataSize
+        BLINK_SBLOG << __FUNCTION__ << " this=" << this << " failed. newDataSize=" << newDataSize
             << " currentTime=" << currentTime << " buffered=" << webTimeRangesToString(m_webSourceBuffer->buffered());
     }
     return result;
 }
 
 void SourceBuffer::appendBufferInternal(const unsigned char* data, unsigned size, ExceptionState& exceptionState)
 {
     TRACE_EVENT_ASYNC_BEGIN1("media", "SourceBuffer::appendBuffer", this, "size", size);
     // Section 3.2 appendBuffer()
     // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-SourceBuffer-appendBuffer-void-ArrayBufferView-data
@@ skipping 75 matching lines @@
         m_pendingAppendDataOffset = 0;
 
         // 4. Queue a task to fire a simple event named update at this SourceBuffer object.
         scheduleEvent(EventTypeNames::update);
 
         // 5. Queue a task to fire a simple event named updateend at this SourceBuffer object.
         scheduleEvent(EventTypeNames::updateend);
     }
 
     TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::appendBuffer", this);
-    SBLOG << __FUNCTION__ << " done. this=" << this << " buffered=" << webTimeRangesToString(m_webSourceBuffer->buffered());
+    BLINK_SBLOG << __FUNCTION__ << " done. this=" << this << " buffered=" << webTimeRangesToString(m_webSourceBuffer->buffered());
 }
 
 void SourceBuffer::removeAsyncPart()
 {
     DCHECK(m_updating);
     DCHECK_GE(m_pendingRemoveStart, 0);
     DCHECK_LT(m_pendingRemoveStart, m_pendingRemoveEnd);
 
     // Section 3.2 remove() method steps
     // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-SourceBuffer-remove-void-double-start-double-end
@@ skipping 93 matching lines @@
 
     // 12. Loop Done: Set the updating attribute to false.
     m_updating = false;
 
     // 13. Queue a task to fire a simple event named update at this SourceBuffer object.
     scheduleEvent(EventTypeNames::update);
 
     // 14. Queue a task to fire a simple event named updateend at this SourceBuffer object.
     scheduleEvent(EventTypeNames::updateend);
     TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::appendStream", this);
-    SBLOG << __FUNCTION__ << " ended. this=" << this << " buffered=" << webTimeRangesToString(m_webSourceBuffer->buffered());
+    BLINK_SBLOG << __FUNCTION__ << " ended. this=" << this << " buffered=" << webTimeRangesToString(m_webSourceBuffer->buffered());
 }
 
 void SourceBuffer::clearAppendStreamState()
 {
     m_streamMaxSizeValid = false;
     m_streamMaxSize = 0;
     m_loader.reset();
     m_stream = nullptr;
 }
 
 void SourceBuffer::appendError(AppendError err)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " AppendError=" << err;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " AppendError=" << err;
     // Section 3.5.3 Append Error Algorithm
     // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#sourcebuffer-append-error
 
     // 1. Run the reset parser state algorithm.
     m_webSourceBuffer->resetParserState();
 
     // 2. Set the updating attribute to false.
     m_updating = false;
 
     // 3. Queue a task to fire a simple event named error at this SourceBuffer object.
     scheduleEvent(EventTypeNames::error);
 
     // 4. Queue a task to fire a simple event named updateend at this SourceBuffer object.
     scheduleEvent(EventTypeNames::updateend);
 
     // 5. If decode error is true, then run the end of stream algorithm with the
     // error parameter set to "decode".
     if (err == DecodeError) {
         m_source->endOfStream("decode", ASSERT_NO_EXCEPTION);
     } else {
         DCHECK_EQ(err, NoDecodeError);
         // Nothing else to do in this case.
     }
 }
 
 void SourceBuffer::didStartLoading()
 {
-    SBLOG << __FUNCTION__ << " this=" << this;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this;
 }
 
 void SourceBuffer::didReceiveDataForClient(const char* data, unsigned dataLength)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " dataLength=" << dataLength;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " dataLength=" << dataLength;
     DCHECK(m_updating);
     DCHECK(m_loader);
 
     // Section 3.5.6 Stream Append Loop
     // http://w3c.github.io/media-source/#sourcebuffer-stream-append-loop
 
     // 10. Run the coded frame eviction algorithm.
     if (!evictCodedFrames(dataLength)) {
         // 11. (in appendStreamDone) If the buffer full flag equals true, then run the append error algorithm with the decode error parameter set to false and abort this algorithm.
         appendStreamDone(RunAppendErrorWithNoDecodeError);
         return;
     }
 
     if (!m_webSourceBuffer->append(reinterpret_cast<const unsigned char*>(data), dataLength, &m_timestampOffset))
         appendStreamDone(RunAppendErrorWithDecodeError);
 }
 
 void SourceBuffer::didFinishLoading()
 {
-    SBLOG << __FUNCTION__ << " this=" << this;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this;
     DCHECK(m_loader);
     appendStreamDone(NoError);
 }
 
 void SourceBuffer::didFail(FileError::ErrorCode errorCode)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " errorCode=" << errorCode;
+    BLINK_SBLOG << __FUNCTION__ << " this=" << this << " errorCode=" << errorCode;
     // m_loader might be already released, in case appendStream has failed due
     // to evictCodedFrames or WebSourceBuffer append failing in
     // didReceiveDataForClient. In that case appendStreamDone will be invoked
     // from there, no need to repeat it here.
     if (m_loader)
         appendStreamDone(RunAppendErrorWithNoDecodeError);
 }
 
 DEFINE_TRACE(SourceBuffer)
 {
     visitor->trace(m_source);
     visitor->trace(m_trackDefaults);
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_appendBufferAsyncPartRunner);
     visitor->trace(m_removeAsyncPartRunner);
     visitor->trace(m_appendStreamAsyncPartRunner);
     visitor->trace(m_stream);
     visitor->trace(m_audioTracks);
     visitor->trace(m_videoTracks);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink