Assign correct track ids to buffers emitted from StreamParsers

media/formats/mp2t/mp2t_stream_parser_unittest.cc

 // Copyright 2014 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 "media/formats/mp2t/mp2t_stream_parser.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 62 matching lines @@
   std::unique_ptr<Mp2tStreamParser> parser_;
   int segment_count_;
   int config_count_;
   int audio_frame_count_;
   int video_frame_count_;
   bool has_video_;
   DecodeTimestamp audio_min_dts_;
   DecodeTimestamp audio_max_dts_;
   DecodeTimestamp video_min_dts_;
   DecodeTimestamp video_max_dts_;
+  StreamParser::TrackId audio_track_id_;
+  StreamParser::TrackId video_track_id_;
 
   void ResetStats() {
     segment_count_ = 0;
     config_count_ = 0;
     audio_frame_count_ = 0;
     video_frame_count_ = 0;
     audio_min_dts_ = kNoDecodeTimestamp();
     audio_max_dts_ = kNoDecodeTimestamp();
     video_min_dts_ = kNoDecodeTimestamp();
     video_max_dts_ = kNoDecodeTimestamp();
@@ skipping 24 matching lines @@
   }
 
   bool OnNewConfig(std::unique_ptr<MediaTracks> tracks,
                    const StreamParser::TextTrackConfigMap& tc) {
     DVLOG(1) << "OnNewConfig: got " << tracks->tracks().size() << " tracks";
     bool found_audio_track = false;
     bool found_video_track = false;
     for (const auto& track : tracks->tracks()) {
       const auto& track_id = track->bytestream_track_id();
       if (track->type() == MediaTrack::Audio) {
+        audio_track_id_ = track_id;
         found_audio_track = true;
         EXPECT_TRUE(tracks->getAudioConfig(track_id).IsValidConfig());
       } else if (track->type() == MediaTrack::Video) {
+        video_track_id_ = track_id;
         found_video_track = true;
         EXPECT_TRUE(tracks->getVideoConfig(track_id).IsValidConfig());
       } else {
         // Unexpected track type.
         LOG(ERROR) << "Unexpected track type " << track->type();
         EXPECT_TRUE(false);
       }
     }
     EXPECT_TRUE(found_audio_track);
     EXPECT_EQ(has_video_, found_video_track);
@@ skipping 13 matching lines @@
     }
   }
 
   bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
                     const StreamParser::BufferQueue& video_buffers,
                     const StreamParser::TextBufferQueueMap& text_map) {
     EXPECT_GT(config_count_, 0);
     DumpBuffers("audio_buffers", audio_buffers);
     DumpBuffers("video_buffers", video_buffers);
 
+    // Ensure that track ids are properly assigned on all emitted buffers.
+    for (const auto& buf : audio_buffers) {
+      EXPECT_EQ(audio_track_id_, buf->track_id());
+    }
+    for (const auto& buf : video_buffers) {
+      EXPECT_EQ(video_track_id_, buf->track_id());
+    }
+
     // TODO(wolenetz/acolwell): Add text track support to more MSE parsers. See
     // http://crbug.com/336926.
     if (!text_map.empty())
       return false;
 
     // Verify monotonicity.
     if (!IsMonotonic(video_buffers))
       return false;
     if (!IsMonotonic(audio_buffers))
       return false;
@@ skipping 138 matching lines @@
   parser_->Flush();
   EXPECT_EQ(audio_frame_count_, 40);
   EXPECT_EQ(video_frame_count_, 0);
   // This stream has no mid-stream configuration change.
   EXPECT_EQ(config_count_, 1);
   EXPECT_EQ(segment_count_, 1);
 }
 
 }  // namespace mp2t
 }  // namespace media