Remove the AudioManager singleton.

media/tools/player_x11/player_x11.cc

 // Copyright (c) 2011 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 <iostream>
-#include <signal.h>
 #include <X11/keysym.h>
 #include <X11/Xlib.h>
+#include <signal.h>
+
+#include <iostream>  // NOLINT
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
+#include "media/audio/audio_manager.h"
 #include "media/base/filter_collection.h"
 #include "media/base/media.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/message_loop_factory_impl.h"
 #include "media/base/pipeline_impl.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_demuxer_factory.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/file_data_source_factory.h"
 #include "media/filters/null_audio_renderer.h"
 #include "media/filters/reference_audio_renderer.h"
 #include "media/tools/player_x11/gl_video_renderer.h"
 #include "media/tools/player_x11/x11_video_renderer.h"
 
 static Display* g_display = NULL;
 static Window g_window = 0;
 static bool g_running = false;
 
+AudioManager* g_audio_manager = NULL;
+
 class MessageLoopQuitter {
  public:
   explicit MessageLoopQuitter(MessageLoop* loop) : loop_(loop) {}
   void Quit(media::PipelineStatus status) {
     loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
     delete this;
   }
  private:
   MessageLoop* loop_;
   DISALLOW_COPY_AND_ASSIGN(MessageLoopQuitter);
@@ skipping 49 matching lines @@
       message_loop_factory->GetMessageLoop("VideoDecoderThread")));
 
   if (use_gl) {
     collection->AddVideoRenderer(
         new GlVideoRenderer(g_display, g_window, paint_message_loop));
   } else {
     collection->AddVideoRenderer(
         new X11VideoRenderer(g_display, g_window, paint_message_loop));
   }
 
-  if (enable_audio)
-    collection->AddAudioRenderer(new media::ReferenceAudioRenderer());
-  else
+  if (enable_audio) {
+    collection->AddAudioRenderer(
+        new media::ReferenceAudioRenderer(g_audio_manager));
+  } else {
     collection->AddAudioRenderer(new media::NullAudioRenderer());
+  }
 
   // Create the pipeline and start it.
   *pipeline = new media::PipelineImpl(message_loop, new media::MediaLog());
   media::PipelineStatusNotification note;
   (*pipeline)->Start(collection.release(), filename, note.Callback());
 
   // Wait until the pipeline is fully initialized.
   note.Wait();
   if (note.status() != media::PIPELINE_OK) {
     std::cout << "InitPipeline: " << note.status() << std::endl;
@@ skipping 50 matching lines @@
         {
           KeySym key = XKeycodeToKeysym(g_display, e.xkey.keycode, 0);
           if (key == XK_Escape) {
             g_running = false;
             // Quit message_loop only when pipeline is fully stopped.
             MessageLoopQuitter* quitter = new MessageLoopQuitter(message_loop);
             pipeline->Stop(base::Bind(&MessageLoopQuitter::Quit,
                                       base::Unretained(quitter)));
             return;
           } else if (key == XK_space) {
-            if (pipeline->GetPlaybackRate() < 0.01f) // paused
+            if (pipeline->GetPlaybackRate() < 0.01f)  // paused
               pipeline->SetPlaybackRate(1.0f);
             else
               pipeline->SetPlaybackRate(0.0f);
           }
         }
         break;
       default:
         break;
     }
   }
 
   message_loop->PostDelayedTask(FROM_HERE, base::Bind(
       &PeriodicalUpdate, make_scoped_refptr(pipeline),
       message_loop, audio_only), 10);
 }
 
 int main(int argc, char** argv) {
+  scoped_refptr<AudioManager> audio_manager(AudioManager::Create());
+  g_audio_manager = audio_manager;
+
   // Read arguments.
   if (argc == 1) {
     std::cout << "Usage: " << argv[0] << " --file=FILE" << std::endl
               << std::endl
               << "Optional arguments:" << std::endl
               << "  [--audio]"
               << "  [--alsa-device=DEVICE]"
               << "  [--use-gl]" << std::endl
               << " Press [ESC] to stop" << std::endl
               << " Press [SPACE] to toggle pause/play" << std::endl
@@ skipping 38 matching lines @@
                    message_loop_factory.get())) {
     // Main loop of the application.
     g_running = true;
 
     // Check if video is present.
     audio_only = !pipeline->HasVideo();
 
     message_loop.PostTask(FROM_HERE, base::Bind(
         &PeriodicalUpdate, pipeline, &message_loop, audio_only));
     message_loop.Run();
-  } else{
+  } else {
     std::cout << "Pipeline initialization failed..." << std::endl;
   }
 
   // Cleanup tasks.
   message_loop_factory.reset();
 
   thread->Stop();
   XDestroyWindow(g_display, g_window);
   XCloseDisplay(g_display);
+  g_audio_manager = NULL;
+
   return 0;
 }