Remove WebMediaPlayerProxy::video_decoder_ & FFmpegVideoDecoder::set_decryptor.

BUG=None

Review URL: https://chromiumcodereview.appspot.com/10834183

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@150360 0039d316-1c4b-4281-b951-d872f2087c98

media/filters/ffmpeg_video_decoder.cc

@@ -54,13 +54,14 @@ static int GetThreadCount(CodecID codec_id) {
 }
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(
-    const base::Callback<MessageLoop*()>& message_loop_cb)
+    const base::Callback<MessageLoop*()>& message_loop_cb,
+    Decryptor* decryptor)
     : message_loop_factory_cb_(message_loop_cb),
       message_loop_(NULL),
       state_(kUninitialized),
       codec_context_(NULL),
       av_frame_(NULL),
-      decryptor_(NULL) {
+      decryptor_(decryptor) {
 }
 
 int FFmpegVideoDecoder::GetVideoBuffer(AVCodecContext* codec_context,
@@ -256,11 +257,6 @@ void FFmpegVideoDecoder::DoStop() {
   base::ResetAndReturn(&stop_cb_).Run();
 }
 
-void FFmpegVideoDecoder::set_decryptor(Decryptor* decryptor) {
-  DCHECK_EQ(state_, kUninitialized);
-  decryptor_ = decryptor;
-}
-
 FFmpegVideoDecoder::~FFmpegVideoDecoder() {
   ReleaseFFmpegResources();
 }

media/filters/ffmpeg_video_decoder.h

@@ -22,7 +22,8 @@ class DecoderBuffer;
 
 class MEDIA_EXPORT FFmpegVideoDecoder : public VideoDecoder {
  public:
-  FFmpegVideoDecoder(const base::Callback<MessageLoop*()>& message_loop_cb);
+  FFmpegVideoDecoder(const base::Callback<MessageLoop*()>& message_loop_cb,
+                     Decryptor* decryptor);
 
   // VideoDecoder implementation.
   virtual void Initialize(const scoped_refptr<DemuxerStream>& stream,
@@ -32,10 +33,6 @@ class MEDIA_EXPORT FFmpegVideoDecoder : public VideoDecoder {
   virtual void Reset(const base::Closure& closure) OVERRIDE;
   virtual void Stop(const base::Closure& closure) OVERRIDE;
 
-  // Must be called prior to initialization if decrypted buffers will be
-  // encountered.
-  void set_decryptor(Decryptor* decryptor);
-
   // Callback called from within FFmpeg to allocate a buffer based on
   // the dimensions of |codec_context|. See AVCodecContext.get_buffer
   // documentation inside FFmpeg.

media/filters/ffmpeg_video_decoder_unittest.cc

@@ -71,14 +71,15 @@ class FFmpegVideoDecoderTest : public testing::Test {
  public:
   FFmpegVideoDecoderTest()
       : decryptor_(new MockDecryptor()),
-        decoder_(new FFmpegVideoDecoder(base::Bind(&Identity<MessageLoop*>,
-                                                   &message_loop_))),
+        decoder_(NULL),
         demuxer_(new StrictMock<MockDemuxerStream>()),
         read_cb_(base::Bind(&FFmpegVideoDecoderTest::FrameReady,
                             base::Unretained(this))) {
     CHECK(FFmpegGlue::GetInstance());
 
-    decoder_->set_decryptor(decryptor_.get());
+    decoder_ = new FFmpegVideoDecoder(base::Bind(&Identity<MessageLoop*>,
+                                                 &message_loop_),
+                                      decryptor_.get());
 
     // Initialize various test buffers.
     frame_buffer_.reset(new uint8[kCodedSize.GetArea()]);

media/filters/pipeline_integration_test.cc

@@ -185,13 +185,11 @@ class PipelineIntegrationTest
  public:
   void StartPipelineWithMediaSource(MockMediaSource* source) {
     pipeline_->Start(
-        CreateFilterCollection(source),
+        CreateFilterCollection(source, NULL),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         QuitOnStatusCB(PIPELINE_OK));
 
-    ASSERT_TRUE(decoder_.get());
-
     message_loop_.Run();
   }
 
@@ -199,13 +197,11 @@ class PipelineIntegrationTest
       MockMediaSource* source,
       FakeDecryptorClient* encrypted_media) {
     pipeline_->Start(
-        CreateFilterCollection(source),
+        CreateFilterCollection(source, encrypted_media->decryptor()),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         QuitOnStatusCB(PIPELINE_OK));
 
-    ASSERT_TRUE(decoder_.get());
-    decoder_->set_decryptor(encrypted_media->decryptor());
     source->set_decryptor_client(encrypted_media);
 
     message_loop_.Run();

media/filters/pipeline_integration_test_base.cc

@@ -171,29 +171,33 @@ scoped_ptr<FilterCollection>
 PipelineIntegrationTestBase::CreateFilterCollection(const std::string& url) {
   scoped_refptr<FileDataSource> data_source = new FileDataSource();
   CHECK(data_source->Initialize(url));
-  return CreateFilterCollection(new FFmpegDemuxer(&message_loop_, data_source));
+  return CreateFilterCollection(new FFmpegDemuxer(&message_loop_, data_source),
+                                NULL);
 }
 
 scoped_ptr<FilterCollection>
 PipelineIntegrationTestBase::CreateFilterCollection(
-    ChunkDemuxerClient* client) {
-  return CreateFilterCollection(new ChunkDemuxer(client));
+    ChunkDemuxerClient* client,
+    Decryptor* decryptor) {
+  return CreateFilterCollection(new ChunkDemuxer(client), decryptor);
 }
 
 scoped_ptr<FilterCollection>
 PipelineIntegrationTestBase::CreateFilterCollection(
-    const scoped_refptr<Demuxer>& demuxer) {
+    const scoped_refptr<Demuxer>& demuxer,
+    Decryptor* decryptor) {
   scoped_ptr<FilterCollection> collection(new FilterCollection());
   collection->SetDemuxer(demuxer);
   collection->AddAudioDecoder(new FFmpegAudioDecoder(
       base::Bind(&MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory_.get()),
                  "AudioDecoderThread")));
-  decoder_ = new FFmpegVideoDecoder(
+  scoped_refptr<VideoDecoder> decoder = new FFmpegVideoDecoder(
       base::Bind(&MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory_.get()),
-                 "VideoDecoderThread"));
-  collection->AddVideoDecoder(decoder_);
+                 "VideoDecoderThread"),
+      decryptor);
+  collection->AddVideoDecoder(decoder);
   // Disable frame dropping if hashing is enabled.
   renderer_ = new VideoRendererBase(
       base::Bind(&PipelineIntegrationTestBase::OnVideoRendererPaint,

media/filters/pipeline_integration_test_base.h

@@ -12,12 +12,13 @@
 #include "media/base/message_loop_factory.h"
 #include "media/base/pipeline.h"
 #include "media/filters/chunk_demuxer.h"
-#include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/video_renderer_base.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 
+class Decryptor;
+
 // Empty MD5 hash string.  Used to verify empty audio or video tracks.
 extern const char kNullHash[];
 
@@ -53,7 +54,7 @@ class PipelineIntegrationTestBase {
   bool WaitUntilCurrentTimeIsAfter(const base::TimeDelta& wait_time);
   scoped_ptr<FilterCollection> CreateFilterCollection(const std::string& url);
   scoped_ptr<FilterCollection> CreateFilterCollection(
-      ChunkDemuxerClient* client);
+      ChunkDemuxerClient* client, Decryptor* decryptor);
 
   // Returns the MD5 hash of all video frames seen.  Should only be called once
   // after playback completes.  First time hashes should be generated with
@@ -72,7 +73,6 @@ class PipelineIntegrationTestBase {
   bool hashing_enabled_;
   scoped_ptr<MessageLoopFactory> message_loop_factory_;
   scoped_refptr<Pipeline> pipeline_;
-  scoped_refptr<FFmpegVideoDecoder> decoder_;
   scoped_refptr<VideoRendererBase> renderer_;
   scoped_refptr<NullAudioSink> audio_sink_;
   bool ended_;
@@ -86,7 +86,7 @@ class PipelineIntegrationTestBase {
   void OnError(PipelineStatus status);
   void QuitAfterCurrentTimeTask(const base::TimeDelta& quit_time);
   scoped_ptr<FilterCollection> CreateFilterCollection(
-      const scoped_refptr<Demuxer>& demuxer);
+      const scoped_refptr<Demuxer>& demuxer, Decryptor* decryptor);
   void OnVideoRendererPaint();
 
   MOCK_METHOD1(OnSetOpaque, void(bool));

media/tools/player_wtl/movie.cc

@@ -80,7 +80,8 @@ bool Movie::Open(const wchar_t* url, VideoRendererBase* video_renderer) {
   collection->AddVideoDecoder(new FFmpegVideoDecoder(
       base::Bind(&MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory_.get()),
-                 "VideoDecoderThread")));
+                 "VideoDecoderThread"),
+      NULL));
 
   // TODO(vrk): Re-enabled audio. (crbug.com/112159)
   collection->AddAudioRenderer(

media/tools/player_x11/player_x11.cc

@@ -122,7 +122,8 @@ bool InitPipeline(MessageLoop* message_loop,
   collection->AddVideoDecoder(new media::FFmpegVideoDecoder(
       base::Bind(&media::MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory),
-                 "VideoDecoderThread")));
+                 "VideoDecoderThread"),
+      NULL));
 
   // Create our video renderer and save a reference to it for painting.
   g_video_renderer = new media::VideoRendererBase(

webkit/media/filter_helpers.cc

@@ -21,18 +21,19 @@ namespace webkit_media {
 static void AddDefaultDecodersToCollection(
     media::MessageLoopFactory* message_loop_factory,
     media::FilterCollection* filter_collection,
-    media::Decryptor* decryptor,
-    scoped_refptr<media::FFmpegVideoDecoder>* ffmpeg_video_decoder) {
+    media::Decryptor* decryptor) {
   filter_collection->AddAudioDecoder(new media::FFmpegAudioDecoder(
       base::Bind(&media::MessageLoopFactory::GetMessageLoop,
                  base::Unretained(message_loop_factory),
                  "AudioDecoderThread")));
-  *ffmpeg_video_decoder = new media::FFmpegVideoDecoder(
-      base::Bind(&media::MessageLoopFactory::GetMessageLoop,
-                 base::Unretained(message_loop_factory),
-                 "VideoDecoderThread"));
-  (*ffmpeg_video_decoder)->set_decryptor(decryptor);
-  filter_collection->AddVideoDecoder(*ffmpeg_video_decoder);
+
+  scoped_refptr<media::FFmpegVideoDecoder> ffmpeg_video_decoder =
+      new media::FFmpegVideoDecoder(
+          base::Bind(&media::MessageLoopFactory::GetMessageLoop,
+                     base::Unretained(message_loop_factory),
+                     "VideoDecoderThread"),
+          decryptor);
+  filter_collection->AddVideoDecoder(ffmpeg_video_decoder);
 }
 
 bool BuildMediaStreamCollection(const WebKit::WebURL& url,
@@ -69,15 +70,14 @@ bool BuildMediaSourceCollection(
     media::ChunkDemuxerClient* client,
     media::MessageLoopFactory* message_loop_factory,
     media::FilterCollection* filter_collection,
-    media::Decryptor* decryptor,
-    scoped_refptr<media::FFmpegVideoDecoder>* video_decoder) {
+    media::Decryptor* decryptor) {
   if (media_source_url.isEmpty() || url != media_source_url)
     return false;
 
   filter_collection->SetDemuxer(new media::ChunkDemuxer(client));
 
   AddDefaultDecodersToCollection(message_loop_factory, filter_collection,
-                                 decryptor, video_decoder);
+                                 decryptor);
   return true;
 }
 
@@ -85,14 +85,13 @@ void BuildDefaultCollection(
     const scoped_refptr<media::DataSource>& data_source,
     media::MessageLoopFactory* message_loop_factory,
     media::FilterCollection* filter_collection,
-    media::Decryptor* decryptor,
-    scoped_refptr<media::FFmpegVideoDecoder>* video_decoder) {
+    media::Decryptor* decryptor) {
   filter_collection->SetDemuxer(new media::FFmpegDemuxer(
       message_loop_factory->GetMessageLoop("PipelineThread"),
       data_source));
 
   AddDefaultDecodersToCollection(message_loop_factory, filter_collection,
-                                 decryptor, video_decoder);
+                                 decryptor);
 }
 
 }  // webkit_media

webkit/media/filter_helpers.h

@@ -44,8 +44,7 @@ bool BuildMediaSourceCollection(
     media::ChunkDemuxerClient* client,
     media::MessageLoopFactory* message_loop_factory,
     media::FilterCollection* filter_collection,
-    media::Decryptor* decryptor,
-    scoped_refptr<media::FFmpegVideoDecoder>* video_decoder);
+    media::Decryptor* decryptor);
 
 // Builds the required filters for handling regular URLs and adds them to
 // |filter_collection| and fills |video_decoder| returning true if successful.
@@ -53,8 +52,7 @@ void BuildDefaultCollection(
     const scoped_refptr<media::DataSource>& data_source,
     media::MessageLoopFactory* message_loop_factory,
     media::FilterCollection* filter_collection,
-    media::Decryptor* decryptor,
-    scoped_refptr<media::FFmpegVideoDecoder>* video_decoder);
+    media::Decryptor* decryptor);
 
 }  // webkit_media
 

