Some fixups for AudioController and unit tests

media/audio/audio_controller.cc

 // Copyright (c) 2010 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 "media/audio/audio_controller.h"
 
 // The following parameters limit the request buffer and packet size from the
 // renderer to avoid renderer from requesting too much memory.
-static const int kMegabytes = 1024 * 1024;
-static const int kMaxHardwareBufferSize = 2 * kMegabytes;
+static const uint32 kMegabytes = 1024 * 1024;
+static const uint32 kMaxHardwareBufferSize = 2 * kMegabytes;
 static const int kMaxChannels = 32;
 static const int kMaxBitsPerSample = 64;
 static const int kMaxSampleRate = 192000;
 
 // Return true if the parameters for creating an audio stream is valid.
 // Return false otherwise.
 static bool CheckParameters(int channels, int sample_rate,
-                            int bits_per_sample, int hardware_buffer_size) {
+                            int bits_per_sample, uint32 hardware_buffer_size) {
   if (channels <= 0 || channels > kMaxChannels)
     return false;
   if (sample_rate <= 0 || sample_rate > kMaxSampleRate)
     return false;
   if (bits_per_sample <= 0 || bits_per_sample > kMaxBitsPerSample)
     return false;
   if (hardware_buffer_size <= 0 ||
       hardware_buffer_size > kMaxHardwareBufferSize) {
     return false;
   }
@@ skipping 16 matching lines @@
   DCHECK(kClosed == state_ || kCreated == state_);
 }
 
 // static
 scoped_refptr<AudioController> AudioController::Create(
     EventHandler* event_handler,
     AudioManager::Format format,
     int channels,
     int sample_rate,
     int bits_per_sample,
-    int hardware_buffer_size,
+    uint32 hardware_buffer_size,
     uint32 buffer_capacity) {
 
   if (!CheckParameters(channels, sample_rate, bits_per_sample,
                        hardware_buffer_size))
     return NULL;
 
   // Starts the audio controller thread.
-  scoped_refptr<AudioController> source = new AudioController(
+  scoped_refptr<AudioController> controller = new AudioController(
       event_handler, buffer_capacity, NULL);
 
   // Start the audio controller thread and post a task to create the
   // audio stream.
-  source->thread_.Start();
-  source->thread_.message_loop()->PostTask(
+  controller->thread_.Start();
+  controller->thread_.message_loop()->PostTask(
       FROM_HERE,
-      NewRunnableMethod(source.get(), &AudioController::DoCreate,
+      NewRunnableMethod(controller.get(), &AudioController::DoCreate,
                         format, channels, sample_rate, bits_per_sample,
                         hardware_buffer_size));
-  return source;
+  return controller;
 }
 
 // static
 scoped_refptr<AudioController> AudioController::CreateLowLatency(
     EventHandler* event_handler,
     AudioManager::Format format,
     int channels,
     int sample_rate,
     int bits_per_sample,
-    int hardware_buffer_size,
+    uint32 hardware_buffer_size,
     SyncReader* sync_reader) {
 
   DCHECK(sync_reader);
 
   if (!CheckParameters(channels, sample_rate, bits_per_sample,
                        hardware_buffer_size))
     return NULL;
 
   // Starts the audio controller thread.
-  scoped_refptr<AudioController> source = new AudioController(
+  scoped_refptr<AudioController> controller = new AudioController(
       event_handler, 0, sync_reader);
 
   // Start the audio controller thread and post a task to create the
   // audio stream.
-  source->thread_.Start();
-  source->thread_.message_loop()->PostTask(
+  controller->thread_.Start();
+  controller->thread_.message_loop()->PostTask(
       FROM_HERE,
-      NewRunnableMethod(source.get(), &AudioController::DoCreate,
+      NewRunnableMethod(controller.get(), &AudioController::DoCreate,
                         format, channels, sample_rate, bits_per_sample,
                         hardware_buffer_size));
-  return source;
+  return controller;
 }
 
 void AudioController::Play() {
   DCHECK(thread_.IsRunning());
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioController::DoPlay));
 }
 
 void AudioController::Pause() {
   DCHECK(thread_.IsRunning());
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioController::DoPause));
 }
 
 void AudioController::Flush() {
   DCHECK(thread_.IsRunning());
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioController::DoFlush));
 }
 
 void AudioController::Close() {
-  DCHECK(thread_.IsRunning());
+  if (!thread_.IsRunning()) {
+    // If the thread is not running make sure we are stopped.
+    DCHECK_EQ(kClosed, state_);
+    return;
+  }
+
+  // Wait for all tasks to complete on the audio thread.
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioController::DoClose));
   thread_.Stop();
 }
 
 void AudioController::SetVolume(double volume) {
   DCHECK(thread_.IsRunning());
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioController::DoSetVolume, volume));
 }
 
 void AudioController::EnqueueData(const uint8* data, uint32 size) {
   // Write data to the push source and ask for more data if needed.
   AutoLock auto_lock(lock_);
   push_source_.Write(data, size);
   SubmitOnMoreData_Locked();
 }
 
 void AudioController::DoCreate(AudioManager::Format format, int channels,
-                               int sample_rate, int bits_per_sample,
-                               int hardware_buffer_size) {
+                              int sample_rate, int bits_per_sample,
+                              uint32 hardware_buffer_size) {
   // Create the stream in the first place.
   stream_ = AudioManager::GetAudioManager()->MakeAudioStream(
       format, channels, sample_rate, bits_per_sample);
 
   if (!stream_) {
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
   if (stream_ && !stream_->Open(hardware_buffer_size)) {
     stream_->Close();
     stream_ = NULL;
 
     // TODO(hclam): Define error types.
     handler_->OnError(this, 0);
     return;
   }
   handler_->OnCreated(this);
+
+  // If in normal latency mode then start buffering.
+  if (!LowLatencyMode()) {
+    AutoLock auto_lock(lock_);
+    SubmitOnMoreData_Locked();
+  }
 }
 
 void AudioController::DoPlay() {
   DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
 
   // We can start from created or paused state.
   if (state_ != kCreated && state_ != kPaused)
     return;
 
   State old_state;
@@ skipping 140 matching lines @@
       push_source_.UnProcessedBytes();
 
   // If we need more data then call the event handler to ask for more data.
   // It is okay that we don't lock in this block because the parameters are
   // correct and in the worst case we are just asking more data than needed.
   AutoUnlock auto_unlock(lock_);
   handler_->OnMoreData(this, timestamp, pending_bytes);
 }
 
 }  // namespace media