Remove the AudioManager singleton.

media/audio/audio_output_controller.h

 // 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.
 
 #ifndef MEDIA_AUDIO_AUDIO_OUTPUT_CONTROLLER_H_
 #define MEDIA_AUDIO_AUDIO_OUTPUT_CONTROLLER_H_
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/time.h"
 #include "media/audio/audio_buffers_state.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/simple_sources.h"
 
 class MessageLoop;
 
 // An AudioOutputController controls an AudioOutputStream and provides data
 // to this output stream. It has an important function that it executes
 // audio operations like play, pause, stop, etc. on a separate thread,
 // namely the audio controller thread.
 //
-// All the public methods of AudioOutputController are non-blocking except
-// close, the actual operations are performed on the audio controller thread.
+// All the public methods of AudioOutputController are non-blocking.
+// The actual operations are performed on the audio thread.
 //
 // Here is a state diagram for the AudioOutputController for default low
 // latency mode; in normal latency mode there is no "starting" or "paused when
 // starting" states, "created" immediately switches to "playing":
 //
 //             .----------------------->  [ Closed / Error ]  <------.
 //             |                                   ^                 |
 //             |                                   |                 |
 //        [ Created ]  -->  [ Starting ]  -->  [ Playing ]  -->  [ Paused ]
 //             ^                 |                 ^                |  ^
 //             |                 |                 |                |  |
 //             |                 |                 `----------------'  |
 //             |                 V                                     |
 //             |        [ PausedWhenStarting ] ------------------------'
 //             |
 //       *[  Empty  ]
 //
 // * Initial state
 //
 // There are two modes of buffering operations supported by this class.
 //
 // Regular latency mode:
 //   In this mode we receive signals from AudioOutputController and then we
 //   enqueue data into it.
 //
 // Low latency mode:
 //   In this mode a DataSource object is given to the AudioOutputController
 //   and AudioOutputController reads from it synchronously.
 //
+// The audio thread itself is owned by the AudioManager that the
+// AudioOutputController holds a reference to.  When performing tasks on the
+// audio thread, the controller must not add or release references to the
+// AudioManager or itself (since it in turn holds a reference to the manager),
+// for delayed tasks as it can slow down or even prevent normal shut down.
+// So, for tasks on the audio thread, the controller uses WeakPtr which enables
+// us to safely cancel pending polling tasks.
+// The owner of the audio thread, AudioManager, will take care of properly
+// shutting it down.
+//
 #include "media/base/media_export.h"
 
 namespace media {
 
 class MEDIA_EXPORT AudioOutputController
     : public base::RefCountedThreadSafe<AudioOutputController>,
       public AudioOutputStream::AudioSourceCallback {
  public:
   // Value sent by the controller to the renderer in low-latency mode
   // indicating that the stream is paused.
@@ skipping 42 matching lines @@
     virtual bool DataReady() = 0;
   };
 
   virtual ~AudioOutputController();
 
   // Factory method for creating an AudioOutputController.
   // If successful, an audio controller thread is created. The audio device
   // will be created on the audio controller thread and when that is done
   // event handler will receive a OnCreated() call.
   static scoped_refptr<AudioOutputController> Create(
+      AudioManager* audio_manager,
       EventHandler* event_handler,
       const AudioParameters& params,
       // Soft limit for buffer capacity in this controller. This parameter
       // is used only in regular latency mode.
       uint32 buffer_capacity);
 
   // Factory method for creating a low latency audio stream.
   static scoped_refptr<AudioOutputController> CreateLowLatency(
+      AudioManager* audio_manager,
       EventHandler* event_handler,
       const AudioParameters& params,
       // External synchronous reader for audio controller.
       SyncReader* sync_reader);
 
   // Methods to control playback of the stream.
 
   // Starts the playback of this audio output stream.
   void Play();
 
@@ skipping 43 matching lines @@
     kPaused,
     kClosed,
     kError,
   };
 
  private:
   // We are polling sync reader if data became available.
   static const int kPollNumAttempts;
   static const int kPollPauseInMilliseconds;
 
-  AudioOutputController(EventHandler* handler,
+  AudioOutputController(AudioManager* audio_manager,
+                        EventHandler* handler,
                         uint32 capacity, SyncReader* sync_reader);
 
   // The following methods are executed on the audio controller thread.
   void DoCreate(const AudioParameters& params);
   void DoPlay();
   void PollAndStartIfDataReady();
   void DoPause();
   void DoFlush();
   void DoClose(const base::Closure& closed_task);
   void DoSetVolume(double volume);
   void DoReportError(int code);
 
   // Helper method to submit a OnMoreData() call to the event handler.
   void SubmitOnMoreData_Locked();
 
   // Helper method that starts physical stream.
   void StartStream();
 
   // Helper method that stops, closes, and NULLs |*stream_|.
   void StopCloseAndClearStream();
 
+  scoped_refptr<AudioManager> audio_manager_;
   // |handler_| may be called only if |state_| is not kClosed.
   EventHandler* handler_;
   AudioOutputStream* stream_;
 
   // The current volume of the audio stream.
   double volume_;
 
   // |state_| is written on the audio controller thread and is read on the
   // hardware audio thread. These operations need to be locked. But lock
   // is not required for reading on the audio controller thread.
@@ skipping 11 matching lines @@
   // SyncReader is used only in low latency mode for synchronous reading.
   SyncReader* sync_reader_;
 
   // The message loop of audio thread that this object runs on.
   MessageLoop* message_loop_;
 
   // When starting stream we wait for data to become available.
   // Number of times left.
   int number_polling_attempts_left_;
 
+  // Used to post delayed tasks to ourselves that we can cancel.
+  // We don't want the tasks to hold onto a reference as it will slow down
+  // shutdown and force it to wait for the most delayed task.
+  // Also, if we're shutting down, we do not want to poll for more data.
+  base::WeakPtrFactory<AudioOutputController> weak_this_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioOutputController);
 };
 
 }  // namespace media
 
-#endif  //  MEDIA_AUDIO_AUDIO_OUTPUT_CONTROLLER_H_
+#endif  // MEDIA_AUDIO_AUDIO_OUTPUT_CONTROLLER_H_