Reland "media: Refactor MojoMediaClient" with fix.

media/mojo/services/default_mojo_media_client.cc

Index: media/mojo/services/default_mojo_media_client.cc
diff --git a/media/mojo/services/default_mojo_media_client.cc b/media/mojo/services/default_mojo_media_client.cc
index 4facbd1d88aa055325a977682b496125bf269cc1..c602f643bd659e5fafb906e59dfd69d0004f27cd 100644
--- a/media/mojo/services/default_mojo_media_client.cc
+++ b/media/mojo/services/default_mojo_media_client.cc
@@ -2,13 +2,10 @@
 // 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 "media/mojo/services/default_mojo_media_client.h"
 
-#include "base/macros.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/audio_hardware_config.h"
 #include "media/base/media.h"
 #include "media/base/null_video_sink.h"
@@ -18,72 +15,55 @@
 
 namespace media {
 
-namespace {
-class DefaultMojoMediaClient : public MojoMediaClient {
- public:
-  DefaultMojoMediaClient() {}
-
-  // MojoMediaClient overrides.
-  void Initialize() override {
-    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> CreateRendererFactory(
-      const scoped_refptr<MediaLog>& media_log) override {
-    return make_scoped_ptr(new DefaultRendererFactory(media_log, nullptr,
-                                                      *audio_hardware_config_));
-  }
-
-  AudioRendererSink* CreateAudioRendererSink() override {
-    if (!audio_renderer_sink_)
-      audio_renderer_sink_ = new AudioOutputStreamSink();
+DefaultMojoMediaClient::DefaultMojoMediaClient() {}
+
+DefaultMojoMediaClient::~DefaultMojoMediaClient() {}
+
+void DefaultMojoMediaClient::Initialize() {
+  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()));
+}
 
-    return audio_renderer_sink_.get();
-  }
+scoped_ptr<RendererFactory> DefaultMojoMediaClient::CreateRendererFactory(
+    const scoped_refptr<MediaLog>& media_log) {
+  return make_scoped_ptr(
+      new DefaultRendererFactory(media_log, nullptr, *audio_hardware_config_));
+}
 
-  VideoRendererSink* CreateVideoRendererSink(
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) override {
-    if (!video_renderer_sink_) {
-      video_renderer_sink_ = make_scoped_ptr(
-          new NullVideoSink(false, base::TimeDelta::FromSecondsD(1.0 / 60),
-                            NullVideoSink::NewFrameCB(), task_runner));
-    }
+AudioRendererSink* DefaultMojoMediaClient::CreateAudioRendererSink() {
+  if (!audio_renderer_sink_)
+    audio_renderer_sink_ = new AudioOutputStreamSink();
 
-    return video_renderer_sink_.get();
-  }
+  return audio_renderer_sink_.get();
+}
 
-  scoped_ptr<CdmFactory> CreateCdmFactory(
-      mojo::shell::mojom::InterfaceProvider* /* service_provider */) override {
-    return make_scoped_ptr(new DefaultCdmFactory());
+VideoRendererSink* DefaultMojoMediaClient::CreateVideoRendererSink(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+  if (!video_renderer_sink_) {
+    video_renderer_sink_ = make_scoped_ptr(
+        new NullVideoSink(false, base::TimeDelta::FromSecondsD(1.0 / 60),
+                          NullVideoSink::NewFrameCB(), task_runner));
   }
 
- private:
-  FakeAudioLogFactory fake_audio_log_factory_;
-  scoped_ptr<AudioHardwareConfig> audio_hardware_config_;
-  scoped_refptr<AudioRendererSink> audio_renderer_sink_;
-  scoped_ptr<VideoRendererSink> video_renderer_sink_;
-
-  DISALLOW_COPY_AND_ASSIGN(DefaultMojoMediaClient);
-};
-
-}  // namespace (anonymous)
+  return video_renderer_sink_.get();
+}
 
-scoped_ptr<MojoMediaClient> MojoMediaClient::Create() {
-  return make_scoped_ptr(new DefaultMojoMediaClient());
+scoped_ptr<CdmFactory> DefaultMojoMediaClient::CreateCdmFactory(
+    mojo::shell::mojom::InterfaceProvider* /* service_provider */) {
+  return make_scoped_ptr(new DefaultCdmFactory());
 }
 
 }  // namespace media