Fix MSE GC, make it less aggressive, more spec-compliant (Blink CL)

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 22 matching lines @@
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMArrayBufferView.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/events/Event.h"
 #include "core/events/GenericEventQueue.h"
 #include "core/fileapi/FileReaderLoader.h"
+#include "core/html/HTMLMediaElement.h"
+#include "core/html/MediaError.h"
 #include "core/html/TimeRanges.h"
 #include "core/streams/Stream.h"
 #include "modules/mediasource/MediaSource.h"
 #include "platform/Logging.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/WebSourceBuffer.h"
 #include "wtf/MathExtras.h"
 
 #include <limits>
 
@@ skipping 208 matching lines @@
     }
 
     m_webSourceBuffer->setAppendWindowEnd(end);
 
     // 5. Update the attribute to the new value.
     m_appendWindowEnd = end;
 }
 
 void SourceBuffer::appendBuffer(PassRefPtr<DOMArrayBuffer> data, ExceptionState& exceptionState)
 {
+    WTF_LOG(Media, "SourceBuffer::appendBuffer %p size=%u", this, 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(PassRefPtr<DOMArrayBufferView> data, ExceptionState& exceptionState)
 {
+    WTF_LOG(Media, "SourceBuffer::appendBuffer %p size=%u", this, 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)
 {
+    WTF_LOG(Media, "SourceBuffer::appendStream %p maxSize=%llu", this, maxSize);
     m_streamMaxSizeValid = maxSize > 0;
     if (m_streamMaxSizeValid)
         m_streamMaxSize = maxSize;
     appendStreamInternal(stream, exceptionState);
 }
 
 void SourceBuffer::abort(ExceptionState& exceptionState)
 {
     // Section 3.2 abort() method steps.
     // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-SourceBuffer-abort-void
@@ skipping 18 matching lines @@
 
     // 5. Set appendWindowStart to 0.
     setAppendWindowStart(0, exceptionState);
 
     // 6. Set appendWindowEnd to positive Infinity.
     setAppendWindowEnd(std::numeric_limits<double>::infinity(), exceptionState);
 }
 
 void SourceBuffer::remove(double start, double end, ExceptionState& exceptionState)
 {
+    WTF_LOG(Media, "SourceBuffer::remove %p start=%f end=%f", this, start, 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()))) {
         exceptionState.throwDOMException(InvalidAccessError, ExceptionMessages::indexOutsideRange("start", start, 0.0, ExceptionMessages::ExclusiveBound, !m_source || std::isnan(m_source->duration()) ? 0 : m_source->duration(), ExceptionMessages::ExclusiveBound));
         return;
     }
 
     // 3. If end is less than or equal to start or end equals NaN, then throw an InvalidAccessError exception and abort these steps.
@@ skipping 167 matching lines @@
 void SourceBuffer::scheduleEvent(const AtomicString& eventName)
 {
     ASSERT(m_asyncEventQueue);
 
     RefPtrWillBeRawPtr<Event> event = Event::create(eventName);
     event->setTarget(this);
 
     m_asyncEventQueue->enqueueEvent(event.release());
 }
 
+bool SourceBuffer::prepareAppend(size_t newDataSize, ExceptionState& exceptionState)
+{
+    TRACE_EVENT_ASYNC_BEGIN0("media", "SourceBuffer::prepareAppend", this);
+    // http://w3c.github.io/media-source/#sourcebuffer-prepare-append
+    // 3.5.4 Prepare Append Algorithm
+    // 1. If the SourceBuffer 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)) {
+        TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::prepareAppend", this);
+        return false;
+    }
+
+    // 3. If the HTMLMediaElement.error attribute is not null, then throw an InvalidStateError exception and abort these steps.
+    ASSERT(m_source);
+    ASSERT(m_source->mediaElement());
+    if (m_source->mediaElement()->error()) {
+        exceptionState.throwDOMException(InvalidStateError, "The HTMLMediaElement.error attribute is not null.");
+        TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::prepareAppend", this);
+        return false;
+    }
+
+    // 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.
+        WTF_LOG(Media, "SourceBuffer::prepareAppend %p -> throw QuotaExceededError", this);
+        exceptionState.throwDOMException(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)
+{
+    ASSERT(m_source);
+    ASSERT(m_source->mediaElement());
+    double currentTime = m_source->mediaElement()->currentTime();
+    return m_webSourceBuffer->evictCodedFrames(currentTime, newDataSize);
+}
+
 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
 
     // 1. Run the prepare append algorithm.
-    // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#sourcebuffer-prepare-append
-    //  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))
+    if (!prepareAppend(size, exceptionState)) {
+        TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::appendBuffer", this);
         return;
-
-    TRACE_EVENT_ASYNC_BEGIN1("media", "SourceBuffer::appendBuffer", this, "size", size);
-
-    //  3. If the readyState attribute of the parent media source is in the "ended" state then run the following steps: ...
-    m_source->openIfInEndedState();
-
-    //  Steps 4-5 - end "prepare append" algorithm.
+    }
+    TRACE_EVENT_ASYNC_STEP_INTO0("media", "SourceBuffer::appendBuffer", this, "prepareAppend");
 
     // 2. Add data to the end of the input buffer.
     ASSERT(data || size == 0);
     if (data)
         m_pendingAppendData.append(data, size);
     m_pendingAppendDataOffset = 0;
 
     // 3. Set the updating attribute to true.
     m_updating = true;
 
@@ skipping 79 matching lines @@
 
     // 11. Queue a task to fire a simple event named update at this SourceBuffer object.
     scheduleEvent(EventTypeNames::update);
 
     // 12. Queue a task to fire a simple event named updateend at this SourceBuffer object.
     scheduleEvent(EventTypeNames::updateend);
 }
 
 void SourceBuffer::appendStreamInternal(Stream* stream, ExceptionState& exceptionState)
 {
+    TRACE_EVENT_ASYNC_BEGIN0("media", "SourceBuffer::appendStream", this);
+
     // Section 3.2 appendStream()
-    // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#widl-SourceBuffer-appendStream-void-Stream-stream-unsigned-long-long-maxSize
+    // http://w3c.github.io/media-source/#widl-SourceBuffer-appendStream-void-ReadableStream-stream-unsigned-long-long-maxSize
     // (0. If the stream has been neutered, then throw an InvalidAccessError exception and abort these steps.)
     if (stream->isNeutered()) {
         exceptionState.throwDOMException(InvalidAccessError, "The stream provided has been neutered.");
+        TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::appendStream", this);
         return;
     }
 
     // 1. Run the prepare append algorithm.
-    //  Section 3.5.4 Prepare Append Algorithm.
-    //  https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#sourcebuffer-prepare-append
-    //  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))
+    size_t newDataSize = m_streamMaxSizeValid ? m_streamMaxSize : 0;
+    if (!prepareAppend(newDataSize, exceptionState)) {
+        TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::appendStream", this);
         return;
-
-    TRACE_EVENT_ASYNC_BEGIN0("media", "SourceBuffer::appendStream", this);
-
-    //  3. If the readyState attribute of the parent media source is in the "ended" state then run the following steps: ...
-    m_source->openIfInEndedState();
-
-    // Steps 4-5 of the prepare append algorithm are handled by m_webSourceBuffer.
+    }
 
     // 2. Set the updating attribute to true.
     m_updating = true;
 
     // 3. Queue a task to fire a simple event named updatestart at this SourceBuffer object.
     scheduleEvent(EventTypeNames::updatestart);
 
     // 4. Asynchronously run the stream append loop algorithm with stream and maxSize.
-
     stream->neuter();
     m_loader = FileReaderLoader::create(FileReaderLoader::ReadByClient, this);
     m_stream = stream;
     m_appendStreamAsyncPartRunner.runAsync();
 }
 
 void SourceBuffer::appendStreamAsyncPart()
 {
     ASSERT(m_updating);
     ASSERT(m_loader);
     ASSERT(m_stream);
+    TRACE_EVENT_ASYNC_STEP_INTO0("media", "SourceBuffer::appendStream", this, "appendStreamAsyncPart");
 
     // Section 3.5.6 Stream Append Loop
-    // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#sourcebuffer-stream-append-loop
+    // http://w3c.github.io/media-source/#sourcebuffer-stream-append-loop
 
     // 1. If maxSize is set, then let bytesLeft equal maxSize.
     // 2. Loop Top: If maxSize is set and bytesLeft equals 0, then jump to the loop done step below.
     if (m_streamMaxSizeValid && !m_streamMaxSize) {
         appendStreamDone(true);
         return;
     }
 
     // Steps 3-11 are handled by m_loader.
     // Note: Passing 0 here signals that maxSize was not set. (i.e. Read all the data in the stream).
     m_loader->start(executionContext(), *m_stream, m_streamMaxSizeValid ? m_streamMaxSize : 0);
 }
 
 void SourceBuffer::appendStreamDone(bool success)
 {
     ASSERT(m_updating);
     ASSERT(m_loader);
     ASSERT(m_stream);
 
     clearAppendStreamState();
 
     if (!success) {
-        // 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. (Handled by caller)
-        // 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);
+        appendError(false);
         TRACE_EVENT_ASYNC_END0("media", "SourceBuffer::appendStream", this);
         return;
     }
 
     // Section 3.5.6 Stream Append Loop
     // Steps 1-11 are handled by appendStreamAsyncPart(), |m_loader|, and |m_webSourceBuffer|.
+
     // 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);
 }
 
 void SourceBuffer::clearAppendStreamState()
 {
     m_streamMaxSizeValid = false;
     m_streamMaxSize = 0;
     m_loader.clear();
     m_stream = nullptr;
 }
 
+void SourceBuffer::appendError(bool decodeError)
+{
+    // 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->abort();
+
+    // 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 (decodeError)
+        m_source->endOfStream("decode", ASSERT_NO_EXCEPTION);
+}
+
 void SourceBuffer::didStartLoading()
 {
     WTF_LOG(Media, "SourceBuffer::didStartLoading() %p", this);
 }
 
 void SourceBuffer::didReceiveDataForClient(const char* data, unsigned dataLength)
 {
     WTF_LOG(Media, "SourceBuffer::didReceiveDataForClient(%d) %p", dataLength, this);
     ASSERT(m_updating);
     ASSERT(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(false);
+        return;
+    }
+
     m_webSourceBuffer->append(reinterpret_cast<const unsigned char*>(data), dataLength, &m_timestampOffset);
 }
 
 void SourceBuffer::didFinishLoading()
 {
     WTF_LOG(Media, "SourceBuffer::didFinishLoading() %p", this);
+    ASSERT(m_loader);
     appendStreamDone(true);
 }
 
 void SourceBuffer::didFail(FileError::ErrorCode errorCode)
 {
     WTF_LOG(Media, "SourceBuffer::didFail(%d) %p", errorCode, this);
-    appendStreamDone(false);
+    // m_loader might be already released, in case appendStream has failed due
+    // to evictCodedFrames failing in didReceiveDataForClient. In that case
+    // appendStreamDone will be invoked from there, no need to repeat it here.
+    if (m_loader)
+        appendStreamDone(false);
 }
 
 DEFINE_TRACE(SourceBuffer)
 {
     visitor->trace(m_source);
     visitor->trace(m_stream);
     visitor->trace(m_trackDefaults);
     visitor->trace(m_asyncEventQueue);
     RefCountedGarbageCollectedEventTargetWithInlineData<SourceBuffer>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink