MediaRecorder: make sure ondataavailable+onstop events are fired before onerror

content/renderer/media/recorder/media_recorder_handler.cc

 // 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 "content/renderer/media/recorder/media_recorder_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 146 matching lines @@
 bool MediaRecorderHandler::start(int timeslice) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!recording_);
   DCHECK(!media_stream_.isNull());
   DCHECK(timeslice_.is_zero());
   DCHECK(!webm_muxer_);
 
   timeslice_ = TimeDelta::FromMilliseconds(timeslice);
   slice_origin_timestamp_ = TimeTicks::Now();
 
-  blink::WebVector<blink::WebMediaStreamTrack> video_tracks, audio_tracks;
-  media_stream_.videoTracks(video_tracks);
-  media_stream_.audioTracks(audio_tracks);
+  media_stream_.videoTracks(video_tracks_);
+  media_stream_.audioTracks(audio_tracks_);
 
-  if (video_tracks.isEmpty() && audio_tracks.isEmpty()) {
+  if (video_tracks_.isEmpty() && audio_tracks_.isEmpty()) {
     LOG(WARNING) << __func__ << ": no media tracks.";
     return false;
   }
 
   const bool use_video_tracks =
-      !video_tracks.isEmpty() && video_tracks[0].isEnabled() &&
-      video_tracks[0].source().getReadyState() !=
+      !video_tracks_.isEmpty() && video_tracks_[0].isEnabled() &&
+      video_tracks_[0].source().getReadyState() !=
           blink::WebMediaStreamSource::ReadyStateEnded;
   const bool use_audio_tracks =
-      !audio_tracks.isEmpty() && MediaStreamAudioTrack::From(audio_tracks[0]) &&
-      audio_tracks[0].isEnabled() &&
-      audio_tracks[0].source().getReadyState() !=
+      !audio_tracks_.isEmpty() &&
+      MediaStreamAudioTrack::From(audio_tracks_[0]) &&
+      audio_tracks_[0].isEnabled() &&
+      audio_tracks_[0].source().getReadyState() !=
           blink::WebMediaStreamSource::ReadyStateEnded;
 
   if (!use_video_tracks && !use_audio_tracks) {
     LOG(WARNING) << __func__ << ": no tracks to be recorded.";
     return false;
   }
 
   webm_muxer_.reset(new media::WebmMuxer(
       CodecIdToMediaVideoCodec(codec_id_), use_video_tracks, use_audio_tracks,
       base::Bind(&MediaRecorderHandler::WriteData,
                  weak_factory_.GetWeakPtr())));
 
   if (use_video_tracks) {
     // TODO(mcasas): The muxer API supports only one video track. Extend it to
     // several video tracks, see http://crbug.com/528523.
-    LOG_IF(WARNING, video_tracks.size() > 1u)
+    LOG_IF(WARNING, video_tracks_.size() > 1u)
         << "Recording multiple video tracks is not implemented. "
         << "Only recording first video track.";
-    const blink::WebMediaStreamTrack& video_track = video_tracks[0];
+    const blink::WebMediaStreamTrack& video_track = video_tracks_[0];
     if (video_track.isNull())
       return false;
 
     const VideoTrackRecorder::OnEncodedVideoCB on_encoded_video_cb =
         media::BindToCurrentLoop(base::Bind(
             &MediaRecorderHandler::OnEncodedVideo, weak_factory_.GetWeakPtr()));
 
     video_recorders_.emplace_back(new VideoTrackRecorder(
         codec_id_, video_track, on_encoded_video_cb, video_bits_per_second_));
   }
 
   if (use_audio_tracks) {
     // TODO(ajose): The muxer API supports only one audio track. Extend it to
     // several tracks.
-    LOG_IF(WARNING, audio_tracks.size() > 1u)
+    LOG_IF(WARNING, audio_tracks_.size() > 1u)
         << "Recording multiple audio"
         << " tracks is not implemented.  Only recording first audio track.";
-    const blink::WebMediaStreamTrack& audio_track = audio_tracks[0];
+    const blink::WebMediaStreamTrack& audio_track = audio_tracks_[0];
     if (audio_track.isNull())
       return false;
 
     const AudioTrackRecorder::OnEncodedAudioCB on_encoded_audio_cb =
         media::BindToCurrentLoop(base::Bind(
             &MediaRecorderHandler::OnEncodedAudio, weak_factory_.GetWeakPtr()));
 
     audio_recorders_.emplace_back(new AudioTrackRecorder(
         audio_track, on_encoded_audio_cb, audio_bits_per_second_));
   }
 
   recording_ = true;
   return true;
 }
 
 void MediaRecorderHandler::stop() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Don't check |recording_| since we can go directly from pause() to stop().
 
+  weak_factory_.InvalidateWeakPtrs();
   recording_ = false;
   timeslice_ = TimeDelta::FromMilliseconds(0);
   video_recorders_.clear();
   audio_recorders_.clear();
   webm_muxer_.reset();
 }
 
 void MediaRecorderHandler::pause() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(recording_);
@@ skipping 15 matching lines @@
     audio_recorder->Resume();
   webm_muxer_->Resume();
 }
 
 void MediaRecorderHandler::OnEncodedVideo(
     const media::WebmMuxer::VideoParameters& params,
     std::unique_ptr<std::string> encoded_data,
     TimeTicks timestamp,
     bool is_key_frame) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
+
+  if (UpdateTracksAndCheckIfChanged()) {
+    client_->onError("Amount of tracks in MediaStream has changed.");
+    return;
+  }
   if (!webm_muxer_)
     return;
   if (!webm_muxer_->OnEncodedVideo(params, std::move(encoded_data), timestamp,
                                    is_key_frame)) {
     DLOG(ERROR) << "Error muxing video data";
     client_->onError("Error muxing video data");
   }
 }
 
 void MediaRecorderHandler::OnEncodedAudio(
     const media::AudioParameters& params,
     std::unique_ptr<std::string> encoded_data,
     base::TimeTicks timestamp) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
+
+  if (UpdateTracksAndCheckIfChanged()) {
+    client_->onError("Amount of tracks in MediaStream has changed.");
+    return;
+  }
   if (!webm_muxer_)
     return;
   if (!webm_muxer_->OnEncodedAudio(params, std::move(encoded_data),
                                    timestamp)) {
     DLOG(ERROR) << "Error muxing audio data";
     client_->onError("Error muxing audio data");
   }
 }
 
 void MediaRecorderHandler::WriteData(base::StringPiece data) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   const TimeTicks now = TimeTicks::Now();
   // Non-buffered mode does not need to check timestamps.
   if (timeslice_.is_zero()) {
     client_->writeData(data.data(), data.length(), true /* lastInSlice */,
                        (now - TimeTicks::UnixEpoch()).InMillisecondsF());
     return;
   }
 
   const bool last_in_slice = now > slice_origin_timestamp_ + timeslice_;
   DVLOG_IF(1, last_in_slice) << "Slice finished @ " << now;
   if (last_in_slice)
     slice_origin_timestamp_ = now;
   client_->writeData(data.data(), data.length(), last_in_slice,
                      (now - TimeTicks::UnixEpoch()).InMillisecondsF());
 }
 
+bool MediaRecorderHandler::UpdateTracksAndCheckIfChanged() {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+
+  blink::WebVector<blink::WebMediaStreamTrack> video_tracks, audio_tracks;
+  media_stream_.videoTracks(video_tracks);
+  media_stream_.audioTracks(audio_tracks);
+
+  bool video_tracks_changed = video_tracks_.size() != video_tracks.size();
+  bool audio_tracks_changed = audio_tracks_.size() != audio_tracks.size();
+
+  if (!video_tracks_changed) {
+    for (size_t i = 0; i < video_tracks.size(); ++i) {
+      if (video_tracks_[i].id() != video_tracks[i].id()) {
+        video_tracks_changed = true;
+        break;
+      }
+    }
+  }
+  if (!video_tracks_changed && !audio_tracks_changed) {
+    for (size_t i = 0; i < audio_tracks.size(); ++i) {
+      if (audio_tracks_[i].id() != audio_tracks[i].id()) {
+        audio_tracks_changed = true;
+        break;
+      }
+    }
+  }
+
+  if (video_tracks_changed)
+    video_tracks_ = video_tracks;
+  if (audio_tracks_changed)
+    audio_tracks_ = audio_tracks;
+
+  return video_tracks_changed || audio_tracks_changed;
+}
+
 void MediaRecorderHandler::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     const TimeTicks& timestamp) {
   for (const auto& recorder : video_recorders_)
     recorder->OnVideoFrameForTesting(frame, timestamp);
 }
 
 void MediaRecorderHandler::OnAudioBusForTesting(
     const media::AudioBus& audio_bus,
     const base::TimeTicks& timestamp) {
   for (const auto& recorder : audio_recorders_)
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
   for (const auto& recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content