Assign correct track ids to buffers emitted from StreamParsers

media/formats/mp4/mp4_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/mp4/mp4_stream_parser.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 58 matching lines @@
   }
 
  protected:
   scoped_refptr<StrictMock<MockMediaLog>> media_log_;
   std::unique_ptr<MP4StreamParser> parser_;
   bool configs_received_;
   std::unique_ptr<MediaTracks> media_tracks_;
   AudioDecoderConfig audio_decoder_config_;
   VideoDecoderConfig video_decoder_config_;
   DecodeTimestamp lower_bound_;
+  StreamParser::TrackId audio_track_id_;
+  StreamParser::TrackId video_track_id_;
 
   bool AppendData(const uint8_t* data, size_t length) {
     return parser_->Parse(data, length);
   }
 
   bool AppendDataInPieces(const uint8_t* data,
                           size_t length,
                           size_t piece_size) {
     const uint8_t* start = data;
     const uint8_t* end = data + length;
@@ skipping 25 matching lines @@
   }
 
   bool NewConfigF(std::unique_ptr<MediaTracks> tracks,
                   const StreamParser::TextTrackConfigMap& tc) {
     configs_received_ = true;
     CHECK(tracks.get());
     DVLOG(1) << "NewConfigF: got " << tracks->tracks().size() << " tracks";
     for (const auto& track : tracks->tracks()) {
       const auto& track_id = track->bytestream_track_id();
       if (track->type() == MediaTrack::Audio) {
+        audio_track_id_ = track_id;
         audio_decoder_config_ = tracks->getAudioConfig(track_id);
         DVLOG(1) << "Audio track " << track_id << " config="
                  << (audio_decoder_config_.IsValidConfig()
                          ? audio_decoder_config_.AsHumanReadableString()
                          : "INVALID");
       } else if (track->type() == MediaTrack::Video) {
+        video_track_id_ = track_id;
         video_decoder_config_ = tracks->getVideoConfig(track_id);
         DVLOG(1) << "Video track " << track_id << " config="
                  << (video_decoder_config_.IsValidConfig()
                          ? video_decoder_config_.AsHumanReadableString()
                          : "INVALID");
       }
     }
     media_tracks_ = std::move(tracks);
     return true;
   }
 
   void DumpBuffers(const std::string& label,
                    const StreamParser::BufferQueue& buffers) {
     DVLOG(2) << "DumpBuffers: " << label << " size " << buffers.size();
     for (StreamParser::BufferQueue::const_iterator buf = buffers.begin();
          buf != buffers.end(); buf++) {
       DVLOG(3) << "  n=" << buf - buffers.begin()
                << ", size=" << (*buf)->data_size()
                << ", dur=" << (*buf)->duration().InMilliseconds();
     }
   }
 
   bool NewBuffersF(const StreamParser::BufferQueue& audio_buffers,
                    const StreamParser::BufferQueue& video_buffers,
                    const StreamParser::TextBufferQueueMap& text_map) {
     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;
 
     // Find the second highest timestamp so that we know what the
     // timestamps on the next set of buffers must be >= than.
     DecodeTimestamp audio = !audio_buffers.empty() ?
         audio_buffers.back()->GetDecodeTimestamp() : kNoDecodeTimestamp();
     DecodeTimestamp video = !video_buffers.empty() ?
@@ skipping 364 matching lines @@
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-avt_subt_frag.mp4");
 
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 }  // namespace mp4
 }  // namespace media