Fix bug when unplugging an audio input device whilst using speech input.

media/audio/audio_input_controller.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/audio_input_controller.h"
 
 #include "base/threading/thread_restrictions.h"
 #include "media/base/limits.h"
 
+namespace {
+const int kMaxInputChannels = 2;
+const int kTimerResetInterval = 1; // One second.
+}
+
 namespace media {
 
-static const int kMaxInputChannels = 2;
-
 // static
 AudioInputController::Factory* AudioInputController::factory_ = NULL;
 
 AudioInputController::AudioInputController(EventHandler* handler,
                                            SyncWriter* sync_writer)
     : handler_(handler),
       stream_(NULL),
+      ALLOW_THIS_IN_INITIALIZER_LIST(no_data_timer_(
+          base::TimeDelta::FromSeconds(kTimerResetInterval),
+          this,
+          &AudioInputController::DoReportNoDataError)),
       state_(kEmpty),
       thread_("AudioInputControllerThread"),
       sync_writer_(sync_writer) {
 }
 
 AudioInputController::~AudioInputController() {
   DCHECK(kClosed == state_ || kCreated == state_ || kEmpty == state_);
 }
 
 // static
@@ skipping 85 matching lines @@
   }
 
   if (stream_ && !stream_->Open()) {
     stream_->Close();
     stream_ = NULL;
     // TODO(satish): Define error types.
     handler_->OnError(this, 0);
     return;
   }
 
+  thread_.message_loop()->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(this, &AudioInputController::DoResetNoDataTimer));
   state_ = kCreated;
   handler_->OnCreated(this);
 }
 
 void AudioInputController::DoRecord() {
   DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
 
   if (state_ != kCreated)
     return;
 
@@ skipping 25 matching lines @@
   // Since the stream is closed at this point there's no other threads reading
   // |state_| so we don't need to lock.
   state_ = kClosed;
 }
 
 void AudioInputController::DoReportError(int code) {
   DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
   handler_->OnError(this, code);
 }
 
+void AudioInputController::DoReportNoDataError() {
+  DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
+  handler_->OnError(this, 0);
+}
+
+void AudioInputController::DoResetNoDataTimer() {
+  DCHECK_EQ(thread_.message_loop(), MessageLoop::current());
+  no_data_timer_.Reset();
+}
+
 void AudioInputController::OnData(AudioInputStream* stream, const uint8* data,
                                   uint32 size) {
   {
     base::AutoLock auto_lock(lock_);
     if (state_ != kRecording)
       return;
   }
 
+  thread_.message_loop()->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(this, &AudioInputController::DoResetNoDataTimer));
+
   // Use SyncSocket if we are in a low-latency mode.
   if (LowLatencyMode()) {
     sync_writer_->Write(data, size);
     sync_writer_->UpdateRecordedBytes(size);
     return;
   }
 
   handler_->OnData(this, data, size);
 }
 
 void AudioInputController::OnClose(AudioInputStream* stream) {
   // TODO(satish): Sometimes the device driver closes the input stream without
   // us asking for it (may be if the device was unplugged?). Check how to handle
   // such cases here.
 }
 
 void AudioInputController::OnError(AudioInputStream* stream, int code) {
   // Handle error on the audio controller thread.
   thread_.message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &AudioInputController::DoReportError, code));
 }
 
 }  // namespace media