Implemented Multiple video track recoding.

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"
@@ skipping 58 matching lines @@
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
   media_stream_.videoTracks(video_tracks);
 
   if (video_tracks.isEmpty()) {
     // TODO(mcasas): Add audio_tracks and update the code in this function
     // correspondingly, see http://crbug.com/528519. As of now, only video
     // tracks are supported.
     LOG(WARNING) << "Recording no video tracks is not implemented";
     return false;
   }
-  // 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) << "Recording multiple video"
-      << " tracks is not implemented.  Only recording first video track.";
-  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()));
+  for (const blink::WebMediaStreamTrack& video_track : video_tracks) {
+    if (video_track.isNull()) {

[mcasas, 2015/10/06 17:53:13]

Is this possible at all?

[msu.koo, 2015/10/07 04:52:19]

I cannot see the routine checking the validity of |video_track| before here. If
you mind, how about DCHECK?

+      LOG(WARNING) << "|video_track| is null";
+      continue;
+    }
 
-  video_recorders_.push_back(new VideoTrackRecorder(video_track,
-                                                    on_encoded_video_cb));
+    const VideoTrackRecorder::OnEncodedVideoCB on_encoded_video_cb =
+        media::BindToCurrentLoop(
+            base::Bind(&MediaRecorderHandler::OnEncodedVideo,
+                       weak_factory_.GetWeakPtr(),
+                       webm_muxer_->GetNextVideoTrackIndex()));
+    video_recorders_.push_back(
+        new VideoTrackRecorder(video_track, on_encoded_video_cb));
+    recording_ = true;
+  }
 
-  recording_ = true;
   return true;
 }
 
 void MediaRecorderHandler::stop() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(recording_);
 
   recording_ = false;
   video_recorders_.clear();
   webm_muxer_.reset();
 }
 
 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::OnEncodedVideo(
+    int track_index,
     const scoped_refptr<media::VideoFrame>& video_frame,
     scoped_ptr<std::string> encoded_data,
     base::TimeTicks timestamp,
     bool is_key_frame) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   if (webm_muxer_) {
-    webm_muxer_->OnEncodedVideo(video_frame, encoded_data.Pass(), timestamp,
-                                is_key_frame);
+    webm_muxer_->OnEncodedVideo(track_index, video_frame, encoded_data.Pass(),
+                                timestamp, is_key_frame);
   }
 }
 
 void MediaRecorderHandler::WriteData(base::StringPiece data) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   client_->writeData(data.data(), data.length(), 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