Implemented Multiple video track recoding.

media/capture/webm_muxer_unittest.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 "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/video_frame.h"
@@ skipping 61 matching lines @@
 }
 
 // This test sends two frames and checks that the WriteCallback is called with
 // appropriate params in both cases.
 TEST_F(WebmMuxerTest, OnEncodedVideoTwoFrames) {
   const gfx::Size frame_size(160, 80);
   const scoped_refptr<VideoFrame> video_frame =
       VideoFrame::CreateBlackFrame(frame_size);
   const std::string encoded_data("abcdefghijklmnopqrstuvwxyz");
 
+  WebmMuxer::EncodedVideoCB encoded_video_cb =
+      webm_muxer_.GenerateOnEncodedVideoCallback();
+
   EXPECT_CALL(*this, WriteCallback(_))
       .Times(AtLeast(1))
       .WillRepeatedly(WithArgs<0>(
           Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
-  webm_muxer_.OnEncodedVideo(video_frame,
-                             make_scoped_ptr(new std::string(encoded_data)),
-                             base::TimeTicks::Now(),
-                             false  /* keyframe */);
+
+  encoded_video_cb.Run(video_frame,
+                       make_scoped_ptr(new std::string(encoded_data)),
+                       base::TimeTicks::Now(),
+                       false  /* keyframe */);
 
   // First time around WriteCallback() is pinged a number of times to write the
   // Matroska header, but at the end it dumps |encoded_data|.
+  EXPECT_EQ(last_encoded_length_, encoded_data.size());
+  EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
+  EXPECT_GE(GetWebmMuxerPosition(), static_cast<int64_t>(last_encoded_length_));
+  EXPECT_EQ(GetWebmSegmentMode(), mkvmuxer::Segment::kLive);
+
+  const int64_t begin_of_second_block = accumulated_position_;
+  EXPECT_CALL(*this, WriteCallback(_))
+      .Times(AtLeast(1))
+      .WillRepeatedly(WithArgs<0>(
+          Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
+  encoded_video_cb.Run(video_frame,
+                       make_scoped_ptr(new std::string(encoded_data)),
+                       base::TimeTicks::Now(),
+                       false  /* keyframe */);
+
+  // The second time around the callbacks should include a SimpleBlock header,
+  // namely the track index, a timestamp and a flags byte, for a total of 6B.
+  EXPECT_EQ(last_encoded_length_, encoded_data.size());
+  EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
+  const uint32_t kSimpleBlockSize = 6u;
+  EXPECT_EQ(static_cast<int64_t>(begin_of_second_block + kSimpleBlockSize +
+                                 encoded_data.size()),
+            accumulated_position_);
+}
+
+TEST_F(WebmMuxerTest, OnEncodedVideoTwoTracks) {
+  const gfx::Size frame_size(160, 80);
+  const scoped_refptr<VideoFrame> video_frame =
+      VideoFrame::CreateBlackFrame(frame_size);
+  const std::string encoded_data("abcdefghijklmnopqrstuvwxyz");
+  WebmMuxer::EncodedVideoCB encoded_video_cb_1 =
+        webm_muxer_.GenerateOnEncodedVideoCallback();
+  WebmMuxer::EncodedVideoCB encoded_video_cb_2 =
+        webm_muxer_.GenerateOnEncodedVideoCallback();
+  EXPECT_CALL(*this, WriteCallback(_))
+      .Times(AtLeast(1))
+      .WillRepeatedly(WithArgs<0>(
+          Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
+  encoded_video_cb_1.Run(video_frame,
+                         make_scoped_ptr(new std::string(encoded_data)),
+                         base::TimeTicks::Now(),
+                         false  /* keyframe */);
+
+  // First time around WriteCallback() is pinged a number of times to write the
+  // Matroska header, but at the end it dumps |encoded_data|.
   EXPECT_EQ(last_encoded_length_, encoded_data.size());
   EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
   EXPECT_GE(GetWebmMuxerPosition(), static_cast<int64_t>(last_encoded_length_));
   EXPECT_EQ(GetWebmSegmentMode(), mkvmuxer::Segment::kLive);
 
   const int64_t begin_of_second_block = accumulated_position_;
   EXPECT_CALL(*this, WriteCallback(_))
       .Times(AtLeast(1))
       .WillRepeatedly(WithArgs<0>(
           Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
-  webm_muxer_.OnEncodedVideo(video_frame,
-                             make_scoped_ptr(new std::string(encoded_data)),
-                             base::TimeTicks::Now(),
-                             false  /* keyframe */);
+  encoded_video_cb_2.Run(video_frame,
+                         make_scoped_ptr(new std::string(encoded_data)),
+                         base::TimeTicks::Now(),
+                         false  /* keyframe */);
 
   // The second time around the callbacks should include a SimpleBlock header,
   // namely the track index, a timestamp and a flags byte, for a total of 6B.
   EXPECT_EQ(last_encoded_length_, encoded_data.size());
   EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
   const uint32_t kSimpleBlockSize = 6u;
   EXPECT_EQ(static_cast<int64_t>(begin_of_second_block + kSimpleBlockSize +
                                  encoded_data.size()),
             accumulated_position_);
 }
 
 }  // namespace media