Add AudioParameters struct. Use it everywhere.

BUG=None
TEST=unittests

Review URL: http://codereview.chromium.org/3226012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@58097 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 46 insertions, 70 deletions

diff --git a/media/audio/linux/alsa_output.cc b/media/audio/linux/alsa_output.cc
index e8ebc5c..e3670d8 100644
--- a/media/audio/linux/alsa_output.cc
+++ b/media/audio/linux/alsa_output.cc
@@ -117,7 +117,7 @@ namespace {
 
 // ALSA is currently limited to 48Khz.
 // TODO(fbarchard): Resample audio from higher frequency to 48000.
-const uint32 kMaxSampleRate = 48000;
+const int kAlsaMaxSampleRate = 48000;
 
 snd_pcm_format_t BitsToFormat(char bits_per_sample) {
   switch (bits_per_sample) {
@@ -237,20 +237,17 @@ std::ostream& operator<<(std::ostream& os,
 }
 
 AlsaPcmOutputStream::AlsaPcmOutputStream(const std::string& device_name,
-                                         AudioManager::Format format,
-                                         uint32 channels,
-                                         uint32 sample_rate,
-                                         uint32 bits_per_sample,
+                                         AudioParameters params,
                                          AlsaWrapper* wrapper,
                                          AudioManagerLinux* manager,
                                          MessageLoop* message_loop)
     : shared_data_(MessageLoop::current()),
       requested_device_name_(device_name),
-      pcm_format_(BitsToFormat(bits_per_sample)),
-      channels_(channels),
-      sample_rate_(sample_rate),
-      bytes_per_sample_(bits_per_sample / 8),
-      bytes_per_frame_(channels_ * bits_per_sample / 8),
+      pcm_format_(BitsToFormat(params.bits_per_sample)),
+      channels_(params.channels),
+      sample_rate_(params.sample_rate),
+      bytes_per_sample_(params.bits_per_sample / 8),
+      bytes_per_frame_(channels_ * params.bits_per_sample / 8),
       should_downmix_(false),
       latency_micros_(0),
       micros_per_packet_(0),
@@ -265,18 +262,18 @@ AlsaPcmOutputStream::AlsaPcmOutputStream(const std::string& device_name,
       message_loop_(message_loop) {
 
   // Sanity check input values.
-  if ((sample_rate > kMaxSampleRate) || (sample_rate <= 0)) {
+  if ((params.sample_rate > kAlsaMaxSampleRate) || (params.sample_rate <= 0)) {
     LOG(WARNING) << "Unsupported audio frequency.";
     shared_data_.TransitionTo(kInError);
   }
 
-  if (AudioManager::AUDIO_PCM_LINEAR != format) {
+  if (AudioParameters::AUDIO_PCM_LINEAR != params.format) {
     LOG(WARNING) << "Only linear PCM supported.";
     shared_data_.TransitionTo(kInError);
   }
 
   if (pcm_format_ == SND_PCM_FORMAT_UNKNOWN) {
-    LOG(WARNING) << "Unsupported bits per sample: " << bits_per_sample;
+    LOG(WARNING) << "Unsupported bits per sample: " << params.bits_per_sample;
     shared_data_.TransitionTo(kInError);
   }
 }
diff --git a/media/audio/linux/alsa_output.h b/media/audio/linux/alsa_output.h
index f98f2c0..f6fd0d6 100644
--- a/media/audio/linux/alsa_output.h
+++ b/media/audio/linux/alsa_output.h
@@ -37,7 +37,7 @@
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "media/audio/audio_io.h"
-#include "media/audio/audio_manager_base.h"
+#include "media/audio/audio_parameters.h"
 
 namespace media {
 class SeekableBuffer;
@@ -45,6 +45,7 @@ class SeekableBuffer;
 
 class AlsaWrapper;
 class AudioManagerLinux;
+class MessageLoop;
 
 class AlsaPcmOutputStream :
     public AudioOutputStream,
@@ -72,10 +73,7 @@ class AlsaPcmOutputStream :
   //
   // If unsure of what to use for |device_name|, use |kAutoSelectDevice|.
   AlsaPcmOutputStream(const std::string& device_name,
-                      AudioManager::Format format,
-                      uint32 channels,
-                      uint32 sample_rate,
-                      uint32 bits_per_sample,
+                      AudioParameters params,
                       AlsaWrapper* wrapper,
                       AudioManagerLinux* manager,
                       MessageLoop* message_loop);
diff --git a/media/audio/linux/alsa_output_unittest.cc b/media/audio/linux/alsa_output_unittest.cc
index 7d3a283..23d86d32 100644
--- a/media/audio/linux/alsa_output_unittest.cc
+++ b/media/audio/linux/alsa_output_unittest.cc
@@ -71,12 +71,10 @@ class MockAudioManagerLinux : public AudioManagerLinux {
   MOCK_METHOD0(Init, void());
   MOCK_METHOD0(HasAudioOutputDevices, bool());
   MOCK_METHOD0(HasAudioInputDevices, bool());
-  MOCK_METHOD4(MakeAudioOutputStream, AudioOutputStream*(Format format,
-                                                         int channels,
-                                                         int sample_rate,
-                                                         char bits_per_sample));
+  MOCK_METHOD1(MakeAudioOutputStream, AudioOutputStream*(
+      AudioParameters params));
   MOCK_METHOD5(MakeAudioInputStream, AudioInputStream*(
-      Format format,
+      AudioParameters::Format format,
       int channels,
       int sample_rate,
       char bits_per_sample,
@@ -98,11 +96,10 @@ class AlsaPcmOutputStreamTest : public testing::Test {
   }
 
   AlsaPcmOutputStream* CreateStreamWithChannels(int channels) {
+    AudioParameters params(kTestFormat, channels, kTestSampleRate,
+                           kTestBitsPerSample);
     return new AlsaPcmOutputStream(kTestDeviceName,
-                                   kTestFormat,
-                                   channels,
-                                   kTestSampleRate,
-                                   kTestBitsPerSample,
+                                   params,
                                    &mock_alsa_wrapper_,
                                    &mock_manager_,
                                    &message_loop_);
@@ -131,7 +128,7 @@ class AlsaPcmOutputStreamTest : public testing::Test {
   static const int kTestSampleRate;
   static const int kTestBitsPerSample;
   static const int kTestBytesPerFrame;
-  static const AudioManager::Format kTestFormat;
+  static const AudioParameters::Format kTestFormat;
   static const char kTestDeviceName[];
   static const char kDummyMessage[];
   static const uint32 kTestFramesPerPacket;
@@ -160,13 +157,13 @@ class AlsaPcmOutputStreamTest : public testing::Test {
 
 const int AlsaPcmOutputStreamTest::kTestChannels = 2;
 const int AlsaPcmOutputStreamTest::kTestSampleRate =
-    AudioManager::kAudioCDSampleRate;
+    AudioParameters::kAudioCDSampleRate;
 const int AlsaPcmOutputStreamTest::kTestBitsPerSample = 8;
 const int AlsaPcmOutputStreamTest::kTestBytesPerFrame =
     AlsaPcmOutputStreamTest::kTestBitsPerSample / 8 *
     AlsaPcmOutputStreamTest::kTestChannels;
-const AudioManager::Format AlsaPcmOutputStreamTest::kTestFormat =
-    AudioManager::AUDIO_PCM_LINEAR;
+const AudioParameters::Format AlsaPcmOutputStreamTest::kTestFormat =
+    AudioParameters::AUDIO_PCM_LINEAR;
 const char AlsaPcmOutputStreamTest::kTestDeviceName[] = "TestDevice";
 const char AlsaPcmOutputStreamTest::kDummyMessage[] = "dummy";
 const uint32 AlsaPcmOutputStreamTest::kTestFramesPerPacket = 1000;
@@ -202,11 +199,10 @@ TEST_F(AlsaPcmOutputStreamTest, ConstructedState) {
             test_stream_->shared_data_.state());
 
   // Bad bits per sample.
+  AudioParameters bad_bps_params(kTestFormat, kTestChannels,
+                                 kTestSampleRate, kTestBitsPerSample - 1);
   test_stream_ = new AlsaPcmOutputStream(kTestDeviceName,
-                                         kTestFormat,
-                                         kTestChannels,
-                                         kTestSampleRate,
-                                         kTestBitsPerSample - 1,
+                                         bad_bps_params,
                                          &mock_alsa_wrapper_,
                                          &mock_manager_,
                                          &message_loop_);
@@ -214,11 +210,11 @@ TEST_F(AlsaPcmOutputStreamTest, ConstructedState) {
             test_stream_->shared_data_.state());
 
   // Bad format.
+  AudioParameters bad_format_params(
+      AudioParameters::AUDIO_LAST_FORMAT, kTestChannels,
+      kTestSampleRate, kTestBitsPerSample);
   test_stream_ = new AlsaPcmOutputStream(kTestDeviceName,
-                                         AudioManager::AUDIO_LAST_FORMAT,
-                                         kTestChannels,
-                                         kTestSampleRate,
-                                         kTestBitsPerSample,
+                                         bad_format_params,
                                          &mock_alsa_wrapper_,
                                          &mock_manager_,
                                          &message_loop_);
diff --git a/media/audio/linux/audio_manager_linux.cc b/media/audio/linux/audio_manager_linux.cc
index 713a753..00f23b1a 100644
--- a/media/audio/linux/audio_manager_linux.cc
+++ b/media/audio/linux/audio_manager_linux.cc
@@ -23,29 +23,11 @@ bool AudioManagerLinux::HasAudioInputDevices() {
   return false;
 }
 
-AudioInputStream* AudioManagerLinux::MakeAudioInputStream(
-    Format format,
-    int channels,
-    int sample_rate,
-    char bits_per_sample,
-    uint32 samples_per_packet) {
-  if (format == AUDIO_MOCK) {
-    return FakeAudioInputStream::MakeFakeStream(channels, bits_per_sample,
-                                                sample_rate,
-                                                samples_per_packet);
-  }
-  // TODO(satish): implement.
-  return NULL;
-}
-
 AudioOutputStream* AudioManagerLinux::MakeAudioOutputStream(
-    Format format,
-    int channels,
-    int sample_rate,
-    char bits_per_sample) {
+    AudioParameters params) {
   // Early return for testing hook.  Do this before checking for
   // |initialized_|.
-  if (format == AudioManager::AUDIO_MOCK) {
+  if (params.format == AudioParameters::AUDIO_MOCK) {
     return FakeAudioOutputStream::MakeFakeStream();
   }
 
@@ -59,8 +41,7 @@ AudioOutputStream* AudioManagerLinux::MakeAudioOutputStream(
         switches::kAlsaDevice);
   }
   AlsaPcmOutputStream* stream =
-      new AlsaPcmOutputStream(device_name, format, channels, sample_rate,
-                              bits_per_sample, wrapper_.get(), this,
+      new AlsaPcmOutputStream(device_name, params, wrapper_.get(), this,
                               GetMessageLoop());
 
   AutoLock l(lock_);
@@ -68,6 +49,15 @@ AudioOutputStream* AudioManagerLinux::MakeAudioOutputStream(
   return stream;
 }
 
+AudioInputStream* AudioManagerLinux::MakeAudioInputStream(
+    AudioParameters params, uint32 samples_per_packet) {
+  if (params.format == AudioParameters::AUDIO_MOCK) {
+    return FakeAudioInputStream::MakeFakeStream(params, samples_per_packet);
+  }
+  // TODO(satish): implement.
+  return NULL;
+}
+
 AudioManagerLinux::AudioManagerLinux() {
 }
 
diff --git a/media/audio/linux/audio_manager_linux.h b/media/audio/linux/audio_manager_linux.h
index 2703eed..f13e1a8 100644
--- a/media/audio/linux/audio_manager_linux.h
+++ b/media/audio/linux/audio_manager_linux.h
@@ -26,21 +26,16 @@ class AudioManagerLinux : public AudioManagerBase {
   // Implementation of AudioManager.
   virtual bool HasAudioOutputDevices();
   virtual bool HasAudioInputDevices();
-  virtual AudioOutputStream* MakeAudioOutputStream(Format format, int channels,
-                                                   int sample_rate,
-                                                   char bits_per_sample);
-  virtual AudioInputStream* MakeAudioInputStream(Format format, int channels,
-                                                 int sample_rate,
-                                                 char bits_per_sample,
-                                                 uint32 samples_per_packet);
+  virtual AudioOutputStream* MakeAudioOutputStream(AudioParameters params);
+  virtual AudioInputStream* MakeAudioInputStream(
+      AudioParameters params, uint32 samples_per_packet);
+
   virtual void MuteAll();
   virtual void UnMuteAll();
 
   virtual void ReleaseOutputStream(AlsaPcmOutputStream* stream);
 
  protected:
-  // Friend function for invoking the destructor at exit.
-  friend void DestroyAudioManagerLinux(void*);
   virtual ~AudioManagerLinux();
 
  private: