Enable the AudioInputTest tests + Fix PCMQueueInAudioInputStream.

media/audio/mac/audio_input_mac.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 "media/audio/mac/audio_input_mac.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/mac/audio_manager_mac.h"
 
 #if !defined(MAC_OS_X_VERSION_10_6) || \
     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
 enum {
   kAudioQueueErr_EnqueueDuringReset = -66632
 };
 #endif
 
 PCMQueueInAudioInputStream::PCMQueueInAudioInputStream(
     AudioManagerMac* manager, const AudioParameters& params)
     : manager_(manager),
       callback_(NULL),
       audio_queue_(NULL),
-      buffer_size_bytes_(0) {
+      buffer_size_bytes_(0),
+      started_(false) {
   // We must have a manager.
   DCHECK(manager_);
   // A frame is one sample across all channels. In interleaved audio the per
   // frame fields identify the set of n |channels|. In uncompressed audio, a
   // packet is always one frame.
   format_.mSampleRate = params.sample_rate;
   format_.mFormatID = kAudioFormatLinearPCM;
   format_.mFormatFlags = kLinearPCMFormatFlagIsPacked |
                          kLinearPCMFormatFlagIsSignedInteger;
   format_.mBitsPerChannel = params.bits_per_sample;
@@ skipping 26 matching lines @@
   return SetupBuffers();
 }
 
 void PCMQueueInAudioInputStream::Start(AudioInputCallback* callback) {
   DCHECK(callback);
   DLOG_IF(ERROR, !audio_queue_) << "Open() has not been called successfully";
   if (callback_ || !audio_queue_)
     return;
   callback_ = callback;
   OSStatus err = AudioQueueStart(audio_queue_, NULL);
-  if (err != noErr)
+  if (err != noErr) {
     HandleError(err);
-  else
+  } else {
+    started_ = true;
     manager_->IncreaseActiveInputStreamCount();
+  }
 }
 
 void PCMQueueInAudioInputStream::Stop() {
-  if (!audio_queue_)
+  if (!audio_queue_ || !started_)
     return;
+
   // Stop is always called before Close. In case of error, this will be
   // also called when closing the input controller.
   manager_->DecreaseActiveInputStreamCount();
 
   // We request a synchronous stop, so the next call can take some time. In
   // the windows implementation we block here as well.
   OSStatus err = AudioQueueStop(audio_queue_, true);
   if (err != noErr)
     HandleError(err);
+
+  started_ = false;
 }
 
 void PCMQueueInAudioInputStream::Close() {
   // It is valid to call Close() before calling Open() or Start(), thus
   // |audio_queue_| and |callback_| might be NULL.
   if (audio_queue_) {
     OSStatus err = AudioQueueDispose(audio_queue_, true);
     audio_queue_ = NULL;
     if (err != noErr)
       HandleError(err);
@@ skipping 78 matching lines @@
       // TODO(joth): PCMQueueOutAudioOutputStream uses callback_ to provide an
       // extra guard for this situation, but it seems to introduce more
       // complications than it solves (memory barrier issues accessing it from
       // multiple threads, looses the means to indicate OnClosed to client).
       // Should determine if we need to do something equivalent here.
       return;
     }
     HandleError(err);
   }
 }