Adds method to provide custom AudioManager at runtime.

media/audio/audio_manager.h

 // Copyright (c) 2012 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_MANAGER_H_
 #define MEDIA_AUDIO_AUDIO_MANAGER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string16.h"
 #include "media/audio/audio_device_name.h"
 #include "media/audio/audio_logging.h"
 #include "media/audio/audio_parameters.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace media {
 
 class AudioInputStream;
+class AudioManagerFactory;
 class AudioOutputStream;
 
 // Manages all audio resources.  Provides some convenience functions that avoid
 // the need to provide iterators over the existing streams.
 class MEDIA_EXPORT AudioManager {
-  public:
-   virtual ~AudioManager();
+ public:
+  virtual ~AudioManager();
+
+  // This provides an alternative to the statically linked factory method used
+  // to create AudioManager. This is useful for dynamically-linked third
+  // party clients seeking to provide a platform-specific implementation of
+  // AudioManager. After this is called, all static AudioManager::Create*
+  // methods will return an instance of AudioManager provided by |factory|. This
+  // call may be made at most once per process, and before any calls to static
+  // AudioManager::Create* methods. This method takes ownership of |factory|,
+  // which must not be NULL.
+  static void SetFactory(AudioManagerFactory* factory);
 
   // Construct the audio manager; only one instance is allowed.  The manager
   // will forward CreateAudioLog() calls to the provided AudioLogFactory; as
   // such |audio_log_factory| must outlive the AudioManager.
   static AudioManager* Create(AudioLogFactory* audio_log_factory);
 
   // Similar to Create() except also schedules a monitor on the given task
   // runner to ensure the audio thread is not stuck for more than 60 seconds; if
   // a hang is detected, the process will be crashed.
   static AudioManager* CreateWithHangTimer(
       AudioLogFactory* audio_log_factory,
       const scoped_refptr<base::SingleThreadTaskRunner>& monitor_task_runner);
 
   // Similar to Create() except uses a FakeAudioLogFactory for testing.
   static AudioManager* CreateForTesting();
 
+  // Should only be used for testing. Resets a previously-set
+  // AudioManagerFactory. The instance of AudioManager is not affected.
+  static void ResetFactoryForTesting();
+
   // Returns the pointer to the last created instance, or NULL if not yet
   // created. This is a utility method for the code outside of media directory,
   // like src/chrome.
   static AudioManager* Get();
 
   // Returns true if the OS reports existence of audio devices. This does not
   // guarantee that the existing devices support all formats and sample rates.
   virtual bool HasAudioOutputDevices() = 0;
 
   // Returns true if the OS reports existence of audio recording devices. This
@@ skipping 66 matching lines @@
   // |bits_per_sample| can be any value supported by the platform.
   // |samples_per_packet| is in hertz as well and can be 0 to |sample_rate|,
   // with 0 suggesting that the implementation use a default value for that
   // platform.
   // Returns NULL if the combination of the parameters is not supported, or if
   // we have reached some other platform specific limit.
   //
   // Do not free the returned AudioInputStream. It is owned by AudioManager.
   // When you are done with it, call |Stop()| and |Close()| to release it.
   virtual AudioInputStream* MakeAudioInputStream(
-      const AudioParameters& params, const std::string& device_id) = 0;
+      const AudioParameters& params,
+      const std::string& device_id) = 0;
 
   // Returns the task runner used for audio IO.
   virtual scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() = 0;
 
   // Heavyweight tasks should use GetWorkerTaskRunner() instead of
   // GetTaskRunner(). On most platforms they are the same, but some share the
   // UI loop with the audio IO loop.
   virtual scoped_refptr<base::SingleThreadTaskRunner> GetWorkerTaskRunner() = 0;
 
   // Allows clients to listen for device state changes; e.g. preferred sample
@@ skipping 48 matching lines @@
  protected:
   AudioManager();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioManager);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_AUDIO_AUDIO_MANAGER_H_