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 wer
mcasas
2015/07/30 13:20:36
I can imagine an unsupported mimeType, f.i. record
|
+ 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
mcasas
2015/07/30 13:20:36
I know :(
Is there any way to have a WebMediaStrea
|
+ 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 th
mcasas
2015/07/30 13:20:36
Yes but the same doc says:
"Implementors are encou
|
+} |
+ |
+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:
mcasas
2015/07/30 13:20:36
I presume it has to do with the way start() is cal
|
+ |
+ 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 |