Render inband text tracks in the media pipeline

content/renderer/media/webmediaplayer_impl.h

 // 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.
 
 // Delegate calls from WebCore::MediaPlayerPrivate to Chrome's video player.
 // It contains Pipeline which is the actual media player pipeline, it glues
 // the media player pipeline, data source, audio renderer and renderer.
 // Pipeline would creates multiple threads and access some public methods
 // of this class, so we need to be extra careful about concurrent access of
 // methods and members.
 //
 // Other issues:
 // During tear down of the whole browser or a tab, the DOM tree may not be
 // destructed nicely, and there will be some dangling media threads trying to
 // the main thread, so we need this class to listen to destruction event of the
 // main thread and cleanup the media threads when the even is received. Also
 // at destruction of this class we will need to unhook it from destruction event
 // list of the main thread.
 
 #ifndef CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
 #define CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_
 
+#include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
 #include "cc/layers/video_frame_provider.h"
 #include "content/renderer/media/crypto/proxy_decryptor.h"
@@ skipping 15 matching lines @@
 namespace WebKit {
 class WebFrame;
 }
 
 namespace base {
 class MessageLoopProxy;
 }
 
 namespace media {
 class ChunkDemuxer;
-class FFmpegDemuxer;
+class DemuxerStream;
 class GpuVideoAcceleratorFactories;
 class MediaLog;
+class TextCue;
 }
 
 namespace webkit {
 class WebLayerImpl;
 }
 
 namespace content {
 class BufferedDataSource;
 class WebAudioSourceProviderImpl;
 class WebMediaPlayerDelegate;
@@ skipping 119 matching lines @@
   void OnKeyAdded(const std::string& session_id);
   void OnKeyError(const std::string& session_id,
                   media::MediaKeys::KeyError error_code,
                   int system_code);
   void OnKeyMessage(const std::string& session_id,
                     const std::vector<uint8>& message,
                     const std::string& default_url);
   void OnNeedKey(const std::string& type,
                  const std::string& session_id,
                  const std::vector<uint8>& init_data);
+  // TODO(matthewjheaney): Once we're satisfied that we have the threading model
+  // correct for handling text cues, move the media source from OnTextTrack over
+  // to AddTextStream.
   scoped_ptr<media::TextTrack> OnTextTrack(media::TextKind kind,
                                            const std::string& label,
                                            const std::string& language);
+  void AddTextStream(media::DemuxerStream* stream,
+                     media::TextKind kind,
+                     const std::string& label,
+                     const std::string& language);
   void SetOpaque(bool);
 
  private:
   // Called after |defer_load_cb_| has decided to allow the load. If
   // |defer_load_cb_| is null this is called immediately.
   void DoLoad(LoadType load_type,
               const WebKit::WebURL& url,
               CORSMode cors_mode);
 
   // Called after asynchronous initialization of a data source completed.
@@ skipping 38 matching lines @@
   // Gets the duration value reported by the pipeline.
   double GetPipelineDuration() const;
 
   // Notifies WebKit of the duration change.
   void OnDurationChange();
 
   // Called by VideoRendererBase on its internal thread with the new frame to be
   // painted.
   void FrameReady(const scoped_refptr<media::VideoFrame>& frame);
 
+  // Called by the TextRenderer when a decoded cue has been delivered on
+  // |text_stream|, and hence that it be added to the cue list for its
+  // associated text track.
+  void CueReady(media::DemuxerStream* text_stream,
+                const scoped_refptr<media::TextCue>& text_cue);
+
   WebKit::WebFrame* frame_;
 
   // TODO(hclam): get rid of these members and read from the pipeline directly.
   WebKit::WebMediaPlayer::NetworkState network_state_;
   WebKit::WebMediaPlayer::ReadyState ready_state_;
 
   // Keep a list of buffered time ranges.
   WebKit::WebTimeRanges buffered_;
 
   // Message loops for posting tasks on Chrome's main thread. Also used
@@ skipping 89 matching lines @@
   // playback.
   scoped_ptr<webkit::WebLayerImpl> video_weblayer_;
 
   // A pointer back to the compositor to inform it about state changes. This is
   // not NULL while the compositor is actively using this webmediaplayer.
   cc::VideoFrameProvider::Client* video_frame_provider_client_;
 
   // Text track objects get a unique index value when they're created.
   int text_track_index_;
 
+  // Manipulation of TextTrack objects must be done on the main loop, not the
+  // media loop, so we declare this cache here. Objects in the pipeline
+  // dispatch callbacks to player (using DemuxerStream as the key), the
+  // player looks up the associated TextTrack, and then it manipulates the
+  // TextTrack object as necessary.
+  typedef std::map<media::DemuxerStream*, media::TextTrack*> TextTrackMap;
+  TextTrackMap text_track_map_;
+
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBMEDIAPLAYER_IMPL_H_