Allow media track switching.

media/renderers/video_renderer_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.
 
 #ifndef MEDIA_RENDERERS_VIDEO_RENDERER_IMPL_H_
 #define MEDIA_RENDERERS_VIDEO_RENDERER_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 10 matching lines @@
 #include "media/base/decryptor.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_log.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_renderer.h"
 #include "media/base/video_renderer_sink.h"
 #include "media/filters/decoder_stream.h"
 #include "media/filters/video_renderer_algorithm.h"
+#include "media/renderers/default_renderer_factory.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 class TickClock;
 }
 
 namespace media {
 
 // VideoRendererImpl handles reading from a VideoFrameStream storing the
 // results in a queue of decoded frames and executing a callback when a frame is
 // ready for rendering.
 class MEDIA_EXPORT VideoRendererImpl
     : public VideoRenderer,
       public NON_EXPORTED_BASE(VideoRendererSink::RenderCallback) {
  public:
   // |decoders| contains the VideoDecoders to use when initializing.
   //
   // Implementors should avoid doing any sort of heavy work in this method and
   // instead post a task to a common/worker thread to handle rendering.  Slowing
   // down the video thread may result in losing synchronization with audio.
   //
   // Setting |drop_frames_| to true causes the renderer to drop expired frames.
   VideoRendererImpl(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
       const scoped_refptr<base::TaskRunner>& worker_task_runner,
       VideoRendererSink* sink,
-      ScopedVector<VideoDecoder> decoders,
+      const CreateVideoDecodersCB& create_video_decoders_cb,
       bool drop_frames,
       GpuVideoAcceleratorFactories* gpu_factories,
       const scoped_refptr<MediaLog>& media_log);
   ~VideoRendererImpl() override;
 
   // VideoRenderer implementation.
   void Initialize(DemuxerStream* stream,
                   CdmContext* cdm_context,
                   RendererClient* client,
                   const TimeSource::WallClockTimeCB& wall_clock_time_cb,
@@ skipping 143 matching lines @@
   bool low_delay_;
 
   // Keeps track of whether we received the end of stream buffer and finished
   // rendering.
   bool received_end_of_stream_;
   bool rendered_end_of_stream_;
 
   // Important detail: being in kPlaying doesn't imply that video is being
   // rendered. Rather, it means that the renderer is ready to go. The actual
   // rendering of video is controlled by time advancing via |get_time_cb_|.
+  // Video renderer can be reinitialized completely by calling Initialize again
+  // when it is in a kFlushed state with video sink stopped.
   //
-  //   kUninitialized
-  //         | Initialize()
-  //         |
-  //         V
-  //    kInitializing
-  //         | Decoders initialized
-  //         |
-  //         V            Decoders reset
-  //      kFlushed <------------------ kFlushing
-  //         | StartPlayingFrom()         ^
-  //         |                            |
-  //         |                            | Flush()
-  //         `---------> kPlaying --------'
+  //    kUninitialized
+  //  +------> | Initialize()
+  //  |        |
+  //  |        V
+  //  |   kInitializing
+  //  |        | Decoders initialized
+  //  |        |
+  //  |        V            Decoders reset
+  //  ---- kFlushed <------------------ kFlushing
+  //           | StartPlayingFrom()         ^
+  //           |                            |
+  //           |                            | Flush()
+  //           `---------> kPlaying --------'
   enum State {
     kUninitialized,
     kInitializing,
     kFlushing,
     kFlushed,
     kPlaying
   };
   State state_;
 
+  // TODO(servolk): Consider using DecoderFactory here instead of the
+  // CreateVideoDecodersCB.
+  CreateVideoDecodersCB create_video_decoders_cb_;
+  GpuVideoAcceleratorFactories* gpu_factories_;
+  scoped_refptr<base::TaskRunner> worker_task_runner_;
+
   // Keep track of the outstanding read on the VideoFrameStream. Flushing can
   // only complete once the read has completed.
   bool pending_read_;
 
   bool drop_frames_;
 
   BufferingState buffering_state_;
 
   // Playback operation callbacks.
   PipelineStatusCB init_cb_;
@@ skipping 48 matching lines @@
   // want to discard video frames that might be received after the stream has
   // been reset.
   base::WeakPtrFactory<VideoRendererImpl> frame_callback_weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRendererImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_RENDERERS_VIDEO_RENDERER_IMPL_H_