MediaRecorder: Adding BlobEvent and connecting it in MediaRecorderHandler

Source/modules/mediarecorder/MediaRecorder.cpp

 // 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/mediarecorder/MediaRecorder.h"
 
 #include "core/dom/DOMError.h"
 #include "core/fileapi/Blob.h"
 #include "modules/EventModules.h"
 #include "modules/EventTargetModules.h"
+#include "modules/mediarecorder/BlobEvent.h"
 #include "modules/mediarecorder/MediaRecorderErrorEvent.h"
 #include "platform/NotImplemented.h"
 #include "platform/blob/BlobData.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebMediaStream.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 123 matching lines @@
     m_recorderHandler->resume();
 }
 
 void MediaRecorder::requestData(ExceptionState& exceptionState)
 {
     if (m_state != State::Recording) {
         exceptionState.throwDOMException(InvalidStateError, "The MediaRecorder's state is '" + stateToString(m_state) + "'.");
         return;
     }
 
-    createBlobEvent(BlobData::create());
+    createBlobEvent(nullptr);
 }
 
 String MediaRecorder::canRecordMimeType(const String& mimeType)
 {
     RawPtr<WebMediaRecorderHandler> handler = Platform::current()->createMediaRecorderHandler();
     if (!handler)
         return emptyString();
 
     // MediaRecorder canRecordMimeType() MUST return 'probably' "if the UA is
     // confident that mimeType represents a type that it can record" [1], but a
@@ skipping 39 matching lines @@
 
 void MediaRecorder::writeData(const char* data, size_t length, bool lastInSlice)
 {
     if (!lastInSlice && m_stopped) {
         m_stopped = false;
         scheduleDispatchEvent(Event::create(EventTypeNames::start));
     }
 
     // TODO(mcasas): Act as |m_ignoredMutedMedia| instructs if |m_stream| track(s) is in muted() state.
     // TODO(mcasas): Use |lastInSlice| to indicate to JS that recording is done.
-
     OwnPtr<BlobData> blobData = BlobData::create();
     blobData->appendBytes(data, length);
-    createBlobEvent(blobData.release());
+    createBlobEvent(Blob::create(BlobDataHandle::create(blobData.release(), length)));
 }
 
 void MediaRecorder::failOutOfMemory(const WebString& message)
 {
     scheduleDispatchEvent(MediaRecorderErrorEvent::create(
         EventTypeNames::error, false, false, "OutOfMemory", message));
 
     if (m_state == State::Recording)
         stopRecording();
 }
 
 void MediaRecorder::failIllegalStreamModification(const WebString& message)
 {
     scheduleDispatchEvent(MediaRecorderErrorEvent::create(
         EventTypeNames::error, false, false, "IllegalStreamModification", message));
 
     if (m_state == State::Recording)
         stopRecording();
 }
 
 void MediaRecorder::failOtherRecordingError(const WebString& message)
 {
     scheduleDispatchEvent(MediaRecorderErrorEvent::create(
         EventTypeNames::error, false, false, "OtherRecordingError", message));
 
     if (m_state == State::Recording)
         stopRecording();
 }
 
-void MediaRecorder::createBlobEvent(PassOwnPtr<BlobData> blobData)
+void MediaRecorder::createBlobEvent(Blob* blob)
 {
-    // TODO(mcasas): Launch a BlobEvent when that class is landed, but also see https://github.com/w3c/mediacapture-record/issues/17.
-    notImplemented();
+    // TODO(mcasas): Consider launching an Event with a TypedArray inside, see https://github.com/w3c/mediacapture-record/issues/17.
+    scheduleDispatchEvent(BlobEvent::create(EventTypeNames::dataavailable, blob));
 }
 
 void MediaRecorder::stopRecording()
 {
     ASSERT(m_state != State::Inactive);
     m_state = State::Inactive;
 
     m_recorderHandler->stop();
 
-    createBlobEvent(BlobData::create());
+    createBlobEvent(nullptr);
 
     scheduleDispatchEvent(Event::create(EventTypeNames::stop));
 }
 
 void MediaRecorder::scheduleDispatchEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     m_scheduledEvents.append(event);
 
     m_dispatchScheduledEventRunner.runAsync();
 }
 
 void MediaRecorder::dispatchScheduledEvent()
 {
     WillBeHeapVector<RefPtrWillBeMember<Event>> events;
     events.swap(m_scheduledEvents);
 
     for (const auto& event : events)
         dispatchEvent(event);
 }
 
 DEFINE_TRACE(MediaRecorder)
 {
     visitor->trace(m_stream);
     visitor->trace(m_scheduledEvents);
     RefCountedGarbageCollectedEventTargetWithInlineData<MediaRecorder>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink