Defer input stream start around suspend and resume.

media/audio/mac/audio_input_mac.cc

 // 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.
 
 #include "media/audio/mac/audio_input_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
-#include "media/audio/audio_manager_base.h"
-
+#include "media/audio/mac/audio_manager_mac.h"
 
 namespace media {
 
 PCMQueueInAudioInputStream::PCMQueueInAudioInputStream(
-    AudioManagerBase* manager, const AudioParameters& params)
+    AudioManagerMac* manager, const AudioParameters& params)
     : manager_(manager),
       callback_(NULL),
       audio_queue_(NULL),
       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.
@@ skipping 29 matching lines @@
     return false;
   }
   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;
+
+  // Check if we should defer Start() for http://crbug.com/160920.
+  if (manager_->ShouldDeferStreamStart()) {
+    // Use a cancellable closure so that if Stop() is called before Start()
+    // actually runs, we can cancel the pending start.
+    DCHECK(deferred_start_cb_.IsCancelled());
+    deferred_start_cb_.Reset(base::Bind(
+        &PCMQueueInAudioInputStream::Start, base::Unretained(this), callback));
+    manager_->GetTaskRunner()->PostDelayedTask(
+        FROM_HERE,
+        deferred_start_cb_.callback(),
+        base::TimeDelta::FromSeconds(
+            AudioManagerMac::kStartDelayInSecsForPowerEvents));
+    return;
+  }
+
   callback_ = callback;
   OSStatus err = AudioQueueStart(audio_queue_, NULL);
   if (err != noErr) {
     HandleError(err);
   } else {
     started_ = true;
   }
 }
 
 void PCMQueueInAudioInputStream::Stop() {
+  deferred_start_cb_.Cancel();
   if (!audio_queue_ || !started_)
     return;
 
   // 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;
@@ skipping 132 matching lines @@
       // 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);
   }
 }
 
 }  // namespace media