Remove MediaSourcePrivate/SourceBufferPrivate

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 21 matching lines @@
 #include "modules/mediasource/SourceBuffer.h"
 
 #include "bindings/v8/ExceptionState.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/fileapi/Stream.h"
 #include "core/html/TimeRanges.h"
-#include "core/platform/graphics/SourceBufferPrivate.h"
 #include "modules/mediasource/MediaSource.h"
 #include "platform/Logging.h"
 #include "platform/TraceEvent.h"
+#include "public/platform/WebSourceBuffer.h"
+#include "public/platform/WebTimeRange.h"
 #include "wtf/ArrayBuffer.h"
 #include "wtf/ArrayBufferView.h"
 #include "wtf/MathExtras.h"
 
 #include <limits>
 
+using blink::WebSourceBuffer;
+using blink::WebTimeRanges;
+
 namespace WebCore {
 
-PassRefPtr<SourceBuffer> SourceBuffer::create(PassOwnPtr<SourceBufferPrivate> sourceBufferPrivate, MediaSource* source, GenericEventQueue* asyncEventQueue)
+PassRefPtr<SourceBuffer> SourceBuffer::create(PassOwnPtr<WebSourceBuffer> webSourceBuffer, MediaSource* source, GenericEventQueue* asyncEventQueue)
 {
-    RefPtr<SourceBuffer> sourceBuffer(adoptRef(new SourceBuffer(sourceBufferPrivate, source, asyncEventQueue)));
+    RefPtr<SourceBuffer> sourceBuffer(adoptRef(new SourceBuffer(webSourceBuffer, source, asyncEventQueue)));
     sourceBuffer->suspendIfNeeded();
     return sourceBuffer.release();
 }
 
-SourceBuffer::SourceBuffer(PassOwnPtr<SourceBufferPrivate> sourceBufferPrivate, MediaSource* source, GenericEventQueue* asyncEventQueue)
+SourceBuffer::SourceBuffer(PassOwnPtr<WebSourceBuffer> webSourceBuffer, MediaSource* source, GenericEventQueue* asyncEventQueue)
     : ActiveDOMObject(source->executionContext())
-    , m_private(sourceBufferPrivate)
+    , m_webSourceBuffer(webSourceBuffer)
     , m_source(source)
     , m_asyncEventQueue(asyncEventQueue)
     , m_updating(false)
     , m_timestampOffset(0)
     , m_appendWindowStart(0)
     , m_appendWindowEnd(std::numeric_limits<double>::infinity())
     , m_appendBufferAsyncPartRunner(this, &SourceBuffer::appendBufferAsyncPart)
     , m_pendingRemoveStart(-1)
     , m_pendingRemoveEnd(-1)
     , m_removeAsyncPartRunner(this, &SourceBuffer::removeAsyncPart)
     , m_streamMaxSizeValid(false)
     , m_streamMaxSize(0)
     , m_appendStreamAsyncPartRunner(this, &SourceBuffer::appendStreamAsyncPart)
 {
-    ASSERT(m_private);
+    ASSERT(m_webSourceBuffer);
     ASSERT(m_source);
     ScriptWrappable::init(this);
 }
 
 SourceBuffer::~SourceBuffer()
 {
     ASSERT(isRemoved());
     ASSERT(!m_loader);
     ASSERT(!m_stream);
 }
 
 PassRefPtr<TimeRanges> SourceBuffer::buffered(ExceptionState& es) const
 {
     // Section 3.1 buffered attribute steps.
     // 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.
     if (isRemoved()) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return 0;
     }
 
     // 2. Return a new static normalized TimeRanges object for the media segments buffered.
-    return m_private->buffered();
+    WebTimeRanges webRanges = m_webSourceBuffer->buffered();
+    RefPtr<TimeRanges> ranges = TimeRanges::create();
+    for (size_t i = 0; i < webRanges.size(); ++i)
+        ranges->add(webRanges[i].start, webRanges[i].end);
+    return ranges.release();
 }
 
 double SourceBuffer::timestampOffset() const
 {
     return m_timestampOffset;
 }
 
 void SourceBuffer::setTimestampOffset(double offset, ExceptionState& es)
 {
     // Section 3.1 timestampOffset attribute setter steps.
     // 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 (isRemoved() || m_updating) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         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"
     // 4.2 Queue a task to fire a simple event named sourceopen at the parent media source.
     m_source->openIfInEndedState();
 
     // 5. If this object is waiting for the end of a media segment to be appended, then throw an InvalidStateError
     // and abort these steps.
     //
     // FIXME: Add step 6 text when mode attribute is implemented.
-    if (!m_private->setTimestampOffset(offset)) {
+    if (!m_webSourceBuffer->setTimestampOffset(offset)) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return;
     }
 
     // 7. Update the attribute to new timestamp offset.
     m_timestampOffset = offset;
 }
 
 double SourceBuffer::appendWindowStart() const
 {
@@ skipping 19 matching lines @@
         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) {
         es.throwUninformativeAndGenericDOMException(InvalidAccessError);
         return;
     }
 
-    m_private->setAppendWindowStart(start);
+    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& es)
 {
     // Section 3.1 appendWindowEnd attribute setter steps.
     // 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 (isRemoved() || m_updating) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return;
     }
 
     // 3. If the new value equals NaN, then throw an InvalidAccessError and abort these steps.
     // 4. If the new value is less than or equal to appendWindowStart then throw an InvalidAccessError
     //    exception and abort these steps.
     if (std::isnan(end) || end <= m_appendWindowStart) {
         es.throwUninformativeAndGenericDOMException(InvalidAccessError);
         return;
     }
 
