Render inband text tracks in the media pipeline

media/webm/webm_stream_parser.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 "media/webm/webm_stream_parser.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/logging.h"
-#include "base/stl_util.h"
 #include "media/webm/webm_cluster_parser.h"
 #include "media/webm/webm_constants.h"
 #include "media/webm/webm_content_encodings.h"
 #include "media/webm/webm_crypto_helpers.h"
 #include "media/webm/webm_info_parser.h"
 #include "media/webm/webm_tracks_parser.h"
 
 namespace media {
 
 WebMStreamParser::WebMStreamParser()
     : state_(kWaitingForInit),
       waiting_for_buffers_(false) {
 }
 
 WebMStreamParser::~WebMStreamParser() {
-  STLDeleteValues(&text_track_map_);
 }
 
 void WebMStreamParser::Init(const InitCB& init_cb,
                             const NewConfigCB& config_cb,
                             const NewBuffersCB& new_buffers_cb,
                             const NewTextBuffersCB& text_cb,
                             const NeedKeyCB& need_key_cb,
-                            const AddTextTrackCB& add_text_track_cb,
+                            const NewTextTrackCB& new_text_track_cb,
                             const NewMediaSegmentCB& new_segment_cb,
                             const base::Closure& end_of_segment_cb,
                             const LogCB& log_cb) {
   DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
   DCHECK(!config_cb.is_null());
   DCHECK(!new_buffers_cb.is_null());
   DCHECK(!text_cb.is_null());
   DCHECK(!need_key_cb.is_null());
   DCHECK(!new_segment_cb.is_null());
   DCHECK(!end_of_segment_cb.is_null());
 
   ChangeState(kParsingHeaders);
   init_cb_ = init_cb;
   config_cb_ = config_cb;
   new_buffers_cb_ = new_buffers_cb;
   text_cb_ = text_cb;
   need_key_cb_ = need_key_cb;
-  add_text_track_cb_ = add_text_track_cb;
+  new_text_track_cb_ = new_text_track_cb;
   new_segment_cb_ = new_segment_cb;
   end_of_segment_cb_ = end_of_segment_cb;
   log_cb_ = log_cb;
 }
 
 void WebMStreamParser::Flush() {
   DCHECK_NE(state_, kWaitingForInit);
 
   byte_queue_.Reset();
 
@@ skipping 102 matching lines @@
   WebMInfoParser info_parser;
   result = info_parser.Parse(cur, cur_size);
 
   if (result <= 0)
     return result;
 
   cur += result;
   cur_size -= result;
   bytes_parsed += result;
 
-  WebMTracksParser tracks_parser(log_cb_, add_text_track_cb_.is_null());
+  WebMTracksParser tracks_parser(log_cb_, new_text_track_cb_.is_null());
   result = tracks_parser.Parse(cur, cur_size);
 
   if (result <= 0)
     return result;
 
   bytes_parsed += result;
 
   base::TimeDelta duration = kInfiniteDuration();
 
   if (info_parser.duration() > 0) {
@@ skipping 16 matching lines @@
   }
 
   typedef WebMTracksParser::TextTracks TextTracks;
   const TextTracks& text_tracks = tracks_parser.text_tracks();
 
   for (TextTracks::const_iterator itr = text_tracks.begin();
        itr != text_tracks.end(); ++itr) {
     const WebMTracksParser::TextTrackInfo& text_track_info = itr->second;
 
     // TODO(matthewjheaney): verify that WebVTT uses ISO 639-2 for lang
-    scoped_ptr<TextTrack> text_track =
-        add_text_track_cb_.Run(text_track_info.kind,
-                               text_track_info.name,
-                               text_track_info.language);
-
-    // Assume ownership of pointer, and cache the text track object, for use
-    // later when we have text track buffers. (The text track objects are
-    // deallocated in the dtor for this class.)
-
-    if (text_track)
-      text_track_map_.insert(std::make_pair(itr->first, text_track.release()));
+    new_text_track_cb_.Run(itr->first,
+                           text_track_info.kind,
+                           text_track_info.name,
+                           text_track_info.language);
   }
 
   cluster_parser_.reset(new WebMClusterParser(
       info_parser.timecode_scale(),
       tracks_parser.audio_track_num(),
       tracks_parser.video_track_num(),
       text_tracks,
       tracks_parser.ignored_tracks(),
       tracks_parser.audio_encryption_key_id(),
       tracks_parser.video_encryption_key_id(),
@@ skipping 58 matching lines @@
     return -1;
   }
 
   WebMClusterParser::TextTrackIterator text_track_iter =
     cluster_parser_->CreateTextTrackIterator();
 
   int text_track_num;
   const BufferQueue* text_buffers;
 
   while (text_track_iter(&text_track_num, &text_buffers)) {
-    TextTrackMap::iterator find_result = text_track_map_.find(text_track_num);
-
-    if (find_result == text_track_map_.end())
-      continue;
-
-    TextTrack* const text_track = find_result->second;
-
-    if (!text_buffers->empty() && !text_cb_.Run(text_track, *text_buffers))
+    if (!text_buffers->empty() && !text_cb_.Run(text_track_num, *text_buffers))
       return -1;
   }
 
   if (cluster_ended)
     end_of_segment_cb_.Run();
 
   return bytes_parsed;
 }
 
 void WebMStreamParser::FireNeedKey(const std::string& key_id) {
   std::vector<uint8> key_id_vector(key_id.begin(), key_id.end());
   need_key_cb_.Run(kWebMEncryptInitDataType, key_id_vector);
 }
 
 }  // namespace media