MSE: Plumb ChunkDemuxer appendData failures into append Error algorithm

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 798 matching lines @@
     TRACE_EVENT_ASYNC_STEP_INTO1("media", "SourceBuffer::appendBuffer", this, "appending", "appendSize", static_cast<unsigned>(appendSize));
 
     // |zero| is used for 0 byte appends so we always have a valid pointer.
     // We need to convey all appends, even 0 byte ones to |m_webSourceBuffer|
     // so that it can clear its end of stream state if necessary.
     unsigned char zero = 0;
     unsigned char* appendData = &zero;
     if (appendSize)
         appendData = m_pendingAppendData.data() + m_pendingAppendDataOffset;
 
-    m_webSourceBuffer->append(appendData, appendSize, &m_timestampOffset);
+    bool appendSuccess = m_webSourceBuffer->append(appendData, appendSize, &m_timestampOffset);
 
-    m_pendingAppendDataOffset += appendSize;
+    if (!appendSuccess) {
+        m_pendingAppendData.clear();
+        m_pendingAppendDataOffset = 0;
+        appendError(DecodeError);
+    } else {
+        m_pendingAppendDataOffset += appendSize;
 
-    if (m_pendingAppendDataOffset < m_pendingAppendData.size()) {
-        m_appendBufferAsyncPartRunner->runAsync();
-        TRACE_EVENT_ASYNC_STEP_INTO0("media", "SourceBuffer::appendBuffer", this, "nextPieceDelay");
-        return;
+        if (m_pendingAppendDataOffset < m_pendingAppendData.size()) {
+            m_appendBufferAsyncPartRunner->runAsync();
+            TRACE_EVENT_ASYNC_STEP_INTO0("media", "SourceBuffer::appendBuffer", this, "nextPieceDelay");
+            return;
+        }
+
+        // 3. Set the updating attribute to false.
+        m_updating = false;
+        m_pendingAppendData.clear();
+        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);
     }
 
-    // 3. Set the updating attribute to false.
-    m_updating = false;
-    m_pendingAppendData.clear();
-    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());
 }
 
 void SourceBuffer::removeAsyncPart()
 {
     DCHECK(m_updating);
     DCHECK_GE(m_pendingRemoveStart, 0);
     DCHECK_LT(m_pendingRemoveStart, m_pendingRemoveEnd);
 
@@ skipping 54 matching lines @@
     DCHECK(m_loader);
     DCHECK(m_stream);
     TRACE_EVENT_ASYNC_STEP_INTO0("media", "SourceBuffer::appendStream", this, "appendStreamAsyncPart");
 
     // Section 3.5.6 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);
+        appendStreamDone(NoError);
         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(getExecutionContext(), *m_stream, m_streamMaxSizeValid ? m_streamMaxSize : 0);
 }
 
-void SourceBuffer::appendStreamDone(bool success)
+void SourceBuffer::appendStreamDone(AppendStreamDoneAction action)
 {
     DCHECK(m_updating);
     DCHECK(m_loader);
     DCHECK(m_stream);
 
     clearAppendStreamState();
 
-    if (!success) {
-        appendError(false);
+    if (action != NoError) {
+        if (action == RunAppendErrorWithNoDecodeError) {
+            appendError(NoDecodeError);
+        } else {
+            DCHECK_EQ(action, RunAppendErrorWithDecodeError);
+            appendError(DecodeError);
+        }
+
         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);
     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(bool decodeError)
+void SourceBuffer::appendError(AppendError err)
 {
-    SBLOG << __FUNCTION__ << " this=" << this << " decodeError=" << decodeError;
+    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 (decodeError)
+    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;
 }
 
 void SourceBuffer::didReceiveDataForClient(const char* data, unsigned dataLength)
 {
     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(false);
+        appendStreamDone(RunAppendErrorWithNoDecodeError);
         return;
     }
 
-    m_webSourceBuffer->append(reinterpret_cast<const unsigned char*>(data), dataLength, &m_timestampOffset);
+    if (!m_webSourceBuffer->append(reinterpret_cast<const unsigned char*>(data), dataLength, &m_timestampOffset))
+        appendStreamDone(RunAppendErrorWithDecodeError);
 }
 
 void SourceBuffer::didFinishLoading()
 {
     SBLOG << __FUNCTION__ << " this=" << this;
     DCHECK(m_loader);
-    appendStreamDone(true);
+    appendStreamDone(NoError);
 }
 
 void SourceBuffer::didFail(FileError::ErrorCode errorCode)
 {
     SBLOG << __FUNCTION__ << " this=" << this << " errorCode=" << errorCode;
     // 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.
+    // 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(false);
+        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