Make initial reset period configurable for audio input no data timer.

media/audio/audio_input_controller.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/audio_input_controller.h"
 
 #include "base/bind.h"
 #include "base/threading/thread_restrictions.h"
 #include "media/base/limits.h"
 
 namespace {
 const int kMaxInputChannels = 2;
-const int kTimerResetInterval = 1;  // One second.
+const int kTimerResetIntervalSeconds = 1;
+#if defined(OS_IOS)
+// The first callback on iOS is received after the current background
+// audio has faded away.
+const int kTimerInitialIntervalSeconds = 4;
+#else
+const int kTimerInitialIntervalSeconds = 1;
+#endif  // defined(OS_IOS)
 }
 
 namespace media {
 
 // static
 AudioInputController::Factory* AudioInputController::factory_ = NULL;
 
 AudioInputController::AudioInputController(EventHandler* handler,
                                            SyncWriter* sync_writer)
     : creator_loop_(base::MessageLoopProxy::current()),
@@ skipping 108 matching lines @@
 
   if (stream_ && !stream_->Open()) {
     stream_->Close();
     stream_ = NULL;
     // TODO(satish): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
   DCHECK(!no_data_timer_.get());
-  // Create the data timer which will call DoCheckForNoData() after a delay
-  // of |kTimerResetInterval| seconds. The timer is started in DoRecord()
-  // and restarted in each DoCheckForNoData() callback.
-  no_data_timer_.reset(new base::DelayTimer<AudioInputController>(FROM_HERE,
-      base::TimeDelta::FromSeconds(kTimerResetInterval),
-      this,
-      &AudioInputController::DoCheckForNoData));
-
+  // Create the data timer which will call DoCheckForNoData(). The timer
+  // is started in DoRecord() and restarted in each DoCheckForNoData() callback.
+  no_data_timer_.reset(new base::Timer(
+      FROM_HERE, base::TimeDelta::FromSeconds(kTimerInitialIntervalSeconds),
+      base::Bind(&AudioInputController::DoCheckForNoData,
+      base::Unretained(this)), false));
   state_ = kCreated;
   handler_->OnCreated(this);
 }
 
 void AudioInputController::DoRecord() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (state_ != kCreated)
     return;
 
   {
     base::AutoLock auto_lock(lock_);
     state_ = kRecording;
   }
 
-  // Start the data timer. Once |kTimerResetInterval| seconds have passed,
+  // Start the data timer. Once |kTimerResetIntervalSeconds| have passed,
   // a callback to DoCheckForNoData() is made.
   no_data_timer_->Reset();
 
   stream_->Start(this);
   handler_->OnRecording(this);
 }
 
 void AudioInputController::DoClose() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
@@ skipping 60 matching lines @@
     // capture device has been removed or disabled.
     handler_->OnError(this, 0);
     return;
   }
 
   // Mark data as non-active. The flag will be re-enabled in OnData() each
   // time a data packet is received. Hence, under normal conditions, the
   // flag will only be disabled during a very short period.
   SetDataIsActive(false);
 
-  // Restart the timer to ensure that we check the flag in one second again.
-  no_data_timer_->Reset();
+  // Restart the timer to ensure that we check the flag again in
+  // |kTimerResetIntervalSeconds|.
+  no_data_timer_->Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kTimerResetIntervalSeconds),
+      base::Bind(&AudioInputController::DoCheckForNoData,
+      base::Unretained(this)));
 }
 
 void AudioInputController::OnData(AudioInputStream* stream, const uint8* data,
                                   uint32 size, uint32 hardware_delay_bytes,
                                   double volume) {
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != kRecording)
       return;
   }
@@ skipping 43 matching lines @@
 
 void AudioInputController::SetDataIsActive(bool enabled) {
   base::subtle::Release_Store(&data_is_active_, enabled);
 }
 
 bool AudioInputController::GetDataIsActive() {
   return (base::subtle::Acquire_Load(&data_is_active_) != false);
 }
 
 }  // namespace media