-    m_private->setAppendWindowEnd(end);
+    m_webSourceBuffer->setAppendWindowEnd(end);
 
     // 5. Update the attribute to the new value.
     m_appendWindowEnd = end;
 }
 
 void SourceBuffer::appendBuffer(PassRefPtr<ArrayBuffer> data, ExceptionState& es)
 {
     // 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. If data is null then throw an InvalidAccessError exception and abort these steps.
@@ skipping 42 matching lines @@
     //    then throw an InvalidStateError exception and abort these steps.
     if (isRemoved() || !m_source->isOpen()) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         return;
     }
 
     // 3. If the sourceBuffer.updating attribute equals true, then run the following steps: ...
     abortIfUpdating();
 
     // 4. Run the reset parser state algorithm.
-    m_private->abort();
+    m_webSourceBuffer->abort();
 
     // 5. Set appendWindowStart to 0.
     setAppendWindowStart(0, es);
 
     // 6. Set appendWindowEnd to positive Infinity.
     setAppendWindowEnd(std::numeric_limits<double>::infinity(), es);
 }
 
 void SourceBuffer::remove(double start, double end, ExceptionState& es)
 {
@@ skipping 74 matching lines @@
     TRACE_EVENT_ASYNC_END0("media", traceEventName, this);
 }
 
 void SourceBuffer::removedFromMediaSource()
 {
     if (isRemoved())
         return;
 
     abortIfUpdating();
 
-    m_private->removedFromMediaSource();
+    m_webSourceBuffer->removedFromMediaSource();

[acolwell GONE FROM CHROMIUM, 2013/11/11 18:06:55]

I believe you can & should clear m_webSourceBuffer after this call.

[philipj_slow, 2013/11/12 09:43:51]

I noticed the .clear() in the code that I removed, but brushed it aside a an
artifact of the glue layer. Thanks for paying attention when I didn't!

     m_source = 0;
     m_asyncEventQueue = 0;
 }
 
 bool SourceBuffer::hasPendingActivity() const
 {
     return m_source;
 }
 
 void SourceBuffer::suspend()
@@ skipping 84 matching lines @@
     TRACE_EVENT_ASYNC_STEP0("media", "SourceBuffer::appendBuffer", this, "appending");
 
     // Section 3.5.4 Buffer Append Algorithm
     // https://dvcs.w3.org/hg/html-media/raw-file/default/media-source/media-source.html#sourcebuffer-buffer-append
 
     // 1. Run the segment parser loop algorithm.
     // Step 2 doesn't apply since we run Step 1 synchronously here.
     size_t appendSize = m_pendingAppendData.size();
     if (!appendSize) {
         // Resize buffer for 0 byte appends so we always have a valid pointer.
-        // We need to convey all appends, even 0 byte ones to |m_private| so
-        // that it can clear its end of stream state if necessary.
+        // 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.
         m_pendingAppendData.resize(1);
     }
-    m_private->append(m_pendingAppendData.data(), appendSize);
+    m_webSourceBuffer->append(m_pendingAppendData.data(), appendSize);
 
     // 3. Set the updating attribute to false.
     m_updating = false;
     m_pendingAppendData.clear();
 
     // 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);
 }
 
 void SourceBuffer::removeAsyncPart()
 {
     ASSERT(m_updating);
     ASSERT(m_pendingRemoveStart >= 0);
     ASSERT(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
 
     // 9. Run the coded frame removal algorithm with start and end as the start and end of the removal range.
-    m_private->remove(m_pendingRemoveStart, m_pendingRemoveEnd);
+    m_webSourceBuffer->remove(m_pendingRemoveStart, m_pendingRemoveEnd);
 
     // 10. Set the updating attribute to false.
     m_updating = false;
     m_pendingRemoveStart = -1;
     m_pendingRemoveEnd = -1;
 
     // 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.
@@ skipping 18 matching lines @@
     if (isRemoved() || m_updating) {
         es.throwUninformativeAndGenericDOMException(InvalidStateError);
         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_private.
+    // Steps 4-5 of the prepare append algorithm are handled by m_webSourceBuffer.
 
     // 3. Set the updating attribute to true.
     m_updating = true;
 
     // 4. Queue a task to fire a simple event named updatestart at this SourceBuffer object.
     scheduleEvent(EventTypeNames::updatestart);
 
     // 5. Asynchronously run the stream append loop algorithm with stream and maxSize.
 
     stream->neuter();
@@ skipping 42 matching lines @@
         // 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);
         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_private|.
+    // 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);
 }
@@ skipping 10 matching lines @@
 {
     LOG(Media, "SourceBuffer::didStartLoading() %p", this);
 }
 
 void SourceBuffer::didReceiveDataForClient(const char* data, unsigned dataLength)
 {
     LOG(Media, "SourceBuffer::didReceiveDataForClient(%d) %p", dataLength, this);
     ASSERT(m_updating);
     ASSERT(m_loader);
 
-    m_private->append(reinterpret_cast<const unsigned char*>(data), dataLength);
+    m_webSourceBuffer->append(reinterpret_cast<const unsigned char*>(data), dataLength);
 }
 
 void SourceBuffer::didFinishLoading()
 {
     LOG(Media, "SourceBuffer::didFinishLoading() %p", this);
     appendStreamDone(true);
 }
 
 void SourceBuffer::didFail(FileError::ErrorCode errorCode)
 {
     LOG(Media, "SourceBuffer::didFail(%d) %p", errorCode, this);
     appendStreamDone(false);
 }
 
 } // namespace WebCore