Render inband text tracks in the media pipeline

media/mp4/mp4_stream_parser_unittest.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
@@ skipping 44 matching lines @@
       start += append_size;
     }
     return true;
   }
 
   void InitF(bool init_ok, base::TimeDelta duration) {
     DVLOG(1) << "InitF: ok=" << init_ok
              << ", dur=" << duration.InMilliseconds();
   }
 
-  bool NewConfigF(const AudioDecoderConfig& ac, const VideoDecoderConfig& vc) {
+  bool NewConfigF(const AudioDecoderConfig& ac,
+                  const VideoDecoderConfig& vc,
+                  const TextTrackConfigMap& tc) {
     DVLOG(1) << "NewConfigF: audio=" << ac.IsValidConfig()
              << ", video=" << vc.IsValidConfig();
     configs_received_ = true;
     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) {
     DumpBuffers("audio_buffers", audio_buffers);
     DumpBuffers("video_buffers", video_buffers);
     return true;
   }
 
-  bool NewTextBuffersF(TextTrack* text_track,
+  bool NewTextBuffersF(int text_track,
                        const StreamParser::BufferQueue& buffers) {
     return true;
   }
 
   void KeyNeededF(const std::string& type,
                   const std::vector<uint8>& init_data) {
     DVLOG(1) << "KeyNeededF: " << init_data.size();
     EXPECT_EQ(kMp4InitDataType, type);
     EXPECT_FALSE(init_data.empty());
   }
 
-  scoped_ptr<TextTrack> AddTextTrackF(
-      TextKind kind,
-      const std::string& label,
-      const std::string& language) {
-    return scoped_ptr<TextTrack>();
-  }
-
   void NewSegmentF() {
     DVLOG(1) << "NewSegmentF";
   }
 
   void EndOfSegmentF() {
     DVLOG(1) << "EndOfSegmentF()";
   }
 
   void InitializeParser() {
     parser_->Init(
         base::Bind(&MP4StreamParserTest::InitF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::NewConfigF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::NewBuffersF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::NewTextBuffersF,
                    base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::KeyNeededF, base::Unretained(this)),
-        base::Bind(&MP4StreamParserTest::AddTextTrackF, base::Unretained(this)),
+        true,
         base::Bind(&MP4StreamParserTest::NewSegmentF, base::Unretained(this)),
         base::Bind(&MP4StreamParserTest::EndOfSegmentF,
                    base::Unretained(this)),
         LogCB());
   }
 
   bool ParseMP4File(const std::string& filename, int append_bytes) {
     InitializeParser();
 
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
@@ skipping 69 matching lines @@
   EXPECT_TRUE(AppendDataInPieces(buffer->data() + kFirstMoofOffset,
                                  buffer->data_size() - kFirstMoofOffset,
                                  512));
 }
 
 // TODO(strobe): Create and test media which uses CENC auxiliary info stored
 // inside a private box
 
 }  // namespace mp4
 }  // namespace media