MediaRecorder: support |timecode| and remove |m_ignoreMutedMedia|.

third_party/WebKit/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 "modules/mediarecorder/MediaRecorder.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "core/events/Event.h"
 #include "core/fileapi/Blob.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "modules/EventTargetModules.h"
 #include "modules/mediarecorder/BlobEvent.h"
 #include "platform/blob/BlobData.h"
 #include "platform/network/mime/ContentType.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebMediaStream.h"
+#include "wtf/CurrentTime.h"
 #include "wtf/PtrUtil.h"
 #include <algorithm>
 #include <limits>
 
 namespace blink {
 
 namespace {
 
 const char* kDefaultMimeType = "video/webm";
 
@@ skipping 131 matching lines @@
 
 MediaRecorder::MediaRecorder(ExecutionContext* context,
                              MediaStream* stream,
                              const MediaRecorderOptions& options,
                              ExceptionState& exceptionState)
     : SuspendableObject(context),
       m_stream(stream),
       m_streamAmountOfTracks(stream->getTracks().size()),
       m_mimeType(options.hasMimeType() ? options.mimeType() : kDefaultMimeType),
       m_stopped(true),
-      m_ignoreMutedMedia(true),
       m_audioBitsPerSecond(0),
       m_videoBitsPerSecond(0),
       m_state(State::Inactive),
       m_dispatchScheduledEventRunner(AsyncMethodRunner<MediaRecorder>::create(
           this,
           &MediaRecorder::dispatchScheduledEvent)) {
   DCHECK(m_stream->getTracks().size());
 
   m_recorderHandler =
       WTF::wrapUnique(Platform::current()->createMediaRecorderHandler());
@@ skipping 93 matching lines @@
   scheduleDispatchEvent(Event::create(EventTypeNames::resume));
 }
 
 void MediaRecorder::requestData(ExceptionState& exceptionState) {
   if (m_state == State::Inactive) {
     exceptionState.throwDOMException(
         InvalidStateError,
         "The MediaRecorder's state is '" + stateToString(m_state) + "'.");
     return;
   }
-  writeData(nullptr /* data */, 0 /* length */, true /* lastInSlice */);
+  writeData(nullptr /* data */, 0 /* length */, true /* lastInSlice */,
+            WTF::currentTimeMS());
 }
 
 bool MediaRecorder::isTypeSupported(const String& type) {
   WebMediaRecorderHandler* handler =
       Platform::current()->createMediaRecorderHandler();
   if (!handler)
     return false;
 
   // If true is returned from this method, it only indicates that the
   // MediaRecorder implementation is capable of recording Blob objects for the
@@ skipping 25 matching lines @@
   if (m_stopped)
     return;
 
   m_stopped = true;
   m_stream.clear();
   m_recorderHandler.reset();
 }
 
 void MediaRecorder::writeData(const char* data,
                               size_t length,
-                              bool lastInSlice) {
+                              bool lastInSlice,
+                              double timecode) {
   if (m_stopped && !lastInSlice) {
     m_stopped = false;
     scheduleDispatchEvent(Event::create(EventTypeNames::start));
   }
   if (m_stream && m_streamAmountOfTracks != m_stream->getTracks().size()) {
     m_streamAmountOfTracks = m_stream->getTracks().size();
     onError("Amount of tracks in MediaStream has changed.");
   }
 
   // TODO(mcasas): Act as |m_ignoredMutedMedia| instructs if |m_stream| track(s)
   // is in muted() state.
 
   if (!m_blobData) {
     m_blobData = BlobData::create();
     m_blobData->setContentType(m_mimeType);
   }
   if (data)
     m_blobData->appendBytes(data, length);
 
   if (!lastInSlice)
     return;
 
   // Cache |m_blobData->length()| before release()ng it.
   const long long blobDataLength = m_blobData->length();
-  createBlobEvent(Blob::create(
-      BlobDataHandle::create(std::move(m_blobData), blobDataLength)));
+  createBlobEvent(Blob::create(BlobDataHandle::create(std::move(m_blobData),
+                                                      blobDataLength)),
+                  timecode);
 }
 
 void MediaRecorder::onError(const WebString& message) {
   // TODO(mcasas): Beef up the Error Event and add the |message|, see
   // https://github.com/w3c/mediacapture-record/issues/31
   scheduleDispatchEvent(Event::create(EventTypeNames::error));
 }
 
-void MediaRecorder::createBlobEvent(Blob* blob) {
-  // 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::createBlobEvent(Blob* blob, double timecode) {
+  scheduleDispatchEvent(
+      BlobEvent::create(EventTypeNames::dataavailable, blob, timecode));
 }
 
 void MediaRecorder::stopRecording() {
   DCHECK(m_state != State::Inactive);
   m_state = State::Inactive;
 
   m_recorderHandler->stop();
 
-  writeData(nullptr /* data */, 0 /* length */, true /* lastInSlice */);
+  writeData(nullptr /* data */, 0 /* length */, true /* lastInSlice */,
+            WTF::currentTimeMS());
   scheduleDispatchEvent(Event::create(EventTypeNames::stop));
 }
 
 void MediaRecorder::scheduleDispatchEvent(Event* event) {
   m_scheduledEvents.push_back(event);
 
   m_dispatchScheduledEventRunner->runAsync();
 }
 
 void MediaRecorder::dispatchScheduledEvent() {
   HeapVector<Member<Event>> events;
   events.swap(m_scheduledEvents);
 
   for (const auto& event : events)
     dispatchEvent(event);
 }
 
 DEFINE_TRACE(MediaRecorder) {
   visitor->trace(m_stream);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   SuspendableObject::trace(visitor);
 }
 
 }  // namespace blink