MediaRecorder Blink part

Source/modules/mediastream/MediaRecorder.cpp

Index: Source/modules/mediastream/MediaRecorder.cpp
diff --git a/Source/modules/mediastream/MediaRecorder.cpp b/Source/modules/mediastream/MediaRecorder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e810643c37bf0486f434f344f7f6b718f1170349
--- /dev/null
+++ b/Source/modules/mediastream/MediaRecorder.cpp
@@ -0,0 +1,303 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "modules/mediastream/MediaRecorder.h"
+
+#include "core/dom/DOMError.h"
+#include "core/fileapi/Blob.h"
+#include "modules/EventModules.h"
+#include "modules/EventTargetModules.h"
+#include "modules/mediastream/BlobEvent.h"
+#include "modules/mediastream/MediaRecorderErrorEvent.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebMediaStream.h"
+
+namespace blink {
+
+namespace {
+
+const AtomicString& inactiveState()
+{
+    DEFINE_STATIC_LOCAL(const AtomicString, ended, ("inactive", AtomicString::ConstructFromLiteral));
+    return ended;
+}
+
+const AtomicString& recordingState()
+{
+    DEFINE_STATIC_LOCAL(const AtomicString, ended, ("recording", AtomicString::ConstructFromLiteral));
+    return ended;
+}
+
+const AtomicString& pausedState()
+{
+    DEFINE_STATIC_LOCAL(const AtomicString, ended, ("paused", AtomicString::ConstructFromLiteral));
+    return ended;
+}
+
+} // namespace
+
+MediaRecorder* MediaRecorder::create(ExecutionContext* context, MediaStream* stream, ExceptionState& exceptionState)
+{
+    MediaRecorder* recorder = new MediaRecorder(context, stream, String(), exceptionState);
+    recorder->suspendIfNeeded();
+
+    return recorder;
+}
+
+MediaRecorder* MediaRecorder::create(ExecutionContext* context, MediaStream* stream,  const String& mimeType, ExceptionState& exceptionState)
+{
+    MediaRecorder* recorder = new MediaRecorder(context, stream, mimeType, exceptionState);
+    recorder->suspendIfNeeded();
+
+    return recorder;
+}
+
+MediaRecorder::MediaRecorder(ExecutionContext* context, MediaStream* stream, const String& mimeType, ExceptionState& exceptionState)
+    : ActiveDOMObject(context)
+    , m_stream(stream)
+    , m_stopped(false)
+    , m_mimeType(mimeType)
+    , m_state(inactiveState())
+    , m_ignoreMutedMedia(true)
+    , m_dispatchScheduledEventRunner(this, &MediaRecorder::dispatchScheduledEvent)
+{
+    m_recorderHandler = adoptPtr(Platform::current()->createMediaRecorderHandler());
+
+    if (!m_recorderHandler) {
+        m_stopped = true;
+        exceptionState.throwDOMException(NotSupportedError,
+            "No MediaRecorder handler can be created.");

[Peter Beverloo, 2015/07/29 16:54:22]

I find this more often in media code, but if I were a Web Developer and I'd get
the message "No MediaRecorder handler can be created" that wouldn't be very
helpful to me.

For now, we don't support this because the Chromium-side is not here. However,
more specifically to line 77, when would that ever be a valid situation to be
in? Should we ASSERT() on successful initialization instead?

(Once Chromium implements createMediaRecorderHandler(), I think we should also
ASSERT() on m_recordedHandler.)

[mcasas, 2015/07/30 13:20:36]

I can imagine an unsupported mimeType, f.i. recording in an unsupported
video codec. For the experimental version, only VP8 is in the radar.
Done. Added a TODO() to ASSERT() for it once the Cr parts
are landed.

+        return;
+    }
+
+    if (!m_recorderHandler->initialize(this, stream->descriptor(), m_mimeType)) {
+        m_stopped = true;
+        exceptionState.throwDOMException(NotSupportedError,
+            "Failed to initialize native MediaRecorder.");
+        return;
+    }
+}
+
+MediaRecorder::~MediaRecorder()
+{
+}
+
+void MediaRecorder::start(ExceptionState& exceptionState)
+{
+    if (m_state != inactiveState()) {
+        exceptionState.throwDOMException(InvalidStateError,
+            "The MediaRecorder's state is '" + m_state + "'.");
+        return;
+    }
+    m_state = recordingState();
+
+    m_recorderHandler->start();
+}
+
+void MediaRecorder::start(int& timeSlice, ExceptionState& exceptionState)
+{
+    if (m_state != inactiveState()) {
+        exceptionState.throwDOMException(InvalidStateError,
+            "The MediaRecorder's state is '" + m_state + "'.");
+        return;
+    }
+    m_state = recordingState();
+
+    m_recorderHandler->start(timeSlice);
+}
+
+void MediaRecorder::stop(ExceptionState& exceptionState)
+{
+    if (m_state == inactiveState()) {
+        exceptionState.throwDOMException(InvalidStateError,
+            "The MediaRecorder's state is '" + m_state + "'.");
+        return;
+    }
+
+    // Raise a dataavailable event containing the Blob of data that has been gathered.
+    // Raise a stop event.
+    doStop();
+}
+
+void MediaRecorder::pause(ExceptionState& exceptionState)
+{
+    if (m_state == inactiveState()) {
+        exceptionState.throwDOMException(InvalidStateError,
+            "The MediaRecorder's state is '" + m_state + "'.");
+        return;
+    }
+    if (m_state == pausedState())
+        return;
+
+    m_state = pausedState();
+
+    m_recorderHandler->pause();
+
+    scheduleDispatchEvent(Event::create(EventTypeNames::pause));
+}
+
+void MediaRecorder::resume(ExceptionState& exceptionState)
+{
+    if (m_state == inactiveState()) {
+        exceptionState.throwDOMException(InvalidStateError,
+            "The MediaRecorder's state is '" + m_state + "'.");
+        return;
+    }
+    if (m_state == recordingState())
+        return;
+
+    m_state = recordingState();
+
+    m_recorderHandler->resume();
+}
+
+void MediaRecorder::requestData(ExceptionState& exceptionState)
+{
+    if (m_state != recordingState()) {
+        exceptionState.throwDOMException(InvalidStateError,
+            "The MediaRecorder's state is '" + m_state + "'.");
+        return;
+    }
+
+    createBlobEvent(BlobData::create());
+}
+
+String MediaRecorder::canRecordMimeType(const String& mimeType)
+{
+    RawPtr<WebMediaRecorderHandler> handler = Platform::current()->createMediaRecorderHandler();

[Peter Beverloo, 2015/07/29 16:54:22]

This is a bit unfortunate. The embedder could end up creating
MediaRecordedHandler for two reasons - actually using one, or checking whether a
mime type could be supported. It would simplify your code if you add two APIs to
Platform.h instead.

[mcasas, 2015/07/30 13:20:36]

I know :(
Is there any way to have a WebMediaStreamHandler static method?

+    if (!handler)
+        return "";
+
+    return handler->canSupportMimeType(mimeType) ? "maybe" : "";

[Peter Beverloo, 2015/07/29 16:54:22]

This is a tri-state:

  (1) The empty string if the UA knows it can't record |mimeType|.
  (2) "probably" if it's confident it can record |mimeType|.
  (3) "maybe" if it's not certain whether it can record |mimeType|.

Is it deliberate that we don't want to support "probably"? That should be
documented in the APIs header in that case.

(Reading a "bool canSupport()" function returning TRUE doesn't strike me as
meaning "maybe".)

[mcasas, 2015/07/30 13:20:36]

Yes but the same doc says:
"Implementors are encouraged to return "maybe" unless the
type can be confidently established as being supported or not."

The encoder creation itself could fail for a number of reasons,
so I believe "maybe" and "" are the only possible outcomes.
I'll add some info everywhere.

+}
+
+const AtomicString& MediaRecorder::interfaceName() const
+{
+    return EventTargetNames::MediaRecorder;
+}
+
+ExecutionContext* MediaRecorder::executionContext() const
+{
+    return ActiveDOMObject::executionContext();
+}
+
+void MediaRecorder::suspend()
+{
+    m_dispatchScheduledEventRunner.suspend();
+}
+
+void MediaRecorder::resume()
+{
+    m_dispatchScheduledEventRunner.resume();
+}
+
+void MediaRecorder::stop()
+{
+    if (m_stopped)
+        return;
+
+    m_stopped = true;
+    m_stream.clear();
+    m_recorderHandler.clear();
+
+    m_dispatchScheduledEventRunner.stop();
+}
+
+void MediaRecorder::writeData(const char* data, size_t length, bool lastInSlice)
+{
+    ASSERT(m_state == recordingState());
+
+    if (m_stopped) {
+        m_stopped = false;
+        scheduleDispatchEvent(Event::create(EventTypeNames::start));
+    }
+
+    // TODO(mcasas): Use |lastInSlice| to indicate to JS that recording is done.
+
+    OwnPtr<BlobData> blobData = BlobData::create();
+    blobData->appendBytes(data, length);
+    createBlobEvent(blobData.release());
+}
+
+void MediaRecorder::failOutOfMemory(const WebString& message)
+{
+    scheduleDispatchEvent(MediaRecorderErrorEvent::create(
+        EventTypeNames::error, false, false, "OutOfMemory", message));
+
+    if (m_state == recordingState())
+        doStop();
+}
+
+void MediaRecorder::failIllegalStreamModification(const WebString& message)
+{
+    scheduleDispatchEvent(MediaRecorderErrorEvent::create(
+        EventTypeNames::error, false, false, "IllegalStreamModification", message));
+
+    if (m_state == recordingState())
+        doStop();
+}
+
+void MediaRecorder::failOtherRecordingError(const WebString& message)
+{
+    scheduleDispatchEvent(MediaRecorderErrorEvent::create(
+        EventTypeNames::error, false, false, "OtherRecordingError", message));
+
+    if (m_state == recordingState())
+        doStop();
+}
+
+void MediaRecorder::createBlobEvent(PassOwnPtr<BlobData> blobData)
+{
+    // blobData (Move-only) -> BlobDataHandle (ref-cnt) -> Blob
+    const long long length = blobData->length();
+    RefPtr<BlobDataHandle> blob_data_handle =
+        BlobDataHandle::create(blobData, length);
+
+    scheduleDispatchEvent(BlobEvent::create(EventTypeNames::dataavailable,
+        false, false, Blob::create(blob_data_handle)));
+}
+
+void MediaRecorder::doStop()
+{
+    ASSERT(m_state != inactiveState());
+    m_state = inactiveState();
+
+    m_recorderHandler->stop();
+
+    createBlobEvent(BlobData::create());

[Peter Beverloo, 2015/07/29 16:54:22]

Is this correct? Suppose that you have this code:

===============
var recorder = new MediaRecorder(stream);
recorder.start();

// ... ondataavailable gets invoked, stream is still active.

recorder.stop()

// ... ondataavailable gets invoked with an empty Blob,.

===============

When calling .stop(), the spec says that it should fire dataavailable
"containing the Blob of data that has been gathered". It's left ambiguous
whether that entails *all* data (the linguistic interpretation), or just the
data since the last event (in which case this may be correct).

[mcasas, 2015/07/30 13:20:36]

I presume it has to do with the way start() is called:

- if a |timeSlice| is passed as an argument, we will ping
back every so often and then, the last result is gathered
and sent after stop() has been, asynchronously, invoked. 
The asynchronicity is the point here that justifies the 
after-stop-onDataAvailable().

- If, on the other hand, start() is called with no arguments, 
then the draft is less clear IMHO. It could equate |timeSlice|
to infinite, in which case the JS might get a humongous 
Blob after stop() containing all the recorded stuff, or it might
assume |timeSlice = 0|, so that onDataAvailable() is called
everytime there's something to be stored. But in all cases,
stop() is understood as stopdAndFlushRecordedData().

Makes sense?

+
+    scheduleDispatchEvent(Event::create(EventTypeNames::stop));
+}
+
+void MediaRecorder::scheduleDispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
+{
+    m_scheduledEvents.append(event);
+
+    m_dispatchScheduledEventRunner.runAsync();
+}
+
+void MediaRecorder::dispatchScheduledEvent()
+{
+    if (m_stopped)
+        return;
+
+    WillBeHeapVector<RefPtrWillBeMember<Event>> events;
+    events.swap(m_scheduledEvents);
+
+    WillBeHeapVector<RefPtrWillBeMember<Event>>::iterator it = events.begin();
+    for (; it != events.end(); ++it)
+        dispatchEvent((*it).release());
+
+    events.clear();
+}
+
+DEFINE_TRACE(MediaRecorder)
+{
+    visitor->trace(m_stream);
+    RefCountedGarbageCollectedEventTargetWithInlineData<MediaRecorder>::trace(visitor);
+    ActiveDOMObject::trace(visitor);
+}
+
+} // namespace blink