MediaRecorderHandler (video part) and unittests

content/renderer/media/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/media_recorder_handler.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "content/renderer/media/video_track_recorder.h"
+#include "media/base/bind_to_current_loop.h"
+#include "media/capture/webm_muxer.h"
+//
+namespace content {
+
+MediaRecorderHandler::MediaRecorderHandler()
+    : recording_(false), client_(nullptr), weak_factory_(this) {
+  DVLOG(3) << __FUNCTION__;
+}
+
+MediaRecorderHandler::~MediaRecorderHandler() {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  // Send a |last_in_slice| to our |client_|.
+  if (client_)
+    client_->writeData(nullptr, 0u, true);
+}
+
+bool MediaRecorderHandler::canSupportMimeType(
+    const blink::WebString& mimeType) {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool MediaRecorderHandler::initialize(MediaRecorderHandlerClient* client,
+                                      const blink::WebMediaStream& media_stream,
+                                      const blink::WebString& mimeType) {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  // TODO(mcasas): check canSupportMimeType(mimeType) is true.
+  media_stream_ = media_stream;
+  DCHECK(client);
+  client_ = client;
+
+  return true;
+}
+
+bool MediaRecorderHandler::start() {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  DCHECK(!recording_);
+  return start(0);
+}
+
+bool MediaRecorderHandler::start(int timeslice) {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  DCHECK(!recording_);
+  DCHECK(!media_stream_.isNull());
+
+  webm_muxer_.reset(new media::WebmMuxer(media::BindToCurrentLoop(base::Bind(
+      &MediaRecorderHandler::WriteData, weak_factory_.GetWeakPtr()))));
+  DCHECK(webm_muxer_);
+
+  blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
+  media_stream_.videoTracks(video_tracks);
+  DCHECK(!video_tracks.isEmpty());

[miu, 2015/09/02 21:28:12]

It's possible to record MediaStreams that only have audio tracks, right?  If so,
this DCHECK is invalid.

[mcasas, 2015/09/04 02:16:30]

Done.

+
+  for (const auto& video_track : video_tracks) {
+    DCHECK(!video_track.isNull());
+
+    const VideoTrackRecorder::OnEncodedVideoCB on_encoded_video_cb = base::Bind(
+        &media::WebmMuxer::OnEncodedVideo, base::Unretained(webm_muxer_.get()));

[miu, 2015/09/02 21:28:12]

So, if there are multiple video tracks, it looks like the video frames from
different tracks will get jumbled together into a single video track in the
WebmMuxer.  So, does this mean you need to resurrect the "AddTrack()" method in
WebmMuxer to support multiple video tracks?

[mcasas, 2015/09/04 02:16:30]

I can envision the overwhelming majority of users 
recording a single Video track. So for the time being 
I believe supporting one such is not too limiting. I 
guess in that case is best to leave things as they are,
and added a DCHECK+TODO.

[miu, 2015/09/04 21:48:52]

SGTM.

However, since this is an issue of incomplete implementation, it's best not to
crash the process.  Instead, the code should try to continue normally whenever
the the "audio only" or "multiple video tracks" cases are presented to this
method.  Instead of the DCHECKs, you could:

  LOG_IF(WARNING, !audio_tracks.isEmpty()) << "Recording audio tracks is not
implemented for MediaStream " << identifier;

  LOG_IF(WARNING, video_tracks.size() > 1) << "Recording multiple video tracks
is not implemented.  Only recording first video track in the MediaStream " <<
identifier;

Also, please either convert your for-loop to an if-statement, or add a break
statement at the end of the block.

[mcasas, 2015/09/05 02:43:01]

Done.

+
+    video_recorders_.push_back(new VideoTrackRecorder(video_track,
+                                                      on_encoded_video_cb));
+  }
+
+  // TODO(mcasas): Add audio_tracks.
+
+  recording_ = true;
+  return true;
+}
+
+void MediaRecorderHandler::stop() {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  DCHECK(recording_);
+
+  recording_ = false;
+  video_recorders_.clear();
+  webm_muxer_.reset(NULL);
+}
+
+void MediaRecorderHandler::pause() {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  DCHECK(recording_);
+  recording_ = false;
+  NOTIMPLEMENTED();
+}
+
+void MediaRecorderHandler::resume() {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  DCHECK(!recording_);
+  recording_ = true;
+  NOTIMPLEMENTED();
+}
+
+void MediaRecorderHandler::WriteData(const base::StringPiece& data) {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+  client_->writeData(data.data(), data.size(), false  /* lastInslice */);
+}
+
+void MediaRecorderHandler::OnVideoFrameForTesting(
+    const scoped_refptr<media::VideoFrame>& frame,
+    const base::TimeTicks& timestamp) {
+  for (auto* recorder : video_recorders_)
+    recorder->OnVideoFrameForTesting(frame, timestamp);
+}
+
+}  // namespace content