webkit/media/webmediaplayer_impl.cc

@@ -241,13 +241,10 @@ void WebMediaPlayerImpl::load(const WebKit::WebURL& url, CORSMode cors_mode) {
   }
 
   // Media source pipelines can start immediately.
-  scoped_refptr<media::FFmpegVideoDecoder> video_decoder;
   if (BuildMediaSourceCollection(url, GetClient()->sourceURL(), proxy_,
                                  message_loop_factory_.get(),
                                  filter_collection_.get(),
-                                 &decryptor_,
-                                 &video_decoder)) {
-    proxy_->set_video_decoder(video_decoder);
+                                 &decryptor_)) {
     StartPipeline();
     return;
   }
@@ -268,9 +265,7 @@ void WebMediaPlayerImpl::load(const WebKit::WebURL& url, CORSMode cors_mode) {
   BuildDefaultCollection(proxy_->data_source(),
                          message_loop_factory_.get(),
                          filter_collection_.get(),
-                         &decryptor_,
-                         &video_decoder);
-  proxy_->set_video_decoder(video_decoder);
+                         &decryptor_);
 }
 
 void WebMediaPlayerImpl::cancelLoad() {

webkit/media/webmediaplayer_proxy.cc

@@ -87,7 +87,6 @@ void WebMediaPlayerProxy::Detach() {
   webmediaplayer_ = NULL;
   data_source_ = NULL;
   frame_provider_ = NULL;
-  video_decoder_ = NULL;
 }
 
 void WebMediaPlayerProxy::PipelineInitializationCallback(

webkit/media/webmediaplayer_proxy.h

@@ -60,11 +60,6 @@ class WebMediaPlayerProxy
     frame_provider_ = frame_provider;
   }
 
-  void set_video_decoder(
-      const scoped_refptr<media::FFmpegVideoDecoder>& video_decoder) {
-    video_decoder_ = video_decoder;
-  }
-
   // Methods for Filter -> WebMediaPlayerImpl communication.
   void Repaint();
   void SetOpaque(bool opaque);
@@ -177,7 +172,6 @@ class WebMediaPlayerProxy
   scoped_refptr<BufferedDataSource> data_source_;
   scoped_refptr<media::VideoRendererBase> frame_provider_;
   SkCanvasVideoRenderer video_renderer_;
-  scoped_refptr<media::FFmpegVideoDecoder> video_decoder_;
 
   base::Lock lock_;
   int outstanding_repaints_;