Introduce media::RendererFactory interface.

media/filters/default_renderer_factory.cc

Index: media/filters/default_renderer_factory.cc
diff --git a/media/filters/default_renderer_factory.cc b/media/filters/default_renderer_factory.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3754e1c0aa058a72d7784b330884bd673ed3b809
--- /dev/null
+++ b/media/filters/default_renderer_factory.cc
@@ -0,0 +1,93 @@
+// 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/filters/default_renderer_factory.h"
+
+#include "base/bind.h"
+#include "base/single_thread_task_runner.h"
+#include "media/filters/audio_renderer_impl.h"
+#include "media/filters/ffmpeg_audio_decoder.h"
+#include "media/filters/ffmpeg_video_decoder.h"
+#include "media/filters/gpu_video_accelerator_factories.h"
+#include "media/filters/gpu_video_decoder.h"
+#include "media/filters/opus_audio_decoder.h"
+#include "media/filters/renderer_impl.h"
+#include "media/filters/video_renderer_impl.h"
+#include "media/filters/vpx_video_decoder.h"
+
+namespace media {
+
+// TODO(xhwang): We are abusing CreateMediaSourceErrorEvent() in a lot of places

[DaleCurtis, 2014/12/08 22:12:09]

+1 ... though MSE abuses it to report things that aren't errors too :|

[xhwang, 2014/12/08 23:44:09]

Acknowledged.

+// that are not MediaSource related. Fix this in a separate CL.
+static void LogError(const scoped_refptr<MediaLog>& media_log,
+                     const std::string& error) {
+  media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
+}
+
+DefaultRendererFactory::DefaultRendererFactory(
+    const ExternalRendererCreationCB& external_renderer_creation_cb,
+    const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+    const scoped_refptr<MediaLog>& media_log,
+    const scoped_refptr<GpuVideoAcceleratorFactories>& gpu_factories,
+    const AudioHardwareConfig& audio_hardware_config)
+    : external_renderer_creation_cb_(external_renderer_creation_cb),
+      media_task_runner_(media_task_runner),
+      media_log_(media_log),
+      gpu_factories_(gpu_factories),
+      audio_hardware_config_(audio_hardware_config) {
+}
+
+DefaultRendererFactory::~DefaultRendererFactory() {
+}
+
+scoped_ptr<Renderer> DefaultRendererFactory::CreateRenderer(
+    AudioRendererSink* audio_renderer_sink) {

[DaleCurtis, 2014/12/08 22:12:09]

Probably the sink could be created in the RenderFrame too and dropped from the
WebMediaPlayerParams if you like; there may be some typing issues around
AudioRendererSink vs AudioSourceProvider though...

[xhwang, 2014/12/08 23:44:09]

Actually I like to pass the AudioRendererSink in so that the media::Renderer can
use it to render audio. But we may do this in init time, as we does for
paint_cb. I'd keep it as is and see how it goes...

+  LOG(ERROR) << __FUNCTION__;

[DaleCurtis, 2014/12/08 22:12:09]

DVLOG() ?

[xhwang, 2014/12/08 23:44:09]

oops, debug code that I forgot to remove :) removed.

+  DCHECK(audio_renderer_sink);
+
+  if (!external_renderer_creation_cb_.is_null()) {
+    scoped_ptr<Renderer> renderer =
+        external_renderer_creation_cb_.Run(media_task_runner_);
+    if (renderer.get())
+      return renderer.Pass();
+  }
+
+  // Create our audio decoders and renderer.
+  ScopedVector<AudioDecoder> audio_decoders;
+
+  audio_decoders.push_back(new FFmpegAudioDecoder(
+      media_task_runner_, base::Bind(&LogError, media_log_)));
+  audio_decoders.push_back(new OpusAudioDecoder(media_task_runner_));
+
+  scoped_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
+      media_task_runner_, audio_renderer_sink, audio_decoders.Pass(),
+      audio_hardware_config_, media_log_));
+
+  // Create our video decoders and renderer.
+  ScopedVector<VideoDecoder> video_decoders;
+
+  // |gpu_factories_| requires that its entry points be called on its
+  // |GetTaskRunner()|.  Since |pipeline_| will own decoders created from the
+  // factories, require that their message loops are identical.
+  DCHECK(!gpu_factories_.get() ||
+         (gpu_factories_->GetTaskRunner() == media_task_runner_.get()));
+
+  if (gpu_factories_.get())
+    video_decoders.push_back(new GpuVideoDecoder(gpu_factories_));
+
+#if !defined(MEDIA_DISABLE_LIBVPX)
+  video_decoders.push_back(new VpxVideoDecoder(media_task_runner_));
+#endif  // !defined(MEDIA_DISABLE_LIBVPX)
+
+  video_decoders.push_back(new FFmpegVideoDecoder(media_task_runner_));
+
+  scoped_ptr<VideoRenderer> video_renderer(new VideoRendererImpl(
+      media_task_runner_, video_decoders.Pass(), true, media_log_));
+
+  // Create renderer.
+  return scoped_ptr<Renderer>(new RendererImpl(
+      media_task_runner_, audio_renderer.Pass(), video_renderer.Pass()));
+}
+
+}  // namespace media