media: Support RendererFactory in MojoMediaClient.

media/mojo/services/default_mojo_media_client.cc

 // Copyright 2014 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/mojo/services/mojo_media_client.h"
 
-#include "base/files/file_path.h"
-#include "base/path_service.h"
+#include "base/memory/scoped_ptr.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/audio_output_stream_sink.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/base/media.h"
 #include "media/base/null_video_sink.h"
-#include "media/filters/opus_audio_decoder.h"
-
-#if !defined(MEDIA_DISABLE_FFMPEG)
-#include "media/filters/ffmpeg_audio_decoder.h"
-#include "media/filters/ffmpeg_video_decoder.h"
-#endif
-
-#if !defined(MEDIA_DISABLE_LIBVPX)
-#include "media/filters/vpx_video_decoder.h"
-#endif
+#include "media/renderers/default_renderer_factory.h"
+#include "media/renderers/gpu_video_accelerator_factories.h"
 
 namespace media {
 namespace internal {
 
 class DefaultMojoMediaClient : public PlatformMojoMediaClient {
  public:
   DefaultMojoMediaClient() {
     InitializeMediaLibrary();
 
     // TODO(dalecurtis): We should find a single owner per process for the audio
     // manager or make it a lazy instance.  It's not safe to call Get()/Create()
     // across multiple threads...
     //
     // TODO(dalecurtis): Eventually we'll want something other than a fake audio
     // log factory here too.  We should probably at least DVLOG() such info.
     AudioManager* audio_manager = AudioManager::Get();
     if (!audio_manager)
       audio_manager = media::AudioManager::Create(&fake_audio_log_factory_);
 
     audio_hardware_config_.reset(new AudioHardwareConfig(
         audio_manager->GetInputStreamParameters(
             AudioManagerBase::kDefaultDeviceId),
         audio_manager->GetDefaultOutputStreamParameters()));
   }
 
+  scoped_ptr<RendererFactory> GetRendererFactory(
+      const scoped_refptr<MediaLog>& media_log) override {
+    return make_scoped_ptr(new DefaultRendererFactory(media_log, nullptr,
+                                                      *audio_hardware_config_));
+  }
+
   ScopedVector<AudioDecoder> GetAudioDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
-      const LogCB& media_log_cb) override {
-    ScopedVector<AudioDecoder> audio_decoders;
-
-#if !defined(MEDIA_DISABLE_FFMPEG)
-    audio_decoders.push_back(
-        new FFmpegAudioDecoder(media_task_runner, media_log_cb));
-    audio_decoders.push_back(new OpusAudioDecoder(media_task_runner));
-#endif
-
-    return audio_decoders.Pass();
+      const scoped_refptr<MediaLog>& media_log) override {
+    NOTREACHED();
+    return ScopedVector<AudioDecoder>();
   }
 
   ScopedVector<VideoDecoder> GetVideoDecoders(
       const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
-      const LogCB& media_log_cb) override {
-    ScopedVector<VideoDecoder> video_decoders;
-
-    // TODO(dalecurtis): If we ever need GPU video decoders, we'll need to
-    // figure out how to retrieve the GpuVideoAcceleratorFactories...
-
-#if !defined(MEDIA_DISABLE_LIBVPX)
-    video_decoders.push_back(new VpxVideoDecoder(media_task_runner));
-#endif
-
-#if !defined(MEDIA_DISABLE_FFMPEG)
-    video_decoders.push_back(new FFmpegVideoDecoder(media_task_runner));
-#endif
-
-    return video_decoders.Pass();
+      const scoped_refptr<MediaLog>& media_log) override {
+    NOTREACHED();
+    return ScopedVector<VideoDecoder>();
   }
 
   scoped_refptr<AudioRendererSink> GetAudioRendererSink() override {
     return new AudioOutputStreamSink();
   }
 
   scoped_ptr<VideoRendererSink> GetVideoRendererSink(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) override {
     return make_scoped_ptr(
         new NullVideoSink(false, base::TimeDelta::FromSecondsD(1.0 / 60),
@@ skipping 10 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DefaultMojoMediaClient);
 };
 
 scoped_ptr<PlatformMojoMediaClient> CreatePlatformMojoMediaClient() {
   return make_scoped_ptr(new DefaultMojoMediaClient());
 }
 
 }  // namespace internal
 }  // namespace media