Render inband text tracks in the media pipeline

media/mp3/mp3_stream_parser_unittest.cc

 // Copyright 2013 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 "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/test_data_util.h"
+#include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
 #include "media/mp3/mp3_stream_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 
 class MP3StreamParserTest : public testing::Test {
  public:
   MP3StreamParserTest() {}
 
@@ skipping 17 matching lines @@
     }
     return true;
   }
 
   void OnInitDone(bool success, base::TimeDelta duration) {
     DVLOG(1) << __FUNCTION__ << "(" << success << ", "
              << duration.InMilliseconds() << ")";
   }
 
   bool OnNewConfig(const AudioDecoderConfig& audio_config,
-                   const VideoDecoderConfig& video_config) {
+                   const VideoDecoderConfig& video_config,
+                   const StreamParser::TextTrackConfigMap& text_config) {
     DVLOG(1) << __FUNCTION__ << "(" << audio_config.IsValidConfig() << ", "
              << video_config.IsValidConfig() << ")";
     EXPECT_TRUE(audio_config.IsValidConfig());
     EXPECT_FALSE(video_config.IsValidConfig());
     return true;
   }
 
   std::string BufferQueueToString(const StreamParser::BufferQueue& buffers) {
     std::stringstream ss;
 
@@ skipping 14 matching lines @@
                     const StreamParser::BufferQueue& video_buffers) {
     EXPECT_FALSE(audio_buffers.empty());
     EXPECT_TRUE(video_buffers.empty());
 
     std::string buffers_str = BufferQueueToString(audio_buffers);
     DVLOG(1) << __FUNCTION__ << " : " << buffers_str;
     results_stream_ << buffers_str;
     return true;
   }
 
-  bool OnNewTextBuffers(TextTrack* text_track,
-                        const StreamParser::BufferQueue& buffers) {
-    return true;
-  }
-
   void OnKeyNeeded(const std::string& type,
                    const std::vector<uint8>& init_data) {
     DVLOG(1) << __FUNCTION__ << "(" << type << ", " << init_data.size() << ")";
   }
 
-  scoped_ptr<TextTrack> OnAddTextTrack(TextKind kind,
-                                       const std::string& label,
-                                       const std::string& language) {
-    return scoped_ptr<TextTrack>();
-  }
-
   void OnNewSegment() {
     DVLOG(1) << __FUNCTION__;
     results_stream_ << "NewSegment";
   }
 
   void OnEndOfSegment() {
     DVLOG(1) << __FUNCTION__;
     results_stream_ << "EndOfSegment";
   }
 
   void InitializeParser() {
     parser_.Init(
         base::Bind(&MP3StreamParserTest::OnInitDone, base::Unretained(this)),
         base::Bind(&MP3StreamParserTest::OnNewConfig, base::Unretained(this)),
         base::Bind(&MP3StreamParserTest::OnNewBuffers, base::Unretained(this)),
-        base::Bind(&MP3StreamParserTest::OnNewTextBuffers,
-                   base::Unretained(this)),
+        StreamParser::NewTextBuffersCB(),
         base::Bind(&MP3StreamParserTest::OnKeyNeeded, base::Unretained(this)),
-        base::Bind(&MP3StreamParserTest::OnAddTextTrack,
-                   base::Unretained(this)),
         base::Bind(&MP3StreamParserTest::OnNewSegment, base::Unretained(this)),
         base::Bind(&MP3StreamParserTest::OnEndOfSegment,
                    base::Unretained(this)),
         LogCB());
   }
 
   std::string ParseFile(const std::string& filename, int append_bytes) {
     results_stream_.clear();
     InitializeParser();
 
@@ skipping 40 matching lines @@
       "EndOfSegment"
       "NewSegment"
       "{ 130K 156K 182K }"
       "{ 208K 235K 261K 287K }"
       "{ 313K }"
       "EndOfSegment";
   EXPECT_EQ(expected, ParseFile("sfx.mp3", 512));
 }
 
 }  // namespace media